hedgequantx 2.9.197 → 2.9.199

package/package.json

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

package/src/lib/m/s1.js

@@ -113,6 +113,13 @@ class HQXUltraScalpingStrategy extends EventEmitter {
     this.recentTrades = [];
     this.winStreak = 0;
     this.lossStreak = 0;
+    
+    // === CRITICAL: Cooldown & Risk Management ===
+    this.lastSignalTime = 0;
+    this.signalCooldownMs = 30000;  // 30 seconds minimum between signals
+    this.maxConsecutiveLosses = 3;  // Stop trading after 3 consecutive losses
+    this.minConfidenceThreshold = 0.65;  // Minimum 65% confidence (was 55%)
+    this.tradingEnabled = true;
   }
 
   /**
@@ -266,6 +273,33 @@ class HQXUltraScalpingStrategy extends EventEmitter {
   // SIGNAL GENERATION
   // ===========================================================================
   _generateSignal(contractId, currentPrice, zscore, vpin, kyleLambda, kalmanEstimate, regime, volParams, ofi, bars) {
+    // CRITICAL: Check if trading is enabled
+    if (!this.tradingEnabled) {
+      this.emit('log', { type: 'debug', message: `Trading disabled (${this.lossStreak} consecutive losses)` });
+      return null;
+    }
+    
+    // CRITICAL: Check cooldown
+    const now = Date.now();
+    const timeSinceLastSignal = now - this.lastSignalTime;
+    if (timeSinceLastSignal < this.signalCooldownMs) {
+      // Silent - don't spam logs
+      return null;
+    }
+    
+    // CRITICAL: Check consecutive losses
+    if (this.lossStreak >= this.maxConsecutiveLosses) {
+      this.tradingEnabled = false;
+      this.emit('log', { type: 'info', message: `Trading paused: ${this.lossStreak} consecutive losses. Waiting for cooldown...` });
+      // Auto re-enable after 2 minutes
+      setTimeout(() => {
+        this.tradingEnabled = true;
+        this.lossStreak = 0;
+        this.emit('log', { type: 'info', message: 'Trading re-enabled after cooldown' });
+      }, 120000);
+      return null;
+    }
+    
     const absZscore = Math.abs(zscore);
     if (absZscore < volParams.zscoreThreshold) return null;
     if (vpin > this.vpinToxicThreshold) return null;
@@ -275,7 +309,13 @@ class HQXUltraScalpingStrategy extends EventEmitter {
     else if (zscore > volParams.zscoreThreshold) direction = 'short';
     else return null;
 
-    const ofiConfirms = (direction === 'long' && ofi > 0.1) || (direction === 'short' && ofi < -0.1);
+    // CRITICAL: OFI must confirm direction (stronger filter)
+    const ofiConfirms = (direction === 'long' && ofi > 0.15) || (direction === 'short' && ofi < -0.15);
+    if (!ofiConfirms) {
+      this.emit('log', { type: 'debug', message: `Signal rejected: OFI (${(ofi * 100).toFixed(1)}%) doesn't confirm ${direction}` });
+      return null;
+    }
+    
     const kalmanDiff = currentPrice - kalmanEstimate;
     const kalmanConfirms = (direction === 'long' && kalmanDiff < 0) || (direction === 'short' && kalmanDiff > 0);
 
@@ -293,7 +333,15 @@ class HQXUltraScalpingStrategy extends EventEmitter {
                        scores.kalman * 0.15 + scores.volatility * 0.10 + scores.ofi * 0.20;
 
     const confidence = Math.min(1.0, scores.composite + volParams.confidenceBonus);
-    if (confidence < 0.55) return null;
+    
+    // CRITICAL: Higher confidence threshold (65% minimum)
+    if (confidence < this.minConfidenceThreshold) {
+      this.emit('log', { type: 'debug', message: `Signal rejected: confidence ${(confidence * 100).toFixed(1)}% < ${this.minConfidenceThreshold * 100}%` });
+      return null;
+    }
+    
+    // Update last signal time
+    this.lastSignalTime = now;
 
     const stopTicks = Math.round(this.baseStopTicks * volParams.stopMultiplier);
     const targetTicks = Math.round(this.baseTargetTicks * volParams.targetMultiplier);
@@ -386,13 +434,36 @@ class HQXUltraScalpingStrategy extends EventEmitter {
   }
 
   /**
-   * Record trade result
+   * Record trade result - CRITICAL for risk management
+   * @param {number} pnl - Trade P&L (positive or negative)
    */
   recordTradeResult(pnl) {
+    // Only record actual trades (not P&L updates)
+    // A trade is considered closed when P&L changes significantly
+    const lastTrade = this.recentTrades[this.recentTrades.length - 1];
+    if (lastTrade && Math.abs(pnl - lastTrade.pnl) < 0.5) {
+      // Same P&L, ignore duplicate
+      return;
+    }
+    
     this.recentTrades.push({ pnl, timestamp: Date.now() });
     if (this.recentTrades.length > 100) this.recentTrades.shift();
-    if (pnl > 0) { this.winStreak++; this.lossStreak = 0; }
-    else { this.lossStreak++; this.winStreak = 0; }
+    
+    if (pnl > 0) {
+      this.winStreak++;
+      this.lossStreak = 0;
+      this.tradingEnabled = true;  // Re-enable on win
+      this.emit('log', { type: 'info', message: `WIN +$${pnl.toFixed(2)} | Streak: ${this.winStreak}` });
+    } else if (pnl < 0) {
+      this.lossStreak++;
+      this.winStreak = 0;
+      this.emit('log', { type: 'info', message: `LOSS $${pnl.toFixed(2)} | Streak: -${this.lossStreak}` });
+      
+      // Check if we need to pause trading
+      if (this.lossStreak >= this.maxConsecutiveLosses) {
+        this.emit('log', { type: 'info', message: `Max losses reached (${this.lossStreak}). Pausing...` });
+      }
+    }
   }
 
   /**
@@ -401,6 +472,97 @@ class HQXUltraScalpingStrategy extends EventEmitter {
   getBarHistory(contractId) {
     return this.barHistory.get(contractId) || [];
   }
+  
+  /**
+   * Get analysis state for logging/debugging
+   * @param {string} contractId - Contract ID
+   * @param {number} currentPrice - Current price
+   * @returns {Object} Current strategy state
+   */
+  getAnalysisState(contractId, currentPrice) {
+    const prices = this.priceBuffer.get(contractId);
+    const volumes = this.volumeBuffer.get(contractId);
+    const bars = this.barHistory.get(contractId);
+    
+    if (!prices || !volumes || !bars || bars.length < 20) {
+      return {
+        ready: false,
+        barsProcessed: bars?.length || 0,
+        swingsDetected: 0,
+        activeZones: 0,
+      };
+    }
+    
+    const zscore = computeZScore(prices);
+    const vpin = computeVPIN(volumes, this.vpinWindow);
+    const ofi = computeOrderFlowImbalance(bars, this.ofiLookback);
+    
+    return {
+      ready: bars.length >= 50,
+      barsProcessed: bars.length,
+      swingsDetected: 0,
+      activeZones: 0,
+      zScore: zscore,
+      vpin: vpin,
+      ofi: ofi,
+      tradingEnabled: this.tradingEnabled,
+      lossStreak: this.lossStreak,
+      winStreak: this.winStreak,
+      cooldownRemaining: Math.max(0, this.signalCooldownMs - (Date.now() - this.lastSignalTime)),
+    };
+  }
+  
+  /**
+   * Preload historical bars for faster warmup
+   * @param {string} contractId - Contract ID
+   * @param {Array} histBars - Historical bar data [{timestamp, open, high, low, close, volume}, ...]
+   */
+  preloadBars(contractId, histBars) {
+    if (!histBars || histBars.length === 0) return;
+    
+    if (!this.barHistory.has(contractId)) {
+      this.initialize(contractId);
+    }
+    
+    const bars = this.barHistory.get(contractId);
+    const prices = this.priceBuffer.get(contractId);
+    const volumes = this.volumeBuffer.get(contractId);
+    
+    for (const bar of histBars) {
+      bars.push({
+        timestamp: bar.timestamp,
+        open: bar.open,
+        high: bar.high,
+        low: bar.low,
+        close: bar.close,
+        volume: bar.volume || 1,
+        delta: 0,
+        tickCount: 1
+      });
+      
+      prices.push(bar.close);
+      
+      const barRange = bar.high - bar.low;
+      let buyVol = (bar.volume || 1) * 0.5;
+      let sellVol = (bar.volume || 1) * 0.5;
+      if (barRange > 0) {
+        const closePosition = (bar.close - bar.low) / barRange;
+        buyVol = (bar.volume || 1) * closePosition;
+        sellVol = (bar.volume || 1) * (1 - closePosition);
+      }
+      volumes.push({ buy: buyVol, sell: sellVol });
+    }
+    
+    // Trim to max sizes
+    while (bars.length > 500) bars.shift();
+    while (prices.length > 200) prices.shift();
+    while (volumes.length > 100) volumes.shift();
+    
+    // Set last bar time to now
+    this.lastBarTime.set(contractId, Date.now());
+    
+    this.emit('log', { type: 'info', message: `Preloaded ${histBars.length} bars for ${contractId}` });
+  }
 
   /**
    * Reset strategy