hedgequantx 2.9.239 → 2.9.241

package/dist/lib/m/s1-models.js

@@ -24,28 +24,30 @@
 'use strict';
 
 // =============================================================================
-// PRE-ALLOCATED REGIME PARAMETERS (avoid object creation)
+// REGIME PARAMETERS - EXACT MATCH TO PYTHON BACKTEST
+// Backtest Result: $2,012,373.75 | 146,685 trades | 71.1% WR
+// Z-Score Entry: >2.5 | Exit: <0.5 | Stop: 8 ticks | Target: 16 ticks
 // =============================================================================
 
 const REGIME_LOW = Object.freeze({
-  stopMultiplier: 0.8,
-  targetMultiplier: 0.9,
-  zscoreThreshold: 1.2,
-  confidenceBonus: 0.05
+  stopMultiplier: 1.0,
+  targetMultiplier: 1.0,
+  zscoreThreshold: 2.5,  // BACKTEST EXACT: 2.5
+  confidenceBonus: 0.0
 });
 
 const REGIME_NORMAL = Object.freeze({
   stopMultiplier: 1.0,
   targetMultiplier: 1.0,
-  zscoreThreshold: 1.5,
+  zscoreThreshold: 2.5,  // BACKTEST EXACT: 2.5
   confidenceBonus: 0.0
 });
 
 const REGIME_HIGH = Object.freeze({
-  stopMultiplier: 1.3,
-  targetMultiplier: 1.2,
-  zscoreThreshold: 2.0,
-  confidenceBonus: -0.05
+  stopMultiplier: 1.0,
+  targetMultiplier: 1.0,
+  zscoreThreshold: 2.5,  // BACKTEST EXACT: 2.5
+  confidenceBonus: 0.0
 });
 
 // Pre-allocated result object for Kalman filter (reused)
@@ -65,61 +67,49 @@ const _regimeResult = {
 // =============================================================================
 
 /**
- * Compute Z-Score with zero intermediate array allocations
- * Uses in-place calculation with index arithmetic
+ * Compute Z-Score - EXACT MATCH TO PYTHON BACKTEST
+ * 
+ * PYTHON CODE (from ultra_scalper_v2_protected.py):
+ * ```python
+ * for i in range(lookback, n):
+ *     window = prices[i-lookback:i]  # EXCLUDES current price!
+ *     mean = np.mean(window)
+ *     std = np.std(window)
+ *     if std > 0:
+ *         zscore[i] = (prices[i] - mean) / std
+ * ```
  * 
- * @param {number[]} prices - Price buffer (circular or linear)
- * @param {number} length - Actual number of valid prices
- * @param {number} window - Lookback window (default 50)
+ * CRITICAL: Mean/std are calculated from PREVIOUS 100 prices, NOT including current!
+ * 
+ * @param {number[]} prices - Price buffer
+ * @param {number} lookback - Lookback window (default 100 to match Python)
  * @returns {number} Z-Score value
  */
-function computeZScore(prices, window = 50) {
+function computeZScore(prices, lookback = 100) {
   const length = prices.length;
-  if (length === 0) return 0;
+  
+  // Need at least lookback+1 prices (lookback for window + 1 for current)
+  if (length <= lookback) return 0;
 
   const currentPrice = prices[length - 1];
   
-  // Determine effective window
-  const n = length < window ? length : window;
-  const startIdx = length - n;
+  // CRITICAL: Window is [i-lookback : i], which EXCLUDES current price
+  // This matches Python: window = prices[i-lookback:i]
+  const windowEnd = length - 1;  // Exclude current price
+  const windowStart = windowEnd - lookback;
   
-  // Single-pass mean calculation (no slice, no reduce)
+  // Single-pass mean and std calculation over lookback window
   let sum = 0;
   let sumSq = 0;
-  for (let i = startIdx; i < length; i++) {
+  for (let i = windowStart; i < windowEnd; i++) {
     const p = prices[i];
     sum += p;
-    sumSq += p * p;  // Faster than Math.pow(p, 2)
+    sumSq += p * p;
   }
   
-  const mean = sum / n;
-  const variance = (sumSq / n) - (mean * mean);
-  
-  // Blend cumulative and rolling std if enough data (like Python backtest)
-  let std;
-  if (length >= 100) {
-    const cumulativeStd = Math.sqrt(Math.max(0, variance));
-    
-    // Calculate rolling std over last 100 prices (in-place)
-    const rollingStart = length - 100;
-    let rollingSum = 0;
-    for (let i = rollingStart; i < length; i++) {
-      rollingSum += prices[i];
-    }
-    const rollingMean = rollingSum / 100;
-    
-    let rollingVarSum = 0;
-    for (let i = rollingStart; i < length; i++) {
-      const diff = prices[i] - rollingMean;
-      rollingVarSum += diff * diff;
-    }
-    const rollingStd = Math.sqrt(rollingVarSum / 100);
-    
-    // Blend: 30% cumulative, 70% rolling (matches Python)
-    std = cumulativeStd * 0.3 + rollingStd * 0.7;
-  } else {
-    std = Math.sqrt(Math.max(0, variance));
-  }
+  const mean = sum / lookback;
+  const variance = (sumSq / lookback) - (mean * mean);
+  const std = Math.sqrt(Math.max(0, variance));
 
   if (std < 0.0001) return 0;
   return (currentPrice - mean) / std;

package/dist/lib/m/ultra-scalping.js

@@ -79,21 +79,33 @@ class HQXUltraScalpingStrategy extends EventEmitter {
     this.tickSize = 0.25;
     this.tickValue = 5.0;
 
-    // === Model Parameters (BACKTEST VALIDATED - $2,012,373.75) ===
-    this.zscoreEntryThreshold = 2.5;  // BACKTEST: Z-Score Entry >2.5
-    this.zscoreExitThreshold = 0.5;
+    // ==========================================================================
+    // EXACT MATCH TO PYTHON BACKTEST CONFIG
+    // Result: $2,012,373.75 | 146,685 trades | 71.1% WR
+    // ==========================================================================
+    
+    // Z-Score Parameters (EXACT FROM PYTHON)
+    this.zscoreLookback = 100;        // PYTHON: zscore_lookback: 100
+    this.zscoreEntryThreshold = 2.5;  // PYTHON: zscore_entry: 2.5
+    this.zscoreExitThreshold = 0.5;   // PYTHON: zscore_exit: 0.5
+    
+    // Trade Parameters (EXACT FROM PYTHON)
+    this.baseStopTicks = 8;           // PYTHON: stop_ticks: 8
+    this.baseTargetTicks = 16;        // PYTHON: target_ticks: 16
+    this.breakevenTicks = 4;          // PYTHON: be_ticks: 4
+    this.trailActivationTicks = 6;    // PYTHON: trail_activation: 6
+    this.profitLockPct = 0.5;         // PYTHON: trail_pct: 0.5
+    
+    // Risk Management (EXACT FROM PYTHON)
+    this.cooldownTicks = 100;         // PYTHON: cooldown: 100
+    this.maxConsecutiveLosses = 10;   // PYTHON: max_consecutive_losses: 10
+    
+    // NOT USED AS FILTERS (Python doesn't use these)
     this.vpinWindow = 50;
     this.vpinToxicThreshold = 0.7;
+    this.ofiLookback = 20;
     this.kalmanProcessNoise = 0.01;
     this.kalmanMeasurementNoise = 0.1;
-    this.volatilityLookback = 100;
-    this.ofiLookback = 20;
-
-    // === Trade Parameters (BACKTEST VALIDATED) ===
-    this.baseStopTicks = 8;     // $40
-    this.baseTargetTicks = 16;  // $80
-    this.breakevenTicks = 4;    // Move to BE at +4 ticks
-    this.profitLockPct = 0.5;   // Lock 50% of profit
 
     // === State Storage ===
     this.barHistory = new Map();
@@ -102,22 +114,15 @@ class HQXUltraScalpingStrategy extends EventEmitter {
     this.volumeBuffer = new Map();
     this.tradesBuffer = new Map();
     this.atrHistory = new Map();
-
-    // === Tick aggregation ===
-    this.tickBuffer = new Map();
-    this.lastBarTime = new Map();
-    this.barIntervalMs = 5000; // 5-second bars
+    this.tickBuffer = new Map();      // For tick aggregation
+    this.lastBarTime = new Map();     // Last bar timestamp per contract
 
     // === Performance Tracking ===
+    this.tickCount = 0;               // Total ticks processed
+    this.lastSignalTick = 0;          // Tick count at last signal (for cooldown)
     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;
   }
 
@@ -171,8 +176,8 @@ class HQXUltraScalpingStrategy extends EventEmitter {
       this.initialize(contractId);
     }
     
-    // Track total ticks and last price
-    this._totalTicks = (this._totalTicks || 0) + 1;
+    // Track total ticks (CRITICAL for tick-based cooldown like Python)
+    this.tickCount++;
     this._lastPrice = price;
     this._currentContractId = contractId;
 
@@ -231,23 +236,21 @@ class HQXUltraScalpingStrategy extends EventEmitter {
       const vpinPct = (vpin * 100).toFixed(0);
       const zRounded = Math.round(zscore * 10) / 10; // Round to 0.1
       
-      // Check cooldown
-      const now = Date.now();
-      const timeSinceLastSignal = now - this.lastSignalTime;
-      const cooldownRemaining = Math.max(0, this.signalCooldownMs - timeSinceLastSignal);
+      // Check tick-based cooldown (matches Python)
+      const ticksSinceLastSignal = this.tickCount - this.lastSignalTick;
+      const cooldownRemaining = Math.max(0, this.cooldownTicks - ticksSinceLastSignal);
       
       // Trading disabled?
       if (!this.tradingEnabled) {
         state = 'paused';
         message = `[${sym}] ${priceStr} | PAUSED - ${this.lossStreak} losses | Cooldown active`;
       }
-      // In cooldown?
-      else if (cooldownRemaining > 0 && this.lastSignalTime > 0) {
-        const secs = Math.ceil(cooldownRemaining / 1000);
-        state = `cooldown-${secs}`;
-        message = `[${sym}] ${priceStr} | Cooldown ${secs}s | Z:${zRounded}σ OFI:${ofiPct}%`;
+      // In tick-based cooldown?
+      else if (cooldownRemaining > 0 && this.lastSignalTick > 0) {
+        state = `cooldown-${cooldownRemaining}`;
+        message = `[${sym}] ${priceStr} | Cooldown ${cooldownRemaining} ticks | Z:${zRounded}σ OFI:${ofiPct}%`;
       }
-      // VPIN toxic?
+      // VPIN toxic? (info only, not a hard filter)
       else if (vpin > this.vpinToxicThreshold) {
         state = 'vpin-toxic';
         message = `[${sym}] ${priceStr} | VPIN toxic ${vpinPct}% > 70% | No entry - informed traders active`;
@@ -394,51 +397,65 @@ class HQXUltraScalpingStrategy extends EventEmitter {
       return null;
     }
     
-    // CRITICAL: Check cooldown
-    const now = Date.now();
-    const timeSinceLastSignal = now - this.lastSignalTime;
-    if (timeSinceLastSignal < this.signalCooldownMs) {
+    // CRITICAL: Tick-based cooldown (MATCHES PYTHON: cooldown = 100 ticks)
+    // Python: if i - last_trade_idx < cooldown_ticks: continue
+    const ticksSinceLastSignal = this.tickCount - this.lastSignalTick;
+    if (ticksSinceLastSignal < this.cooldownTicks) {
       // Silent - don't spam logs
       return null;
     }
     
-    // CRITICAL: Check consecutive losses
+    // Extra cooldown after losses (MATCHES PYTHON)
+    // Python: extra_cooldown = consecutive_losses * 50
+    if (this.lossStreak > 0) {
+      const extraCooldown = this.lossStreak * 50;
+      if (ticksSinceLastSignal < this.cooldownTicks + extraCooldown) {
+        return null;
+      }
+    }
+    
+    // CRITICAL: Check consecutive losses (kill switch)
     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
+      // Auto re-enable after 1 hour (matches Python: 3600_000_000 us = 1 hour)
       setTimeout(() => {
         this.tradingEnabled = true;
         this.lossStreak = 0;
         this.emit('log', { type: 'info', message: 'Trading re-enabled after cooldown' });
-      }, 120000);
+      }, 3600000);
       return null;
     }
     
+    // =========================================================================
+    // ENTRY LOGIC - MATCHES PYTHON BACKTEST EXACTLY
+    // Python backtest: Z-Score >2.5 = entry, no OFI/VPIN/Kalman filters
+    // Result: 146,685 trades, 71.1% WR, $2,012,373.75
+    // =========================================================================
+    
     const absZscore = Math.abs(zscore);
+    
+    // Z-Score threshold check (ONLY filter from Python backtest)
     if (absZscore < volParams.zscoreThreshold) return null;
-    if (vpin > this.vpinToxicThreshold) return null;
 
+    // Determine direction based on Z-Score
     let direction;
-    if (zscore < -volParams.zscoreThreshold) direction = 'long';
-    else if (zscore > volParams.zscoreThreshold) direction = 'short';
+    if (zscore < -volParams.zscoreThreshold) direction = 'long';   // Price below mean = buy
+    else if (zscore > volParams.zscoreThreshold) direction = 'short'; // Price above mean = sell
     else return null;
-
-    // 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;
-    }
     
+    // OFI/VPIN/Kalman used for confidence scoring only (NOT as hard filters)
+    const ofiConfirms = (direction === 'long' && ofi > 0.1) || (direction === 'short' && ofi < -0.1);
     const kalmanDiff = currentPrice - kalmanEstimate;
     const kalmanConfirms = (direction === 'long' && kalmanDiff < 0) || (direction === 'short' && kalmanDiff > 0);
+    const vpinOk = vpin < this.vpinToxicThreshold;
 
+    // Composite confidence score (informational, not blocking)
     const scores = {
       zscore: Math.min(1.0, absZscore / 4.0),
-      vpin: 1.0 - vpin,
+      vpin: vpinOk ? (1.0 - vpin) : 0.3,
       kyleLambda: kyleLambda > 0.001 ? 0.5 : 0.8,
-      kalman: kalmanConfirms ? 0.8 : 0.4,
+      kalman: kalmanConfirms ? 0.8 : 0.5,
       volatility: regime === 'normal' ? 0.8 : regime === 'low' ? 0.7 : 0.6,
       ofi: ofiConfirms ? 0.9 : 0.5,
       composite: 0
@@ -449,14 +466,8 @@ class HQXUltraScalpingStrategy extends EventEmitter {
 
     const confidence = Math.min(1.0, scores.composite + volParams.confidenceBonus);
     
-    // 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;
+    // Update last signal tick (tick-based cooldown like Python)
+    this.lastSignalTick = this.tickCount;
 
     const stopTicks = Math.round(this.baseStopTicks * volParams.stopMultiplier);
     const targetTicks = Math.round(this.baseTargetTicks * volParams.targetMultiplier);
@@ -623,7 +634,8 @@ class HQXUltraScalpingStrategy extends EventEmitter {
       tradingEnabled: this.tradingEnabled,
       lossStreak: this.lossStreak,
       winStreak: this.winStreak,
-      cooldownRemaining: Math.max(0, this.signalCooldownMs - (Date.now() - this.lastSignalTime)),
+      cooldownRemaining: Math.max(0, this.cooldownTicks - (this.tickCount - this.lastSignalTick)),
+      tickCount: this.tickCount,
     };
   }
   

package/package.json

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

package/src/services/daemon/client.js

@@ -43,6 +43,21 @@ class DaemonClient extends EventEmitter {
     
     /** @type {Object|null} Cached daemon info */
     this.daemonInfo = null;
+    
+    /** @type {boolean} Auto-reconnect enabled */
+    this.autoReconnect = true;
+    
+    /** @type {number} Reconnect attempts */
+    this.reconnectAttempts = 0;
+    
+    /** @type {number} Max reconnect attempts */
+    this.maxReconnectAttempts = 10;
+    
+    /** @type {NodeJS.Timeout|null} Reconnect timer */
+    this.reconnectTimer = null;
+    
+    /** @type {boolean} Intentionally disconnecting */
+    this._disconnecting = false;
   }
   
   /**
@@ -64,6 +79,9 @@ class DaemonClient extends EventEmitter {
           this.daemonInfo = await this._request(MSG_TYPE.HANDSHAKE, null, TIMEOUTS.HANDSHAKE);
           log.debug('Handshake complete', this.daemonInfo);
           
+          // Reset reconnect attempts on successful connection
+          this.reconnectAttempts = 0;
+          
           // Start ping interval
           this._startPing();
           
@@ -84,8 +102,14 @@ class DaemonClient extends EventEmitter {
       
       this.socket.on('close', () => {
         log.debug('Disconnected from daemon');
+        const wasConnected = this.connected;
         this._cleanup();
         this.emit('disconnected');
+        
+        // Auto-reconnect if enabled and not intentionally disconnecting
+        if (wasConnected && this.autoReconnect && !this._disconnecting) {
+          this._scheduleReconnect();
+        }
       });
       
       this.socket.on('error', (err) => {
@@ -113,16 +137,28 @@ class DaemonClient extends EventEmitter {
   
   /**
    * Disconnect from daemon
+   * @param {boolean} [permanent=false] - If true, disable auto-reconnect
    */
-  disconnect() {
+  disconnect(permanent = false) {
+    this._disconnecting = true;
+    if (permanent) {
+      this.autoReconnect = false;
+    }
+    
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    
     if (this.socket) {
       this.socket.destroy();
     }
     this._cleanup();
+    this._disconnecting = false;
   }
   
   /**
-   * Cleanup state
+   * Cleanup state (does NOT clear reconnect state)
    */
   _cleanup() {
     this.connected = false;
@@ -137,6 +173,18 @@ class DaemonClient extends EventEmitter {
     this.socket = null;
   }
   
+  /**
+   * Enable/disable auto-reconnect
+   * @param {boolean} enable
+   */
+  setAutoReconnect(enable) {
+    this.autoReconnect = enable;
+    if (!enable && this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  
   /**
    * Start ping interval
    */
@@ -145,12 +193,49 @@ class DaemonClient extends EventEmitter {
       try {
         await this._request(MSG_TYPE.PING, null, TIMEOUTS.PING_TIMEOUT);
       } catch (err) {
-        log.warn('Ping failed, disconnecting');
-        this.disconnect();
+        log.warn('Ping failed, will auto-reconnect');
+        // Don't call disconnect() - let socket close trigger reconnect
+        if (this.socket) {
+          this.socket.destroy();
+        }
       }
     }, TIMEOUTS.PING_INTERVAL);
   }
   
+  /**
+   * Schedule auto-reconnect with exponential backoff
+   */
+  _scheduleReconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+    }
+    
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      log.error('Max reconnect attempts reached, giving up');
+      this.emit('reconnectFailed');
+      return;
+    }
+    
+    // Exponential backoff: 1s, 2s, 4s, 8s... max 30s
+    const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
+    this.reconnectAttempts++;
+    
+    log.debug(`Scheduling reconnect in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      log.debug('Attempting reconnect...');
+      
+      const success = await this.connect();
+      if (success) {
+        log.debug('Reconnected successfully');
+        this.reconnectAttempts = 0;
+        this.emit('reconnected');
+      }
+      // If failed, the connect() will trigger another close -> scheduleReconnect
+    }, delay);
+  }
+  
   /**
    * Handle incoming message
    * @param {Object} msg

package/src/services/rithmic/orders.js

@@ -145,11 +145,18 @@ const placeOrder = async (service, orderData) => {
             orderTag,
           });
         } else if (status === 5 || status === 6) {
+          // Extract rejection reason from rpCode[1] if available
+          const rpCode = order.rpCode;
+          let errorMsg = `Order rejected: status ${status}`;
+          if (rpCode && Array.isArray(rpCode) && rpCode.length > 1 && rpCode[1]) {
+            errorMsg = `Order rejected: ${rpCode[1]}`;
+          }
           resolve({
             success: false,
-            error: `Order rejected: status ${status}`,
+            error: errorMsg,
             orderId: order.basketId,
             orderTag,
+            rpCode,
           });
         }
       }
@@ -169,6 +176,11 @@ const placeOrder = async (service, orderData) => {
                    routes.values().next().value?.tradeRoute || null;
     }
     
+    // Warn if no trade route - Rithmic will reject the order
+    if (!tradeRoute) {
+      DEBUG && console.log('[Orders] WARNING: No trade route for', exchange, '- order may be rejected');
+    }
+    
     // HFT: Reuse template and mutate (faster than object spread)
     ORDER_REQUEST_TEMPLATE.userMsg[0] = orderTag;
     ORDER_REQUEST_TEMPLATE.fcmId = service.loginInfo.fcmId;