hedgequantx 2.5.35 → 2.5.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.5.35",
+  "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/pages/stats.js

@@ -449,11 +449,15 @@ const showStats = async (service) => {
       
       // Add consensus info if in consensus mode
       if (isConsensusMode && consensusData) {
-        const agreement = consensusData.agreement !== null 
-          ? Math.round(consensusData.agreement * 100) + '%' 
-          : 'N/A';
+        const isUnanimous = consensusData.isUnanimous;
         const consensusAction = consensusData.action || 'PENDING';
-        agentsData.push({ label: 'CONSENSUS:', value: chalk.magenta(consensusAction + ' (' + agreement + ')') });
+        // Show action with unanimity status
+        const consensusDisplay = isUnanimous 
+          ? chalk.green(consensusAction + ' (UNANIMOUS)')
+          : chalk.yellow(consensusAction + ' (DISAGREEMENT)');
+        agentsData.push({ label: 'DECISION:', value: consensusDisplay });
+      } else if (isConsensusMode) {
+        agentsData.push({ label: 'DECISION:', value: chalk.white('WAITING...') });
       }
       
       // Add each agent as a separate line with ● indicator

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,