hedgequantx 2.6.149 → 2.6.151

package/package.json

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

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

@@ -0,0 +1,493 @@
+/**
+ * Custom Strategy - AI-Generated Trading Strategy
+ * 
+ * Flow:
+ * 1. User describes strategy in natural language
+ * 2. Connected AI agent generates the code
+ * 3. Agent tests and validates the code
+ * 4. User confirms, enters TARGET/RISK
+ * 5. Execution same as one-account
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+
+const { connections } = require('../../services');
+const { AlgoUI, renderSessionSummary, renderMultiSymbolSummary } = require('./ui');
+const { prompts } = require('../../utils');
+const { checkMarketHours } = require('../../services/projectx/market');
+const { FAST_SCALPING } = require('../../config/settings');
+const { PositionManager } = require('../../services/position-manager');
+const { RithmicMarketDataFeed } = require('../../services/rithmic/market-data');
+const { algoLogger } = require('./logger');
+const { recoveryMath } = require('../../services/strategy/recovery-math');
+const aiService = require('../../services/ai');
+const { launchMultiSymbolRithmic } = require('./one-account');
+
+// Strategy template that the AI will fill
+const STRATEGY_TEMPLATE = `/**
+ * Custom Strategy: {{STRATEGY_NAME}}
+ * Generated by AI Agent
+ * 
+ * Description: {{STRATEGY_DESCRIPTION}}
+ */
+
+const EventEmitter = require('events');
+
+class CustomStrategy extends EventEmitter {
+  constructor() {
+    super();
+    this.tickSize = null;
+    this.tickValue = null;
+    this.contractId = null;
+    this.initialized = false;
+    this.tickCount = 0;
+    this.lastSignalTime = 0;
+    this.cooldownMs = 5000;
+    
+    // Strategy-specific state
+    {{STRATEGY_STATE}}
+  }
+
+  initialize(contractId, tickSize, tickValue) {
+    if (!contractId || tickSize === undefined || tickValue === undefined) {
+      throw new Error('Strategy requires contractId, tickSize, and tickValue from API');
+    }
+    this.contractId = contractId;
+    this.tickSize = tickSize;
+    this.tickValue = tickValue;
+    this.initialized = true;
+  }
+
+  processTick(tick) {
+    if (!this.initialized) return;
+    this.tickCount++;
+    
+    const { price, bid, ask, volume, side, timestamp } = tick;
+    
+    // Strategy logic
+    {{STRATEGY_LOGIC}}
+  }
+
+  _emitSignal(direction, confidence, entry) {
+    const now = Date.now();
+    if (now - this.lastSignalTime < this.cooldownMs) return;
+    this.lastSignalTime = now;
+    
+    const signal = {
+      id: \`custom-\${now}\`,
+      timestamp: now,
+      contractId: this.contractId,
+      direction,
+      confidence,
+      entry,
+    };
+    
+    this.emit('signal', signal);
+  }
+
+  getState() {
+    return {
+      tickCount: this.tickCount,
+      {{STRATEGY_GET_STATE}}
+    };
+  }
+
+  getModelValues() {
+    return this.getState();
+  }
+
+  reset() {
+    this.tickCount = 0;
+    this.lastSignalTime = 0;
+    {{STRATEGY_RESET}}
+  }
+}
+
+module.exports = { CustomStrategy };
+`;
+
+/**
+ * Get strategy directory
+ */
+function getStrategyDir() {
+  const dir = path.join(os.homedir(), '.hqx', 'strategies');
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+
+/**
+ * Generate strategy code using AI agent
+ */
+async function generateStrategyCode(description, agentName) {
+  const agent = aiService.getAgents().find(a => a.name === agentName || a.provider === agentName);
+  if (!agent) {
+    return { success: false, error: 'No AI agent available' };
+  }
+
+  const prompt = `You are a trading strategy code generator. Generate a trading strategy based on this description:
+
+"${description}"
+
+You must output ONLY valid JavaScript code that fills in these template sections:
+
+1. STRATEGY_NAME: A short name for the strategy (string)
+2. STRATEGY_DESCRIPTION: One line description (string)
+3. STRATEGY_STATE: Variable declarations for strategy state (e.g., "this.ema = 0; this.prices = [];")
+4. STRATEGY_LOGIC: The main logic that processes each tick and calls this._emitSignal(direction, confidence, price) when conditions are met
+   - direction: 'long' or 'short'
+   - confidence: number between 0 and 1
+   - price: the entry price
+5. STRATEGY_GET_STATE: Return additional state variables (e.g., "ema: this.ema,")
+6. STRATEGY_RESET: Reset strategy-specific state (e.g., "this.ema = 0; this.prices = [];")
+
+Available in processTick:
+- tick.price, tick.bid, tick.ask, tick.volume, tick.side, tick.timestamp
+- this.tickSize, this.tickValue (contract specs)
+- this.tickCount (number of ticks processed)
+
+Output format (JSON):
+{
+  "STRATEGY_NAME": "...",
+  "STRATEGY_DESCRIPTION": "...",
+  "STRATEGY_STATE": "...",
+  "STRATEGY_LOGIC": "...",
+  "STRATEGY_GET_STATE": "...",
+  "STRATEGY_RESET": "..."
+}
+
+IMPORTANT: Output ONLY the JSON, no markdown, no explanation.`;
+
+  try {
+    const response = await aiService.chat(agentName, [
+      { role: 'user', content: prompt }
+    ]);
+
+    if (!response.success) {
+      return { success: false, error: response.error || 'AI request failed' };
+    }
+
+    // Parse JSON response
+    let strategyParts;
+    try {
+      // Extract JSON from response (might have markdown)
+      let jsonStr = response.content || response.message || '';
+      const jsonMatch = jsonStr.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        jsonStr = jsonMatch[0];
+      }
+      strategyParts = JSON.parse(jsonStr);
+    } catch (parseError) {
+      return { success: false, error: `Failed to parse AI response: ${parseError.message}` };
+    }
+
+    // Build the code
+    let code = STRATEGY_TEMPLATE;
+    code = code.replace('{{STRATEGY_NAME}}', strategyParts.STRATEGY_NAME || 'Custom Strategy');
+    code = code.replace('{{STRATEGY_DESCRIPTION}}', strategyParts.STRATEGY_DESCRIPTION || description);
+    code = code.replace('{{STRATEGY_STATE}}', strategyParts.STRATEGY_STATE || '');
+    code = code.replace('{{STRATEGY_LOGIC}}', strategyParts.STRATEGY_LOGIC || '// No logic generated');
+    code = code.replace('{{STRATEGY_GET_STATE}}', strategyParts.STRATEGY_GET_STATE || '');
+    code = code.replace('{{STRATEGY_RESET}}', strategyParts.STRATEGY_RESET || '');
+
+    return { 
+      success: true, 
+      code,
+      name: strategyParts.STRATEGY_NAME || 'Custom Strategy',
+    };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Validate generated strategy code
+ */
+async function validateStrategyCode(code, filepath) {
+  const errors = [];
+  
+  // 1. Write to file
+  try {
+    fs.writeFileSync(filepath, code, 'utf8');
+  } catch (e) {
+    return { success: false, errors: [`Failed to write file: ${e.message}`] };
+  }
+
+  // 2. Syntax check - try to require it
+  try {
+    // Clear require cache
+    delete require.cache[require.resolve(filepath)];
+    const mod = require(filepath);
+    
+    if (!mod.CustomStrategy) {
+      errors.push('Module does not export CustomStrategy class');
+    } else {
+      // 3. Instantiation test
+      const instance = new mod.CustomStrategy();
+      
+      // 4. Check required methods
+      if (typeof instance.initialize !== 'function') {
+        errors.push('Missing initialize() method');
+      }
+      if (typeof instance.processTick !== 'function') {
+        errors.push('Missing processTick() method');
+      }
+      if (typeof instance.getState !== 'function') {
+        errors.push('Missing getState() method');
+      }
+      if (typeof instance.on !== 'function') {
+        errors.push('Strategy must extend EventEmitter');
+      }
+      
+      // 5. Dry-run with fake tick
+      try {
+        instance.initialize('TEST', 0.25, 12.50);
+        instance.processTick({
+          price: 5000,
+          bid: 4999.75,
+          ask: 5000.25,
+          volume: 1,
+          side: 'BUY',
+          timestamp: Date.now(),
+        });
+        // Process a few more ticks
+        for (let i = 0; i < 10; i++) {
+          instance.processTick({
+            price: 5000 + (Math.random() - 0.5) * 2,
+            bid: 4999.75,
+            ask: 5000.25,
+            volume: 1,
+            side: Math.random() > 0.5 ? 'BUY' : 'SELL',
+            timestamp: Date.now(),
+          });
+        }
+      } catch (e) {
+        errors.push(`Runtime error in processTick: ${e.message}`);
+      }
+    }
+  } catch (e) {
+    errors.push(`Syntax/Import error: ${e.message}`);
+  }
+
+  if (errors.length > 0) {
+    return { success: false, errors };
+  }
+
+  return { success: true, errors: [] };
+}
+
+/**
+ * Custom Strategy Menu
+ */
+const customStrategyMenu = async (service) => {
+  console.clear();
+  
+  // Check if AI agent is connected
+  const agents = aiService.getAgents();
+  if (!agents || agents.length === 0) {
+    console.log(chalk.red('\n  No AI agent connected.'));
+    console.log(chalk.gray('  Connect an AI agent in AI SETTINGS first.\n'));
+    await prompts.waitForEnter();
+    return;
+  }
+
+  const agentName = agents[0].name || agents[0].provider;
+  console.log(chalk.cyan('\n  ╔════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.cyan('  ║') + chalk.yellow.bold('              CUSTOM STRATEGY - AI GENERATED                ') + chalk.cyan('║'));
+  console.log(chalk.cyan('  ╠════════════════════════════════════════════════════════════╣'));
+  console.log(chalk.cyan('  ║') + chalk.gray(` Agent: ${agentName.padEnd(51)}`) + chalk.cyan('║'));
+  console.log(chalk.cyan('  ╚════════════════════════════════════════════════════════════╝\n'));
+
+  // Step 1: Get strategy description from user
+  console.log(chalk.yellow('  Describe your trading strategy in natural language:'));
+  console.log(chalk.gray('  (Example: "Buy when price crosses above 20-period EMA and RSI < 30")'));
+  console.log(chalk.gray('  (Example: "Scalp long when 3 consecutive green ticks with increasing volume")\n'));
+
+  const description = await prompts.textInput(chalk.cyan('  STRATEGY: '));
+  if (!description || description.trim().length < 10) {
+    console.log(chalk.red('\n  Strategy description too short. Minimum 10 characters.\n'));
+    await prompts.waitForEnter();
+    return;
+  }
+
+  // Step 2: Generate strategy code
+  console.log(chalk.cyan('\n  Generating strategy code...'));
+  const spinner = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let spinnerIdx = 0;
+  const spinnerInterval = setInterval(() => {
+    process.stdout.write(`\r  ${spinner[spinnerIdx++ % spinner.length]} Generating...`);
+  }, 100);
+
+  const genResult = await generateStrategyCode(description, agentName);
+  clearInterval(spinnerInterval);
+  process.stdout.write('\r                              \r');
+
+  if (!genResult.success) {
+    console.log(chalk.red(`\n  Failed to generate strategy: ${genResult.error}\n`));
+    await prompts.waitForEnter();
+    return;
+  }
+
+  console.log(chalk.green(`  ✓ Strategy "${genResult.name}" generated`));
+
+  // Step 3: Save and validate
+  const timestamp = Date.now();
+  const filename = `custom_${timestamp}.js`;
+  const filepath = path.join(getStrategyDir(), filename);
+
+  console.log(chalk.cyan('  Validating strategy...'));
+
+  const validation = await validateStrategyCode(genResult.code, filepath);
+
+  if (!validation.success) {
+    console.log(chalk.red('\n  Strategy validation FAILED:'));
+    for (const err of validation.errors) {
+      console.log(chalk.red(`    - ${err}`));
+    }
+    console.log(chalk.gray(`\n  Code saved to: ${filepath}`));
+    console.log(chalk.gray('  You can manually fix and retry.\n'));
+    await prompts.waitForEnter();
+    return;
+  }
+
+  console.log(chalk.green('  ✓ Strategy validated successfully'));
+  console.log(chalk.gray(`  Saved to: ${filepath}\n`));
+
+  // Step 4: Show strategy summary and confirm
+  console.log(chalk.cyan('  ╔════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.cyan('  ║') + chalk.green.bold('                    STRATEGY READY                          ') + chalk.cyan('║'));
+  console.log(chalk.cyan('  ╠════════════════════════════════════════════════════════════╣'));
+  console.log(chalk.cyan('  ║') + chalk.white(` Name: ${genResult.name.substring(0, 51).padEnd(51)}`) + chalk.cyan('║'));
+  console.log(chalk.cyan('  ║') + chalk.gray(` File: ${filename.padEnd(51)}`) + chalk.cyan('║'));
+  console.log(chalk.cyan('  ╚════════════════════════════════════════════════════════════╝\n'));
+
+  const confirm = await prompts.textInput(chalk.cyan('  Continue with this strategy? (Y/n): '));
+  if (confirm.toLowerCase() === 'n') {
+    console.log(chalk.yellow('\n  Cancelled.\n'));
+    await prompts.waitForEnter();
+    return;
+  }
+
+  // Step 5: Continue with normal one-account flow
+  // Load the custom strategy
+  const CustomStrategyModule = require(filepath);
+  
+  // Pass to execution with the custom strategy
+  await executeWithCustomStrategy(service, CustomStrategyModule.CustomStrategy, genResult.name);
+};
+
+/**
+ * Execute trading with custom strategy
+ * Same as one-account but uses the custom strategy class
+ */
+async function executeWithCustomStrategy(service, StrategyClass, strategyName) {
+  // Import one-account's configuration prompts
+  const { getLogoWidth, drawBoxHeaderContinue, drawBoxFooter, displayBanner } = require('../../ui');
+  
+  // Get accounts
+  const accountsResult = await service.getTradingAccounts();
+  if (!accountsResult.success || !accountsResult.accounts?.length) {
+    console.log(chalk.red('\n  No trading accounts available.\n'));
+    await prompts.waitForEnter();
+    return;
+  }
+
+  // Account selection
+  console.log(chalk.cyan('\n  SELECT ACCOUNT:\n'));
+  accountsResult.accounts.forEach((acc, i) => {
+    const balance = acc.balance !== null ? `$${acc.balance.toLocaleString()}` : 'N/A';
+    console.log(chalk.cyan(`  [${i + 1}]`) + chalk.white(` ${acc.name || acc.accountId}`) + chalk.gray(` - ${balance}`));
+  });
+
+  const accChoice = await prompts.numberInput('\n  ACCOUNT #:', 1, 1, accountsResult.accounts.length);
+  if (accChoice === null) return;
+  const account = accountsResult.accounts[accChoice - 1];
+
+  // Symbol selection
+  const symbolInput = await prompts.textInput(chalk.cyan('  SYMBOL (e.g., MES, MNQ): '));
+  if (!symbolInput) return;
+  const symbols = symbolInput.toUpperCase().split(',').map(s => s.trim()).filter(Boolean);
+
+  // Target and Risk
+  const dailyTarget = await prompts.numberInput('  TARGET ($):', 1000, 100, 50000);
+  if (dailyTarget === null) return;
+
+  const maxRisk = await prompts.numberInput('  MAX RISK ($):', 500, 50, 10000);
+  if (maxRisk === null) return;
+
+  // Confirm
+  console.log(chalk.cyan('\n  ╔════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.cyan('  ║') + chalk.yellow.bold('                    CONFIRM SETTINGS                        ') + chalk.cyan('║'));
+  console.log(chalk.cyan('  ╠════════════════════════════════════════════════════════════╣'));
+  console.log(chalk.cyan('  ║') + chalk.white(` Strategy: ${strategyName.substring(0, 47).padEnd(47)}`) + chalk.cyan('║'));
+  console.log(chalk.cyan('  ║') + chalk.white(` Account:  ${(account.name || account.accountId).substring(0, 47).padEnd(47)}`) + chalk.cyan('║'));
+  console.log(chalk.cyan('  ║') + chalk.white(` Symbols:  ${symbols.join(', ').substring(0, 47).padEnd(47)}`) + chalk.cyan('║'));
+  console.log(chalk.cyan('  ║') + chalk.green(` Target:   $${dailyTarget.toLocaleString().padEnd(46)}`) + chalk.cyan('║'));
+  console.log(chalk.cyan('  ║') + chalk.red(` Risk:     $${maxRisk.toLocaleString().padEnd(46)}`) + chalk.cyan('║'));
+  console.log(chalk.cyan('  ╚════════════════════════════════════════════════════════════╝\n'));
+
+  const startConfirm = await prompts.textInput(chalk.cyan('  START TRADING? (Y/n): '));
+  if (startConfirm.toLowerCase() === 'n') {
+    console.log(chalk.yellow('\n  Cancelled.\n'));
+    await prompts.waitForEnter();
+    return;
+  }
+
+  // Launch with custom strategy
+  console.log(chalk.green('\n  Starting custom strategy trading...\n'));
+  
+  // Get front month contracts for each symbol
+  const contracts = [];
+  for (const symbol of symbols) {
+    // Get front month contract from Rithmic API
+    const frontMonth = await service.getFrontMonthContract(symbol);
+    if (frontMonth && frontMonth.success) {
+      contracts.push({
+        name: frontMonth.symbol || symbol,
+        symbol: frontMonth.symbol || symbol,
+        exchange: frontMonth.exchange || 'CME',
+        id: frontMonth.contractId || symbol,
+        tickSize: frontMonth.tickSize,
+        tickValue: frontMonth.tickValue,
+        qty: 1, // Default 1 contract per symbol
+      });
+    } else {
+      // Fallback - use symbol directly
+      contracts.push({
+        name: symbol,
+        symbol: symbol,
+        exchange: 'CME',
+        id: symbol,
+        tickSize: null,
+        tickValue: null,
+        qty: 1,
+      });
+    }
+  }
+
+  if (contracts.length === 0) {
+    console.log(chalk.red('\n  No valid contracts found.\n'));
+    await prompts.waitForEnter();
+    return;
+  }
+
+  // Config for launchMultiSymbolRithmic
+  const config = {
+    dailyTarget,
+    maxRisk,
+    showName: true,
+    enableAI: false, // Custom strategy doesn't need AI supervisor (it IS the AI strategy)
+  };
+
+  // Launch with custom strategy class
+  await launchMultiSymbolRithmic(service, account, contracts, config, StrategyClass);
+}
+
+module.exports = { customStrategyMenu, generateStrategyCode, validateStrategyCode };

package/src/pages/algo/index.js

@@ -9,6 +9,8 @@ const { checkMarketHours } = require('../../services/projectx/market');
 
 const { oneAccountMenu } = require('./one-account');
 const { copyTradingMenu } = require('./copy-trading');
+const { customStrategyMenu } = require('./custom-strategy');
+const aiService = require('../../services/ai');
 
 /**
  * Algo Trading Menu - Simplified
@@ -59,13 +61,23 @@ const algoTradingMenu = async (service) => {
     return chalk.cyan('║') + ' ' + content + ' '.repeat(Math.max(0, padding - 1)) + chalk.cyan('║');
   };
   
+  // Check if AI agent is connected
+  const agents = aiService.getAgents();
+  const hasAgent = agents && agents.length > 0;
+  
   console.clear();
   displayBanner();
   drawBoxHeaderContinue('ALGO TRADING', boxWidth);
   
-  // Centered menu line: numbers in cyan, text in yellow
-  const menuText = chalk.cyan('[1]') + chalk.yellow(' ONE ACCOUNT    ') + chalk.cyan('[2]') + chalk.yellow(' COPY TRADING');
-  const plainLen = '[1] ONE ACCOUNT    [2] COPY TRADING'.length;
+  // Menu options - show CUSTOM STRATEGY only if agent connected
+  let menuText, plainLen;
+  if (hasAgent) {
+    menuText = chalk.cyan('[1]') + chalk.yellow(' ONE ACCOUNT  ') + chalk.cyan('[2]') + chalk.yellow(' COPY TRADING  ') + chalk.cyan('[3]') + chalk.green(' CUSTOM STRATEGY');
+    plainLen = '[1] ONE ACCOUNT  [2] COPY TRADING  [3] CUSTOM STRATEGY'.length;
+  } else {
+    menuText = chalk.cyan('[1]') + chalk.yellow(' ONE ACCOUNT    ') + chalk.cyan('[2]') + chalk.yellow(' COPY TRADING');
+    plainLen = '[1] ONE ACCOUNT    [2] COPY TRADING'.length;
+  }
   const leftPad = Math.floor((W - plainLen) / 2);
   const rightPad = W - plainLen - leftPad;
   console.log(chalk.cyan('║') + ' '.repeat(leftPad) + menuText + ' '.repeat(rightPad) + chalk.cyan('║'));
@@ -92,6 +104,15 @@ const algoTradingMenu = async (service) => {
       await prompts.waitForEnter();
     }
     return algoTradingMenu(service);
+  } else if (choice === '3' && hasAgent) {
+    try {
+      await customStrategyMenu(service);
+    } catch (err) {
+      console.log(chalk.red(`\n  ERROR: ${err.message}`));
+      console.log(chalk.gray(`  ${err.stack}`));
+      await prompts.waitForEnter();
+    }
+    return algoTradingMenu(service);
   }
   
   // Empty or other = back

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

@@ -1428,8 +1428,9 @@ const launchAlgo = async (service, account, contract, config) => {
  * @param {Object} account - Trading account
  * @param {Array} contracts - Array of contracts to trade
  * @param {Object} config - Algo configuration
+ * @param {Function} [CustomStrategyClass] - Optional custom strategy class (if not provided, uses hftStrategy)
  */
-const launchMultiSymbolRithmic = async (service, account, contracts, config) => {
+const launchMultiSymbolRithmic = async (service, account, contracts, config, CustomStrategyClass = null) => {
   const { dailyTarget, maxRisk, showName, enableAI } = config;
   
   const accountName = showName 
@@ -1553,7 +1554,13 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
     const { tickSize, tickValue, contractId } = contractInfoMap[symbolName];
     
     // Create strategy instance for this symbol
-    const strategy = Object.create(hftStrategy);
+    // Use custom strategy class if provided, otherwise use default hftStrategy
+    let strategy;
+    if (CustomStrategyClass) {
+      strategy = new CustomStrategyClass();
+    } else {
+      strategy = Object.create(hftStrategy);
+    }
     if (tickSize !== null && tickValue !== null) {
       strategy.initialize(contractId, tickSize, tickValue);
     }
@@ -2022,78 +2029,58 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
     ]);
     
     try {
-      // Step 1: Cancel all pending orders
+      // CRITICAL: Use ONLY Rithmic API to get REAL positions from exchange
+      // DO NOT use local stats which can be corrupted
+      
+      // Step 1: Cancel all pending orders first
       ui.addLog('info', 'Cancelling all orders...');
       ui.render(stats);
       try {
         if (service && typeof service.cancelAllOrders === 'function') {
           await withTimeout(service.cancelAllOrders(rithmicAccountId), TIMEOUT_MS);
+          ui.addLog('success', 'All orders cancelled');
         }
       } catch (e) {
         ui.addLog('warning', `Cancel orders: ${e.message}`);
       }
       
-      // Step 2: Force close each symbol's position via fastExit
-      ui.addLog('info', 'Closing all positions...');
+      // Step 2: Use Rithmic flattenAll - reads REAL positions from exchange
+      ui.addLog('info', 'Flattening all positions via Rithmic API...');
       ui.render(stats);
       
-      for (const [symbolName, symStats] of Object.entries(stats.symbolStats)) {
-        // Get position from positionManager (more reliable than stats)
-        const pm = positionManagers[symbolName];
-        const pmPosition = pm?.currentPosition;
-        
-        // Use PM position if available, otherwise fallback to stats
-        let posQty = 0;
-        let closeSide = 0;
-        
-        if (pmPosition && pmPosition.size > 0) {
-          posQty = pmPosition.size;
-          closeSide = pmPosition.side === 0 ? 1 : 0; // Sell if long (0), Buy if short (1)
-        } else if (symStats.position && symStats.position !== 0) {
-          // Fallback: use stats but sanitize the value
-          posQty = Math.min(Math.abs(Number(symStats.position) || 0), 10); // Max 10 contracts safety
-          if (posQty === 0) posQty = 1; // Default to 1 if we think there's a position
-          closeSide = symStats.position > 0 ? 1 : 0;
-        }
-        
-        if (posQty === 0) continue;
-        
-        const sideStr = closeSide === 1 ? 'SELL' : 'BUY';
-        
-        ui.addLog('info', `Closing [${symbolName}] ${sideStr} ${posQty}x...`);
-        ui.render(stats);
-        
-        try {
-          // Try fastExit first (fastest)
-          if (service && typeof service.fastExit === 'function') {
-            const result = await withTimeout(service.fastExit({
-              accountId: rithmicAccountId,
-              symbol: symbolName,
-              exchange: contractInfoMap[symbolName]?.exchange || 'CME',
-              size: posQty,
-              side: closeSide,
-            }), TIMEOUT_MS);
-            
-            if (result.success) {
-              ui.addLog('success', `[${symbolName}] FLATTENED`);
-              symStats.position = 0;
-            } else {
-              ui.addLog('error', `[${symbolName}] Exit failed: ${result.error}`);
+      try {
+        if (service && typeof service.flattenAll === 'function') {
+          const result = await withTimeout(service.flattenAll(rithmicAccountId), TIMEOUT_MS);
+          if (result && result.results) {
+            for (const r of result.results) {
+              if (r.success) {
+                ui.addLog('success', `[${r.symbol}] FLATTENED`);
+              } else {
+                ui.addLog('error', `[${r.symbol}] ${r.error || 'Failed'}`);
+              }
             }
           }
-        } catch (e) {
-          ui.addLog('error', `[${symbolName}] Exit error: ${e.message}`);
+          ui.addLog('success', 'Flatten all complete');
+        } else if (service && typeof service.emergencyStop === 'function') {
+          // Fallback to emergencyStop
+          await withTimeout(service.emergencyStop(rithmicAccountId), TIMEOUT_MS);
+          ui.addLog('success', 'Emergency stop complete');
         }
+      } catch (e) {
+        ui.addLog('warning', `Flatten: ${e.message}`);
       }
       
-      // Step 3: Fallback - call service.emergencyStop for any remaining
-      try {
-        if (service && typeof service.emergencyStop === 'function') {
-          await withTimeout(service.emergencyStop(rithmicAccountId), TIMEOUT_MS);
+      // Step 3: Reset local state
+      for (const [symbolName, symStats] of Object.entries(stats.symbolStats)) {
+        symStats.position = 0;
+        symStats.openPnl = 0;
+        // Also reset position manager
+        const pm = positionManagers[symbolName];
+        if (pm) {
+          try { pm.reset?.(); } catch {}
         }
-      } catch (e) {
-        // Silent - already tried individual closes
       }
+      stats.openPnl = 0;
       
       ui.addLog('success', '████ EMERGENCY STOP COMPLETE ████');
       
@@ -2207,4 +2194,4 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
   await prompts.waitForEnter();
 };
 
-module.exports = { oneAccountMenu };
+module.exports = { oneAccountMenu, launchMultiSymbolRithmic };