hedgequantx 2.9.50 → 2.9.52

package/package.json

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

package/src/lib/smart-logs.js

@@ -0,0 +1,419 @@
+/**
+ * =============================================================================
+ * Smart Logging System
+ * =============================================================================
+ * Non-repetitive, contextual, varied log messages
+ * - Uses message pools to avoid repetition
+ * - Tracks recent messages to ensure variety
+ * - Provides market-context-aware messages
+ */
+
+'use strict';
+
+// Track recently used messages to avoid repetition
+const recentMessages = new Map();
+const MAX_RECENT = 5;
+
+/**
+ * Get a message from a pool, avoiding recent ones
+ */
+function getVariedMessage(category, pool, defaultMsg) {
+  const recent = recentMessages.get(category) || [];
+
+  // Filter out recently used messages
+  const available = pool.filter(msg => !recent.includes(msg));
+
+  // If all messages were recently used, reset
+  if (available.length === 0) {
+    recentMessages.set(category, []);
+    return pool[Math.floor(Math.random() * pool.length)] || defaultMsg;
+  }
+
+  // Pick a random available message
+  const chosen = available[Math.floor(Math.random() * available.length)] || defaultMsg;
+
+  // Track it
+  recent.push(chosen);
+  if (recent.length > MAX_RECENT) recent.shift();
+  recentMessages.set(category, recent);
+
+  return chosen;
+}
+
+// =============================================================================
+// MESSAGE POOLS - Market Flow
+// =============================================================================
+
+const LONG_BIAS_MESSAGES = [
+  'Bullish bias detected',
+  'Buyers in control',
+  'Long-side pressure',
+  'Bid accumulation',
+  'Buy programs active',
+];
+
+const SHORT_BIAS_MESSAGES = [
+  'Bearish bias detected',
+  'Sellers in control',
+  'Short-side pressure',
+  'Offer distribution',
+  'Sell programs active',
+];
+
+const FLAT_BIAS_MESSAGES = [
+  'Market balanced',
+  'Two-way flow',
+  'Consolidation mode',
+  'No clear direction',
+  'Mixed signals',
+];
+
+// =============================================================================
+// MESSAGE POOLS - Trading Events
+// =============================================================================
+
+const SIGNAL_LONG_MESSAGES = [
+  'Buy signal generated',
+  'Long opportunity detected',
+  'Bullish setup confirmed',
+  'Entry signal: LONG',
+  'Buy zone activated',
+];
+
+const SIGNAL_SHORT_MESSAGES = [
+  'Sell signal generated',
+  'Short opportunity detected',
+  'Bearish setup confirmed',
+  'Entry signal: SHORT',
+  'Sell zone activated',
+];
+
+const ENTRY_LONG_MESSAGES = [
+  'Long position opened',
+  'Buy order filled',
+  'Entered long',
+  'Long initiated',
+  'Position: LONG',
+];
+
+const ENTRY_SHORT_MESSAGES = [
+  'Short position opened',
+  'Sell order filled',
+  'Entered short',
+  'Short initiated',
+  'Position: SHORT',
+];
+
+const EXIT_PROFIT_MESSAGES = [
+  'Target reached',
+  'Profit taken',
+  'Winner closed',
+  'TP hit',
+  'Profit locked',
+];
+
+const EXIT_LOSS_MESSAGES = [
+  'Stop triggered',
+  'Loss taken',
+  'Loser closed',
+  'SL hit',
+  'Risk contained',
+];
+
+// =============================================================================
+// MESSAGE POOLS - Analysis
+// =============================================================================
+
+const ZONE_APPROACH_MESSAGES = [
+  'Approaching key level',
+  'Zone test incoming',
+  'Near decision point',
+  'Level approach detected',
+  'Key zone in range',
+];
+
+const ZONE_CONFIRMED_MESSAGES = [
+  'Zone confirmation',
+  'Level validated',
+  'Support/resistance active',
+  'Zone reaction detected',
+  'Level holding',
+];
+
+const HIGH_VOLATILITY_MESSAGES = [
+  'Volatility elevated',
+  'High ATR detected',
+  'Increased price range',
+  'Market volatile',
+  'Wide swings detected',
+];
+
+const LOW_VOLATILITY_MESSAGES = [
+  'Low volatility',
+  'Tight range detected',
+  'Compressed price action',
+  'Market quiet',
+  'Narrow swings',
+];
+
+// =============================================================================
+// MESSAGE POOLS - Risk
+// =============================================================================
+
+const RISK_PASSED_MESSAGES = [
+  'Risk check passed',
+  'Trade approved',
+  'Within risk limits',
+  'Risk validated',
+  'Clear to trade',
+];
+
+const RISK_BLOCKED_MESSAGES = [
+  'Risk limit reached',
+  'Trade blocked',
+  'Exceeds risk threshold',
+  'Risk rejected',
+  'Waiting for conditions',
+];
+
+// =============================================================================
+// MESSAGE POOLS - Status
+// =============================================================================
+
+const SCANNING_MESSAGES = [
+  'Scanning market...',
+  'Analyzing flow...',
+  'Monitoring structure...',
+  'Watching for setups...',
+  'Evaluating conditions...',
+];
+
+const WAITING_MESSAGES = [
+  'Waiting for confirmation...',
+  'Pending trigger...',
+  'Standby mode...',
+  'Awaiting signal...',
+  'Ready to act...',
+];
+
+// =============================================================================
+// MESSAGE POOLS - Tick Flow
+// =============================================================================
+
+const TICK_FLOW_MESSAGES = [
+  'Processing tick data',
+  'Market data flowing',
+  'Live feed active',
+  'Tick stream healthy',
+  'Data streaming',
+];
+
+const BUILDING_BARS_MESSAGES = [
+  'Building price bars',
+  'Aggregating ticks',
+  'Forming candles',
+  'Bar construction',
+  'Chart building',
+];
+
+const MODEL_ANALYSIS_MESSAGES = [
+  'Running models',
+  'Analyzing patterns',
+  'Computing signals',
+  'Model evaluation',
+  'Strategy analysis',
+];
+
+// =============================================================================
+// SMART LOG GENERATORS
+// =============================================================================
+
+/**
+ * Get a market bias log
+ */
+function getMarketBiasLog(direction, delta, buyPressure) {
+  let pool;
+  switch (direction) {
+    case 'LONG': pool = LONG_BIAS_MESSAGES; break;
+    case 'SHORT': pool = SHORT_BIAS_MESSAGES; break;
+    default: pool = FLAT_BIAS_MESSAGES;
+  }
+
+  const message = getVariedMessage(`bias_${direction}`, pool, `${direction} bias`);
+  const arrow = direction === 'LONG' ? '▲' : direction === 'SHORT' ? '▼' : '=';
+
+  let details;
+  if (delta !== undefined && buyPressure !== undefined) {
+    details = `${arrow} delta: ${delta > 0 ? '+' : ''}${delta} | buy: ${buyPressure.toFixed(0)}%`;
+  }
+
+  return { message, details };
+}
+
+/**
+ * Get a signal log
+ */
+function getSignalLog(direction, symbol, confidence, strategy) {
+  const pool = direction === 'LONG' ? SIGNAL_LONG_MESSAGES : SIGNAL_SHORT_MESSAGES;
+  const message = getVariedMessage(`signal_${direction}`, pool, `${direction} signal`);
+  const arrow = direction === 'LONG' ? '▲' : '▼';
+
+  return {
+    message: `${arrow} ${message}`,
+    details: `${symbol} | ${confidence.toFixed(0)}% | ${strategy}`,
+  };
+}
+
+/**
+ * Get an entry log
+ */
+function getEntryLog(direction, symbol, size, price) {
+  const pool = direction === 'LONG' ? ENTRY_LONG_MESSAGES : ENTRY_SHORT_MESSAGES;
+  const message = getVariedMessage(`entry_${direction}`, pool, `${direction} entry`);
+  const arrow = direction === 'LONG' ? '▲' : '▼';
+
+  return {
+    message: `${arrow} ${message}`,
+    details: `${size}x ${symbol} @ ${price.toFixed(2)}`,
+  };
+}
+
+/**
+ * Get an exit log
+ */
+function getExitLog(isProfit, symbol, size, price, pnl) {
+  const pool = isProfit ? EXIT_PROFIT_MESSAGES : EXIT_LOSS_MESSAGES;
+  const category = isProfit ? 'exit_profit' : 'exit_loss';
+  const message = getVariedMessage(category, pool, isProfit ? 'Profit taken' : 'Loss taken');
+  const pnlStr = pnl >= 0 ? `+$${pnl.toFixed(2)}` : `-$${Math.abs(pnl).toFixed(2)}`;
+
+  return {
+    message,
+    details: `${size}x ${symbol} @ ${price.toFixed(2)} | ${pnlStr}`,
+  };
+}
+
+/**
+ * Get a zone approach log
+ */
+function getZoneApproachLog(zoneType, level) {
+  const message = getVariedMessage('zone_approach', ZONE_APPROACH_MESSAGES, 'Zone approach');
+  return { message, details: `${zoneType} @ ${level.toFixed(2)}` };
+}
+
+/**
+ * Get a zone confirmation log
+ */
+function getZoneConfirmationLog(zoneType, level) {
+  const message = getVariedMessage('zone_confirm', ZONE_CONFIRMED_MESSAGES, 'Zone confirmed');
+  return { message, details: `${zoneType} @ ${level.toFixed(2)}` };
+}
+
+/**
+ * Get a volatility log
+ */
+function getVolatilityLog(isHigh, atr) {
+  const pool = isHigh ? HIGH_VOLATILITY_MESSAGES : LOW_VOLATILITY_MESSAGES;
+  const category = isHigh ? 'vol_high' : 'vol_low';
+  const message = getVariedMessage(category, pool, isHigh ? 'High volatility' : 'Low volatility');
+  return { message, details: atr ? `ATR: ${atr.toFixed(2)}` : undefined };
+}
+
+/**
+ * Get a risk check log
+ */
+function getRiskCheckLog(passed, reason) {
+  const pool = passed ? RISK_PASSED_MESSAGES : RISK_BLOCKED_MESSAGES;
+  const category = passed ? 'risk_pass' : 'risk_block';
+  const message = getVariedMessage(category, pool, passed ? 'Passed' : 'Blocked');
+  return { message, details: reason };
+}
+
+/**
+ * Get a scanning/waiting log
+ */
+function getScanningLog(isScanning = true) {
+  const pool = isScanning ? SCANNING_MESSAGES : WAITING_MESSAGES;
+  const category = isScanning ? 'scanning' : 'waiting';
+  const message = getVariedMessage(category, pool, isScanning ? 'Scanning...' : 'Waiting...');
+  return { message };
+}
+
+/**
+ * Get tick flow log
+ */
+function getTickFlowLog(tickCount, ticksPerSecond) {
+  const message = getVariedMessage('tick_flow', TICK_FLOW_MESSAGES, 'Tick flow');
+  return { message, details: `#${tickCount} | ${ticksPerSecond}/sec` };
+}
+
+/**
+ * Get building bars log
+ */
+function getBuildingBarsLog(barCount) {
+  const message = getVariedMessage('building_bars', BUILDING_BARS_MESSAGES, 'Building bars');
+  return { message, details: `${barCount} bars` };
+}
+
+/**
+ * Get model analysis log
+ */
+function getModelAnalysisLog(modelValues) {
+  const message = getVariedMessage('model_analysis', MODEL_ANALYSIS_MESSAGES, 'Analyzing');
+  const details = modelValues 
+    ? `Z:${modelValues.zscore} | VPIN:${modelValues.vpin} | OFI:${modelValues.ofi}`
+    : undefined;
+  return { message, details };
+}
+
+/**
+ * Get position update log with varied messaging
+ */
+function getPositionUpdateLog(side, size, unrealizedPnL, distanceToStop, distanceToTarget, holdTime) {
+  const arrow = side === 'LONG' ? '▲' : '▼';
+  const pnlStr = unrealizedPnL >= 0 ? `+$${unrealizedPnL.toFixed(2)}` : `-$${Math.abs(unrealizedPnL).toFixed(2)}`;
+
+  // Vary the message based on P&L status
+  let prefix;
+  if (unrealizedPnL > 0 && distanceToTarget < distanceToStop) {
+    const targetPct = Math.round((1 - distanceToTarget / (distanceToStop + distanceToTarget)) * 100);
+    prefix = targetPct > 75 ? 'Near target' : targetPct > 50 ? 'Running profit' : 'In profit';
+  } else if (unrealizedPnL < 0 && distanceToStop < distanceToTarget) {
+    const risk = Math.round((1 - distanceToStop / (distanceToStop + distanceToTarget)) * 100);
+    prefix = risk > 75 ? 'Stop risk' : risk > 50 ? 'Underwater' : 'Managing loss';
+  } else if (Math.abs(unrealizedPnL) < 5) {
+    prefix = 'Near entry';
+  } else {
+    prefix = unrealizedPnL > 0 ? 'In profit' : 'Managing';
+  }
+
+  return {
+    message: `${arrow} ${side} ${size}x`,
+    details: `${prefix}: ${pnlStr} | SL: ${distanceToStop.toFixed(0)}t | TP: ${distanceToTarget.toFixed(0)}t | ${holdTime}s`,
+  };
+}
+
+/**
+ * Get price change log
+ */
+function getPriceChangeLog(direction, price, change) {
+  const arrow = direction === 'UP' ? '▲' : '▼';
+  return { message: `${arrow} ${price.toFixed(2)}`, details: `${direction} ${change.toFixed(2)}` };
+}
+
+module.exports = {
+  getMarketBiasLog,
+  getSignalLog,
+  getEntryLog,
+  getExitLog,
+  getZoneApproachLog,
+  getZoneConfirmationLog,
+  getVolatilityLog,
+  getRiskCheckLog,
+  getScanningLog,
+  getTickFlowLog,
+  getBuildingBarsLog,
+  getModelAnalysisLog,
+  getPositionUpdateLog,
+  getPriceChangeLog,
+};

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

@@ -9,6 +9,7 @@ const { AlgoUI, renderSessionSummary } = require('./ui');
 const { loadStrategy } = require('../../lib/m');
 const { MarketDataFeed } = require('../../lib/data');
 const { SupervisionEngine } = require('../../services/ai-supervision');
+const smartLogs = require('../../lib/smart-logs');
 
 /**
  * Execute algo strategy with market data
@@ -37,7 +38,8 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   const accountName = showName 
     ? (account.accountName || account.rithmicAccountId || account.accountId) 
     : 'HQX *****';
-  const symbolName = contract.name;
+  const symbolName = contract.name;  // Display name: "Micro E-mini S&P 500"
+  const symbolCode = contract.symbol || contract.id;  // Rithmic symbol: "MESH6"
   const contractId = contract.id;
   const tickSize = contract.tickSize || 0.25;
   
@@ -93,18 +95,24 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   
   // Handle strategy signals
   strategy.on('signal', async (signal) => {
-    ui.addLog('info', `SIGNAL DETECTED: ${signal.direction?.toUpperCase()}`);
+    const dir = signal.direction?.toUpperCase() || 'UNKNOWN';
+    const signalLog = smartLogs.getSignalLog(dir, symbolCode, (signal.confidence || 0) * 100, strategyName);
+    ui.addLog('info', `${signalLog.message}`);
+    ui.addLog('info', signalLog.details);
     
     if (!running) {
-      ui.addLog('info', 'Signal ignored: not running');
+      const riskLog = smartLogs.getRiskCheckLog(false, 'Algo stopped');
+      ui.addLog('info', riskLog.message);
       return;
     }
     if (pendingOrder) {
-      ui.addLog('info', 'Signal ignored: order pending');
+      const riskLog = smartLogs.getRiskCheckLog(false, 'Order pending');
+      ui.addLog('info', riskLog.message);
       return;
     }
     if (currentPosition !== 0) {
-      ui.addLog('info', `Signal ignored: position open (${currentPosition})`);
+      const riskLog = smartLogs.getRiskCheckLog(false, `Position open (${currentPosition})`);
+      ui.addLog('info', riskLog.message);
       return;
     }
     
@@ -114,7 +122,8 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
     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)}%)`);
+    const riskLog = smartLogs.getRiskCheckLog(true, `${direction.toUpperCase()} @ ${entry.toFixed(2)}`);
+    ui.addLog('info', `${riskLog.message} - ${riskLog.details}`);
     
     // Multi-Agent AI Supervision
     if (supervisionEnabled && supervisionEngine) {
@@ -173,8 +182,9 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
       if (orderResult.success) {
         currentPosition = direction === 'long' ? orderSize : -orderSize;
         stats.trades++;
-        ui.addLog('fill_' + (direction === 'long' ? 'buy' : 'sell'), 
-          `OPENED ${direction.toUpperCase()} ${orderSize}x @ market`);
+        const entryLog = smartLogs.getEntryLog(direction.toUpperCase(), symbolCode, orderSize, entry);
+        ui.addLog('fill_' + (direction === 'long' ? 'buy' : 'sell'), entryLog.message);
+        ui.addLog('info', entryLog.details);
         
         // Bracket orders
         if (stopLoss && takeProfit) {
@@ -203,6 +213,10 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   let lastAsk = null;
   let ticksPerSecond = 0;
   let lastTickSecond = Math.floor(Date.now() / 1000);
+  let lastLogSecond = 0;
+  let buyVolume = 0;
+  let sellVolume = 0;
+  let barCount = 0;
   
   marketFeed.on('tick', (tick) => {
     tickCount++;
@@ -220,32 +234,69 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
     aiContext.recentTicks.push(tick);
     if (aiContext.recentTicks.length > aiContext.maxTicks) aiContext.recentTicks.shift();
     
-    // Smart logs for tick flow
     const price = tick.price || tick.tradePrice;
     const bid = tick.bid || tick.bidPrice;
     const ask = tick.ask || tick.askPrice;
+    const volume = tick.volume || tick.size || 1;
+    
+    // Track buy/sell volume
+    if (tick.side === 'buy' || tick.aggressor === 1) buyVolume += volume;
+    else if (tick.side === 'sell' || tick.aggressor === 2) sellVolume += volume;
+    else if (price && lastPrice) {
+      if (price > lastPrice) buyVolume += volume;
+      else if (price < lastPrice) sellVolume += volume;
+    }
     
     // Log first tick
     if (tickCount === 1) {
-      ui.addLog('info', `First tick received @ ${price?.toFixed(2) || 'N/A'}`);
-      ui.addLog('info', `Tick type: ${tick.type || 'unknown'}`);
+      ui.addLog('connected', `First tick @ ${price?.toFixed(2) || 'N/A'}`);
     }
     
-    // Log price changes
-    if (price && lastPrice && price !== lastPrice) {
-      const direction = price > lastPrice ? 'UP' : 'DOWN';
-      const change = Math.abs(price - lastPrice).toFixed(2);
-      if (tickCount <= 10 || tickCount % 50 === 0) {
-        ui.addLog('info', `Price ${direction} ${change} -> ${price.toFixed(2)}`);
+    // === SMART LOGS EVERY SECOND ===
+    if (currentSecond !== lastLogSecond && tickCount > 1) {
+      lastLogSecond = currentSecond;
+      
+      const totalVol = buyVolume + sellVolume;
+      const buyPressure = totalVol > 0 ? (buyVolume / totalVol) * 100 : 50;
+      const delta = buyVolume - sellVolume;
+      
+      // Determine market bias
+      let bias = 'FLAT';
+      if (buyPressure > 55) bias = 'LONG';
+      else if (buyPressure < 45) bias = 'SHORT';
+      
+      // Get smart log for market bias
+      const biasLog = smartLogs.getMarketBiasLog(bias, delta, buyPressure);
+      ui.addLog('info', `${biasLog.message} ${biasLog.details || ''}`);
+      
+      // Get model values if available
+      const modelValues = strategy.getModelValues?.(contractId);
+      if (modelValues) {
+        barCount = modelValues.bars || barCount;
+        if (barCount >= 50) {
+          const modelLog = smartLogs.getModelAnalysisLog(modelValues);
+          ui.addLog('info', `${modelLog.message} ${modelLog.details || ''}`);
+        } else {
+          const barLog = smartLogs.getBuildingBarsLog(barCount);
+          ui.addLog('info', `${barLog.message} (${barLog.details})`);
+        }
       }
-    }
-    
-    // Log bid/ask spread
-    if (bid && ask && (bid !== lastBid || ask !== lastAsk)) {
-      const spread = (ask - bid).toFixed(2);
-      if (tickCount <= 5) {
-        ui.addLog('info', `Spread: ${spread} (Bid: ${bid.toFixed(2)} / Ask: ${ask.toFixed(2)})`);
+      
+      // Scanning log every 3 seconds
+      if (currentSecond % 3 === 0 && currentPosition === 0) {
+        const scanLog = smartLogs.getScanningLog(true);
+        ui.addLog('info', scanLog.message);
+      }
+      
+      // Tick flow log every 5 seconds
+      if (currentSecond % 5 === 0) {
+        const tickLog = smartLogs.getTickFlowLog(tickCount, ticksPerSecond);
+        ui.addLog('info', `${tickLog.message} ${tickLog.details}`);
       }
+      
+      // Reset volume counters
+      buyVolume = 0;
+      sellVolume = 0;
     }
     
     lastPrice = price;
@@ -255,19 +306,12 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
     strategy.processTick({
       contractId: tick.contractId || contractId,
       price: price, bid: bid, ask: ask,
-      volume: tick.volume || tick.size || 1, 
+      volume: volume, 
       side: tick.side || tick.lastTradeSide || 'unknown',
       timestamp: tick.timestamp || Date.now()
     });
     
     stats.latency = Date.now() - latencyStart;
-    
-    // Periodic status logs
-    if (tickCount === 10) ui.addLog('info', `Receiving ticks... (${ticksPerSecond}/sec)`);
-    if (tickCount === 50) ui.addLog('info', `50 ticks processed, strategy analyzing...`);
-    if (tickCount % 200 === 0) {
-      ui.addLog('info', `Tick #${tickCount} @ ${price?.toFixed(2) || 'N/A'} | ${ticksPerSecond}/sec`);
-    }
   });
   
   marketFeed.on('connected', () => { 
@@ -287,7 +331,8 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
       throw new Error('Rithmic credentials not available');
     }
     await marketFeed.connect(rithmicCredentials);
-    await marketFeed.subscribe(symbolName, contract.exchange || 'CME');
+    await marketFeed.subscribe(symbolCode, contract.exchange || 'CME');
+    ui.addLog('info', `Symbol code: ${symbolCode}`);
   } catch (e) {
     ui.addLog('error', `Failed to connect: ${e.message}`);
   }

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

@@ -14,6 +14,7 @@ const { getActiveAgentCount, getSupervisionConfig, getActiveAgents } = require('
 const { launchCopyTrading } = require('./copy-executor');
 const { runPreflightCheck, formatPreflightResults, getPreflightSummary } = require('../../services/ai-supervision');
 const { getAvailableStrategies } = require('../../lib/m');
+const { getLastCopyTradingConfig, saveCopyTradingConfig } = require('../../services/algo-config');
 
 /**
  * Copy Trading Menu
@@ -54,6 +55,98 @@ const copyTradingMenu = async () => {
   
   spinner.succeed(`Found ${activeAccounts.length} active accounts`);
   
+  // Check for saved config
+  const lastConfig = getLastCopyTradingConfig();
+  
+  if (lastConfig) {
+    // Try to find matching accounts
+    const matchingLead = activeAccounts.find(acc => 
+      acc.accountId === lastConfig.leadAccountId || 
+      acc.accountName === lastConfig.leadAccountName
+    );
+    
+    if (matchingLead && lastConfig.followerAccountIds?.length > 0) {
+      const matchingFollowers = lastConfig.followerAccountIds
+        .map(id => activeAccounts.find(acc => acc.accountId === id || acc.accountName === id))
+        .filter(Boolean);
+      
+      if (matchingFollowers.length > 0) {
+        console.log();
+        console.log(chalk.cyan('  Last configuration found:'));
+        console.log(chalk.gray(`    Lead: ${lastConfig.leadAccountName} (${lastConfig.leadPropfirm})`));
+        console.log(chalk.gray(`    Followers: ${matchingFollowers.length} account(s)`));
+        console.log(chalk.gray(`    Symbol: ${lastConfig.symbol}`));
+        console.log(chalk.gray(`    Strategy: ${lastConfig.strategyName}`));
+        console.log(chalk.gray(`    Lead contracts: ${lastConfig.leadContracts} | Follower: ${lastConfig.followerContracts}`));
+        console.log(chalk.gray(`    Target: $${lastConfig.dailyTarget} | Risk: $${lastConfig.maxRisk}`));
+        console.log();
+        
+        const reuseConfig = await prompts.confirmPrompt('Use last configuration?', true);
+        
+        if (reuseConfig) {
+          // Load contracts to find symbol
+          const leadService = matchingLead.service || connections.getServiceForAccount(matchingLead.accountId);
+          const contractsResult = await leadService.getContracts();
+          const contract = contractsResult.success 
+            ? contractsResult.contracts.find(c => c.symbol === lastConfig.symbol)
+            : null;
+          
+          // Find strategy
+          const strategies = getAvailableStrategies();
+          const strategy = strategies.find(s => s.id === lastConfig.strategyId);
+          
+          if (contract && strategy) {
+            console.log(chalk.green('  ✓ Configuration loaded'));
+            
+            // Check for AI Supervision
+            const agentCount = getActiveAgentCount();
+            let supervisionConfig = null;
+            
+            if (agentCount > 0) {
+              console.log();
+              console.log(chalk.cyan(`  ${agentCount} AI Agent(s) available for supervision`));
+              const enableAI = await prompts.confirmPrompt('Enable AI Supervision?', true);
+              
+              if (enableAI) {
+                const agents = getActiveAgents();
+                const preflightResults = await runPreflightCheck(agents);
+                const lines = formatPreflightResults(preflightResults, 60);
+                for (const line of lines) console.log(line);
+                const summary = getPreflightSummary(preflightResults);
+                console.log();
+                console.log(`  ${summary.text}`);
+                
+                if (!preflightResults.success) {
+                  console.log(chalk.red('  Cannot start algo - fix agent connections first.'));
+                  await prompts.waitForEnter();
+                  return;
+                }
+                supervisionConfig = getSupervisionConfig();
+              }
+            }
+            
+            const confirm = await prompts.confirmPrompt('Start Copy Trading?', true);
+            if (!confirm) return;
+            
+            await launchCopyTrading({
+              lead: { account: matchingLead, contracts: lastConfig.leadContracts },
+              followers: matchingFollowers.map(f => ({ account: f, contracts: lastConfig.followerContracts })),
+              contract,
+              strategy,
+              dailyTarget: lastConfig.dailyTarget,
+              maxRisk: lastConfig.maxRisk,
+              showNames: lastConfig.showNames,
+              supervisionConfig
+            });
+            return;
+          } else {
+            console.log(chalk.yellow('  Symbol or strategy no longer available, please reconfigure'));
+          }
+        }
+      }
+    }
+  }
+  
   // Step 1: Select LEAD Account
   console.log();
   console.log(chalk.cyan.bold('  STEP 1: SELECT LEAD ACCOUNT'));
@@ -204,6 +297,22 @@ const copyTradingMenu = async () => {
   const confirm = await prompts.confirmPrompt('Start Copy Trading?', true);
   if (!confirm) return;
   
+  // Save config for next time
+  saveCopyTradingConfig({
+    leadAccountId: leadAccount.accountId || leadAccount.rithmicAccountId,
+    leadAccountName: leadAccount.accountName || leadAccount.rithmicAccountId || leadAccount.accountId,
+    leadPropfirm: leadAccount.propfirm || leadAccount.platform || 'Unknown',
+    followerAccountIds: followers.map(f => f.accountId || f.rithmicAccountId),
+    symbol: contract.symbol,
+    strategyId: strategy.id,
+    strategyName: strategy.name,
+    leadContracts,
+    followerContracts,
+    dailyTarget,
+    maxRisk,
+    showNames
+  });
+  
   await launchCopyTrading({
     lead: { account: leadAccount, contracts: leadContracts },
     followers: followers.map(f => ({ account: f, contracts: followerContracts })),

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

@@ -13,6 +13,7 @@ const { executeAlgo } = require('./algo-executor');
 const { getActiveAgentCount, getSupervisionConfig, getActiveAgents } = require('../ai-agents');
 const { runPreflightCheck, formatPreflightResults, getPreflightSummary } = require('../../services/ai-supervision');
 const { getAvailableStrategies } = require('../../lib/m');
+const { getLastOneAccountConfig, saveOneAccountConfig } = require('../../services/algo-config');
 
 
 
@@ -54,37 +55,112 @@ const oneAccountMenu = async (service) => {
   
   spinner.succeed(`Found ${activeAccounts.length} active account(s)`);
   
-  // Select account - display RAW API fields
-  const options = activeAccounts.map(acc => {
-    // Use what API returns: rithmicAccountId or accountName for Rithmic
-    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
-    };
-  });
-  options.push({ label: '< Back', value: 'back' });
-  
-  const selectedAccount = await prompts.selectOption('Select Account:', options);
-  if (!selectedAccount || selectedAccount === 'back') return;
-  
-  // Use the service attached to the account (from getAllAccounts), fallback to getServiceForAccount
-  const accountService = selectedAccount.service || connections.getServiceForAccount(selectedAccount.accountId) || service;
-  
-  // Select symbol
-  const contract = await selectSymbol(accountService, selectedAccount);
-  if (!contract) return;
-  
-  // Select strategy
-  const strategy = await selectStrategy();
-  if (!strategy) return;
+  // Check for saved config
+  const lastConfig = getLastOneAccountConfig();
+  let selectedAccount = null;
+  let contract = null;
+  let strategy = null;
+  let config = null;
+  let accountService = null;
+  
+  if (lastConfig) {
+    // Try to find matching account and offer to reuse config
+    const matchingAccount = activeAccounts.find(acc => 
+      acc.accountId === lastConfig.accountId || 
+      acc.rithmicAccountId === lastConfig.accountId ||
+      acc.accountName === lastConfig.accountName
+    );
+    
+    if (matchingAccount) {
+      console.log();
+      console.log(chalk.cyan('  Last configuration found:'));
+      console.log(chalk.gray(`    Account: ${lastConfig.accountName} (${lastConfig.propfirm})`));
+      console.log(chalk.gray(`    Symbol: ${lastConfig.symbol}`));
+      console.log(chalk.gray(`    Strategy: ${lastConfig.strategyName}`));
+      console.log(chalk.gray(`    Contracts: ${lastConfig.contracts} | Target: $${lastConfig.dailyTarget} | Risk: $${lastConfig.maxRisk}`));
+      console.log();
+      
+      const reuseConfig = await prompts.confirmPrompt('Use last configuration?', true);
+      
+      if (reuseConfig) {
+        selectedAccount = matchingAccount;
+        accountService = selectedAccount.service || connections.getServiceForAccount(selectedAccount.accountId) || service;
+        
+        // Load contracts to find the saved symbol
+        const contractsResult = await accountService.getContracts();
+        if (contractsResult.success) {
+          contract = contractsResult.contracts.find(c => c.symbol === lastConfig.symbol);
+        }
+        
+        // Find strategy
+        const strategies = getAvailableStrategies();
+        strategy = strategies.find(s => s.id === lastConfig.strategyId);
+        
+        // Restore config
+        if (contract && strategy) {
+          config = {
+            contracts: lastConfig.contracts,
+            dailyTarget: lastConfig.dailyTarget,
+            maxRisk: lastConfig.maxRisk,
+            showName: lastConfig.showName
+          };
+          console.log(chalk.green('  ✓ Configuration loaded'));
+        } else {
+          console.log(chalk.yellow('  Symbol or strategy no longer available, please reconfigure'));
+          selectedAccount = null;
+        }
+      }
+    }
+  }
   
-  // Configure algo
-  const config = await configureAlgo(selectedAccount, contract, strategy);
-  if (!config) return;
+  // If no saved config used, go through normal selection
+  if (!selectedAccount) {
+    // Select account - display RAW API fields
+    const options = activeAccounts.map(acc => {
+      // Use what API returns: rithmicAccountId or accountName for Rithmic
+      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
+      };
+    });
+    options.push({ label: '< Back', value: 'back' });
+    
+    selectedAccount = await prompts.selectOption('Select Account:', options);
+    if (!selectedAccount || selectedAccount === 'back') return;
+    
+    // Use the service attached to the account (from getAllAccounts), fallback to getServiceForAccount
+    accountService = selectedAccount.service || connections.getServiceForAccount(selectedAccount.accountId) || service;
+    
+    // Select symbol
+    contract = await selectSymbol(accountService, selectedAccount);
+    if (!contract) return;
+    
+    // Select strategy
+    strategy = await selectStrategy();
+    if (!strategy) return;
+    
+    // Configure algo
+    config = await configureAlgo(selectedAccount, contract, strategy);
+    if (!config) return;
+    
+    // Save config for next time
+    saveOneAccountConfig({
+      accountId: selectedAccount.accountId || selectedAccount.rithmicAccountId,
+      accountName: selectedAccount.accountName || selectedAccount.rithmicAccountId || selectedAccount.accountId,
+      propfirm: selectedAccount.propfirm || selectedAccount.platform || 'Unknown',
+      symbol: contract.symbol,
+      strategyId: strategy.id,
+      strategyName: strategy.name,
+      contracts: config.contracts,
+      dailyTarget: config.dailyTarget,
+      maxRisk: config.maxRisk,
+      showName: config.showName
+    });
+  }
   
   // Check for AI Supervision BEFORE asking to start
   const agentCount = getActiveAgentCount();

package/src/services/algo-config.js

@@ -0,0 +1,102 @@
+/**
+ * Algo Config Storage - Persist algo configuration between sessions
+ * Saves to ~/.hqx/algo-config.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.hqx');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'algo-config.json');
+
+/**
+ * Ensure config directory exists
+ */
+const ensureConfigDir = () => {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+};
+
+/**
+ * Load saved config
+ * @returns {Object|null} Saved config or null
+ */
+const loadConfig = () => {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const data = fs.readFileSync(CONFIG_FILE, 'utf8');
+      return JSON.parse(data);
+    }
+  } catch (e) {
+    // Ignore errors, return null
+  }
+  return null;
+};
+
+/**
+ * Save config
+ * @param {Object} config - Config to save
+ */
+const saveConfig = (config) => {
+  try {
+    ensureConfigDir();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+  } catch (e) {
+    // Ignore save errors
+  }
+};
+
+/**
+ * Get last config for one-account mode
+ * @returns {Object|null}
+ */
+const getLastOneAccountConfig = () => {
+  const config = loadConfig();
+  return config?.oneAccount || null;
+};
+
+/**
+ * Save one-account config
+ * @param {Object} data - { accountId, accountName, propfirm, symbol, strategyId, contracts, dailyTarget, maxRisk, showName }
+ */
+const saveOneAccountConfig = (data) => {
+  const config = loadConfig() || {};
+  config.oneAccount = {
+    ...data,
+    savedAt: Date.now()
+  };
+  saveConfig(config);
+};
+
+/**
+ * Get last config for copy-trading mode
+ * @returns {Object|null}
+ */
+const getLastCopyTradingConfig = () => {
+  const config = loadConfig();
+  return config?.copyTrading || null;
+};
+
+/**
+ * Save copy-trading config
+ * @param {Object} data - { masterAccountId, followerAccountIds, symbol, strategyId, contracts, dailyTarget, maxRisk }
+ */
+const saveCopyTradingConfig = (data) => {
+  const config = loadConfig() || {};
+  config.copyTrading = {
+    ...data,
+    savedAt: Date.now()
+  };
+  saveConfig(config);
+};
+
+module.exports = {
+  loadConfig,
+  saveConfig,
+  getLastOneAccountConfig,
+  saveOneAccountConfig,
+  getLastCopyTradingConfig,
+  saveCopyTradingConfig,
+};