hedgequantx 2.6.160 → 2.6.161

package/package.json

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

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

@@ -17,535 +17,19 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { analyzePerformance, getMarketAdvice, callAI } = require('./client');
+const {
+  calculateTrendStrength, calculateRecentRange, calculatePriceVelocity,
+  getMarketSession, getMinutesSinceOpen, analyzePriceLevelInteraction,
+  determineLevelType, analyzePriceAction, analyzeVolume, calculateVolatility
+} = require('./supervisor-utils');
 
 // Path for persisted learning data
-const DATA_DIR = path.join(os.homedir(), '.hqx');
-const LEARNING_FILE = path.join(DATA_DIR, 'ai-learning.json');
 
-/**
- * Load persisted learning data from disk
- * Contains full memory of strategy behavior over weeks/months
- */
-const loadLearningData = () => {
-  try {
-    if (!fs.existsSync(DATA_DIR)) {
-      fs.mkdirSync(DATA_DIR, { recursive: true });
-    }
-    
-    if (fs.existsSync(LEARNING_FILE)) {
-      const data = JSON.parse(fs.readFileSync(LEARNING_FILE, 'utf8'));
-      
-      // Clean old sessions (keep only last 1 month / 31 days)
-      const oneMonthAgo = Date.now() - (31 * 24 * 60 * 60 * 1000);
-      const sessions = (data.sessions || []).filter(s => 
-        new Date(s.date).getTime() > oneMonthAgo
-      );
-      
-      return {
-        // Pattern memory
-        winningPatterns: data.winningPatterns || [],
-        losingPatterns: data.losingPatterns || [],
-        
-        // Optimization history
-        optimizations: data.optimizations || [],
-        
-        // Symbol-specific data (NQ, ES, etc.)
-        symbols: data.symbols || {},
-        
-        // Full session history (last 30 days)
-        sessions: sessions,
-        
-        // Hourly performance analysis
-        hourlyStats: data.hourlyStats || {},
-        
-        // Day of week analysis
-        dayOfWeekStats: data.dayOfWeekStats || {},
-        
-        // Strategy behavior profile
-        strategyProfile: data.strategyProfile || {
-          bestHours: [],
-          worstHours: [],
-          avgWinStreak: 0,
-          avgLossStreak: 0,
-          preferredConditions: null
-        },
-        
-        // Lifetime stats
-        totalSessions: data.totalSessions || 0,
-        totalTrades: data.totalTrades || 0,
-        totalWins: data.totalWins || 0,
-        totalLosses: data.totalLosses || 0,
-        lifetimePnL: data.lifetimePnL || 0,
-        
-        lastUpdated: data.lastUpdated || null,
-        firstSession: data.firstSession || null
-      };
-    }
-  } catch (e) {
-    // Silent fail - start fresh
-  }
-  
-  return {
-    winningPatterns: [],
-    losingPatterns: [],
-    optimizations: [],
-    symbols: {},
-    sessions: [],
-    hourlyStats: {},
-    dayOfWeekStats: {},
-    strategyProfile: {
-      bestHours: [],
-      worstHours: [],
-      avgWinStreak: 0,
-      avgLossStreak: 0,
-      preferredConditions: null
-    },
-    totalSessions: 0,
-    totalTrades: 0,
-    totalWins: 0,
-    totalLosses: 0,
-    lifetimePnL: 0,
-    lastUpdated: null,
-    firstSession: null
-  };
-};
-
-/**
- * Get or create symbol data structure
- */
-const getSymbolData = (symbolName) => {
-  const data = loadLearningData();
-  if (!data.symbols[symbolName]) {
-    return {
-      name: symbolName,
-      levels: [],           // Key price levels
-      sessions: [],         // Trading sessions history
-      patterns: [],         // Symbol-specific patterns
-      stats: {
-        trades: 0,
-        wins: 0,
-        losses: 0,
-        pnl: 0
-      }
-    };
-  }
-  return data.symbols[symbolName];
-};
-
-/**
- * Record a key price level for a symbol
- * Called when trades happen at significant levels
- */
-const recordPriceLevel = (symbolName, price, type, outcome) => {
-  // type: 'support', 'resistance', 'breakout', 'rejection'
-  // outcome: 'win', 'loss', 'neutral'
-  
-  const level = {
-    price: Math.round(price * 4) / 4, // Round to nearest 0.25
-    type,
-    outcome,
-    timestamp: Date.now(),
-    date: new Date().toISOString().split('T')[0],
-    hour: new Date().getHours()
-  };
-  
-  if (!supervisorState.currentSymbol) {
-    supervisorState.currentSymbol = symbolName;
-  }
-  
-  if (!supervisorState.symbolLevels) {
-    supervisorState.symbolLevels = [];
-  }
-  
-  // Check if level already exists (within 2 ticks)
-  const tickSize = symbolName.includes('NQ') ? 0.25 : 0.25;
-  const existing = supervisorState.symbolLevels.find(l => 
-    Math.abs(l.price - level.price) <= tickSize * 2
-  );
-  
-  if (existing) {
-    // Update existing level
-    existing.touches = (existing.touches || 1) + 1;
-    existing.lastTouch = Date.now();
-    existing.outcomes = existing.outcomes || [];
-    existing.outcomes.push(outcome);
-  } else {
-    // New level
-    level.touches = 1;
-    level.outcomes = [outcome];
-    supervisorState.symbolLevels.push(level);
-  }
-};
-
-/**
- * Analyze current price against known levels
- * Returns nearby important levels
- */
-const analyzeNearbyLevels = (symbolName, currentPrice) => {
-  const data = loadLearningData();
-  const symbolData = data.symbols[symbolName];
-  
-  if (!symbolData || !symbolData.levels || symbolData.levels.length === 0) {
-    return { nearbyLevels: [], message: 'No historical levels' };
-  }
-  
-  const tickSize = symbolName.includes('NQ') ? 0.25 : 0.25;
-  const range = tickSize * 20; // Look within 20 ticks
-  
-  const nearbyLevels = symbolData.levels
-    .filter(l => Math.abs(l.price - currentPrice) <= range)
-    .sort((a, b) => Math.abs(a.price - currentPrice) - Math.abs(b.price - currentPrice))
-    .slice(0, 5) // Top 5 nearest levels
-    .map(l => {
-      const winRate = l.outcomes ? 
-        l.outcomes.filter(o => o === 'win').length / l.outcomes.length : 0;
-      return {
-        price: l.price,
-        distance: Math.round((l.price - currentPrice) / tickSize),
-        type: l.type,
-        touches: l.touches || 1,
-        winRate: Math.round(winRate * 100),
-        direction: l.price > currentPrice ? 'above' : 'below'
-      };
-    });
-  
-  return {
-    nearbyLevels,
-    message: nearbyLevels.length > 0 ? 
-      `${nearbyLevels.length} known levels nearby` : 
-      'No known levels nearby'
-  };
-};
-
-/**
- * Save learning data to disk
- * Full memory of strategy behavior over 1 month
- */
-const saveLearningData = () => {
-  try {
-    if (!fs.existsSync(DATA_DIR)) {
-      fs.mkdirSync(DATA_DIR, { recursive: true });
-    }
-    
-    // Load existing data first
-    const existing = loadLearningData();
-    
-    const now = new Date();
-    const currentHour = now.getHours();
-    const currentDay = now.getDay(); // 0=Sunday, 1=Monday, etc.
-    const dayNames = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
-    
-    // Merge symbol data
-    const symbols = { ...existing.symbols };
-    if (supervisorState.currentSymbol) {
-      const sym = supervisorState.currentSymbol;
-      if (!symbols[sym]) {
-        symbols[sym] = {
-          name: sym,
-          levels: [],
-          sessions: [],
-          stats: { trades: 0, wins: 0, losses: 0, pnl: 0 },
-          hourlyStats: {},
-          dayOfWeekStats: {}
-        };
-      }
-      
-      // Merge levels - keep last 50 most important
-      const existingLevels = symbols[sym].levels || [];
-      const newLevels = supervisorState.symbolLevels || [];
-      symbols[sym].levels = mergeLevels(existingLevels, newLevels, 50);
-      
-      // Add current session summary
-      symbols[sym].sessions.push({
-        date: now.toISOString(),
-        hour: currentHour,
-        dayOfWeek: dayNames[currentDay],
-        trades: supervisorState.performance.trades,
-        wins: supervisorState.performance.wins,
-        losses: supervisorState.performance.losses,
-        pnl: supervisorState.performance.totalPnL,
-        levelsWorked: newLevels.length,
-        maxWinStreak: supervisorState.performance.maxWinStreak,
-        maxLossStreak: supervisorState.performance.maxLossStreak
-      });
-      
-      // Keep only last 31 days of sessions per symbol
-      const oneMonthAgo = Date.now() - (31 * 24 * 60 * 60 * 1000);
-      symbols[sym].sessions = symbols[sym].sessions.filter(s => 
-        new Date(s.date).getTime() > oneMonthAgo
-      );
-      
-      // Update symbol stats
-      symbols[sym].stats.trades += supervisorState.performance.trades;
-      symbols[sym].stats.wins += supervisorState.performance.wins;
-      symbols[sym].stats.losses += supervisorState.performance.losses;
-      symbols[sym].stats.pnl += supervisorState.performance.totalPnL;
-    }
-    
-    // Update hourly stats (which hours perform best)
-    const hourlyStats = { ...existing.hourlyStats };
-    const hourKey = String(currentHour);
-    if (!hourlyStats[hourKey]) {
-      hourlyStats[hourKey] = { trades: 0, wins: 0, losses: 0, pnl: 0 };
-    }
-    hourlyStats[hourKey].trades += supervisorState.performance.trades;
-    hourlyStats[hourKey].wins += supervisorState.performance.wins;
-    hourlyStats[hourKey].losses += supervisorState.performance.losses;
-    hourlyStats[hourKey].pnl += supervisorState.performance.totalPnL;
-    
-    // Update day of week stats
-    const dayOfWeekStats = { ...existing.dayOfWeekStats };
-    const dayKey = dayNames[currentDay];
-    if (!dayOfWeekStats[dayKey]) {
-      dayOfWeekStats[dayKey] = { trades: 0, wins: 0, losses: 0, pnl: 0 };
-    }
-    dayOfWeekStats[dayKey].trades += supervisorState.performance.trades;
-    dayOfWeekStats[dayKey].wins += supervisorState.performance.wins;
-    dayOfWeekStats[dayKey].losses += supervisorState.performance.losses;
-    dayOfWeekStats[dayKey].pnl += supervisorState.performance.totalPnL;
-    
-    // Build strategy profile from data
-    const strategyProfile = buildStrategyProfile(hourlyStats, dayOfWeekStats, existing.sessions);
-    
-    // Current session record
-    const currentSession = {
-      date: now.toISOString(),
-      symbol: supervisorState.currentSymbol,
-      hour: currentHour,
-      dayOfWeek: dayNames[currentDay],
-      trades: supervisorState.performance.trades,
-      wins: supervisorState.performance.wins,
-      losses: supervisorState.performance.losses,
-      pnl: supervisorState.performance.totalPnL,
-      maxWinStreak: supervisorState.performance.maxWinStreak,
-      maxLossStreak: supervisorState.performance.maxLossStreak,
-      optimizationsApplied: supervisorState.optimizations.length,
-      levelsLearned: (supervisorState.symbolLevels || []).length
-    };
-    
-    // Merge sessions (keep 1 month)
-    const oneMonthAgo = Date.now() - (31 * 24 * 60 * 60 * 1000);
-    const sessions = [...existing.sessions, currentSession].filter(s => 
-      new Date(s.date).getTime() > oneMonthAgo
-    );
-    
-    // Build data to save
-    const dataToSave = {
-      // Patterns - keep last 100 of each type
-      winningPatterns: mergePatterns(existing.winningPatterns, supervisorState.winningPatterns, 100),
-      losingPatterns: mergePatterns(existing.losingPatterns, supervisorState.losingPatterns, 100),
-      
-      // Optimizations history - keep last 50
-      optimizations: [...existing.optimizations, ...supervisorState.optimizations].slice(-50),
-      
-      // Symbol-specific data
-      symbols,
-      
-      // Full session history (1 month)
-      sessions,
-      
-      // Performance by hour and day
-      hourlyStats,
-      dayOfWeekStats,
-      
-      // Strategy behavior profile
-      strategyProfile,
-      
-      // Lifetime stats
-      totalSessions: existing.totalSessions + 1,
-      totalTrades: existing.totalTrades + supervisorState.performance.trades,
-      totalWins: existing.totalWins + supervisorState.performance.wins,
-      totalLosses: existing.totalLosses + supervisorState.performance.losses,
-      lifetimePnL: existing.lifetimePnL + supervisorState.performance.totalPnL,
-      
-      // Metadata
-      firstSession: existing.firstSession || now.toISOString(),
-      lastUpdated: now.toISOString()
-    };
-    
-    fs.writeFileSync(LEARNING_FILE, JSON.stringify(dataToSave, null, 2));
-    return true;
-  } catch (e) {
-    return false;
-  }
-};
-
-/**
- * Build strategy profile from historical data
- * Identifies best/worst hours, days, and patterns
- */
-const buildStrategyProfile = (hourlyStats, dayOfWeekStats, sessions) => {
-  // Find best and worst hours
-  const hours = Object.entries(hourlyStats)
-    .map(([hour, stats]) => ({
-      hour: parseInt(hour),
-      winRate: stats.trades > 0 ? (stats.wins / stats.trades) * 100 : 0,
-      pnl: stats.pnl,
-      trades: stats.trades
-    }))
-    .filter(h => h.trades >= 3) // Need at least 3 trades to be significant
-    .sort((a, b) => b.winRate - a.winRate);
-  
-  const bestHours = hours.slice(0, 3).map(h => h.hour);
-  const worstHours = hours.slice(-3).map(h => h.hour);
-  
-  // Find best and worst days
-  const days = Object.entries(dayOfWeekStats)
-    .map(([day, stats]) => ({
-      day,
-      winRate: stats.trades > 0 ? (stats.wins / stats.trades) * 100 : 0,
-      pnl: stats.pnl,
-      trades: stats.trades
-    }))
-    .filter(d => d.trades >= 3)
-    .sort((a, b) => b.winRate - a.winRate);
-  
-  const bestDays = days.slice(0, 2).map(d => d.day);
-  const worstDays = days.slice(-2).map(d => d.day);
-  
-  // Calculate average streaks from sessions
-  let totalWinStreaks = 0, totalLossStreaks = 0, streakCount = 0;
-  for (const session of sessions) {
-    if (session.maxWinStreak) totalWinStreaks += session.maxWinStreak;
-    if (session.maxLossStreak) totalLossStreaks += session.maxLossStreak;
-    streakCount++;
-  }
-  
-  return {
-    bestHours,
-    worstHours,
-    bestDays,
-    worstDays,
-    avgWinStreak: streakCount > 0 ? Math.round(totalWinStreaks / streakCount * 10) / 10 : 0,
-    avgLossStreak: streakCount > 0 ? Math.round(totalLossStreaks / streakCount * 10) / 10 : 0,
-    totalSessionsAnalyzed: sessions.length
-  };
-};
-
-/**
- * Merge pattern arrays, keeping most recent unique entries
- */
-const mergePatterns = (existing, current, maxCount) => {
-  const merged = [...existing, ...current];
-  
-  // Sort by timestamp descending (most recent first)
-  merged.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
-  
-  // Keep only maxCount most recent
-  return merged.slice(0, maxCount);
-};
-
-/**
- * Merge price levels, prioritizing most touched and most recent
- */
-const mergeLevels = (existing, current, maxCount) => {
-  const merged = [...existing];
-  
-  for (const level of current) {
-    const tickSize = 0.25;
-    const existingIdx = merged.findIndex(l => 
-      Math.abs(l.price - level.price) <= tickSize * 2
-    );
-    
-    if (existingIdx >= 0) {
-      // Update existing level
-      merged[existingIdx].touches = (merged[existingIdx].touches || 1) + (level.touches || 1);
-      merged[existingIdx].lastTouch = Math.max(merged[existingIdx].lastTouch || 0, level.lastTouch || level.timestamp || 0);
-      merged[existingIdx].outcomes = [...(merged[existingIdx].outcomes || []), ...(level.outcomes || [])].slice(-20);
-    } else {
-      merged.push(level);
-    }
-  }
-  
-  // Sort by importance (touches * recency)
-  const now = Date.now();
-  merged.sort((a, b) => {
-    const scoreA = (a.touches || 1) * (1 / (1 + (now - (a.lastTouch || a.timestamp || 0)) / 86400000));
-    const scoreB = (b.touches || 1) * (1 / (1 + (now - (b.lastTouch || b.timestamp || 0)) / 86400000));
-    return scoreB - scoreA;
-  });
-  
-  return merged.slice(0, maxCount);
-};
-
-/**
- * DEPRECATED - moved inline
- */
-const mergePatternsDEP = (existing, current, maxCount) => {
-  const merged = [...existing, ...current];
-  merged.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
-  
-  // Keep only maxCount most recent
-  return merged.slice(0, maxCount);
-};
-
-// Singleton supervisor state
-let supervisorState = {
-  active: false,
-  agents: [],
-  strategy: null,
-  service: null,
-  accountId: null,
-  
-  // Current symbol being traded
-  currentSymbol: null,
-  
-  // Real-time data (synced with strategy)
-  ticks: [],
-  signals: [],
-  trades: [],
-  
-  // Symbol-specific levels learned this session
-  symbolLevels: [],
-  
-  // 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'
-  },
-  
-  // Behavior history for graph (action over time)
-  // Values: 0=PAUSE, 1=CAUTIOUS, 2=NORMAL, 3=AGGRESSIVE
-  behaviorHistory: [],
-  behaviorStartTime: null,
-  
-  // Lifetime stats loaded from previous sessions
-  lifetimeStats: null,
-  
-  // Previous sessions memory (loaded on init)
-  previousSessions: [],
-  
-  // Hourly performance tracking
-  hourlyPerformance: {}
-};
-
-// Analysis interval
-let analysisInterval = null;
+const {
+  DATA_DIR, LEARNING_FILE, loadLearningData, getSymbolData,
+  recordPriceLevel, analyzeNearbyLevels, saveLearningData,
+  buildStrategyProfile, mergePatterns, mergeLevels, clearLearningData
+} = require('./supervisor-data');
 
 /**
  * Initialize supervisor with strategy and agents
@@ -946,168 +430,6 @@ const feedTradeResult = (trade) => {
   }
 };
 
-/**
- * Calculate trend strength from ticks
- * Compares short-term vs medium-term trend
- */
-const calculateTrendStrength = (ticks) => {
-  if (!ticks || ticks.length < 20) return { strength: 0, direction: 'unknown' };
-  
-  const prices = ticks.map(t => t.price).filter(Boolean);
-  if (prices.length < 20) return { strength: 0, direction: 'unknown' };
-  
-  // Short-term trend (last 20)
-  const shortTerm = prices.slice(-20);
-  const shortChange = shortTerm[shortTerm.length - 1] - shortTerm[0];
-  
-  // Medium-term trend (last 50 or all)
-  const mediumTerm = prices.slice(-50);
-  const mediumChange = mediumTerm[mediumTerm.length - 1] - mediumTerm[0];
-  
-  // Strength = how aligned are short and medium trends
-  const aligned = (shortChange > 0 && mediumChange > 0) || (shortChange < 0 && mediumChange < 0);
-  const avgRange = Math.abs(Math.max(...prices) - Math.min(...prices)) || 1;
-  
-  return {
-    strength: aligned ? Math.min(1, (Math.abs(shortChange) + Math.abs(mediumChange)) / avgRange) : 0,
-    direction: mediumChange > 0 ? 'bullish' : mediumChange < 0 ? 'bearish' : 'neutral',
-    shortTermDirection: shortChange > 0 ? 'up' : shortChange < 0 ? 'down' : 'flat',
-    aligned
-  };
-};
-
-/**
- * Calculate recent price range
- */
-const calculateRecentRange = (ticks, count) => {
-  if (!ticks || ticks.length === 0) return { high: 0, low: 0, range: 0 };
-  
-  const prices = ticks.slice(-count).map(t => t.price).filter(Boolean);
-  if (prices.length === 0) return { high: 0, low: 0, range: 0 };
-  
-  const high = Math.max(...prices);
-  const low = Math.min(...prices);
-  
-  return { high, low, range: high - low };
-};
-
-/**
- * Calculate price velocity (speed of movement)
- */
-const calculatePriceVelocity = (ticks, count) => {
-  if (!ticks || ticks.length < 2) return { velocity: 0, acceleration: 0 };
-  
-  const recentTicks = ticks.slice(-count);
-  if (recentTicks.length < 2) return { velocity: 0, acceleration: 0 };
-  
-  const prices = recentTicks.map(t => t.price).filter(Boolean);
-  if (prices.length < 2) return { velocity: 0, acceleration: 0 };
-  
-  // Velocity = price change per tick
-  const totalChange = prices[prices.length - 1] - prices[0];
-  const velocity = totalChange / prices.length;
-  
-  // Acceleration = change in velocity
-  const midPoint = Math.floor(prices.length / 2);
-  const firstHalfVelocity = (prices[midPoint] - prices[0]) / midPoint;
-  const secondHalfVelocity = (prices[prices.length - 1] - prices[midPoint]) / (prices.length - midPoint);
-  const acceleration = secondHalfVelocity - firstHalfVelocity;
-  
-  return { velocity, acceleration };
-};
-
-/**
- * Get current market session
- */
-const getMarketSession = (hour) => {
-  // US Eastern Time sessions (adjust if needed)
-  if (hour >= 9 && hour < 12) return 'morning';
-  if (hour >= 12 && hour < 14) return 'midday';
-  if (hour >= 14 && hour < 16) return 'afternoon';
-  if (hour >= 16 && hour < 18) return 'close';
-  if (hour >= 18 || hour < 9) return 'overnight';
-  return 'unknown';
-};
-
-/**
- * Get minutes since market open (9:30 AM ET)
- */
-const getMinutesSinceOpen = (hour) => {
-  const marketOpenHour = 9;
-  const marketOpenMinute = 30;
-  const now = new Date();
-  const currentMinutes = hour * 60 + now.getMinutes();
-  const openMinutes = marketOpenHour * 60 + marketOpenMinute;
-  return Math.max(0, currentMinutes - openMinutes);
-};
-
-/**
- * Analyze price level interaction
- * Determines if entry was near support/resistance
- */
-const analyzePriceLevelInteraction = (entryPrice, ticks) => {
-  if (!ticks || ticks.length < 20) return null;
-  
-  const prices = ticks.map(t => t.price).filter(Boolean);
-  if (prices.length < 20) return null;
-  
-  const high = Math.max(...prices);
-  const low = Math.min(...prices);
-  const range = high - low || 1;
-  
-  // Position within range (0 = at low, 1 = at high)
-  const positionInRange = (entryPrice - low) / range;
-  
-  // Distance to recent high/low
-  const distanceToHigh = high - entryPrice;
-  const distanceToLow = entryPrice - low;
-  
-  // Determine level type
-  let levelType = 'middle';
-  if (positionInRange > 0.8) levelType = 'near_high';
-  else if (positionInRange < 0.2) levelType = 'near_low';
-  else if (positionInRange > 0.6) levelType = 'upper_middle';
-  else if (positionInRange < 0.4) levelType = 'lower_middle';
-  
-  return {
-    positionInRange: Math.round(positionInRange * 100) / 100,
-    distanceToHigh,
-    distanceToLow,
-    recentHigh: high,
-    recentLow: low,
-    levelType
-  };
-};
-
-/**
- * Determine what type of level this price represents
- */
-const determineLevelType = (price, ticks) => {
-  if (!ticks || ticks.length < 10) return 'unknown';
-  
-  const prices = ticks.map(t => t.price).filter(Boolean);
-  if (prices.length < 10) return 'unknown';
-  
-  const high = Math.max(...prices);
-  const low = Math.min(...prices);
-  const range = high - low || 1;
-  const tickSize = 0.25;
-  
-  // Check if near recent high (potential resistance)
-  if (Math.abs(price - high) <= tickSize * 4) return 'resistance';
-  
-  // Check if near recent low (potential support)
-  if (Math.abs(price - low) <= tickSize * 4) return 'support';
-  
-  // Check for breakout (above recent high)
-  if (price > high) return 'breakout_high';
-  
-  // Check for breakdown (below recent low)
-  if (price < low) return 'breakout_low';
-  
-  return 'middle';
-};
-
 /**
  * Learn from a completed trade
  * Extracts patterns from winning and losing trades
@@ -1215,69 +537,6 @@ const getHourlyWinRate = (hour) => {
   return null;
 };
 
-/**
- * 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
@@ -2019,20 +1278,6 @@ const getLifetimeStats = () => {
   };
 };
 
-/**
- * Clear all learned data (reset AI memory)
- */
-const clearLearningData = () => {
-  try {
-    if (fs.existsSync(LEARNING_FILE)) {
-      fs.unlinkSync(LEARNING_FILE);
-    }
-    return true;
-  } catch (e) {
-    return false;
-  }
-};
-
 module.exports = {
   // Core lifecycle
   initialize,

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

@@ -0,0 +1,195 @@
+/**
+ * Supervisor Data Management
+ * Handles persistence and data operations for AI learning
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const DATA_DIR = path.join(os.homedir(), '.hqx');
+const LEARNING_FILE = path.join(DATA_DIR, 'ai-learning.json');
+
+const loadLearningData = () => {
+  try {
+    if (!fs.existsSync(DATA_DIR)) {
+      fs.mkdirSync(DATA_DIR, { recursive: true });
+    }
+    if (fs.existsSync(LEARNING_FILE)) {
+      const data = JSON.parse(fs.readFileSync(LEARNING_FILE, 'utf8'));
+      const oneMonthAgo = Date.now() - (31 * 24 * 60 * 60 * 1000);
+      const sessions = (data.sessions || []).filter(s => 
+        new Date(s.date).getTime() > oneMonthAgo
+      );
+      return {
+        winningPatterns: data.winningPatterns || [],
+        losingPatterns: data.losingPatterns || [],
+        optimizations: data.optimizations || [],
+        symbols: data.symbols || {},
+        sessions,
+        hourlyStats: data.hourlyStats || {},
+        dayOfWeekStats: data.dayOfWeekStats || {},
+        strategyProfile: data.strategyProfile || {
+          bestHours: [], worstHours: [], avgWinStreak: 0, avgLossStreak: 0, preferredConditions: null
+        },
+        totalSessions: data.totalSessions || 0,
+        totalTrades: data.totalTrades || 0,
+        totalWins: data.totalWins || 0,
+        totalLosses: data.totalLosses || 0,
+        lifetimePnL: data.lifetimePnL || 0,
+        lastUpdated: data.lastUpdated || null,
+        firstSession: data.firstSession || null
+      };
+    }
+  } catch (e) { /* Silent fail */ }
+  return {
+    winningPatterns: [], losingPatterns: [], optimizations: [], symbols: {}, sessions: [],
+    hourlyStats: {}, dayOfWeekStats: {},
+    strategyProfile: { bestHours: [], worstHours: [], avgWinStreak: 0, avgLossStreak: 0, preferredConditions: null },
+    totalSessions: 0, totalTrades: 0, totalWins: 0, totalLosses: 0, lifetimePnL: 0,
+    lastUpdated: null, firstSession: null
+  };
+};
+
+const getSymbolData = (symbolName) => {
+  const data = loadLearningData();
+  if (!data.symbols[symbolName]) {
+    return {
+      name: symbolName, levels: { support: [], resistance: [] },
+      patterns: { winning: [], losing: [] }, stats: { trades: 0, wins: 0, avgWin: 0, avgLoss: 0 }
+    };
+  }
+  return data.symbols[symbolName];
+};
+
+const recordPriceLevel = (symbolName, price, type, outcome) => {
+  const data = loadLearningData();
+  if (!data.symbols[symbolName]) {
+    data.symbols[symbolName] = {
+      name: symbolName, levels: { support: [], resistance: [] },
+      patterns: { winning: [], losing: [] }, stats: { trades: 0, wins: 0, avgWin: 0, avgLoss: 0 }
+    };
+  }
+  const symbol = data.symbols[symbolName];
+  const levelKey = type === 'support' ? 'support' : 'resistance';
+  const existingLevel = symbol.levels[levelKey].find(l => Math.abs(l.price - price) <= 0.5);
+  if (existingLevel) {
+    existingLevel.touches++;
+    existingLevel.lastTouched = Date.now();
+    if (outcome === 'held') existingLevel.held++;
+    else existingLevel.broken++;
+  } else {
+    symbol.levels[levelKey].push({
+      price, touches: 1, held: outcome === 'held' ? 1 : 0,
+      broken: outcome === 'broken' ? 1 : 0, firstSeen: Date.now(), lastTouched: Date.now()
+    });
+  }
+  symbol.levels[levelKey].sort((a, b) => b.touches - a.touches);
+  if (symbol.levels[levelKey].length > 20) {
+    symbol.levels[levelKey] = symbol.levels[levelKey].slice(0, 20);
+  }
+  saveLearningData(data);
+};
+
+const analyzeNearbyLevels = (symbolName, currentPrice) => {
+  const symbolData = getSymbolData(symbolName);
+  const nearby = { support: [], resistance: [] };
+  const range = 10;
+  symbolData.levels.support.forEach(level => {
+    if (Math.abs(level.price - currentPrice) <= range) {
+      nearby.support.push({ ...level, distance: currentPrice - level.price });
+    }
+  });
+  symbolData.levels.resistance.forEach(level => {
+    if (Math.abs(level.price - currentPrice) <= range) {
+      nearby.resistance.push({ ...level, distance: level.price - currentPrice });
+    }
+  });
+  nearby.support.sort((a, b) => a.distance - b.distance);
+  nearby.resistance.sort((a, b) => a.distance - b.distance);
+  return nearby;
+};
+
+const saveLearningData = (data) => {
+  try {
+    if (!fs.existsSync(DATA_DIR)) {
+      fs.mkdirSync(DATA_DIR, { recursive: true });
+    }
+    data.lastUpdated = new Date().toISOString();
+    fs.writeFileSync(LEARNING_FILE, JSON.stringify(data, null, 2));
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+const buildStrategyProfile = (hourlyStats, dayOfWeekStats, sessions) => {
+  const profile = { bestHours: [], worstHours: [], avgWinStreak: 0, avgLossStreak: 0, preferredConditions: null };
+  const hourlyArray = Object.entries(hourlyStats)
+    .filter(([_, stats]) => stats.trades >= 5)
+    .map(([hour, stats]) => ({ hour: parseInt(hour), winRate: stats.wins / stats.trades, trades: stats.trades, pnl: stats.pnl }));
+  hourlyArray.sort((a, b) => b.winRate - a.winRate);
+  profile.bestHours = hourlyArray.slice(0, 3).map(h => ({ hour: h.hour, winRate: Math.round(h.winRate * 100) }));
+  profile.worstHours = hourlyArray.slice(-3).reverse().map(h => ({ hour: h.hour, winRate: Math.round(h.winRate * 100) }));
+  if (sessions.length >= 5) {
+    const winStreaks = sessions.map(s => s.maxWinStreak || 0).filter(Boolean);
+    const lossStreaks = sessions.map(s => s.maxLossStreak || 0).filter(Boolean);
+    profile.avgWinStreak = winStreaks.length > 0 ? winStreaks.reduce((a, b) => a + b, 0) / winStreaks.length : 0;
+    profile.avgLossStreak = lossStreaks.length > 0 ? lossStreaks.reduce((a, b) => a + b, 0) / lossStreaks.length : 0;
+  }
+  return profile;
+};
+
+const mergePatterns = (existing, current, maxCount) => {
+  const merged = [...existing];
+  current.forEach(pattern => {
+    const similar = merged.find(p => p.timeContext?.hour === pattern.timeContext?.hour && p.direction === pattern.direction);
+    if (!similar) merged.push(pattern);
+  });
+  merged.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
+  return merged.slice(0, maxCount);
+};
+
+const mergeLevels = (existing, current, maxCount) => {
+  const merged = [...existing];
+  current.forEach(level => {
+    const similar = merged.find(l => Math.abs(l.price - level.price) <= 0.5);
+    if (similar) {
+      similar.touches += level.touches || 1;
+      similar.held += level.held || 0;
+      similar.broken += level.broken || 0;
+      similar.lastTouched = Math.max(similar.lastTouched || 0, level.lastTouched || Date.now());
+    } else {
+      merged.push(level);
+    }
+  });
+  merged.sort((a, b) => b.touches - a.touches);
+  return merged.slice(0, maxCount);
+};
+
+const clearLearningData = () => {
+  try {
+    if (fs.existsSync(LEARNING_FILE)) {
+      fs.unlinkSync(LEARNING_FILE);
+    }
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+module.exports = {
+  DATA_DIR,
+  LEARNING_FILE,
+  loadLearningData,
+  getSymbolData,
+  recordPriceLevel,
+  analyzeNearbyLevels,
+  saveLearningData,
+  buildStrategyProfile,
+  mergePatterns,
+  mergeLevels,
+  clearLearningData
+};

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

@@ -0,0 +1,158 @@
+/**
+ * Supervisor Utility Functions
+ * Pure functions for market analysis - no state dependencies
+ */
+
+'use strict';
+
+const calculateTrendStrength = (ticks) => {
+  if (!ticks || ticks.length < 20) return { strength: 0, direction: 'unknown' };
+  const prices = ticks.map(t => t.price).filter(Boolean);
+  if (prices.length < 20) return { strength: 0, direction: 'unknown' };
+  const shortTerm = prices.slice(-20);
+  const shortChange = shortTerm[shortTerm.length - 1] - shortTerm[0];
+  const mediumTerm = prices.slice(-50);
+  const mediumChange = mediumTerm[mediumTerm.length - 1] - mediumTerm[0];
+  const aligned = (shortChange > 0 && mediumChange > 0) || (shortChange < 0 && mediumChange < 0);
+  const avgRange = Math.abs(Math.max(...prices) - Math.min(...prices)) || 1;
+  return {
+    strength: aligned ? Math.min(1, (Math.abs(shortChange) + Math.abs(mediumChange)) / avgRange) : 0,
+    direction: mediumChange > 0 ? 'bullish' : mediumChange < 0 ? 'bearish' : 'neutral',
+    shortTermDirection: shortChange > 0 ? 'up' : shortChange < 0 ? 'down' : 'flat',
+    aligned
+  };
+};
+
+const calculateRecentRange = (ticks, count) => {
+  if (!ticks || ticks.length === 0) return { high: 0, low: 0, range: 0 };
+  const prices = ticks.slice(-count).map(t => t.price).filter(Boolean);
+  if (prices.length === 0) return { high: 0, low: 0, range: 0 };
+  const high = Math.max(...prices);
+  const low = Math.min(...prices);
+  return { high, low, range: high - low };
+};
+
+const calculatePriceVelocity = (ticks, count) => {
+  if (!ticks || ticks.length < 2) return { velocity: 0, acceleration: 0 };
+  const recentTicks = ticks.slice(-count);
+  if (recentTicks.length < 2) return { velocity: 0, acceleration: 0 };
+  const prices = recentTicks.map(t => t.price).filter(Boolean);
+  if (prices.length < 2) return { velocity: 0, acceleration: 0 };
+  const totalChange = prices[prices.length - 1] - prices[0];
+  const velocity = totalChange / prices.length;
+  const midPoint = Math.floor(prices.length / 2);
+  const firstHalfVelocity = (prices[midPoint] - prices[0]) / midPoint;
+  const secondHalfVelocity = (prices[prices.length - 1] - prices[midPoint]) / (prices.length - midPoint);
+  const acceleration = secondHalfVelocity - firstHalfVelocity;
+  return { velocity, acceleration };
+};
+
+const getMarketSession = (hour) => {
+  if (hour >= 9 && hour < 12) return 'morning';
+  if (hour >= 12 && hour < 14) return 'midday';
+  if (hour >= 14 && hour < 16) return 'afternoon';
+  if (hour >= 16 && hour < 18) return 'close';
+  if (hour >= 18 || hour < 9) return 'overnight';
+  return 'unknown';
+};
+
+const getMinutesSinceOpen = (hour) => {
+  const now = new Date();
+  const currentMinutes = hour * 60 + now.getMinutes();
+  const openMinutes = 9 * 60 + 30;
+  return Math.max(0, currentMinutes - openMinutes);
+};
+
+const analyzePriceLevelInteraction = (entryPrice, ticks) => {
+  if (!ticks || ticks.length < 20) return null;
+  const prices = ticks.map(t => t.price).filter(Boolean);
+  if (prices.length < 20) return null;
+  const high = Math.max(...prices);
+  const low = Math.min(...prices);
+  const range = high - low || 1;
+  const positionInRange = (entryPrice - low) / range;
+  let levelType = 'middle';
+  if (positionInRange > 0.8) levelType = 'near_high';
+  else if (positionInRange < 0.2) levelType = 'near_low';
+  else if (positionInRange > 0.6) levelType = 'upper_middle';
+  else if (positionInRange < 0.4) levelType = 'lower_middle';
+  return {
+    positionInRange: Math.round(positionInRange * 100) / 100,
+    distanceToHigh: high - entryPrice,
+    distanceToLow: entryPrice - low,
+    recentHigh: high,
+    recentLow: low,
+    levelType
+  };
+};
+
+const determineLevelType = (price, ticks) => {
+  if (!ticks || ticks.length < 10) return 'unknown';
+  const prices = ticks.map(t => t.price).filter(Boolean);
+  if (prices.length < 10) return 'unknown';
+  const high = Math.max(...prices);
+  const low = Math.min(...prices);
+  const tickSize = 0.25;
+  if (Math.abs(price - high) <= tickSize * 4) return 'resistance';
+  if (Math.abs(price - low) <= tickSize * 4) return 'support';
+  if (price > high) return 'breakout_high';
+  if (price < low) return 'breakout_low';
+  return 'middle';
+};
+
+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
+  };
+};
+
+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;
+  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'
+  };
+};
+
+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);
+};
+
+module.exports = {
+  calculateTrendStrength,
+  calculateRecentRange,
+  calculatePriceVelocity,
+  getMarketSession,
+  getMinutesSinceOpen,
+  analyzePriceLevelInteraction,
+  determineLevelType,
+  analyzePriceAction,
+  analyzeVolume,
+  calculateVolatility
+};