hedgequantx 2.6.160 → 2.6.162

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,