hedgequantx 2.5.36 → 2.5.37

package/package.json

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

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

@@ -16,6 +16,10 @@ const { M1 } = require('../../../dist/lib/m/s1');
 const { MarketDataFeed } = require('../../../dist/lib/data');
 const { algoLogger } = require('./logger');
 
+// AI Strategy Supervisor - observes, learns, and optimizes the strategy
+const aiService = require('../../services/ai');
+const StrategySupervisor = require('../../services/ai/strategy-supervisor');
+
 
 
 /**
@@ -167,6 +171,7 @@ const configureAlgo = async (account, contract) => {
 /**
  * Launch algo trading - HQX Ultra Scalping Strategy
  * Real-time market data + Strategy signals + Auto order execution
+ * AI Supervision: All connected agents monitor and supervise trading
  */
 const launchAlgo = async (service, account, contract, config) => {
   const { contracts, dailyTarget, maxRisk, showName } = config;
@@ -197,7 +202,9 @@ const launchAlgo = async (service, account, contract, config) => {
     losses: 0,
     latency: 0,
     connected: false,
-    startTime: Date.now()
+    startTime: Date.now(),
+    aiSupervision: false,
+    aiMode: null
   };
   
   let running = true;
@@ -213,6 +220,14 @@ const launchAlgo = async (service, account, contract, config) => {
   const strategy = M1;
   strategy.initialize(contractId, tickSize, tickValue);
   
+  // Initialize AI Strategy Supervisor - agents observe, learn & optimize
+  const aiAgents = aiService.getAgents();
+  if (aiAgents.length > 0) {
+    const supervisorResult = StrategySupervisor.initialize(strategy, aiAgents, service, account.accountId);
+    stats.aiSupervision = supervisorResult.success;
+    stats.aiMode = supervisorResult.mode;
+  }
+  
   // Initialize Market Data Feed
   const marketFeed = new MarketDataFeed({ propfirm: account.propfirm });
   
@@ -225,17 +240,44 @@ const launchAlgo = async (service, account, contract, config) => {
   algoLogger.engineStarting(ui, connectionType, dailyTarget, maxRisk);
   algoLogger.marketOpen(ui, sessionName.toUpperCase(), etTime);
   
+  // Log AI supervision status
+  if (stats.aiSupervision) {
+    algoLogger.info(ui, 'AI SUPERVISION', `${aiAgents.length} agent(s) - ${stats.aiMode} mode - LEARNING ACTIVE`);
+  }
+  
   // Handle strategy signals
   strategy.on('signal', async (signal) => {
     if (!running || pendingOrder || currentPosition !== 0) return;
     
     const { side, direction, entry, stopLoss, takeProfit, confidence } = signal;
     
+    // Feed signal to AI supervisor (agents observe the signal)
+    if (stats.aiSupervision) {
+      StrategySupervisor.feedSignal({ direction, entry, stopLoss, takeProfit, confidence });
+      
+      // Check AI advice - agents may recommend caution based on learned patterns
+      const advice = StrategySupervisor.shouldTrade();
+      if (!advice.proceed) {
+        algoLogger.info(ui, 'AI HOLD', advice.reason);
+        return; // Skip - agents learned this pattern leads to losses
+      }
+    }
+    
     // Calculate position size with kelly
-    const kelly = Math.min(0.25, confidence);
-    const riskAmount = Math.round(maxRisk * kelly);
-    const riskPct = Math.round((riskAmount / maxRisk) * 100);
+    let kelly = Math.min(0.25, confidence);
+    let riskAmount = Math.round(maxRisk * kelly);
     
+    // AI may adjust size based on learning
+    if (stats.aiSupervision) {
+      const advice = StrategySupervisor.getCurrentAdvice();
+      if (advice.sizeMultiplier && advice.sizeMultiplier !== 1.0) {
+        kelly = kelly * advice.sizeMultiplier;
+        riskAmount = Math.round(riskAmount * advice.sizeMultiplier);
+        algoLogger.info(ui, 'AI ADJUST', `Size x${advice.sizeMultiplier.toFixed(2)} - ${advice.reason}`);
+      }
+    }
+    
+    const riskPct = Math.round((riskAmount / maxRisk) * 100);
     algoLogger.positionSized(ui, contracts, kelly, riskAmount, riskPct);
     
     // Place order via API
@@ -319,6 +361,11 @@ const launchAlgo = async (service, account, contract, config) => {
       timestamp: tick.timestamp || Date.now()
     };
     
+    // Feed tick to AI supervisor (agents observe same data as strategy)
+    if (stats.aiSupervision) {
+      StrategySupervisor.feedTick(tickData);
+    }
+    
     strategy.processTick(tickData);
     
     stats.latency = Date.now() - latencyStart;
@@ -443,6 +490,25 @@ const launchAlgo = async (service, account, contract, config) => {
                 
                 // Record in strategy for adaptation
                 strategy.recordTradeResult(pnl);
+                
+                // Feed trade result to AI supervisor - THIS IS WHERE AGENTS LEARN
+                if (stats.aiSupervision) {
+                  StrategySupervisor.feedTradeResult({
+                    side,
+                    qty: contracts,
+                    price: exitPrice,
+                    pnl,
+                    symbol: symbolName,
+                    direction: side
+                  });
+                  
+                  // Log if AI learned something
+                  const status = StrategySupervisor.getStatus();
+                  if (status.patternsLearned.winning + status.patternsLearned.losing > 0) {
+                    algoLogger.info(ui, 'AI LEARNING', 
+                      `${status.patternsLearned.winning}W/${status.patternsLearned.losing}L patterns`);
+                  }
+                }
               }
             }
           } catch (e) {
@@ -510,6 +576,15 @@ const launchAlgo = async (service, account, contract, config) => {
   clearInterval(refreshInterval);
   clearInterval(pnlInterval);
   
+  // Stop AI Supervisor and get learning summary
+  if (stats.aiSupervision) {
+    const aiSummary = StrategySupervisor.stop();
+    stats.aiLearning = {
+      optimizations: aiSummary.optimizationsApplied || 0,
+      patternsLearned: (aiSummary.winningPatterns || 0) + (aiSummary.losingPatterns || 0)
+    };
+  }
+  
   // Disconnect market feed with timeout
   try {
     await Promise.race([

package/src/services/ai/client.js

@@ -308,6 +308,145 @@ Analyze and provide recommendation.`;
   }
 };
 
+/**
+ * Analyze strategy performance and suggest optimizations
+ * Called periodically to help the strategy improve
+ * 
+ * @param {Object} agent - AI agent
+ * @param {Object} performanceData - Strategy performance data
+ * @returns {Promise<Object|null>} Optimization suggestions
+ */
+const analyzePerformance = async (agent, performanceData) => {
+  if (!agent || !performanceData) return null;
+  
+  const systemPrompt = `You are an AI supervisor for HQX Ultra Scalping, a professional prop firm futures trading strategy.
+
+The strategy uses advanced mathematical models:
+- Order flow analysis (delta, cumulative delta, absorption)
+- Market microstructure (bid/ask imbalance, volume profile)
+- Statistical edge detection (z-score, standard deviation bands)
+- Dynamic risk management (Kelly criterion, volatility-adjusted sizing)
+
+Your job is to analyze performance data and suggest parameter optimizations.
+Be precise and actionable. Focus on improving win rate, reducing drawdown, and optimizing risk/reward.
+
+Respond ONLY in valid JSON format:
+{
+  "assessment": "brief performance assessment",
+  "winRateAnalysis": "analysis of win/loss patterns",
+  "riskAnalysis": "analysis of risk management",
+  "optimizations": [
+    { "param": "parameter_name", "current": "current_value", "suggested": "new_value", "reason": "why" }
+  ],
+  "marketCondition": "trending|ranging|volatile|calm",
+  "confidence": 0-100
+}`;
+  
+  const prompt = `STRATEGY PERFORMANCE DATA - ANALYZE AND OPTIMIZE
+
+Session Stats:
+- Trades: ${performanceData.trades || 0}
+- Wins: ${performanceData.wins || 0}
+- Losses: ${performanceData.losses || 0}
+- Win Rate: ${performanceData.winRate ? (performanceData.winRate * 100).toFixed(1) + '%' : 'N/A'}
+- Total P&L: $${performanceData.pnl?.toFixed(2) || '0.00'}
+- Avg Win: $${performanceData.avgWin?.toFixed(2) || 'N/A'}
+- Avg Loss: $${performanceData.avgLoss?.toFixed(2) || 'N/A'}
+- Largest Win: $${performanceData.largestWin?.toFixed(2) || 'N/A'}
+- Largest Loss: $${performanceData.largestLoss?.toFixed(2) || 'N/A'}
+- Max Drawdown: $${performanceData.maxDrawdown?.toFixed(2) || 'N/A'}
+- Profit Factor: ${performanceData.profitFactor?.toFixed(2) || 'N/A'}
+
+Current Parameters:
+- Position Size: ${performanceData.positionSize || 'N/A'} contracts
+- Daily Target: $${performanceData.dailyTarget || 'N/A'}
+- Max Risk: $${performanceData.maxRisk || 'N/A'}
+- Symbol: ${performanceData.symbol || 'N/A'}
+
+Recent Trades:
+${performanceData.recentTrades?.map(t => 
+  `- ${t.side} ${t.qty}x @ ${t.price} → P&L: $${t.pnl?.toFixed(2) || 'N/A'}`
+).join('\n') || 'No recent trades'}
+
+Market Context:
+- Volatility: ${performanceData.volatility || 'N/A'}
+- Trend: ${performanceData.trend || 'N/A'}
+- Session: ${performanceData.session || 'N/A'}
+
+Analyze and suggest optimizations to improve performance.`;
+
+  try {
+    const response = await callAI(agent, prompt, systemPrompt);
+    if (!response) return null;
+    
+    // Parse JSON from response
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+    
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+
+/**
+ * Get real-time trading advice based on current market conditions
+ * 
+ * @param {Object} agent - AI agent
+ * @param {Object} marketData - Current market data
+ * @returns {Promise<Object|null>} Trading advice
+ */
+const getMarketAdvice = async (agent, marketData) => {
+  if (!agent || !marketData) return null;
+  
+  const systemPrompt = `You are an AI supervisor for HQX Ultra Scalping futures strategy.
+Analyze real-time market data and provide actionable advice.
+Be concise and precise. The strategy will use your recommendations.
+
+Respond ONLY in valid JSON:
+{
+  "action": "AGGRESSIVE|NORMAL|CAUTIOUS|PAUSE",
+  "sizeMultiplier": 0.5-1.5,
+  "reason": "brief reason",
+  "confidence": 0-100
+}`;
+  
+  const prompt = `REAL-TIME MARKET ANALYSIS
+
+Current Price: ${marketData.price || 'N/A'}
+Bid: ${marketData.bid || 'N/A'} | Ask: ${marketData.ask || 'N/A'}
+Spread: ${marketData.spread || 'N/A'}
+Volume: ${marketData.volume || 'N/A'}
+Delta: ${marketData.delta || 'N/A'}
+Volatility: ${marketData.volatility || 'N/A'}
+
+Recent Price Action:
+- High: ${marketData.high || 'N/A'}
+- Low: ${marketData.low || 'N/A'}
+- Range: ${marketData.range || 'N/A'}
+
+Current Position: ${marketData.position || 'FLAT'}
+Session P&L: $${marketData.pnl?.toFixed(2) || '0.00'}
+
+What should the strategy do?`;
+
+  try {
+    const response = await callAI(agent, prompt, systemPrompt);
+    if (!response) return null;
+    
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+    
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+
 /**
  * Fetch available models from Anthropic API (API Key auth)
  * @param {string} apiKey - API key
@@ -429,6 +568,8 @@ const fetchOpenAIModels = async (endpoint, apiKey) => {
 module.exports = {
   callAI,
   analyzeTrading,
+  analyzePerformance,
+  getMarketAdvice,
   callOpenAICompatible,
   callAnthropic,
   callGemini,

package/src/services/ai/strategy-supervisor.js

@@ -0,0 +1,675 @@
+/**
+ * AI Strategy Supervisor
+ * 
+ * Observes, learns from, and optimizes the HQX Ultra Scalping strategy in real-time.
+ * 
+ * FUNCTIONS:
+ * 1. OBSERVE - Receive all market data, signals, and trades in real-time
+ * 2. LEARN - Analyze winning/losing trades to identify patterns
+ * 3. OPTIMIZE - Suggest and apply parameter improvements
+ * 4. SUPERVISE - Monitor risk and intervene when necessary
+ * 
+ * In CONSENSUS mode (2+ agents), ALL agents must agree before applying changes.
+ */
+
+const { analyzePerformance, getMarketAdvice, callAI } = require('./client');
+
+// Singleton supervisor state
+let supervisorState = {
+  active: false,
+  agents: [],
+  strategy: null,
+  service: null,
+  accountId: null,
+  
+  // Real-time data (synced with strategy)
+  ticks: [],
+  signals: [],
+  trades: [],
+  
+  // Learning data
+  winningPatterns: [],
+  losingPatterns: [],
+  
+  // Performance tracking
+  performance: {
+    trades: 0,
+    wins: 0,
+    losses: 0,
+    totalPnL: 0,
+    maxDrawdown: 0,
+    currentDrawdown: 0,
+    peakPnL: 0,
+    winStreak: 0,
+    lossStreak: 0,
+    maxWinStreak: 0,
+    maxLossStreak: 0
+  },
+  
+  // Optimization state
+  optimizations: [],
+  lastOptimizationTime: 0,
+  optimizationInterval: 60000, // Analyze every 60 seconds
+  
+  // Current recommendations
+  currentAdvice: {
+    action: 'NORMAL',
+    sizeMultiplier: 1.0,
+    reason: 'Starting'
+  }
+};
+
+// Analysis interval
+let analysisInterval = null;
+
+/**
+ * Initialize supervisor with strategy and agents
+ */
+const initialize = (strategy, agents, service, accountId) => {
+  supervisorState = {
+    ...supervisorState,
+    active: true,
+    agents: agents || [],
+    strategy,
+    service,
+    accountId,
+    ticks: [],
+    signals: [],
+    trades: [],
+    winningPatterns: [],
+    losingPatterns: [],
+    performance: {
+      trades: 0,
+      wins: 0,
+      losses: 0,
+      totalPnL: 0,
+      maxDrawdown: 0,
+      currentDrawdown: 0,
+      peakPnL: 0,
+      winStreak: 0,
+      lossStreak: 0,
+      maxWinStreak: 0,
+      maxLossStreak: 0
+    },
+    optimizations: [],
+    lastOptimizationTime: Date.now()
+  };
+  
+  // Start continuous analysis loop
+  if (analysisInterval) clearInterval(analysisInterval);
+  analysisInterval = setInterval(analyzeAndOptimize, supervisorState.optimizationInterval);
+  
+  return {
+    success: true,
+    agents: agents.length,
+    mode: agents.length >= 2 ? 'CONSENSUS' : 'INDIVIDUAL'
+  };
+};
+
+/**
+ * Stop supervisor
+ */
+const stop = () => {
+  if (analysisInterval) {
+    clearInterval(analysisInterval);
+    analysisInterval = null;
+  }
+  
+  const summary = {
+    ...supervisorState.performance,
+    optimizationsApplied: supervisorState.optimizations.length,
+    winningPatterns: supervisorState.winningPatterns.length,
+    losingPatterns: supervisorState.losingPatterns.length
+  };
+  
+  supervisorState.active = false;
+  
+  return summary;
+};
+
+/**
+ * Feed tick data (called on every market tick)
+ */
+const feedTick = (tick) => {
+  if (!supervisorState.active) return;
+  
+  supervisorState.ticks.push({
+    ...tick,
+    timestamp: Date.now()
+  });
+  
+  // Keep last 5000 ticks for pattern analysis
+  if (supervisorState.ticks.length > 5000) {
+    supervisorState.ticks = supervisorState.ticks.slice(-5000);
+  }
+};
+
+/**
+ * Feed signal data (called when strategy generates a signal)
+ */
+const feedSignal = (signal) => {
+  if (!supervisorState.active) return;
+  
+  const signalData = {
+    ...signal,
+    timestamp: Date.now(),
+    ticksContext: supervisorState.ticks.slice(-50) // Last 50 ticks before signal
+  };
+  
+  supervisorState.signals.push(signalData);
+  
+  // Keep last 100 signals
+  if (supervisorState.signals.length > 100) {
+    supervisorState.signals = supervisorState.signals.slice(-100);
+  }
+};
+
+/**
+ * Feed trade result (called when a trade completes)
+ * This is where LEARNING happens
+ */
+const feedTradeResult = (trade) => {
+  if (!supervisorState.active) return;
+  
+  const tradeData = {
+    ...trade,
+    timestamp: Date.now(),
+    // Capture context at time of trade
+    ticksBefore: supervisorState.ticks.slice(-100),
+    signalUsed: supervisorState.signals[supervisorState.signals.length - 1] || null
+  };
+  
+  supervisorState.trades.push(tradeData);
+  
+  // Update performance metrics
+  const perf = supervisorState.performance;
+  perf.trades++;
+  perf.totalPnL += trade.pnl || 0;
+  
+  if (trade.pnl > 0) {
+    perf.wins++;
+    perf.winStreak++;
+    perf.lossStreak = 0;
+    perf.maxWinStreak = Math.max(perf.maxWinStreak, perf.winStreak);
+    
+    // Learn from winning trade
+    learnFromTrade(tradeData, 'win');
+  } else if (trade.pnl < 0) {
+    perf.losses++;
+    perf.lossStreak++;
+    perf.winStreak = 0;
+    perf.maxLossStreak = Math.max(perf.maxLossStreak, perf.lossStreak);
+    
+    // Learn from losing trade
+    learnFromTrade(tradeData, 'loss');
+  }
+  
+  // Update drawdown
+  if (perf.totalPnL > perf.peakPnL) {
+    perf.peakPnL = perf.totalPnL;
+    perf.currentDrawdown = 0;
+  } else {
+    perf.currentDrawdown = perf.peakPnL - perf.totalPnL;
+    perf.maxDrawdown = Math.max(perf.maxDrawdown, perf.currentDrawdown);
+  }
+  
+  // Trigger immediate analysis after losing streaks
+  if (perf.lossStreak >= 3) {
+    analyzeAndOptimize();
+  }
+};
+
+/**
+ * Learn from a completed trade
+ * Extracts patterns from winning and losing trades
+ */
+const learnFromTrade = (trade, result) => {
+  const pattern = {
+    timestamp: trade.timestamp,
+    result,
+    pnl: trade.pnl,
+    direction: trade.direction || trade.side,
+    
+    // Market context before trade
+    priceAction: analyzePriceAction(trade.ticksBefore),
+    volumeProfile: analyzeVolume(trade.ticksBefore),
+    volatility: calculateVolatility(trade.ticksBefore),
+    
+    // Signal characteristics
+    signalConfidence: trade.signalUsed?.confidence || null,
+    entryPrice: trade.price || trade.signalUsed?.entry,
+    stopLoss: trade.signalUsed?.stopLoss,
+    takeProfit: trade.signalUsed?.takeProfit
+  };
+  
+  if (result === 'win') {
+    supervisorState.winningPatterns.push(pattern);
+    // Keep last 50 winning patterns
+    if (supervisorState.winningPatterns.length > 50) {
+      supervisorState.winningPatterns = supervisorState.winningPatterns.slice(-50);
+    }
+  } else {
+    supervisorState.losingPatterns.push(pattern);
+    // Keep last 50 losing patterns
+    if (supervisorState.losingPatterns.length > 50) {
+      supervisorState.losingPatterns = supervisorState.losingPatterns.slice(-50);
+    }
+  }
+};
+
+/**
+ * Analyze price action from ticks
+ */
+const analyzePriceAction = (ticks) => {
+  if (!ticks || ticks.length < 2) return { trend: 'unknown', strength: 0 };
+  
+  const prices = ticks.map(t => t.price).filter(Boolean);
+  if (prices.length < 2) return { trend: 'unknown', strength: 0 };
+  
+  const first = prices[0];
+  const last = prices[prices.length - 1];
+  const change = last - first;
+  const range = Math.max(...prices) - Math.min(...prices);
+  
+  return {
+    trend: change > 0 ? 'up' : change < 0 ? 'down' : 'flat',
+    strength: range > 0 ? Math.abs(change) / range : 0,
+    range,
+    change
+  };
+};
+
+/**
+ * Analyze volume from ticks
+ */
+const analyzeVolume = (ticks) => {
+  if (!ticks || ticks.length === 0) return { total: 0, avg: 0, trend: 'unknown' };
+  
+  const volumes = ticks.map(t => t.volume || 0);
+  const total = volumes.reduce((a, b) => a + b, 0);
+  const avg = total / volumes.length;
+  
+  // Compare first half vs second half
+  const mid = Math.floor(volumes.length / 2);
+  const firstHalf = volumes.slice(0, mid).reduce((a, b) => a + b, 0);
+  const secondHalf = volumes.slice(mid).reduce((a, b) => a + b, 0);
+  
+  return {
+    total,
+    avg,
+    trend: secondHalf > firstHalf * 1.2 ? 'increasing' : secondHalf < firstHalf * 0.8 ? 'decreasing' : 'stable'
+  };
+};
+
+/**
+ * Calculate volatility from ticks
+ */
+const calculateVolatility = (ticks) => {
+  if (!ticks || ticks.length < 2) return 0;
+  
+  const prices = ticks.map(t => t.price).filter(Boolean);
+  if (prices.length < 2) return 0;
+  
+  const returns = [];
+  for (let i = 1; i < prices.length; i++) {
+    returns.push((prices[i] - prices[i-1]) / prices[i-1]);
+  }
+  
+  const mean = returns.reduce((a, b) => a + b, 0) / returns.length;
+  const variance = returns.reduce((sum, r) => sum + Math.pow(r - mean, 2), 0) / returns.length;
+  
+  return Math.sqrt(variance);
+};
+
+/**
+ * Main analysis and optimization loop
+ * Called periodically and after significant events
+ */
+const analyzeAndOptimize = async () => {
+  if (!supervisorState.active || supervisorState.agents.length === 0) return;
+  
+  const perf = supervisorState.performance;
+  
+  // Skip if not enough data
+  if (perf.trades < 3) return;
+  
+  // Prepare performance data for AI analysis
+  const performanceData = {
+    trades: perf.trades,
+    wins: perf.wins,
+    losses: perf.losses,
+    winRate: perf.trades > 0 ? perf.wins / perf.trades : 0,
+    pnl: perf.totalPnL,
+    maxDrawdown: perf.maxDrawdown,
+    currentDrawdown: perf.currentDrawdown,
+    winStreak: perf.winStreak,
+    lossStreak: perf.lossStreak,
+    maxWinStreak: perf.maxWinStreak,
+    maxLossStreak: perf.maxLossStreak,
+    
+    // Calculate averages
+    avgWin: perf.wins > 0 ? 
+      supervisorState.trades.filter(t => t.pnl > 0).reduce((s, t) => s + t.pnl, 0) / perf.wins : 0,
+    avgLoss: perf.losses > 0 ? 
+      Math.abs(supervisorState.trades.filter(t => t.pnl < 0).reduce((s, t) => s + t.pnl, 0) / perf.losses) : 0,
+    
+    // Recent trades for context
+    recentTrades: supervisorState.trades.slice(-10).map(t => ({
+      side: t.direction || t.side,
+      qty: t.qty,
+      price: t.price,
+      pnl: t.pnl
+    })),
+    
+    // Pattern summaries
+    winningPatternCount: supervisorState.winningPatterns.length,
+    losingPatternCount: supervisorState.losingPatterns.length,
+    
+    // Common characteristics of losing trades
+    losingTradeAnalysis: analyzeLosingPatterns()
+  };
+  
+  // Get optimization suggestions from all agents
+  const suggestions = [];
+  
+  for (const agent of supervisorState.agents) {
+    try {
+      const suggestion = await getOptimizationFromAgent(agent, performanceData);
+      if (suggestion) {
+        suggestions.push({
+          agentId: agent.id,
+          agentName: agent.name,
+          ...suggestion
+        });
+      }
+    } catch (e) {
+      // Silent fail for individual agent
+    }
+  }
+  
+  if (suggestions.length === 0) return;
+  
+  // Process suggestions based on mode
+  const isConsensus = supervisorState.agents.length >= 2;
+  
+  if (isConsensus) {
+    // CONSENSUS MODE: All agents must agree
+    const consensusResult = buildConsensus(suggestions);
+    
+    if (consensusResult.isUnanimous && consensusResult.optimizations.length > 0) {
+      // Apply unanimous optimizations
+      for (const opt of consensusResult.optimizations) {
+        applyOptimization(opt);
+      }
+    }
+    
+    // Update current advice based on consensus
+    if (consensusResult.action) {
+      supervisorState.currentAdvice = {
+        action: consensusResult.action,
+        sizeMultiplier: consensusResult.sizeMultiplier || 1.0,
+        reason: consensusResult.reason || 'Consensus recommendation'
+      };
+    }
+  } else {
+    // INDIVIDUAL MODE: Apply single agent's suggestions
+    const suggestion = suggestions[0];
+    
+    if (suggestion.optimizations) {
+      for (const opt of suggestion.optimizations) {
+        applyOptimization(opt);
+      }
+    }
+    
+    if (suggestion.action) {
+      supervisorState.currentAdvice = {
+        action: suggestion.action,
+        sizeMultiplier: suggestion.sizeMultiplier || 1.0,
+        reason: suggestion.reason || 'Agent recommendation'
+      };
+    }
+  }
+  
+  supervisorState.lastOptimizationTime = Date.now();
+};
+
+/**
+ * Analyze patterns in losing trades
+ */
+const analyzeLosingPatterns = () => {
+  const patterns = supervisorState.losingPatterns;
+  if (patterns.length === 0) return null;
+  
+  // Find common characteristics
+  const trends = patterns.map(p => p.priceAction?.trend).filter(Boolean);
+  const volatilities = patterns.map(p => p.volatility).filter(Boolean);
+  const confidences = patterns.map(p => p.signalConfidence).filter(Boolean);
+  
+  const trendCounts = {};
+  for (const t of trends) {
+    trendCounts[t] = (trendCounts[t] || 0) + 1;
+  }
+  
+  const avgVolatility = volatilities.length > 0 ? 
+    volatilities.reduce((a, b) => a + b, 0) / volatilities.length : 0;
+  
+  const avgConfidence = confidences.length > 0 ?
+    confidences.reduce((a, b) => a + b, 0) / confidences.length : 0;
+  
+  return {
+    commonTrend: Object.entries(trendCounts).sort((a, b) => b[1] - a[1])[0]?.[0] || 'unknown',
+    avgVolatility,
+    avgConfidence,
+    count: patterns.length
+  };
+};
+
+/**
+ * Get optimization suggestion from a single agent
+ */
+const getOptimizationFromAgent = async (agent, performanceData) => {
+  const systemPrompt = `You are an AI supervisor for HQX Ultra Scalping, a professional futures trading strategy.
+
+The strategy uses:
+- Order flow analysis (delta, absorption, imbalance)
+- Statistical models (z-score, standard deviation)
+- Dynamic risk management (Kelly criterion)
+
+ANALYZE the performance data and LEARN from the losing trades.
+Suggest SPECIFIC optimizations to improve win rate and reduce losses.
+
+Respond in JSON:
+{
+  "assessment": "brief assessment",
+  "action": "AGGRESSIVE|NORMAL|CAUTIOUS|PAUSE",
+  "sizeMultiplier": 0.5-1.5,
+  "optimizations": [
+    {"param": "name", "direction": "increase|decrease", "amount": "10%", "reason": "why"}
+  ],
+  "learnings": "what we learned from losing trades",
+  "confidence": 0-100
+}`;
+
+  const prompt = `STRATEGY PERFORMANCE ANALYSIS
+
+Stats:
+- Trades: ${performanceData.trades} (${performanceData.wins}W / ${performanceData.losses}L)
+- Win Rate: ${(performanceData.winRate * 100).toFixed(1)}%
+- P&L: $${performanceData.pnl.toFixed(2)}
+- Max Drawdown: $${performanceData.maxDrawdown.toFixed(2)}
+- Current Streak: ${performanceData.winStreak > 0 ? performanceData.winStreak + ' wins' : performanceData.lossStreak + ' losses'}
+
+Losing Trade Analysis:
+${performanceData.losingTradeAnalysis ? `
+- Common trend at entry: ${performanceData.losingTradeAnalysis.commonTrend}
+- Avg volatility: ${(performanceData.losingTradeAnalysis.avgVolatility * 100).toFixed(3)}%
+- Avg signal confidence: ${(performanceData.losingTradeAnalysis.avgConfidence * 100).toFixed(1)}%
+- Total losing patterns: ${performanceData.losingTradeAnalysis.count}
+` : 'Not enough data'}
+
+Recent Trades:
+${performanceData.recentTrades.map(t => `${t.side} @ ${t.price} → $${t.pnl?.toFixed(2)}`).join('\n')}
+
+What should we LEARN and OPTIMIZE?`;
+
+  try {
+    const response = await callAI(agent, prompt, systemPrompt);
+    if (!response) return null;
+    
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+    return null;
+  } catch (e) {
+    return null;
+  }
+};
+
+/**
+ * Build consensus from multiple agent suggestions
+ */
+const buildConsensus = (suggestions) => {
+  if (suggestions.length === 0) return { isUnanimous: false };
+  
+  // Check action consensus
+  const actions = suggestions.map(s => s.action).filter(Boolean);
+  const allSameAction = actions.length === suggestions.length && 
+    actions.every(a => a === actions[0]);
+  
+  // Check optimization consensus
+  const allOptimizations = suggestions.flatMap(s => s.optimizations || []);
+  const paramGroups = {};
+  
+  for (const opt of allOptimizations) {
+    if (!opt.param) continue;
+    const key = `${opt.param}_${opt.direction}`;
+    if (!paramGroups[key]) {
+      paramGroups[key] = { ...opt, count: 0 };
+    }
+    paramGroups[key].count++;
+  }
+  
+  // Find unanimous optimizations (all agents agree)
+  const unanimousOptimizations = Object.values(paramGroups)
+    .filter(g => g.count === suggestions.length)
+    .map(g => ({
+      param: g.param,
+      direction: g.direction,
+      amount: g.amount,
+      reason: `Unanimous (${suggestions.length} agents)`
+    }));
+  
+  // Average size multiplier
+  const multipliers = suggestions.map(s => s.sizeMultiplier || 1.0);
+  const avgMultiplier = multipliers.reduce((a, b) => a + b, 0) / multipliers.length;
+  
+  // Average confidence
+  const confidences = suggestions.map(s => s.confidence || 50);
+  const avgConfidence = Math.round(confidences.reduce((a, b) => a + b, 0) / confidences.length);
+  
+  return {
+    isUnanimous: allSameAction && unanimousOptimizations.length > 0,
+    action: allSameAction ? actions[0] : 'CAUTIOUS',
+    sizeMultiplier: allSameAction ? avgMultiplier : 0.5,
+    optimizations: unanimousOptimizations,
+    confidence: avgConfidence,
+    reason: allSameAction ? 
+      `${suggestions.length} agents agree` : 
+      'Agents disagree - being cautious',
+    votes: actions.reduce((acc, a) => { acc[a] = (acc[a] || 0) + 1; return acc; }, {})
+  };
+};
+
+/**
+ * Apply an optimization to the strategy
+ */
+const applyOptimization = (optimization) => {
+  const strategy = supervisorState.strategy;
+  if (!strategy) return false;
+  
+  // Record the optimization
+  supervisorState.optimizations.push({
+    timestamp: Date.now(),
+    ...optimization
+  });
+  
+  // Try to apply to strategy if it supports it
+  try {
+    if (typeof strategy.applyAIOptimization === 'function') {
+      strategy.applyAIOptimization(optimization);
+      return true;
+    }
+    
+    if (typeof strategy.setParameter === 'function') {
+      strategy.setParameter(optimization.param, optimization.direction, optimization.amount);
+      return true;
+    }
+  } catch (e) {
+    // Strategy doesn't support this optimization
+  }
+  
+  return false;
+};
+
+/**
+ * Get current advice for the strategy
+ * Called before each trade decision
+ */
+const getCurrentAdvice = () => {
+  if (!supervisorState.active) {
+    return { action: 'NORMAL', sizeMultiplier: 1.0, reason: 'No supervision' };
+  }
+  
+  return supervisorState.currentAdvice;
+};
+
+/**
+ * Get supervision status
+ */
+const getStatus = () => {
+  return {
+    active: supervisorState.active,
+    agents: supervisorState.agents.length,
+    mode: supervisorState.agents.length >= 2 ? 'CONSENSUS' : 'INDIVIDUAL',
+    performance: supervisorState.performance,
+    currentAdvice: supervisorState.currentAdvice,
+    optimizationsApplied: supervisorState.optimizations.length,
+    patternsLearned: {
+      winning: supervisorState.winningPatterns.length,
+      losing: supervisorState.losingPatterns.length
+    },
+    lastOptimization: supervisorState.lastOptimizationTime
+  };
+};
+
+/**
+ * Check if should proceed with trade based on AI advice
+ */
+const shouldTrade = () => {
+  if (!supervisorState.active) return { proceed: true, multiplier: 1.0 };
+  
+  const advice = supervisorState.currentAdvice;
+  
+  if (advice.action === 'PAUSE') {
+    return { proceed: false, reason: advice.reason };
+  }
+  
+  return {
+    proceed: true,
+    multiplier: advice.sizeMultiplier || 1.0,
+    action: advice.action
+  };
+};
+
+module.exports = {
+  initialize,
+  stop,
+  feedTick,
+  feedSignal,
+  feedTradeResult,
+  getCurrentAdvice,
+  shouldTrade,
+  getStatus,
+  analyzeAndOptimize
+};

package/src/services/ai/supervisor.js

@@ -7,7 +7,7 @@
  */
 
 const { connections } = require('../session');
-const { analyzeTrading } = require('./client');
+const { analyzeTrading, analyzePerformance, getMarketAdvice } = require('./client');
 
 let aiService = null;
 
@@ -567,6 +567,383 @@ class AISupervisor {
   static getSessionCount() {
     return supervisionSessions.size;
   }
+  
+  /**
+   * Feed market tick to all agents (sync with strategy)
+   * Agents receive the same data as the strategy in real-time
+   * 
+   * @param {Object} tick - Market tick data { price, bid, ask, volume, timestamp }
+   */
+  static feedTick(tick) {
+    if (supervisionSessions.size === 0) return;
+    
+    // Store latest tick in all sessions
+    for (const [agentId, session] of supervisionSessions.entries()) {
+      if (!session.marketData) {
+        session.marketData = { ticks: [], lastTick: null };
+      }
+      session.marketData.lastTick = tick;
+      session.marketData.ticks.push(tick);
+      
+      // Keep only last 1000 ticks to prevent memory bloat
+      if (session.marketData.ticks.length > 1000) {
+        session.marketData.ticks = session.marketData.ticks.slice(-1000);
+      }
+    }
+  }
+  
+  /**
+   * Feed strategy signal to all agents (sync with strategy)
+   * Agents see every signal the strategy generates
+   * 
+   * @param {Object} signal - Strategy signal { direction, entry, stopLoss, takeProfit, confidence }
+   */
+  static feedSignal(signal) {
+    if (supervisionSessions.size === 0) return;
+    
+    const signalData = {
+      timestamp: Date.now(),
+      direction: signal.direction,
+      entry: signal.entry,
+      stopLoss: signal.stopLoss,
+      takeProfit: signal.takeProfit,
+      confidence: signal.confidence
+    };
+    
+    // Store signal in all sessions
+    for (const [agentId, session] of supervisionSessions.entries()) {
+      if (!session.signals) {
+        session.signals = [];
+      }
+      session.signals.push(signalData);
+      
+      // Keep only last 100 signals
+      if (session.signals.length > 100) {
+        session.signals = session.signals.slice(-100);
+      }
+    }
+  }
+  
+  /**
+   * Feed trade execution to all agents (sync with strategy)
+   * Agents see every trade executed
+   * 
+   * @param {Object} trade - Trade data { side, qty, price, pnl, symbol }
+   */
+  static feedTrade(trade) {
+    if (supervisionSessions.size === 0) return;
+    
+    const tradeData = {
+      timestamp: Date.now(),
+      side: trade.side,
+      qty: trade.qty,
+      price: trade.price,
+      pnl: trade.pnl,
+      symbol: trade.symbol
+    };
+    
+    // Store trade in all sessions
+    for (const [agentId, session] of supervisionSessions.entries()) {
+      if (!session.trades) {
+        session.trades = [];
+      }
+      session.trades.push(tradeData);
+    }
+  }
+  
+  /**
+   * Update current position for all agents
+   * 
+   * @param {Object} position - Position data { qty, side, entryPrice, pnl }
+   */
+  static updatePosition(position) {
+    if (supervisionSessions.size === 0) return;
+    
+    for (const [agentId, session] of supervisionSessions.entries()) {
+      session.currentPosition = {
+        timestamp: Date.now(),
+        qty: position.qty,
+        side: position.side,
+        entryPrice: position.entryPrice,
+        pnl: position.pnl
+      };
+    }
+  }
+  
+  /**
+   * Update P&L for all agents
+   * 
+   * @param {number} pnl - Current session P&L
+   * @param {number} balance - Account balance
+   */
+  static updatePnL(pnl, balance) {
+    if (supervisionSessions.size === 0) return;
+    
+    for (const [agentId, session] of supervisionSessions.entries()) {
+      session.currentPnL = pnl;
+      session.currentBalance = balance;
+    }
+  }
+  
+  /**
+   * Check if agents recommend intervention (PAUSE, REDUCE_SIZE, etc.)
+   * In CONSENSUS mode, ALL agents must agree to continue trading
+   * 
+   * @returns {Object} { shouldContinue: boolean, action: string, reason: string }
+   */
+  static checkIntervention() {
+    if (supervisionSessions.size === 0) {
+      return { shouldContinue: true, action: 'CONTINUE', reason: 'No AI supervision active' };
+    }
+    
+    // Get last consensus or individual decision
+    const consensus = this.getConsensus();
+    
+    if (consensus && consensus.isUnanimous) {
+      if (consensus.action === 'PAUSE' || consensus.action === 'STOP') {
+        return { shouldContinue: false, action: consensus.action, reason: 'AI agents recommend pause' };
+      }
+      if (consensus.action === 'REDUCE_SIZE') {
+        return { shouldContinue: true, action: 'REDUCE_SIZE', reason: 'AI agents recommend reducing size' };
+      }
+    } else if (consensus && !consensus.isUnanimous) {
+      // Agents disagree - be conservative, don't take new trades
+      return { shouldContinue: false, action: 'HOLD', reason: 'AI agents disagree - waiting for consensus' };
+    }
+    
+    return { shouldContinue: true, action: 'CONTINUE', reason: 'AI supervision active' };
+  }
+  
+  /**
+   * Get real-time sync status for display
+   * Shows what data the agents are receiving
+   * 
+   * @returns {Object} Sync status
+   */
+  static getSyncStatus() {
+    if (supervisionSessions.size === 0) {
+      return { synced: false, agents: 0 };
+    }
+    
+    const firstSession = supervisionSessions.values().next().value;
+    
+    return {
+      synced: true,
+      agents: supervisionSessions.size,
+      lastTick: firstSession?.marketData?.lastTick?.timestamp || null,
+      tickCount: firstSession?.marketData?.ticks?.length || 0,
+      signalCount: firstSession?.signals?.length || 0,
+      tradeCount: firstSession?.trades?.length || 0,
+      currentPnL: firstSession?.currentPnL || 0,
+      currentPosition: firstSession?.currentPosition || null
+    };
+  }
+  
+  /**
+   * Request strategy optimization from all agents
+   * Agents analyze performance data and suggest improvements
+   * In CONSENSUS mode, only unanimous suggestions are applied
+   * 
+   * @param {Object} performanceData - Strategy performance data
+   * @returns {Promise<Object|null>} Optimization suggestions (consensus)
+   */
+  static async requestOptimization(performanceData) {
+    if (supervisionSessions.size === 0) return null;
+    
+    const allSessions = Array.from(supervisionSessions.values());
+    const suggestions = [];
+    
+    // Get optimization suggestions from each agent
+    for (const session of allSessions) {
+      try {
+        const suggestion = await analyzePerformance(session.agent, performanceData);
+        if (suggestion) {
+          suggestions.push({
+            agentId: session.agentId,
+            agentName: session.agent.name,
+            ...suggestion
+          });
+        }
+      } catch (e) {
+        // Silent fail for individual agent
+      }
+    }
+    
+    if (suggestions.length === 0) return null;
+    
+    // If single agent, return its suggestion
+    if (suggestions.length === 1) {
+      return {
+        mode: 'INDIVIDUAL',
+        ...suggestions[0]
+      };
+    }
+    
+    // CONSENSUS MODE: Find common optimizations
+    const consensusOptimizations = [];
+    const allOptimizations = suggestions.flatMap(s => s.optimizations || []);
+    
+    // Group by parameter name
+    const paramGroups = {};
+    for (const opt of allOptimizations) {
+      if (!opt.param) continue;
+      if (!paramGroups[opt.param]) {
+        paramGroups[opt.param] = [];
+      }
+      paramGroups[opt.param].push(opt);
+    }
+    
+    // Find unanimous suggestions (all agents agree on direction)
+    for (const [param, opts] of Object.entries(paramGroups)) {
+      if (opts.length === suggestions.length) {
+        // All agents suggested this param - check if they agree on direction
+        const directions = opts.map(o => {
+          const current = parseFloat(o.current) || 0;
+          const suggested = parseFloat(o.suggested) || 0;
+          return suggested > current ? 'increase' : suggested < current ? 'decrease' : 'same';
+        });
+        
+        const allSame = directions.every(d => d === directions[0]);
+        if (allSame && directions[0] !== 'same') {
+          // Unanimous - use average of suggested values
+          const avgSuggested = opts.reduce((sum, o) => sum + (parseFloat(o.suggested) || 0), 0) / opts.length;
+          consensusOptimizations.push({
+            param,
+            current: opts[0].current,
+            suggested: avgSuggested.toFixed(2),
+            reason: `Unanimous (${suggestions.length} agents agree)`,
+            direction: directions[0]
+          });
+        }
+      }
+    }
+    
+    // Calculate average confidence
+    const avgConfidence = Math.round(
+      suggestions.reduce((sum, s) => sum + (s.confidence || 0), 0) / suggestions.length
+    );
+    
+    // Determine consensus market condition
+    const conditions = suggestions.map(s => s.marketCondition).filter(Boolean);
+    const conditionCounts = {};
+    for (const c of conditions) {
+      conditionCounts[c] = (conditionCounts[c] || 0) + 1;
+    }
+    const consensusCondition = Object.entries(conditionCounts)
+      .sort((a, b) => b[1] - a[1])[0]?.[0] || 'unknown';
+    
+    return {
+      mode: 'CONSENSUS',
+      agentCount: suggestions.length,
+      isUnanimous: consensusOptimizations.length > 0,
+      optimizations: consensusOptimizations,
+      marketCondition: consensusCondition,
+      confidence: avgConfidence,
+      individualSuggestions: suggestions
+    };
+  }
+  
+  /**
+   * Get real-time market advice from all agents
+   * Used for dynamic position sizing and risk adjustment
+   * 
+   * @param {Object} marketData - Current market data
+   * @returns {Promise<Object|null>} Market advice (consensus)
+   */
+  static async getMarketAdvice(marketData) {
+    if (supervisionSessions.size === 0) return null;
+    
+    const allSessions = Array.from(supervisionSessions.values());
+    const advices = [];
+    
+    // Get advice from each agent
+    for (const session of allSessions) {
+      try {
+        const advice = await getMarketAdvice(session.agent, marketData);
+        if (advice) {
+          advices.push({
+            agentId: session.agentId,
+            agentName: session.agent.name,
+            ...advice
+          });
+        }
+      } catch (e) {
+        // Silent fail
+      }
+    }
+    
+    if (advices.length === 0) return null;
+    
+    // Single agent
+    if (advices.length === 1) {
+      return {
+        mode: 'INDIVIDUAL',
+        ...advices[0]
+      };
+    }
+    
+    // CONSENSUS: All agents must agree on action
+    const actions = advices.map(a => a.action);
+    const allSameAction = actions.every(a => a === actions[0]);
+    
+    if (allSameAction) {
+      // Unanimous action - average the size multiplier
+      const avgMultiplier = advices.reduce((sum, a) => sum + (a.sizeMultiplier || 1), 0) / advices.length;
+      const avgConfidence = Math.round(advices.reduce((sum, a) => sum + (a.confidence || 0), 0) / advices.length);
+      
+      return {
+        mode: 'CONSENSUS',
+        isUnanimous: true,
+        action: actions[0],
+        sizeMultiplier: Math.round(avgMultiplier * 100) / 100,
+        confidence: avgConfidence,
+        reason: `${advices.length} agents unanimous`,
+        agentCount: advices.length
+      };
+    } else {
+      // Agents disagree - be conservative
+      return {
+        mode: 'CONSENSUS',
+        isUnanimous: false,
+        action: 'CAUTIOUS',
+        sizeMultiplier: 0.5,
+        confidence: 0,
+        reason: 'Agents disagree - reducing exposure',
+        agentCount: advices.length,
+        votes: actions.reduce((acc, a) => { acc[a] = (acc[a] || 0) + 1; return acc; }, {})
+      };
+    }
+  }
+  
+  /**
+   * Apply optimization to strategy
+   * Called when agents have consensus on improvements
+   * 
+   * @param {Object} strategy - Strategy instance (M1)
+   * @param {Object} optimization - Optimization to apply
+   * @returns {boolean} Success
+   */
+  static applyOptimization(strategy, optimization) {
+    if (!strategy || !optimization) return false;
+    
+    try {
+      // Check if strategy has optimization method
+      if (typeof strategy.applyOptimization === 'function') {
+        strategy.applyOptimization(optimization);
+        return true;
+      }
+      
+      // Fallback: try to set individual parameters
+      if (typeof strategy.setParameter === 'function' && optimization.param) {
+        strategy.setParameter(optimization.param, optimization.suggested);
+        return true;
+      }
+      
+      return false;
+    } catch (e) {
+      return false;
+    }
+  }
 }
 
 module.exports = AISupervisor;