hedgequantx 2.4.6 → 2.4.8

package/src/lib/m/s1.js

@@ -1,372 +1,521 @@
 /**
- * HQX Ultra Scalping Strategy
- * Tick-based real-time scalping
+ * =============================================================================
+ * HQX ULTRA SCALPING STRATEGY
+ * =============================================================================
+ * 6 Mathematical Models with 4-Layer Trailing Stop System
+ *
+ * BACKTEST RESULTS (162 tests, V4):
+ * - Net P&L: $195,272.52
+ * - Win Rate: 86.3%
+ * - Profit Factor: 34.44
+ * - Sharpe: 1.29
+ * - Tests Passed: 150/162 (92.6%)
+ *
+ * MATHEMATICAL MODELS:
+ * 1. Z-Score Mean Reversion (Entry: |Z| > threshold, Exit: |Z| < 0.5)
+ * 2. VPIN (Volume-Synchronized Probability of Informed Trading)
+ * 3. Kyle's Lambda (Price Impact / Liquidity Measurement)
+ * 4. Kalman Filter (Signal Extraction from Noise)
+ * 5. Volatility Regime Detection (Low/Normal/High adaptive)
+ * 6. Order Flow Imbalance (OFI) - Directional Bias Confirmation
+ *
+ * KEY PARAMETERS:
+ * - Stop: 8 ticks = $40
+ * - Target: 16 ticks = $80
+ * - R:R = 1:2
+ * - Trailing: 50% profit lock
+ * 
+ * SOURCE: /root/HQX-Dev/hqx_tg/src/algo/strategy/hqx-ultra-scalping.strategy.ts
  */
+
+'use strict';
+
 const EventEmitter = require('events');
 const { v4: uuidv4 } = require('uuid');
 
-const OS = { B: 0, A: 1 }; // Order Side: Buy, Ask(Sell)
-const SS = { W: 1, M: 2, S: 3, VS: 4, E: 5 }; // Signal Strength
+// =============================================================================
+// CONSTANTS
+// =============================================================================
+
+const OrderSide = { BID: 'BID', ASK: 'ASK' };
+const SignalStrength = { WEAK: 'WEAK', MODERATE: 'MODERATE', STRONG: 'STRONG', VERY_STRONG: 'VERY_STRONG' };
+
+// =============================================================================
+// HELPER: Extract base symbol from contractId
+// =============================================================================
+function extractBaseSymbol(contractId) {
+  // CON.F.US.ENQ.H25 -> NQ, CON.F.US.EP.H25 -> ES
+  const mapping = {
+    'ENQ': 'NQ', 'EP': 'ES', 'EMD': 'EMD', 'RTY': 'RTY',
+    'MNQ': 'MNQ', 'MES': 'MES', 'M2K': 'M2K', 'MYM': 'MYM',
+    'NKD': 'NKD', 'GC': 'GC', 'SI': 'SI', 'CL': 'CL', 'YM': 'YM'
+  };
+  
+  if (!contractId) return 'UNKNOWN';
+  const parts = contractId.split('.');
+  if (parts.length >= 4) {
+    const symbol = parts[3];
+    return mapping[symbol] || symbol;
+  }
+  return contractId;
+}
+
+// =============================================================================
+// HQX ULTRA SCALPING STRATEGY CLASS
+// =============================================================================
 
-/**
- * VWAP Calculator - Real-time tick-based
- */
-class VC {
+class HQXUltraScalpingStrategy extends EventEmitter {
   constructor() {
-    this.data = new Map();
+    super();
+    
+    this.tickSize = 0.25;
+    this.tickValue = 5.0;
+
+    // === Model Parameters (from V4 backtest) ===
+    this.zscoreEntryThreshold = 1.5;  // Adaptive per regime
+    this.zscoreExitThreshold = 0.5;
+    this.vpinWindow = 50;
+    this.vpinToxicThreshold = 0.7;
+    this.kalmanProcessNoise = 0.01;
+    this.kalmanMeasurementNoise = 0.1;
+    this.volatilityLookback = 100;
+    this.ofiLookback = 20;
+
+    // === Trade Parameters (from V4 backtest) ===
+    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();
+    this.kalmanStates = new Map();
+    this.priceBuffer = new Map();
+    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
+
+    // === Performance Tracking ===
+    this.recentTrades = [];
+    this.winStreak = 0;
+    this.lossStreak = 0;
   }
 
-  getKey(c) {
-    return `${c}_${new Date().toISOString().split('T')[0]}`;
+  /**
+   * Initialize strategy for a contract
+   */
+  initialize(contractId, tickSize = 0.25, tickValue = 5.0) {
+    this.tickSize = tickSize;
+    this.tickValue = tickValue;
+    this.barHistory.set(contractId, []);
+    this.priceBuffer.set(contractId, []);
+    this.volumeBuffer.set(contractId, []);
+    this.tradesBuffer.set(contractId, []);
+    this.atrHistory.set(contractId, []);
+    this.tickBuffer.set(contractId, []);
+    this.lastBarTime.set(contractId, 0);
+    this.kalmanStates.set(contractId, { estimate: 0, errorCovariance: 1.0 });
   }
 
-  init(c) {
-    const k = this.getKey(c);
-    if (!this.data.has(k)) {
-      this.data.set(k, {
-        vwap: 0,
-        cumVolume: 0,
-        cumTPV: 0, // cumulative typical price * volume
-        stdDev: 0,
-        prices: [],
-        high: -Infinity,
-        low: Infinity,
-        tickCount: 0
-      });
+  /**
+   * Process a tick - aggregates into bars then runs strategy
+   */
+  processTick(tick) {
+    const contractId = tick.contractId;
+    
+    if (!this.barHistory.has(contractId)) {
+      this.initialize(contractId);
     }
-  }
 
-  // Process each tick
-  addTick(c, price, volume = 1) {
-    const k = this.getKey(c);
-    let d = this.data.get(k);
-    if (!d) {
-      this.init(c);
-      d = this.data.get(k);
-    }
+    // Add tick to buffer
+    let ticks = this.tickBuffer.get(contractId);
+    ticks.push(tick);
 
-    // Update VWAP
-    d.cumVolume += volume;
-    d.cumTPV += price * volume;
-    if (d.cumVolume > 0) {
-      d.vwap = d.cumTPV / d.cumVolume;
+    // Check if we should form a new bar
+    const now = Date.now();
+    const lastBar = this.lastBarTime.get(contractId);
+    
+    if (now - lastBar >= this.barIntervalMs && ticks.length > 0) {
+      const bar = this._aggregateTicksToBar(ticks, now);
+      this.tickBuffer.set(contractId, []);
+      this.lastBarTime.set(contractId, now);
+      
+      if (bar) {
+        const signal = this.processBar(contractId, bar);
+        if (signal) {
+          this.emit('signal', signal);
+          return signal;
+        }
+      }
     }
+    return null;
+  }
 
-    // Track prices for std dev (last 100)
-    d.prices.push(price);
-    if (d.prices.length > 100) d.prices.shift();
-
-    // Calculate standard deviation
-    if (d.prices.length >= 10) {
-      const mean = d.prices.reduce((a, b) => a + b, 0) / d.prices.length;
-      const variance = d.prices.reduce((s, p) => s + Math.pow(p - mean, 2), 0) / d.prices.length;
-      d.stdDev = Math.sqrt(variance);
+  /**
+   * Aggregate ticks into a bar
+   */
+  _aggregateTicksToBar(ticks, timestamp) {
+    if (ticks.length === 0) return null;
+
+    const prices = ticks.map(t => t.price).filter(p => p != null);
+    if (prices.length === 0) return null;
+
+    let buyVol = 0, sellVol = 0;
+    for (let i = 1; i < ticks.length; i++) {
+      const vol = ticks[i].volume || 1;
+      if (ticks[i].price > ticks[i-1].price) buyVol += vol;
+      else if (ticks[i].price < ticks[i-1].price) sellVol += vol;
+      else { buyVol += vol / 2; sellVol += vol / 2; }
     }
 
-    // Update high/low
-    if (price > d.high) d.high = price;
-    if (price < d.low) d.low = price;
-    d.tickCount++;
-
-    return d;
+    return {
+      timestamp,
+      open: prices[0],
+      high: Math.max(...prices),
+      low: Math.min(...prices),
+      close: prices[prices.length - 1],
+      volume: ticks.reduce((sum, t) => sum + (t.volume || 1), 0),
+      delta: buyVol - sellVol,
+      tickCount: ticks.length
+    };
   }
 
-  // Analyze current price vs VWAP
-  analyze(c, currentPrice, tickSize = 0.25) {
-    const k = this.getKey(c);
-    const d = this.data.get(k);
-    if (!d || d.vwap === 0) return null;
-
-    const deviation = currentPrice - d.vwap;
-    const zScore = d.stdDev > 0 ? deviation / d.stdDev : 0;
+  /**
+   * Process a new bar and potentially generate signal
+   */
+  processBar(contractId, bar) {
+    let bars = this.barHistory.get(contractId);
+    if (!bars) {
+      this.initialize(contractId);
+      bars = this.barHistory.get(contractId);
+    }
 
-    return {
-      vwap: d.vwap,
-      price: currentPrice,
-      deviation,
-      zScore,
-      stdDev: d.stdDev,
-      high: d.high,
-      low: d.low,
-      tickCount: d.tickCount
-    };
+    bars.push(bar);
+    if (bars.length > 500) bars.shift();
+
+    // Update price buffer
+    const prices = this.priceBuffer.get(contractId);
+    prices.push(bar.close);
+    if (prices.length > 200) prices.shift();
+
+    // Update volume buffer
+    const volumes = this.volumeBuffer.get(contractId);
+    const barRange = bar.high - bar.low;
+    let buyVol = bar.volume * 0.5;
+    let sellVol = bar.volume * 0.5;
+    if (barRange > 0) {
+      const closePosition = (bar.close - bar.low) / barRange;
+      buyVol = bar.volume * closePosition;
+      sellVol = bar.volume * (1 - closePosition);
+    }
+    volumes.push({ buy: buyVol, sell: sellVol });
+    if (volumes.length > 100) volumes.shift();
+
+    // Need minimum data
+    if (bars.length < 50) return null;
+
+    // === 6 MODELS ===
+    const zscore = this._computeZScore(prices);
+    const vpin = this._computeVPIN(volumes);
+    const kyleLambda = this._computeKyleLambda(bars);
+    const kalmanEstimate = this._applyKalmanFilter(contractId, bar.close);
+    const { regime, params } = this._detectVolatilityRegime(contractId, bars);
+    const ofi = this._computeOrderFlowImbalance(bars);
+
+    // === SIGNAL GENERATION ===
+    return this._generateSignal(contractId, bar.close, zscore, vpin, kyleLambda, kalmanEstimate, regime, params, ofi, bars);
   }
 
-  get(c) {
-    return this.data.get(this.getKey(c)) || null;
+  // ===========================================================================
+  // MODEL 1: Z-SCORE MEAN REVERSION
+  // ===========================================================================
+  _computeZScore(prices, window = 50) {
+    if (prices.length < window) return 0;
+    const recentPrices = prices.slice(-window);
+    const mean = recentPrices.reduce((a, b) => a + b, 0) / window;
+    const variance = recentPrices.reduce((sum, p) => sum + Math.pow(p - mean, 2), 0) / window;
+    const std = Math.sqrt(variance);
+    if (std < 0.0001) return 0;
+    return (prices[prices.length - 1] - mean) / std;
   }
 
-  reset(c) {
-    this.data.delete(this.getKey(c));
+  // ===========================================================================
+  // MODEL 2: VPIN
+  // ===========================================================================
+  _computeVPIN(volumes) {
+    if (volumes.length < this.vpinWindow) return 0.5;
+    const recent = volumes.slice(-this.vpinWindow);
+    let totalBuy = 0, totalSell = 0;
+    for (const v of recent) { totalBuy += v.buy; totalSell += v.sell; }
+    const total = totalBuy + totalSell;
+    if (total < 1) return 0.5;
+    return Math.abs(totalBuy - totalSell) / total;
   }
-}
 
-/**
- * S1 - HQX Ultra Scalping Strategy
- * Pure tick-based, no bar conversion
- */
-class S1 extends EventEmitter {
-  constructor(cfg = {}) {
-    super();
-    
-    // Config
-    this.tickSize = cfg.tickSize || 0.25;
-    this.minRR = cfg.minRR || 1.2; // Minimum risk/reward
-    this.cooldown = cfg.cooldown || 15000; // 15s between signals
-    this.minTicks = cfg.minTicks || 20; // Min ticks before first signal
-    
-    // State
-    this.vc = new VC();
-    this.ticks = new Map(); // contractId -> tick history
-    this.lastSignalTime = 0;
-    this.inPosition = false;
-    
-    // Order flow tracking
-    this.buyVolume = 0;
-    this.sellVolume = 0;
-    this.lastPrice = 0;
-    
-    // Stats
-    this.stats = { signals: 0, trades: 0, wins: 0, losses: 0, pnl: 0 };
+  // ===========================================================================
+  // MODEL 3: KYLE'S LAMBDA
+  // ===========================================================================
+  _computeKyleLambda(bars) {
+    if (bars.length < 20) return 0;
+    const recent = bars.slice(-20);
+    const priceChanges = [], vols = [];
+    for (let i = 1; i < recent.length; i++) {
+      priceChanges.push(recent[i].close - recent[i - 1].close);
+      vols.push(recent[i].volume);
+    }
+    const meanP = priceChanges.reduce((a, b) => a + b, 0) / priceChanges.length;
+    const meanV = vols.reduce((a, b) => a + b, 0) / vols.length;
+    let cov = 0, varV = 0;
+    for (let i = 0; i < priceChanges.length; i++) {
+      cov += (priceChanges[i] - meanP) * (vols[i] - meanV);
+      varV += Math.pow(vols[i] - meanV, 2);
+    }
+    cov /= priceChanges.length;
+    varV /= priceChanges.length;
+    if (varV < 0.0001) return 0;
+    return Math.abs(cov / varV);
   }
 
-  initialize(contractId, tickSize = 0.25) {
-    this.tickSize = tickSize;
-    this.ticks.set(contractId, []);
-    this.vc.init(contractId);
+  // ===========================================================================
+  // MODEL 4: KALMAN FILTER
+  // ===========================================================================
+  _applyKalmanFilter(contractId, measurement) {
+    let state = this.kalmanStates.get(contractId);
+    if (!state) {
+      state = { estimate: measurement, errorCovariance: 1.0 };
+      this.kalmanStates.set(contractId, state);
+      return measurement;
+    }
+    const predictedEstimate = state.estimate;
+    const predictedCovariance = state.errorCovariance + this.kalmanProcessNoise;
+    const kalmanGain = predictedCovariance / (predictedCovariance + this.kalmanMeasurementNoise);
+    state.estimate = predictedEstimate + kalmanGain * (measurement - predictedEstimate);
+    state.errorCovariance = (1 - kalmanGain) * predictedCovariance;
+    return state.estimate;
   }
 
-  /**
-   * Process incoming tick - MAIN ENTRY POINT
-   */
-  processTick(tick) {
-    const { contractId, price, bid, ask, volume = 1, side, timestamp } = tick;
-    
-    if (!price || price <= 0) return null;
-    
-    // Store tick
-    let tickHistory = this.ticks.get(contractId);
-    if (!tickHistory) {
-      tickHistory = [];
-      this.ticks.set(contractId, tickHistory);
+  // ===========================================================================
+  // MODEL 5: VOLATILITY REGIME
+  // ===========================================================================
+  _detectVolatilityRegime(contractId, bars) {
+    const atr = this._calculateATR(bars);
+    let atrHist = this.atrHistory.get(contractId);
+    if (!atrHist) { atrHist = []; this.atrHistory.set(contractId, atrHist); }
+    atrHist.push(atr);
+    if (atrHist.length > 500) atrHist.shift();
+
+    let atrPercentile = 0.5;
+    if (atrHist.length >= 20) {
+      atrPercentile = atrHist.filter(a => a <= atr).length / atrHist.length;
     }
-    
-    const tickData = {
-      price,
-      bid: bid || price,
-      ask: ask || price,
-      volume,
-      side: side || (price >= this.lastPrice ? 'buy' : 'sell'),
-      timestamp: timestamp || Date.now()
-    };
-    
-    tickHistory.push(tickData);
-    if (tickHistory.length > 500) tickHistory.shift();
-    
-    // Update VWAP
-    this.vc.addTick(contractId, price, volume);
-    
-    // Update order flow
-    if (tickData.side === 'buy') {
-      this.buyVolume += volume;
+
+    let regime, params;
+    if (atrPercentile < 0.25) {
+      regime = 'low';
+      params = { stopMultiplier: 0.8, targetMultiplier: 0.9, zscoreThreshold: 1.2, confidenceBonus: 0.05 };
+    } else if (atrPercentile < 0.75) {
+      regime = 'normal';
+      params = { stopMultiplier: 1.0, targetMultiplier: 1.0, zscoreThreshold: 1.5, confidenceBonus: 0.0 };
     } else {
-      this.sellVolume += volume;
+      regime = 'high';
+      params = { stopMultiplier: 1.3, targetMultiplier: 1.2, zscoreThreshold: 2.0, confidenceBonus: -0.05 };
     }
-    
-    this.lastPrice = price;
-    
-    // Check for signal
-    return this.checkSignal(contractId, price, tickHistory);
+    return { regime, params };
   }
 
-  /**
-   * Check if conditions are met for a signal
-   */
-  checkSignal(contractId, price, ticks) {
-    // Need minimum ticks
-    if (ticks.length < this.minTicks) return null;
-    
-    // Cooldown check
-    if (Date.now() - this.lastSignalTime < this.cooldown) return null;
-    
-    // Don't signal if already in position
-    if (this.inPosition) return null;
-    
-    // Get VWAP analysis
-    const vwap = this.vc.analyze(contractId, price, this.tickSize);
-    if (!vwap || vwap.tickCount < this.minTicks) return null;
-    
-    // Calculate order flow imbalance
-    const totalVolume = this.buyVolume + this.sellVolume;
-    const imbalance = totalVolume > 0 ? (this.buyVolume - this.sellVolume) / totalVolume : 0;
-    
-    // Calculate momentum (last 10 ticks)
-    const recentTicks = ticks.slice(-10);
-    const momentum = recentTicks.length >= 2 
-      ? recentTicks[recentTicks.length - 1].price - recentTicks[0].price 
-      : 0;
-    
-    // Signal logic
-    let direction = null;
-    let confidence = 0;
-    
-    // LONG conditions: Price below VWAP + buying pressure
-    if (vwap.zScore < -1.0 && imbalance > 0.1) {
-      direction = 'long';
-      confidence = Math.min(0.9, 0.5 + Math.abs(vwap.zScore) * 0.15 + imbalance * 0.3);
+  _calculateATR(bars, period = 14) {
+    if (bars.length < period + 1) return 2.5;
+    const trValues = [];
+    for (let i = bars.length - period; i < bars.length; i++) {
+      const bar = bars[i];
+      const prevClose = bars[i - 1].close;
+      const tr = Math.max(bar.high - bar.low, Math.abs(bar.high - prevClose), Math.abs(bar.low - prevClose));
+      trValues.push(tr);
     }
-    // SHORT conditions: Price above VWAP + selling pressure  
-    else if (vwap.zScore > 1.0 && imbalance < -0.1) {
-      direction = 'short';
-      confidence = Math.min(0.9, 0.5 + Math.abs(vwap.zScore) * 0.15 + Math.abs(imbalance) * 0.3);
+    return trValues.reduce((a, b) => a + b, 0) / trValues.length;
+  }
+
+  // ===========================================================================
+  // MODEL 6: ORDER FLOW IMBALANCE
+  // ===========================================================================
+  _computeOrderFlowImbalance(bars) {
+    if (bars.length < this.ofiLookback) return 0;
+    const recent = bars.slice(-this.ofiLookback);
+    let buyPressure = 0, sellPressure = 0;
+    for (const bar of recent) {
+      const range = bar.high - bar.low;
+      if (range > 0) {
+        const closePos = (bar.close - bar.low) / range;
+        buyPressure += closePos * bar.volume;
+        sellPressure += (1 - closePos) * bar.volume;
+      }
     }
-    
-    if (!direction || confidence < 0.55) return null;
-    
-    // Calculate SL/TP
-    const stopTicks = 6;
-    const targetTicks = 8;
-    
-    let stopLoss, takeProfit;
+    const total = buyPressure + sellPressure;
+    if (total < 1) return 0;
+    return (buyPressure - sellPressure) / total;
+  }
+
+  // ===========================================================================
+  // SIGNAL GENERATION
+  // ===========================================================================
+  _generateSignal(contractId, currentPrice, zscore, vpin, kyleLambda, kalmanEstimate, regime, volParams, ofi, bars) {
+    const absZscore = Math.abs(zscore);
+    if (absZscore < volParams.zscoreThreshold) return null;
+    if (vpin > this.vpinToxicThreshold) return null;
+
+    let direction;
+    if (zscore < -volParams.zscoreThreshold) direction = 'long';
+    else if (zscore > volParams.zscoreThreshold) direction = 'short';
+    else return null;
+
+    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 scores = {
+      zscore: Math.min(1.0, absZscore / 4.0),
+      vpin: 1.0 - vpin,
+      kyleLambda: kyleLambda > 0.001 ? 0.5 : 0.8,
+      kalman: kalmanConfirms ? 0.8 : 0.4,
+      volatility: regime === 'normal' ? 0.8 : regime === 'low' ? 0.7 : 0.6,
+      ofi: ofiConfirms ? 0.9 : 0.5,
+      composite: 0
+    };
+
+    scores.composite = scores.zscore * 0.30 + scores.vpin * 0.15 + scores.kyleLambda * 0.10 +
+                       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;
+
+    const stopTicks = Math.round(this.baseStopTicks * volParams.stopMultiplier);
+    const targetTicks = Math.round(this.baseTargetTicks * volParams.targetMultiplier);
+    const actualStopTicks = Math.max(6, Math.min(12, stopTicks));
+    const actualTargetTicks = Math.max(actualStopTicks * 1.5, Math.min(24, targetTicks));
+
+    let stopLoss, takeProfit, beBreakeven, profitLockLevel;
     if (direction === 'long') {
-      stopLoss = price - stopTicks * this.tickSize;
-      takeProfit = price + targetTicks * this.tickSize;
+      stopLoss = currentPrice - actualStopTicks * this.tickSize;
+      takeProfit = currentPrice + actualTargetTicks * this.tickSize;
+      beBreakeven = currentPrice + this.breakevenTicks * this.tickSize;
+      profitLockLevel = currentPrice + (actualTargetTicks * this.profitLockPct) * this.tickSize;
     } else {
-      stopLoss = price + stopTicks * this.tickSize;
-      takeProfit = price - targetTicks * this.tickSize;
+      stopLoss = currentPrice + actualStopTicks * this.tickSize;
+      takeProfit = currentPrice - actualTargetTicks * this.tickSize;
+      beBreakeven = currentPrice - this.breakevenTicks * this.tickSize;
+      profitLockLevel = currentPrice - (actualTargetTicks * this.profitLockPct) * this.tickSize;
     }
-    
-    // Check R:R
-    const risk = Math.abs(price - stopLoss);
-    const reward = Math.abs(takeProfit - price);
-    if (reward / risk < this.minRR) return null;
-    
-    // Generate signal
-    this.lastSignalTime = Date.now();
-    this.stats.signals++;
-    
-    const signal = {
+
+    const riskReward = actualTargetTicks / actualStopTicks;
+    const trailTriggerTicks = Math.round(actualTargetTicks * 0.5);
+    const trailDistanceTicks = Math.round(actualStopTicks * 0.4);
+
+    let strength = SignalStrength.MODERATE;
+    if (confidence >= 0.85) strength = SignalStrength.VERY_STRONG;
+    else if (confidence >= 0.75) strength = SignalStrength.STRONG;
+    else if (confidence < 0.60) strength = SignalStrength.WEAK;
+
+    const winProb = 0.5 + (confidence - 0.5) * 0.4;
+    const edge = winProb * Math.abs(takeProfit - currentPrice) - (1 - winProb) * Math.abs(currentPrice - stopLoss);
+
+    return {
       id: uuidv4(),
       timestamp: Date.now(),
+      symbol: extractBaseSymbol(contractId),
       contractId,
+      side: direction === 'long' ? OrderSide.BID : OrderSide.ASK,
       direction,
-      side: direction === 'long' ? OS.B : OS.A,
-      entry: price,
-      entryPrice: price,
+      strategy: 'HQX_ULTRA_SCALPING',
+      strength,
+      edge,
+      confidence,
+      entry: currentPrice,
+      entryPrice: currentPrice,
       stopLoss,
       takeProfit,
-      stopTicks,
-      targetTicks,
-      confidence,
-      zScore: vwap.zScore,
-      vwap: vwap.vwap,
-      imbalance,
-      momentum,
-      riskReward: reward / risk
+      riskReward,
+      stopTicks: actualStopTicks,
+      targetTicks: actualTargetTicks,
+      trailTriggerTicks,
+      trailDistanceTicks,
+      beBreakeven,
+      profitLockLevel,
+      zScore: zscore,
+      zScoreExit: this.zscoreExitThreshold,
+      vpinValue: vpin,
+      kyleLambda,
+      kalmanEstimate,
+      volatilityRegime: regime,
+      ofiValue: ofi,
+      models: scores
     };
-    
-    this.emit('signal', signal);
-    return signal;
   }
 
   /**
-   * Called when entering a position
+   * Check if should exit by Z-Score
    */
-  onPositionOpened() {
-    this.inPosition = true;
+  shouldExitByZScore(contractId) {
+    const prices = this.priceBuffer.get(contractId);
+    if (!prices || prices.length < 50) return false;
+    const zscore = this._computeZScore(prices);
+    return Math.abs(zscore) < this.zscoreExitThreshold;
   }
 
   /**
-   * Called when position is closed
+   * Get current model values
    */
-  onPositionClosed(pnl) {
-    this.inPosition = false;
-    this.recordTradeResult(pnl);
+  getModelValues(contractId) {
+    const prices = this.priceBuffer.get(contractId);
+    const volumes = this.volumeBuffer.get(contractId);
+    const bars = this.barHistory.get(contractId);
+    if (!prices || !volumes || !bars || bars.length < 50) return null;
+
+    return {
+      zscore: this._computeZScore(prices).toFixed(2),
+      vpin: (this._computeVPIN(volumes) * 100).toFixed(1) + '%',
+      ofi: (this._computeOrderFlowImbalance(bars) * 100).toFixed(1) + '%',
+      bars: bars.length
+    };
   }
 
   /**
    * Record trade result
    */
   recordTradeResult(pnl) {
-    this.stats.trades++;
-    this.stats.pnl += pnl;
-    if (pnl > 0) {
-      this.stats.wins++;
-    } else {
-      this.stats.losses++;
-    }
-    
-    // Reset order flow after trade
-    this.buyVolume = 0;
-    this.sellVolume = 0;
+    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; }
   }
 
-  getStats() {
-    return this.stats;
+  /**
+   * Get bar history
+   */
+  getBarHistory(contractId) {
+    return this.barHistory.get(contractId) || [];
   }
 
+  /**
+   * Reset strategy
+   */
   reset(contractId) {
-    this.ticks.set(contractId, []);
-    this.vc.reset(contractId);
-    this.buyVolume = 0;
-    this.sellVolume = 0;
-    this.lastSignalTime = 0;
-    this.inPosition = false;
+    this.barHistory.set(contractId, []);
+    this.priceBuffer.set(contractId, []);
+    this.volumeBuffer.set(contractId, []);
+    this.tradesBuffer.set(contractId, []);
+    this.atrHistory.set(contractId, []);
+    this.tickBuffer.set(contractId, []);
+    this.lastBarTime.set(contractId, 0);
+    this.kalmanStates.set(contractId, { estimate: 0, errorCovariance: 1.0 });
   }
 }
 
-/**
- * M1 - Main Strategy Interface
- */
-class M1 extends EventEmitter {
-  constructor(cfg = {}) {
-    super();
-    this.cfg = cfg;
-    this.s = new S1(cfg);
-    
-    // Forward signals
-    this.s.on('signal', (sig) => {
-      this.emit('signal', {
-        ...sig,
-        side: sig.direction === 'long' ? 'buy' : 'sell',
-        action: 'open',
-        reason: `Z=${sig.zScore.toFixed(2)}, conf=${(sig.confidence * 100).toFixed(0)}%`
-      });
-    });
-  }
-
-  processTick(t) {
-    return this.s.processTick(t);
-  }
-
-  onTick(t) {
-    return this.processTick(t);
-  }
-
-  initialize(contractId, tickSize) {
-    this.s.initialize(contractId, tickSize);
-  }
-
-  onPositionOpened() {
-    this.s.onPositionOpened();
-  }
-
-  onPositionClosed(pnl) {
-    this.s.onPositionClosed(pnl);
-  }
-
-  recordTradeResult(pnl) {
-    this.s.recordTradeResult(pnl);
-  }
-
-  getStats() {
-    return this.s.getStats();
-  }
-
-  reset(contractId) {
-    this.s.reset(contractId);
-    this.emit('log', { type: 'info', message: 'Strategy reset' });
-  }
-}
+// Singleton instance
+const M1 = new HQXUltraScalpingStrategy();
 
-module.exports = { S1, M1, VC, OS, SS };
+module.exports = { M1, HQXUltraScalpingStrategy, OrderSide, SignalStrength };