hedgequantx 2.6.90 → 2.6.92

package/package.json

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

package/src/menus/ai-agent.js

@@ -955,11 +955,23 @@ const setupBrowserOAuth = async (provider, config) => {
   }
   
   // Fallback default models if API doesn't return list
+  // Updated January 2026 with latest models
   const defaultModels = {
     anthropic: ['claude-sonnet-4-20250514', 'claude-opus-4-20250514', 'claude-3-5-sonnet-20241022', 'claude-3-5-haiku-20241022'],
-    openai: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1', 'o1-mini', 'o3-mini'],
+    openai: [
+      'gpt-4.5-preview',      // NEW: GPT-4.5 (latest)
+      'gpt-4.5',              // NEW: GPT-4.5
+      'o3',                   // NEW: o3 (latest reasoning)
+      'o3-mini',              // o3-mini
+      'o1',                   // o1
+      'o1-mini',              // o1-mini
+      'gpt-4o',               // GPT-4o
+      'gpt-4o-mini',          // GPT-4o mini
+      'gpt-4-turbo',          // GPT-4 Turbo
+    ],
     gemini: ['gemini-2.5-pro', 'gemini-2.5-flash', 'gemini-2.0-flash', 'gemini-1.5-pro'],
-    iflow: ['deepseek-v3', 'deepseek-chat', 'kimi', 'glm-4']
+    iflow: ['deepseek-v3', 'deepseek-chat', 'kimi', 'glm-4'],
+    qwen: ['qwen-max', 'qwen-plus', 'qwen-turbo', 'qwen2.5-72b-instruct']
   };
   
   if (!models || models.length === 0) {

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

@@ -23,6 +23,7 @@ const { MarketDataFeed } = require('../../../dist/lib/data');
 const { RithmicMarketDataFeed } = require('../../services/rithmic/market-data');
 const { algoLogger } = require('./logger');
 const { recoveryMath } = require('../../services/strategy/recovery-math');
+const { sessionHistory, SessionHistory } = require('../../services/session-history');
 
 // Use HFT tick-based strategy for Rithmic (fast path), M1 for ProjectX
 const USE_HFT_STRATEGY = true;
@@ -286,6 +287,26 @@ const launchAlgo = async (service, account, contract, config) => {
   let tickCount = 0;
   let lastTradeCount = 0; // Track number of trades from API
   let lastPositionQty = 0; // Track position changes
+  let currentTradeId = null; // Track current trade for history
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // SESSION HISTORY - Save all activity for AI learning
+  // ═══════════════════════════════════════════════════════════════════════════
+  sessionHistory.start(account.accountId, symbolName, account.propfirm || 'unknown', {
+    contracts,
+    dailyTarget,
+    maxRisk,
+    aiEnabled: config.enableAI,
+    agentCount: config.enableAI ? 2 : 0,
+  });
+  
+  // Load historical data for AI learning
+  const historicalData = SessionHistory.getAILearningData();
+  if (historicalData.totalSessions > 0) {
+    algoLogger.info(ui, 'HISTORY LOADED', 
+      `${historicalData.totalSessions} sessions | ${historicalData.totalTrades} trades | ` +
+      `WR: ${(historicalData.statistics?.winRate * 100 || 0).toFixed(0)}%`);
+  }
   
   // Initialize Strategy
   // Use HFT tick-based strategy for Rithmic (fast path), M1 for ProjectX
@@ -647,6 +668,19 @@ const launchAlgo = async (service, account, contract, config) => {
           algoLogger.positionOpened(ui, symbolName, positionSide, contracts, entry);
           algoLogger.entryConfirmed(ui, sideStr, contracts, symbolName, entry);
           
+          // Record trade entry in session history
+          currentTradeId = sessionHistory.recordEntry({
+            direction,
+            symbol: symbolName,
+            quantity: contracts,
+            entryPrice: entry,
+            stopLoss,
+            takeProfit,
+            momentum: strategy.getMomentum?.() || 0,
+            zscore: strategy.getZScore?.() || 0,
+            ofi: strategy.getOFI?.() || 0,
+          });
+          
           // Place bracket orders (SL/TP) - SLOW PATH ONLY
           if (stopLoss && takeProfit) {
             // Stop Loss
@@ -946,6 +980,14 @@ const launchAlgo = async (service, account, contract, config) => {
                 // Record in strategy for adaptation
                 strategy.recordTradeResult(pnl);
                 
+                // Record trade exit in session history
+                sessionHistory.recordExit(currentTradeId, {
+                  exitPrice,
+                  pnl,
+                  reason: pnl >= 0 ? 'takeProfit' : 'stopLoss',
+                });
+                currentTradeId = null;
+                
                 // Feed trade result to AI supervisor - THIS IS WHERE AGENTS LEARN
                 if (stats.aiSupervision) {
                   StrategySupervisor.feedTradeResult({
@@ -1193,6 +1235,15 @@ const launchAlgo = async (service, account, contract, config) => {
     };
   }
   
+  // End session history and save to disk
+  sessionHistory.end({
+    totalTrades: stats.trades,
+    wins: stats.wins,
+    losses: stats.losses,
+    totalPnl: stats.pnl,
+    stopReason,
+  });
+  
   // Disconnect market feed with timeout
   try {
     await Promise.race([

package/src/services/ai/client.js

@@ -554,10 +554,44 @@ const fetchOpenAIModels = async (endpoint, apiKey) => {
     headers['Authorization'] = `Bearer ${apiKey}`;
   }
   
+  // Priority order for OpenAI models (newest/best first)
+  const modelPriority = [
+    'gpt-4.5-preview', 'gpt-4.5',
+    'o3', 'o3-mini', 'o3-mini-high',
+    'o1', 'o1-pro', 'o1-mini',
+    'gpt-4o', 'gpt-4o-mini', 'gpt-4o-audio-preview',
+    'gpt-4-turbo', 'gpt-4-turbo-preview',
+    'gpt-4', 'gpt-3.5-turbo'
+  ];
+  
   try {
     const response = await makeRequest(url, { method: 'GET', headers, timeout: 10000 });
     if (response.data && Array.isArray(response.data)) {
-      return response.data.map(m => m.id).filter(Boolean);
+      const allModels = response.data.map(m => m.id).filter(Boolean);
+      
+      // Filter to only chat/completion models, exclude embeddings/audio-only etc
+      const chatModels = allModels.filter(m => 
+        (m.includes('gpt') || m.includes('o1') || m.includes('o3')) &&
+        !m.includes('embedding') &&
+        !m.includes('whisper') &&
+        !m.includes('tts') &&
+        !m.includes('dall-e') &&
+        !m.includes('davinci') &&
+        !m.includes('babbage') &&
+        !m.includes('instruct')
+      );
+      
+      // Sort by priority
+      chatModels.sort((a, b) => {
+        const aIdx = modelPriority.findIndex(p => a.includes(p));
+        const bIdx = modelPriority.findIndex(p => b.includes(p));
+        if (aIdx === -1 && bIdx === -1) return 0;
+        if (aIdx === -1) return 1;
+        if (bIdx === -1) return -1;
+        return aIdx - bIdx;
+      });
+      
+      return chatModels.length > 0 ? chatModels : allModels;
     }
     return null;
   } catch (error) {

package/src/services/session-history.js

@@ -0,0 +1,475 @@
+/**
+ * =============================================================================
+ * Session History - Persistent learning across trading sessions
+ * =============================================================================
+ * 
+ * Saves all trading activity for AI agents to learn from:
+ * - Trade entries/exits with P&L
+ * - Signals generated (taken and skipped)
+ * - Market conditions at each signal
+ * - AI recommendations and outcomes
+ * 
+ * Data is stored in ~/.hqx/history/ as JSON files
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// History directory
+const HISTORY_DIR = path.join(os.homedir(), '.hqx', 'history');
+const MAX_SESSIONS = 100; // Keep last 100 sessions
+const MAX_TRADES_PER_FILE = 1000;
+
+/**
+ * Ensure history directory exists
+ */
+function ensureDir() {
+  if (!fs.existsSync(HISTORY_DIR)) {
+    fs.mkdirSync(HISTORY_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Session History Manager
+ */
+class SessionHistory {
+  constructor() {
+    this.sessionId = null;
+    this.sessionFile = null;
+    this.data = {
+      sessionId: null,
+      startTime: null,
+      endTime: null,
+      account: null,
+      symbol: null,
+      propfirm: null,
+      config: {},
+      trades: [],
+      signals: [],
+      aiRecommendations: [],
+      marketConditions: [],
+      summary: {
+        totalTrades: 0,
+        wins: 0,
+        losses: 0,
+        breakeven: 0,
+        totalPnl: 0,
+        maxDrawdown: 0,
+        winRate: 0,
+        avgWin: 0,
+        avgLoss: 0,
+        profitFactor: 0,
+      }
+    };
+    this.dirty = false;
+    this.saveTimer = null;
+  }
+
+  /**
+   * Start a new session
+   */
+  start(accountId, symbol, propfirm, config = {}) {
+    ensureDir();
+    
+    this.sessionId = `${Date.now()}_${accountId}_${symbol}`;
+    this.sessionFile = path.join(HISTORY_DIR, `session_${this.sessionId}.json`);
+    
+    this.data = {
+      sessionId: this.sessionId,
+      startTime: new Date().toISOString(),
+      endTime: null,
+      account: accountId,
+      symbol,
+      propfirm,
+      config: {
+        contracts: config.contracts || 1,
+        dailyTarget: config.dailyTarget || 0,
+        maxRisk: config.maxRisk || 0,
+        aiEnabled: config.aiEnabled || false,
+        agentCount: config.agentCount || 0,
+      },
+      trades: [],
+      signals: [],
+      aiRecommendations: [],
+      marketConditions: [],
+      summary: {
+        totalTrades: 0,
+        wins: 0,
+        losses: 0,
+        breakeven: 0,
+        totalPnl: 0,
+        maxDrawdown: 0,
+        winRate: 0,
+        avgWin: 0,
+        avgLoss: 0,
+        profitFactor: 0,
+      }
+    };
+    
+    this.dirty = true;
+    this._scheduleSave();
+    
+    return this.sessionId;
+  }
+
+  /**
+   * Record a trade signal (generated by strategy)
+   */
+  recordSignal(signal) {
+    if (!this.sessionId) return;
+    
+    this.data.signals.push({
+      timestamp: new Date().toISOString(),
+      direction: signal.direction,
+      entry: signal.entry,
+      stopLoss: signal.stopLoss,
+      takeProfit: signal.takeProfit,
+      confidence: signal.confidence,
+      taken: signal.taken !== false, // Default true unless explicitly false
+      skipReason: signal.skipReason || null,
+      // Market context
+      momentum: signal.momentum,
+      zscore: signal.zscore,
+      ofi: signal.ofi,
+      atr: signal.atr,
+      volume: signal.volume,
+    });
+    
+    this.dirty = true;
+    this._scheduleSave();
+  }
+
+  /**
+   * Record a trade entry
+   */
+  recordEntry(trade) {
+    if (!this.sessionId) return;
+    
+    const tradeRecord = {
+      id: `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      entryTime: new Date().toISOString(),
+      exitTime: null,
+      direction: trade.direction,
+      symbol: trade.symbol,
+      quantity: trade.quantity,
+      entryPrice: trade.entryPrice,
+      exitPrice: null,
+      stopLoss: trade.stopLoss,
+      takeProfit: trade.takeProfit,
+      pnl: null,
+      exitReason: null,
+      // Market context at entry
+      momentum: trade.momentum,
+      zscore: trade.zscore,
+      ofi: trade.ofi,
+      // AI context
+      aiAdvice: trade.aiAdvice || null,
+      aiConfidence: trade.aiConfidence || null,
+    };
+    
+    this.data.trades.push(tradeRecord);
+    this.dirty = true;
+    this._scheduleSave();
+    
+    return tradeRecord.id;
+  }
+
+  /**
+   * Record a trade exit
+   */
+  recordExit(tradeId, exitData) {
+    if (!this.sessionId) return;
+    
+    const trade = this.data.trades.find(t => t.id === tradeId);
+    if (!trade) {
+      // Find last unclosed trade
+      const unclosed = this.data.trades.filter(t => !t.exitTime);
+      if (unclosed.length > 0) {
+        const lastTrade = unclosed[unclosed.length - 1];
+        lastTrade.exitTime = new Date().toISOString();
+        lastTrade.exitPrice = exitData.exitPrice;
+        lastTrade.pnl = exitData.pnl;
+        lastTrade.exitReason = exitData.reason || 'unknown';
+      }
+    } else {
+      trade.exitTime = new Date().toISOString();
+      trade.exitPrice = exitData.exitPrice;
+      trade.pnl = exitData.pnl;
+      trade.exitReason = exitData.reason || 'unknown';
+    }
+    
+    this._updateSummary();
+    this.dirty = true;
+    this._scheduleSave();
+  }
+
+  /**
+   * Record AI recommendation
+   */
+  recordAIRecommendation(recommendation) {
+    if (!this.sessionId) return;
+    
+    this.data.aiRecommendations.push({
+      timestamp: new Date().toISOString(),
+      agent: recommendation.agent,
+      action: recommendation.action, // 'proceed', 'skip', 'adjust'
+      reason: recommendation.reason,
+      confidence: recommendation.confidence,
+      adjustment: recommendation.adjustment || null,
+      outcome: null, // Will be filled when trade closes
+    });
+    
+    this.dirty = true;
+    this._scheduleSave();
+  }
+
+  /**
+   * Record market conditions snapshot
+   */
+  recordMarketConditions(conditions) {
+    if (!this.sessionId) return;
+    
+    // Only record every 30 seconds to avoid bloat
+    const lastCondition = this.data.marketConditions[this.data.marketConditions.length - 1];
+    if (lastCondition) {
+      const timeDiff = Date.now() - new Date(lastCondition.timestamp).getTime();
+      if (timeDiff < 30000) return;
+    }
+    
+    this.data.marketConditions.push({
+      timestamp: new Date().toISOString(),
+      price: conditions.price,
+      bid: conditions.bid,
+      ask: conditions.ask,
+      volume: conditions.volume,
+      momentum: conditions.momentum,
+      zscore: conditions.zscore,
+      ofi: conditions.ofi,
+      volatility: conditions.volatility,
+    });
+    
+    // Keep only last 1000 conditions
+    if (this.data.marketConditions.length > 1000) {
+      this.data.marketConditions = this.data.marketConditions.slice(-1000);
+    }
+    
+    this.dirty = true;
+    this._scheduleSave();
+  }
+
+  /**
+   * End session and save final data
+   */
+  end(finalStats = {}) {
+    if (!this.sessionId) return;
+    
+    this.data.endTime = new Date().toISOString();
+    this.data.summary = {
+      ...this.data.summary,
+      ...finalStats,
+    };
+    
+    this._updateSummary();
+    this._saveNow();
+    this._cleanup();
+    
+    const sessionId = this.sessionId;
+    this.sessionId = null;
+    
+    return sessionId;
+  }
+
+  /**
+   * Load all historical sessions for AI learning
+   */
+  static loadHistory(limit = 50) {
+    ensureDir();
+    
+    try {
+      const files = fs.readdirSync(HISTORY_DIR)
+        .filter(f => f.startsWith('session_') && f.endsWith('.json'))
+        .sort()
+        .reverse()
+        .slice(0, limit);
+      
+      const sessions = [];
+      for (const file of files) {
+        try {
+          const data = JSON.parse(fs.readFileSync(path.join(HISTORY_DIR, file), 'utf8'));
+          sessions.push(data);
+        } catch (e) {
+          // Skip corrupted files
+        }
+      }
+      
+      return sessions;
+    } catch (e) {
+      return [];
+    }
+  }
+
+  /**
+   * Get aggregated learning data for AI
+   */
+  static getAILearningData() {
+    const sessions = SessionHistory.loadHistory(50);
+    
+    if (sessions.length === 0) {
+      return {
+        totalSessions: 0,
+        totalTrades: 0,
+        patterns: { winning: [], losing: [] },
+        statistics: null,
+      };
+    }
+    
+    // Aggregate all trades
+    const allTrades = sessions.flatMap(s => s.trades || []).filter(t => t.pnl !== null);
+    const winningTrades = allTrades.filter(t => t.pnl > 0);
+    const losingTrades = allTrades.filter(t => t.pnl < 0);
+    
+    // Extract patterns from winning trades
+    const winningPatterns = winningTrades.map(t => ({
+      direction: t.direction,
+      momentum: t.momentum,
+      zscore: t.zscore,
+      ofi: t.ofi,
+      pnl: t.pnl,
+    })).slice(-100); // Last 100 winning patterns
+    
+    // Extract patterns from losing trades
+    const losingPatterns = losingTrades.map(t => ({
+      direction: t.direction,
+      momentum: t.momentum,
+      zscore: t.zscore,
+      ofi: t.ofi,
+      pnl: t.pnl,
+    })).slice(-100); // Last 100 losing patterns
+    
+    // Calculate aggregate statistics
+    const totalPnl = allTrades.reduce((sum, t) => sum + (t.pnl || 0), 0);
+    const winRate = allTrades.length > 0 ? winningTrades.length / allTrades.length : 0;
+    const avgWin = winningTrades.length > 0 
+      ? winningTrades.reduce((sum, t) => sum + t.pnl, 0) / winningTrades.length 
+      : 0;
+    const avgLoss = losingTrades.length > 0 
+      ? Math.abs(losingTrades.reduce((sum, t) => sum + t.pnl, 0) / losingTrades.length)
+      : 0;
+    const profitFactor = avgLoss > 0 ? (avgWin * winRate) / (avgLoss * (1 - winRate)) : 0;
+    
+    return {
+      totalSessions: sessions.length,
+      totalTrades: allTrades.length,
+      patterns: {
+        winning: winningPatterns,
+        losing: losingPatterns,
+      },
+      statistics: {
+        totalPnl,
+        winRate,
+        avgWin,
+        avgLoss,
+        profitFactor,
+        winningTrades: winningTrades.length,
+        losingTrades: losingTrades.length,
+      },
+      // AI recommendations effectiveness
+      aiRecommendations: sessions.flatMap(s => s.aiRecommendations || []).slice(-200),
+    };
+  }
+
+  /**
+   * Update summary statistics
+   */
+  _updateSummary() {
+    const trades = this.data.trades.filter(t => t.pnl !== null);
+    const wins = trades.filter(t => t.pnl > 0);
+    const losses = trades.filter(t => t.pnl < 0);
+    const breakeven = trades.filter(t => t.pnl === 0);
+    
+    const totalPnl = trades.reduce((sum, t) => sum + t.pnl, 0);
+    const avgWin = wins.length > 0 ? wins.reduce((sum, t) => sum + t.pnl, 0) / wins.length : 0;
+    const avgLoss = losses.length > 0 ? Math.abs(losses.reduce((sum, t) => sum + t.pnl, 0) / losses.length) : 0;
+    
+    // Calculate max drawdown
+    let peak = 0;
+    let maxDrawdown = 0;
+    let cumPnl = 0;
+    for (const trade of trades) {
+      cumPnl += trade.pnl;
+      if (cumPnl > peak) peak = cumPnl;
+      const drawdown = peak - cumPnl;
+      if (drawdown > maxDrawdown) maxDrawdown = drawdown;
+    }
+    
+    this.data.summary = {
+      totalTrades: trades.length,
+      wins: wins.length,
+      losses: losses.length,
+      breakeven: breakeven.length,
+      totalPnl,
+      maxDrawdown,
+      winRate: trades.length > 0 ? wins.length / trades.length : 0,
+      avgWin,
+      avgLoss,
+      profitFactor: avgLoss > 0 ? avgWin / avgLoss : 0,
+    };
+  }
+
+  /**
+   * Schedule a save (debounced)
+   */
+  _scheduleSave() {
+    if (this.saveTimer) return;
+    this.saveTimer = setTimeout(() => {
+      this._saveNow();
+      this.saveTimer = null;
+    }, 5000); // Save every 5 seconds if dirty
+  }
+
+  /**
+   * Save immediately
+   */
+  _saveNow() {
+    if (!this.dirty || !this.sessionFile) return;
+    
+    try {
+      fs.writeFileSync(this.sessionFile, JSON.stringify(this.data, null, 2));
+      this.dirty = false;
+    } catch (e) {
+      // Silent fail - don't interrupt trading
+    }
+  }
+
+  /**
+   * Cleanup old sessions
+   */
+  _cleanup() {
+    try {
+      const files = fs.readdirSync(HISTORY_DIR)
+        .filter(f => f.startsWith('session_') && f.endsWith('.json'))
+        .sort();
+      
+      // Remove old sessions beyond MAX_SESSIONS
+      if (files.length > MAX_SESSIONS) {
+        const toRemove = files.slice(0, files.length - MAX_SESSIONS);
+        for (const file of toRemove) {
+          fs.unlinkSync(path.join(HISTORY_DIR, file));
+        }
+      }
+    } catch (e) {
+      // Silent fail
+    }
+  }
+}
+
+// Singleton instance
+const sessionHistory = new SessionHistory();
+
+module.exports = {
+  SessionHistory,
+  sessionHistory,
+};