hedgequantx 2.6.64 → 2.6.65

package/package.json

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

package/src/config/settings.js

@@ -166,6 +166,16 @@ const FAST_SCALPING = {
   LOG_LATENCY: true,
   LATENCY_TARGET_MS: 50,        // Target entry latency
   LATENCY_WARN_MS: 100,         // Warn if entry takes > 100ms
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // RECOVERY MODE - Math-based adaptive strategy when in drawdown
+  // Uses Kelly Criterion, Volatility scaling, and Win Rate adjustment
+  // ═══════════════════════════════════════════════════════════════════════════
+  RECOVERY: {
+    ENABLED: true,
+    ACTIVATION_PNL: -300,         // Activate recovery at -$300 session P&L
+    DEACTIVATION_PNL: -100,       // Deactivate when recovered to -$100
+  },
 };
 
 // ==================== DEBUG ====================

package/src/menus/ai-agent.js

@@ -434,10 +434,10 @@ const selectCategory = async () => {
   
   const categories = getCategories();
   
-  // Display in 2 columns
+  // Display in 2 columns - Numbers in cyan, titles in yellow
   console.log(make2ColRow(
-    chalk.green('[1] UNIFIED (RECOMMENDED)'),
-    chalk.cyan('[2] DIRECT PROVIDERS')
+    chalk.cyan('[1]') + chalk.yellow(' UNIFIED (RECOMMENDED)'),
+    chalk.cyan('[2]') + chalk.yellow(' DIRECT PROVIDERS')
   ));
   console.log(make2ColRow(
     chalk.white('    1 API = 100+ models'),
@@ -445,21 +445,20 @@ const selectCategory = async () => {
   ));
   console.log(makeLine(''));
   console.log(make2ColRow(
-    chalk.yellow('[3] LOCAL (FREE)'),
-    chalk.white('[4] CUSTOM')
+    chalk.cyan('[3]') + chalk.yellow(' LOCAL (FREE)'),
+    chalk.cyan('[4]') + chalk.yellow(' CUSTOM')
   ));
   console.log(make2ColRow(
     chalk.white('    Run on your machine'),
     chalk.white('    Self-hosted solutions')
   ));
-  console.log(makeLine(''));
-  console.log(makeLine(chalk.white('[<] BACK')));
   
   drawBoxFooter(boxWidth);
   
   const choice = await prompts.textInput(chalk.cyan('SELECT (1-4):'));
   
-  if (choice === '<' || choice?.toLowerCase() === 'b') {
+  // Empty input = go back
+  if (!choice || choice.trim() === '' || choice === '<' || choice?.toLowerCase() === 'b') {
     return await aiAgentMenu();
   }
   
@@ -510,18 +509,23 @@ const selectProvider = async (categoryId) => {
     return await selectCategory();
   }
   
-  // Display providers in 2 columns
+  // Display providers in 2 columns - Numbers in cyan, names in yellow
   for (let i = 0; i < providers.length; i += 2) {
     const left = providers[i];
     const right = providers[i + 1];
     
-    // Provider names
-    const leftName = `[${i + 1}] ${left.name}`;
-    const rightName = right ? `[${i + 2}] ${right.name}` : '';
+    // Provider names - number in cyan, name in yellow
+    const leftNum = `[${i + 1}]`;
+    const rightNum = right ? `[${i + 2}]` : '';
+    const leftName = ` ${left.name}`;
+    const rightName = right ? ` ${right.name}` : '';
+    
+    const leftFull = leftNum + leftName;
+    const rightFull = rightNum + rightName;
     
     console.log(make2ColRow(
-      chalk.cyan(leftName.length > col1Width - 3 ? leftName.substring(0, col1Width - 6) + '...' : leftName),
-      right ? chalk.cyan(rightName.length > col1Width - 3 ? rightName.substring(0, col1Width - 6) + '...' : rightName) : ''
+      chalk.cyan(leftNum) + chalk.yellow(leftName.length > col1Width - leftNum.length - 3 ? leftName.substring(0, col1Width - leftNum.length - 6) + '...' : leftName),
+      right ? chalk.cyan(rightNum) + chalk.yellow(rightName.length > col1Width - rightNum.length - 3 ? rightName.substring(0, col1Width - rightNum.length - 6) + '...' : rightName) : ''
     ));
     
     // Descriptions (truncated)
@@ -536,14 +540,13 @@ const selectProvider = async (categoryId) => {
     console.log(makeLine(''));
   }
   
-  console.log(makeLine(chalk.white('[<] BACK')));
-  
   drawBoxFooter(boxWidth);
   
   const maxNum = providers.length;
   const choice = await prompts.textInput(chalk.cyan(`SELECT (1-${maxNum}):`));
   
-  if (choice === '<' || choice?.toLowerCase() === 'b') {
+  // Empty input = go back
+  if (!choice || choice.trim() === '' || choice === '<' || choice?.toLowerCase() === 'b') {
     return await selectCategory();
   }
   
@@ -590,15 +593,15 @@ const selectProviderOption = async (provider) => {
   console.log(makeLine(chalk.white('SELECT CONNECTION METHOD:')));
   console.log(makeLine(''));
   
-  // Display options in 2 columns
+  // Display options in 2 columns - Numbers in cyan, labels in yellow
   for (let i = 0; i < provider.options.length; i += 2) {
     const left = provider.options[i];
     const right = provider.options[i + 1];
     
-    // Option labels
+    // Option labels - number in cyan, label in yellow
     console.log(make2ColRow(
-      chalk.cyan(`[${i + 1}] ${left.label}`),
-      right ? chalk.cyan(`[${i + 2}] ${right.label}`) : ''
+      chalk.cyan(`[${i + 1}]`) + chalk.yellow(` ${left.label}`),
+      right ? chalk.cyan(`[${i + 2}]`) + chalk.yellow(` ${right.label}`) : ''
     ));
     
     // First description line
@@ -622,13 +625,12 @@ const selectProviderOption = async (provider) => {
     console.log(makeLine(''));
   }
   
-  console.log(makeLine(chalk.white('[<] BACK')));
-  
   drawBoxFooter(boxWidth);
   
   const choice = await prompts.textInput(chalk.cyan('SELECT:'));
   
-  if (choice === '<' || choice?.toLowerCase() === 'b') {
+  // Empty input = go back
+  if (!choice || choice.trim() === '' || choice === '<' || choice?.toLowerCase() === 'b') {
     return await selectProvider(provider.category);
   }
   

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

@@ -22,6 +22,7 @@ const { hftStrategy } = require('../../services/strategy/hft-tick');
 const { MarketDataFeed } = require('../../../dist/lib/data');
 const { RithmicMarketDataFeed } = require('../../services/rithmic/market-data');
 const { algoLogger } = require('./logger');
+const { recoveryMath } = require('../../services/strategy/recovery-math');
 
 // Use HFT tick-based strategy for Rithmic (fast path), M1 for ProjectX
 const USE_HFT_STRATEGY = true;
@@ -331,13 +332,36 @@ const launchAlgo = async (service, account, contract, config) => {
       if (pnlTicks !== null && tickValue !== null) {
         const pnlDollars = pnlTicks * tickValue;
         stats.sessionPnl += pnlDollars; // Track session P&L
+        
+        // Record trade for Recovery Math
+        recoveryMath.recordTrade({
+          pnl: pnlDollars,
+          ticks: pnlTicks,
+          side: pnlTicks >= 0 ? 'win' : 'loss',
+          duration: holdDurationMs,
+        });
+        
+        // Update Recovery Mode state
+        const recovery = recoveryMath.updateSessionPnL(
+          stats.sessionPnl,
+          FAST_SCALPING.RECOVERY?.ACTIVATION_PNL || -300,
+          FAST_SCALPING.RECOVERY?.DEACTIVATION_PNL || -100
+        );
+        
+        // Log recovery mode changes
+        if (recovery.justActivated) {
+          stats.recoveryMode = true;
+          ui.addLog('warning', `RECOVERY MODE ON - Kelly: ${(recoveryMath.calcKelly() * 100).toFixed(0)}% | EV: $${recoveryMath.calcExpectedValue().toFixed(0)}`);
+        } else if (recovery.justDeactivated) {
+          stats.recoveryMode = false;
+          ui.addLog('success', `RECOVERY MODE OFF - Session P&L: $${stats.sessionPnl.toFixed(2)}`);
+        }
+        
         if (pnlDollars >= 0) {
           stats.wins++;
-          // Use 'win' type for green WIN icon
           ui.addLog('win', `+$${pnlDollars.toFixed(2)} @ ${exitPrice} | ${holdSec}s`);
         } else {
           stats.losses++;
-          // Use 'loss' type for red LOSS icon
           ui.addLog('loss', `-$${Math.abs(pnlDollars).toFixed(2)} @ ${exitPrice} | ${holdSec}s`);
         }
       } else {
@@ -508,6 +532,31 @@ const launchAlgo = async (service, account, contract, config) => {
     
     const { side, direction, entry, stopLoss, takeProfit, confidence } = signal;
     
+    // ═══════════════════════════════════════════════════════════════════════════
+    // RECOVERY MODE - Math-based adaptive trading
+    // Uses Kelly Criterion, Expected Value, and Volatility scaling
+    // ═══════════════════════════════════════════════════════════════════════════
+    if (FAST_SCALPING.RECOVERY?.ENABLED) {
+      const recoveryParams = recoveryMath.getRecoveryParams({
+        baseSize: contracts,
+        maxSize: contracts * 2,
+        atr: strategy.getATR?.() || 12,
+        confidence,
+        tickValue,
+      });
+      
+      // In recovery mode: only take positive EV trades
+      if (recoveryParams.recoveryActive && !recoveryParams.shouldTrade) {
+        ui.addLog('warning', `RECOVERY SKIP - EV: $${recoveryParams.expectedValue.toFixed(2)} (need $10+)`);
+        return;
+      }
+      
+      // Log recovery stats periodically
+      if (recoveryParams.recoveryActive && stats.trades % 3 === 0) {
+        ui.addLog('info', `RECOVERY - Kelly: ${(recoveryParams.kelly * 100).toFixed(0)}% | WR: ${(recoveryParams.winRate * 100).toFixed(0)}% | EV: $${recoveryParams.expectedValue.toFixed(0)}`);
+      }
+    }
+    
     // Feed signal to AI supervisor (agents observe the signal)
     if (stats.aiSupervision) {
       StrategySupervisor.feedSignal({ direction, entry, stopLoss, takeProfit, confidence });
@@ -520,8 +569,15 @@ const launchAlgo = async (service, account, contract, config) => {
       }
     }
     
-    // Calculate position size with kelly
-    let kelly = Math.min(0.25, confidence);
+    // Calculate position size with Kelly (math-based)
+    let kelly;
+    if (FAST_SCALPING.RECOVERY?.ENABLED && recoveryMath.trades.length >= 5) {
+      // Use math-based Kelly from trade history
+      kelly = recoveryMath.calcDrawdownAdjustedKelly();
+    } else {
+      // Fallback to confidence-based Kelly
+      kelly = Math.min(0.25, confidence);
+    }
     let riskAmount = Math.round(maxRisk * kelly);
     
     // AI may adjust size based on learning
@@ -680,6 +736,11 @@ const launchAlgo = async (service, account, contract, config) => {
     
     strategy.processTick(tickData);
     
+    // Feed price to Recovery Math for volatility calculation
+    if (FAST_SCALPING.RECOVERY?.ENABLED && tickData.price) {
+      recoveryMath.recordPriceReturn(tickData.price, stats.lastPrice || tickData.price);
+    }
+    
     // Feed price to position manager for exit monitoring (fast path)
     if (useFastPath && positionManager) {
       // Update latest price for position monitoring

package/src/services/strategy/recovery-math.js

@@ -0,0 +1,402 @@
+/**
+ * =============================================================================
+ * Recovery Mode - Mathematical Models for Drawdown Recovery
+ * =============================================================================
+ * 
+ * Uses pure math models to adapt strategy during drawdown:
+ * 
+ * 1. KELLY CRITERION - Optimal position sizing based on win rate & payoff
+ *    f* = (bp - q) / b
+ *    where: b = win/loss ratio, p = win probability, q = 1-p
+ * 
+ * 2. VOLATILITY SCALING - Adjust size inversely to recent volatility
+ *    size_adj = base_size * (target_vol / current_vol)
+ * 
+ * 3. ADAPTIVE THRESHOLDS - Dynamic TP/SL based on ATR
+ *    TP = entry ± (ATR * tp_multiplier)
+ *    SL = entry ± (ATR * sl_multiplier)
+ * 
+ * 4. EXPECTED VALUE FILTER - Only take trades with positive EV
+ *    EV = (win_prob * avg_win) - (loss_prob * avg_loss)
+ * 
+ * 5. DRAWDOWN-ADJUSTED KELLY - Reduce risk as drawdown deepens
+ *    kelly_adj = kelly * (1 - drawdown_pct / max_drawdown)
+ */
+
+'use strict';
+
+const { logger } = require('../../utils/logger');
+const log = logger.scope('RecoveryMath');
+
+/**
+ * Recovery Math Engine
+ * Calculates optimal parameters during drawdown using mathematical models
+ */
+class RecoveryMath {
+  constructor() {
+    // Trade history for calculations
+    this.trades = [];
+    this.maxTrades = 100; // Rolling window
+    
+    // Volatility tracking
+    this.priceReturns = [];
+    this.maxReturns = 200;
+    
+    // Session state
+    this.sessionPnL = 0;
+    this.peakPnL = 0;
+    this.drawdown = 0;
+    this.recoveryActive = false;
+    
+    // Default parameters (will be adjusted dynamically)
+    this.baseParams = {
+      targetTicks: 16,
+      stopTicks: 20,
+      kellyFraction: 0.25, // Use 25% of full Kelly (conservative)
+    };
+  }
+
+  /**
+   * Update session P&L and check recovery activation
+   * @param {number} pnl - Current session P&L
+   * @param {number} activationThreshold - e.g., -300
+   * @param {number} deactivationThreshold - e.g., -100
+   */
+  updateSessionPnL(pnl, activationThreshold = -300, deactivationThreshold = -100) {
+    this.sessionPnL = pnl;
+    
+    // Track peak for drawdown calculation
+    if (pnl > this.peakPnL) {
+      this.peakPnL = pnl;
+    }
+    
+    // Calculate current drawdown
+    this.drawdown = this.peakPnL - pnl;
+    
+    // Check recovery activation
+    const wasActive = this.recoveryActive;
+    
+    if (pnl <= activationThreshold && !this.recoveryActive) {
+      this.recoveryActive = true;
+      log.info('RECOVERY MODE ACTIVATED', { pnl, threshold: activationThreshold });
+    } else if (pnl >= deactivationThreshold && this.recoveryActive) {
+      this.recoveryActive = false;
+      log.info('RECOVERY MODE DEACTIVATED', { pnl, threshold: deactivationThreshold });
+    }
+    
+    return {
+      active: this.recoveryActive,
+      justActivated: this.recoveryActive && !wasActive,
+      justDeactivated: !this.recoveryActive && wasActive,
+      drawdown: this.drawdown,
+    };
+  }
+
+  /**
+   * Record a completed trade for statistics
+   * @param {Object} trade - { pnl, ticks, side, duration }
+   */
+  recordTrade(trade) {
+    this.trades.push({
+      pnl: trade.pnl,
+      ticks: trade.ticks,
+      side: trade.side,
+      duration: trade.duration,
+      timestamp: Date.now(),
+    });
+    
+    // Keep rolling window
+    if (this.trades.length > this.maxTrades) {
+      this.trades.shift();
+    }
+  }
+
+  /**
+   * Record price return for volatility calculation
+   * @param {number} price - Current price
+   * @param {number} prevPrice - Previous price
+   */
+  recordPriceReturn(price, prevPrice) {
+    if (prevPrice > 0) {
+      const ret = (price - prevPrice) / prevPrice;
+      this.priceReturns.push(ret);
+      
+      if (this.priceReturns.length > this.maxReturns) {
+        this.priceReturns.shift();
+      }
+    }
+  }
+
+  /**
+   * Calculate win rate from recent trades
+   * @returns {number} Win rate [0, 1]
+   */
+  calcWinRate() {
+    if (this.trades.length < 5) return 0.5; // Default 50% if insufficient data
+    
+    const wins = this.trades.filter(t => t.pnl > 0).length;
+    return wins / this.trades.length;
+  }
+
+  /**
+   * Calculate average win and loss
+   * @returns {{ avgWin: number, avgLoss: number, payoffRatio: number }}
+   */
+  calcPayoff() {
+    const wins = this.trades.filter(t => t.pnl > 0);
+    const losses = this.trades.filter(t => t.pnl < 0);
+    
+    const avgWin = wins.length > 0 
+      ? wins.reduce((s, t) => s + t.pnl, 0) / wins.length 
+      : 80; // Default $80 (16 ticks on NQ)
+    
+    const avgLoss = losses.length > 0 
+      ? Math.abs(losses.reduce((s, t) => s + t.pnl, 0) / losses.length)
+      : 100; // Default $100 (20 ticks on NQ)
+    
+    return {
+      avgWin,
+      avgLoss,
+      payoffRatio: avgWin / avgLoss,
+    };
+  }
+
+  /**
+   * Calculate Kelly Criterion for optimal bet sizing
+   * f* = (bp - q) / b
+   * where: b = win/loss ratio, p = win probability, q = 1-p
+   * 
+   * @returns {number} Kelly fraction [0, 1]
+   */
+  calcKelly() {
+    const winRate = this.calcWinRate();
+    const { payoffRatio } = this.calcPayoff();
+    
+    const p = winRate;
+    const q = 1 - p;
+    const b = payoffRatio;
+    
+    // Kelly formula
+    let kelly = (b * p - q) / b;
+    
+    // Clamp to reasonable range
+    kelly = Math.max(0, Math.min(1, kelly));
+    
+    return kelly;
+  }
+
+  /**
+   * Calculate drawdown-adjusted Kelly
+   * Reduces risk as drawdown deepens
+   * 
+   * @param {number} maxDrawdown - Maximum allowed drawdown (e.g., 500)
+   * @returns {number} Adjusted Kelly fraction
+   */
+  calcDrawdownAdjustedKelly(maxDrawdown = 500) {
+    const kelly = this.calcKelly();
+    
+    // Reduce Kelly based on current drawdown
+    // At 0% drawdown: use full Kelly
+    // At 100% max drawdown: use 0% Kelly
+    const drawdownPct = Math.min(1, this.drawdown / maxDrawdown);
+    const adjustment = 1 - (drawdownPct * 0.5); // Max 50% reduction
+    
+    return kelly * adjustment;
+  }
+
+  /**
+   * Calculate current volatility (standard deviation of returns)
+   * @returns {number} Volatility (annualized)
+   */
+  calcVolatility() {
+    if (this.priceReturns.length < 20) return 0.02; // Default 2%
+    
+    const mean = this.priceReturns.reduce((s, r) => s + r, 0) / this.priceReturns.length;
+    const variance = this.priceReturns.reduce((s, r) => s + Math.pow(r - mean, 2), 0) / this.priceReturns.length;
+    const stdDev = Math.sqrt(variance);
+    
+    return stdDev;
+  }
+
+  /**
+   * Calculate ATR-based thresholds
+   * @param {number} atr - Average True Range in ticks
+   * @returns {{ targetTicks: number, stopTicks: number }}
+   */
+  calcATRThresholds(atr) {
+    if (!atr || atr < 1) {
+      return {
+        targetTicks: this.baseParams.targetTicks,
+        stopTicks: this.baseParams.stopTicks,
+      };
+    }
+    
+    // Target = 1.5 * ATR (capture 1.5 average moves)
+    // Stop = 2 * ATR (allow 2 average moves against)
+    const targetTicks = Math.round(atr * 1.5);
+    const stopTicks = Math.round(atr * 2);
+    
+    // Clamp to reasonable range
+    return {
+      targetTicks: Math.max(8, Math.min(32, targetTicks)),
+      stopTicks: Math.max(10, Math.min(40, stopTicks)),
+    };
+  }
+
+  /**
+   * Calculate Expected Value of a trade setup
+   * EV = (win_prob * avg_win) - (loss_prob * avg_loss)
+   * 
+   * @param {number} confidence - Signal confidence [0, 1]
+   * @returns {number} Expected value in dollars
+   */
+  calcExpectedValue(confidence = 0.5) {
+    const baseWinRate = this.calcWinRate();
+    const { avgWin, avgLoss } = this.calcPayoff();
+    
+    // Adjust win rate by signal confidence
+    // Higher confidence = higher expected win rate
+    const adjustedWinRate = baseWinRate * (0.5 + confidence * 0.5);
+    
+    const ev = (adjustedWinRate * avgWin) - ((1 - adjustedWinRate) * avgLoss);
+    
+    return ev;
+  }
+
+  /**
+   * Get optimal position size using Kelly and volatility scaling
+   * @param {number} baseSize - Normal position size
+   * @param {number} maxSize - Maximum allowed size
+   * @param {number} targetVol - Target volatility (e.g., 0.02)
+   * @returns {number} Optimal position size
+   */
+  calcOptimalSize(baseSize, maxSize, targetVol = 0.02) {
+    // Get drawdown-adjusted Kelly
+    const kelly = this.calcDrawdownAdjustedKelly();
+    
+    // Get current volatility
+    const currentVol = this.calcVolatility();
+    
+    // Volatility scaling: reduce size when vol is high
+    const volScale = currentVol > 0 ? targetVol / currentVol : 1;
+    const volAdjusted = Math.min(2, Math.max(0.5, volScale)); // Clamp 0.5x - 2x
+    
+    // In recovery mode: use half Kelly (more conservative despite "aggressive")
+    // This is counter-intuitive but mathematically sound:
+    // - We want to recover, but not blow up
+    // - Half Kelly gives ~75% of optimal growth with much less variance
+    const kellyMultiplier = this.recoveryActive 
+      ? this.baseParams.kellyFraction * 0.75  // More conservative in recovery
+      : this.baseParams.kellyFraction;
+    
+    // Calculate optimal size
+    let optimalSize = baseSize * kelly * volAdjusted * kellyMultiplier * 4; // 4x because kelly is small
+    
+    // Clamp to max
+    optimalSize = Math.max(1, Math.min(maxSize, Math.round(optimalSize)));
+    
+    return optimalSize;
+  }
+
+  /**
+   * Get recovery parameters (thresholds, size, filter)
+   * All based on mathematical models
+   * 
+   * @param {Object} context - { baseSize, maxSize, atr, confidence, tickValue }
+   * @returns {Object} Recovery parameters
+   */
+  getRecoveryParams(context) {
+    const { baseSize = 1, maxSize = 5, atr = 12, confidence = 0.5, tickValue = 5 } = context;
+    
+    // Calculate all math-based values
+    const winRate = this.calcWinRate();
+    const { avgWin, avgLoss, payoffRatio } = this.calcPayoff();
+    const kelly = this.calcKelly();
+    const drawdownKelly = this.calcDrawdownAdjustedKelly();
+    const volatility = this.calcVolatility();
+    const ev = this.calcExpectedValue(confidence);
+    const { targetTicks, stopTicks } = this.calcATRThresholds(atr);
+    const optimalSize = this.calcOptimalSize(baseSize, maxSize);
+    
+    // Should we take this trade?
+    // In recovery: only take positive EV trades with high confidence
+    const minEV = this.recoveryActive ? 10 : 0; // Require $10 EV in recovery
+    const shouldTrade = ev >= minEV;
+    
+    return {
+      // Mode status
+      recoveryActive: this.recoveryActive,
+      sessionPnL: this.sessionPnL,
+      drawdown: this.drawdown,
+      
+      // Statistics
+      winRate,
+      avgWin,
+      avgLoss,
+      payoffRatio,
+      
+      // Kelly
+      kelly,
+      drawdownKelly,
+      
+      // Volatility
+      volatility,
+      
+      // Expected Value
+      expectedValue: ev,
+      shouldTrade,
+      
+      // Optimal parameters
+      optimalSize,
+      targetTicks,
+      stopTicks,
+      
+      // Breakeven (based on payoff ratio)
+      // If payoff > 1: early BE (lock small profit)
+      // If payoff < 1: late BE (need bigger moves)
+      breakevenTicks: payoffRatio >= 1 
+        ? Math.max(3, Math.round(targetTicks * 0.3))
+        : Math.max(4, Math.round(targetTicks * 0.4)),
+      
+      // Trailing (based on volatility)
+      // High vol: wider trail
+      // Low vol: tighter trail
+      trailingActivation: Math.round(targetTicks * 0.5),
+      trailingDistance: Math.max(2, Math.round(atr * 0.5)),
+    };
+  }
+
+  /**
+   * Get summary for logging
+   */
+  getSummary() {
+    return {
+      active: this.recoveryActive,
+      sessionPnL: this.sessionPnL,
+      drawdown: this.drawdown,
+      trades: this.trades.length,
+      winRate: (this.calcWinRate() * 100).toFixed(1) + '%',
+      kelly: (this.calcKelly() * 100).toFixed(1) + '%',
+      ev: '$' + this.calcExpectedValue().toFixed(2),
+    };
+  }
+
+  /**
+   * Reset state (new session)
+   */
+  reset() {
+    this.sessionPnL = 0;
+    this.peakPnL = 0;
+    this.drawdown = 0;
+    this.recoveryActive = false;
+    // Keep trade history for learning
+  }
+}
+
+// Singleton instance
+const recoveryMath = new RecoveryMath();
+
+module.exports = {
+  RecoveryMath,
+  recoveryMath,
+};