hedgequantx 2.7.15 → 2.7.17

package/src/lib/m/s1.js

@@ -1,804 +1,423 @@
 /**
  * =============================================================================
- * HQX Ultra-Scalping Strategy
+ * HQX ULTRA SCALPING STRATEGY
  * =============================================================================
- * Proven edge: VWAP Mean Reversion + Order Flow Confirmation + Trailing Stops
+ * 6 Mathematical Models with 4-Layer Trailing Stop System
  *
- * BACKTEST RESULTS (7 months Dec 2020 - Jun 2021, 541M ticks):
- * - Net P&L: +$442,760
- * - Profit Factor: 18.28
- * - Win Rate: 93.1%
- * - Max Drawdown: $190
- * - 7,325 trades, ~$60/trade avg
+ * 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%)
  *
- * MODELS (Weights):
- * 1. VWAP Mean Reversion (25%) - Primary signal source
- * 2. Order Flow Analysis (30%) - Confirmation required
- * 3. DOM Simulation (20%) - Bid/ask pressure
- * 4. Microstructure (10%) - Kyle's lambda, noise ratio
- * 5. Volume Profile (15%) - POC, Value Area context
+ * 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 (from profitable backtest):
- * - Stop: 6 ticks = $30 (1.5 points)
- * - Target: 8 ticks = $40 (2 points)
- * - Trailing: trigger at 4 ticks (50%), trail at 2 ticks
- * - VWAP z-score threshold: 0.8σ
- * - Cooldown: 30 seconds between trades
- * - Max 50 trades/day, stop after 3 consecutive losses
- * - Order flow confirmation: REQUIRED
+ * 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 }; // OrderSide: Bid, Ask
-const SS = { W: 1, M: 2, S: 3, VS: 4, E: 5 }; // SignalStrength
+const {
+  computeZScore,
+  computeVPIN,
+  computeKyleLambda,
+  applyKalmanFilter,
+  calculateATR,
+  detectVolatilityRegime,
+  computeOrderFlowImbalance,
+} = require('./s1-models');
 
 // =============================================================================
-// VWAP CALCULATOR
+// CONSTANTS
 // =============================================================================
 
-class VC {
-  constructor() {
-    this.d = new Map();
-    this.psv = new Map();
-  }
-
-  gk(c) {
-    return `${c}_${new Date().toISOString().split('T')[0]}`;
-  }
-
-  init(c) {
-    const k = this.gk(c);
-    if (!this.d.has(k)) {
-      this.d.set(k, {
-        v: 0, cv: 0, ctpv: 0,
-        ub1: 0, ub2: 0, ub3: 0,
-        lb1: 0, lb2: 0, lb3: 0,
-        sd: 0, tc: 0,
-        hod: -Infinity, lod: Infinity,
-        lu: Date.now()
-      });
-      this.psv.set(k, 0);
-    }
-  }
-
-  pt(c, h, l, cl, vol, ts = Date.now()) {
-    const k = this.gk(c);
-    let d = this.d.get(k);
-    if (!d) { this.init(c); d = this.d.get(k); }
-    
-    const tp = (h + l + cl) / 3;
-    d.cv += vol;
-    d.ctpv += tp * vol;
-    if (d.cv > 0) d.v = d.ctpv / d.cv;
-    
-    const p = this.psv.get(k) || 0;
-    this.psv.set(k, p + tp * tp * vol);
-    this.cs(k);
-    
-    if (h > d.hod) d.hod = h;
-    if (l < d.lod) d.lod = l;
-    d.tc++;
-    d.lu = ts;
-  }
-
-  cs(k) {
-    const d = this.d.get(k);
-    if (!d || d.cv === 0) return;
-    
-    const p = this.psv.get(k) || 0;
-    const ms = p / d.cv;
-    const sm = d.v * d.v;
-    const va = ms - sm;
-    d.sd = Math.sqrt(Math.max(0, va));
-    
-    d.ub1 = d.v + d.sd;
-    d.ub2 = d.v + 2 * d.sd;
-    d.ub3 = d.v + 3 * d.sd;
-    d.lb1 = d.v - d.sd;
-    d.lb2 = d.v - 2 * d.sd;
-    d.lb3 = d.v - 3 * d.sd;
-  }
+const OrderSide = { BID: 'BID', ASK: 'ASK' };
+const SignalStrength = { WEAK: 'WEAK', MODERATE: 'MODERATE', STRONG: 'STRONG', VERY_STRONG: 'VERY_STRONG' };
 
-  an(c, cp, ts = 0.25) {
-    const k = this.gk(c);
-    const d = this.d.get(k);
-    if (!d || d.v === 0) return null;
-    
-    const pd = cp - d.v;
-    const dt = pd / ts;
-    const dv = d.sd > 0 ? pd / d.sd : 0;
-    
-    let pos;
-    if (Math.abs(dv) < 0.1) pos = 'AT';
-    else if (dv > 0) pos = 'ABOVE';
-    else pos = 'BELOW';
-    
-    const ad = Math.abs(dv);
-    let bl;
-    if (ad < 1) bl = 0;
-    else if (ad < 2) bl = 1;
-    else if (ad < 3) bl = 2;
-    else bl = 3;
-    
-    let mrp;
-    if (ad >= 3) mrp = 0.99;
-    else if (ad >= 2) mrp = 0.95;
-    else if (ad >= 1.5) mrp = 0.85;
-    else if (ad >= 1) mrp = 0.68;
-    else mrp = 0.50;
-    
-    return {
-      currentPrice: cp,
-      vwap: d.v,
-      deviation: dv,
-      deviationTicks: dt,
-      position: pos,
-      bandLevel: bl,
-      target: d.v,
-      probability: mrp,
-      isFavorableForMeanReversion: ad >= 1.5
-    };
+// =============================================================================
+// 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;
   }
-
-  get(c) { return this.d.get(this.gk(c)) || null; }
-  reset(c) { const k = this.gk(c); this.d.delete(k); this.psv.delete(k); }
+  return contractId;
 }
 
 // =============================================================================
-// S1 - ULTRA SCALPING STRATEGY
+// HQX ULTRA SCALPING STRATEGY CLASS
 // =============================================================================
 
-class S1 extends EventEmitter {
-  constructor(cfg = {}) {
+class HQXUltraScalpingStrategy extends EventEmitter {
+  constructor() {
     super();
-    this.ts = cfg.tickSize || 0.25;
-    this.tv = cfg.tickValue || 5.0;
-    this.mrr = 1.2; // Min reward/risk
-    this.ap = 14; // ATR period
-    this.ah = []; // ATR history
-    this.ba = 2.5; // Base ATR
-    this.rt = []; // Recent trades
-    this.ws = 0; // Win streak
-    this.ls = 0; // Loss streak
-    this.lsd = null; // Last session date
-    this.bh = new Map(); // Bar history
-    this.vc = new VC(); // VWAP calculator
-    this.lst = 0; // Last signal time
-    this.cd = 30000; // Cooldown 30s
-    this.st = { s: 0, t: 0, w: 0, l: 0, p: 0 }; // Stats
-  }
-
-  initialize(c, ts = 0.25, tv = 5.0) {
-    this.ts = ts;
-    this.tv = tv;
-    this.bh.set(c, []);
-    this.vc.init(c);
-  }
-
-  processTick(t) {
-    const { contractId, price, bid, ask, volume, side, timestamp } = t;
-    const b = {
-      timestamp: timestamp || Date.now(),
-      open: price,
-      high: price,
-      low: price,
-      close: price,
-      volume: volume || 1,
-      trades: 1,
-      delta: side === 'buy' ? (volume || 1) : -(volume || 1),
-      vwap: price
-    };
-    return this.processBar(contractId, b);
-  }
-
-  onTick(t) { return this.processTick(t); }
-
-  processBar(c, b) {
-    let bs = this.bh.get(c);
-    if (!bs) { bs = []; this.bh.set(c, bs); }
-
-    bs.push(b);
-    if (bs.length > 500) bs.shift();
-
-    if (bs.length < 50) return null;
-
-    // Check session date
-    const sd = new Date(b.timestamp).toISOString().split('T')[0];
-    if (this.lsd !== sd) this.lsd = sd;
-
-    // Update VWAP
-    this.vc.pt(c, b.high, b.low, b.close, b.volume, b.timestamp);
-
-    // Get VWAP analysis
-    const va = this.vc.an(c, b.close, this.ts);
-    if (!va) return null;
-
-    // Calculate scores
-    const vs = this.sv(va, b.close);
-    const of = this.aof(bs);
-    const os = this.sof(of);
-    const dd = this.adb(bs);
-    const ds = this.sdd(dd);
-    const md = this.am(bs);
-    const ms = this.sm(md);
-    const pd = this.avp(bs, c, b.close);
-    const ps = this.svp(pd, b.close);
-
-    // Determine direction
-    const { dir, st, ofc } = this.dd(va, of, dd, pd, b.close);
-
-    if (dir === 'none') return null;
-    if (st !== 'vr') return null; // VWAP reversion only
-    if (!ofc) return null; // Require order flow confirmation
-
-    // Calculate confidence
-    const bc = vs * 0.25 + os * 0.30 + ds * 0.20 + ms * 0.10 + ps * 0.15;
-    const cf = Math.min(1.0, bc + 0.05);
-
-    // Get adaptive params
-    const pm = this.gap(bs);
-
-    if (cf < pm.ct) return null;
-
-    // Cooldown check
-    if (Date.now() - this.lst < this.cd) return null;
-
-    // Entry price
-    const ep = b.close;
-
-    // Stops and targets
-    const spt = pm.spt;
-    const tgt = pm.tgt;
-
-    let sl, tp;
-    if (dir === 'long') {
-      sl = ep - spt * this.ts;
-      tp = ep + tgt * this.ts;
-      // Adjust to VWAP if close
-      const vt = va.vwap;
-      if (vt > ep && vt < tp) {
-        const vr = (vt - ep) / this.ts;
-        if (vr >= spt * 1.5) tp = vt;
-      }
-    } else {
-      sl = ep + spt * this.ts;
-      tp = ep - tgt * this.ts;
-      const vt = va.vwap;
-      if (vt < ep && vt > tp) {
-        const vr = (ep - vt) / this.ts;
-        if (vr >= spt * 1.5) tp = vt;
-      }
-    }
-
-    const rt = Math.abs(ep - sl) / this.ts;
-    const rwt = Math.abs(tp - ep) / this.ts;
-
-    if (rwt / rt < this.mrr) return null;
-
-    // Partial targets
-    let p1, p2;
-    if (dir === 'long') {
-      p1 = ep + pm.p1t * this.ts;
-      p2 = ep + pm.p2t * this.ts;
-    } else {
-      p1 = ep - pm.p1t * this.ts;
-      p2 = ep - pm.p2t * this.ts;
-    }
-
-    // Signal strength
-    let str = SS.M;
-    if (cf >= 0.75) str = SS.S;
-    else if (cf >= 0.85) str = SS.VS;
-    else if (cf < 0.55) str = SS.W;
-
-    // Edge calculation
-    const wp = 0.5 + (cf - 0.5) * 0.3;
-    const aw = Math.abs(tp - ep);
-    const al = Math.abs(ep - sl);
-    const eg = wp * aw - (1 - wp) * al;
-
-    this.lst = Date.now();
-    this.st.s++;
-
-    const sig = {
-      id: uuidv4(),
-      timestamp: Date.now(),
-      symbol: c.split('.')[0] || c,
-      contractId: c,
-      side: dir === 'long' ? OS.B : OS.A,
-      direction: dir,
-      strategy: 'ULTRA_SCALPING_VWAP_REVERSION',
-      strength: str,
-      edge: eg,
-      confidence: cf,
-      entry: ep,
-      entryPrice: ep,
-      stopLoss: sl,
-      takeProfit: tp,
-      riskReward: rwt / rt,
-      stopTicks: spt,
-      targetTicks: tgt,
-      trailTriggerTicks: pm.ttt,
-      trailDistanceTicks: pm.tdt,
-      partial1Price: p1,
-      partial2Price: p2,
-      vwapScore: vs,
-      orderFlowScore: os,
-      domScore: ds,
-      microstructureScore: ms,
-      volumeProfileScore: ps,
-      orderFlowConfirmed: ofc,
-      zScore: va.deviation,
-      vwap: va.vwap,
-      regime: pm.rg,
-      expires: Date.now() + 60000
-    };
-
-    this.emit('signal', sig);
-    return sig;
-  }
-
-  recordTradeResult(p) {
-    this.rt.push({ netPnl: p, timestamp: Date.now() });
-    if (this.rt.length > 100) this.rt.shift();
-    if (p > 0) { this.ws++; this.ls = 0; this.st.w++; }
-    else { this.ls++; this.ws = 0; this.st.l++; }
-    this.st.p += p;
-    this.st.t++;
-  }
-
-  // Score VWAP
-  sv(v, cp) {
-    const z = Math.abs(v.deviation);
-    if (z < 0.5) return 0.3;
-    else if (z < 1.0) return 0.6;
-    else if (z < 2.0) return 0.9;
-    else if (z < 2.5) return 0.7;
-    else return 0.4;
-  }
-
-  // Score Order Flow
-  sof(o) {
-    let s = 0.5;
-    s += o.ir * 0.3;
-    if (o.dd) s += 0.2;
-    if (o.ad) s += 0.15;
-    return Math.min(1.0, s);
-  }
-
-  // Score DOM
-  sdd(d) {
-    let s = 0.5;
-    s += Math.abs(d.pi) * 0.25;
-    if (d.sb || d.sa) s += 0.15;
-    if (d.al !== null) s += 0.1;
-    return Math.min(1.0, s);
-  }
-
-  // Score Microstructure
-  sm(m) {
-    const ns = 1.0 - m.nr;
-    const ls = 0.0001 < m.kl && m.kl < 0.001 ? 0.7 : 0.5;
-    return ns * 0.6 + ls * 0.4;
-  }
-
-  // Score Volume Profile
-  svp(p, cp) {
-    let s = 0.5;
-    const pd = Math.abs(cp - p.poc) / this.ts;
-    if (pd < 10) s += 0.2;
-    if (p.val <= cp && cp <= p.vah) s += 0.15;
-    for (const h of p.hvn) {
-      if (Math.abs(cp - h) < 5 * this.ts) { s += 0.15; break; }
-    }
-    return Math.min(1.0, s);
+    
+    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;
   }
 
-  // Analyze Order Flow
-  aof(bs) {
-    if (bs.length < 2) return { d: 0, cd: 0, dd: false, ad: false, ir: 0, as: 'neutral' };
-
-    const cb = bs[bs.length - 1];
-    const pb = bs[bs.length - 2];
-    const br = cb.high - cb.low;
-
-    let bv, sv;
-    if (br > 0) {
-      const cp = (cb.close - cb.low) / br;
-      bv = cb.volume * cp;
-      sv = cb.volume * (1 - cp);
-    } else {
-      bv = cb.volume * 0.5;
-      sv = cb.volume * 0.5;
-    }
-
-    const d = bv - sv;
-    const cd = cb.delta || d;
-
-    // Detect divergence
-    let dv = false;
-    if (bs.length >= 5) {
-      const rb = bs.slice(-5);
-      const pc = rb[4].close - rb[0].close;
-      const ds = rb.reduce((s, b) => s + (b.delta || 0), 0);
-      if ((pc > 0 && ds < -cb.volume * 0.5) || (pc < 0 && ds > cb.volume * 0.5)) dv = true;
-    }
-
-    // Detect absorption
-    const lb = Math.min(20, bs.length);
-    const rbs = bs.slice(-lb);
-    const ar = rbs.reduce((s, b) => s + (b.high - b.low), 0) / lb;
-    const av = rbs.reduce((s, b) => s + b.volume, 0) / lb;
-    const ab = cb.volume > av * 1.5 && br < ar * 0.6;
-
-    const tv = bv + sv;
-    const im = tv > 0 ? Math.abs(bv - sv) / tv : 0;
-
-    let ag;
-    if (bv > sv * 1.3) ag = 'buy';
-    else if (sv > bv * 1.3) ag = 'sell';
-    else ag = 'neutral';
-
-    return { d, cd, dd: dv, ad: ab, ir: im, as: ag };
+  /**
+   * 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 });
   }
 
-  // Analyze DOM from bars
-  adb(bs) {
-    const lb = Math.min(10, bs.length);
-    if (lb < 2) return { bp: 0.5, ap: 0.5, pi: 0, sb: false, sa: false, al: null };
-
-    const rbs = bs.slice(-lb);
-    let bss = [], ass = [];
-
-    for (const b of rbs) {
-      const br = b.high - b.low;
-      if (br > 0) {
-        const cp = (b.close - b.low) / br;
-        bss.push(cp * b.volume);
-        ass.push((1 - cp) * b.volume);
-      }
+  /**
+   * Process a tick - aggregates into bars then runs strategy
+   */
+  processTick(tick) {
+    const contractId = tick.contractId;
+    
+    if (!this.barHistory.has(contractId)) {
+      this.initialize(contractId);
     }
 
-    const t = bss.reduce((a, b) => a + b, 0) + ass.reduce((a, b) => a + b, 0);
-    const bp = t > 0 ? bss.reduce((a, b) => a + b, 0) / t : 0.5;
-    const ap = t > 0 ? ass.reduce((a, b) => a + b, 0) / t : 0.5;
-    const pi = bp - ap;
-
-    const lf = rbs.slice(-5);
-    let hc = 0, lc = 0;
-    for (const b of lf) {
-      const br = b.high - b.low;
-      if (br > 0) {
-        const cp = (b.close - b.low) / br;
-        if (cp > 0.7) hc++;
-        if (cp < 0.3) lc++;
-      }
-    }
+    // Add tick to buffer
+    let ticks = this.tickBuffer.get(contractId);
+    ticks.push(tick);
 
-    let al = null;
-    const ar = rbs.reduce((s, b) => s + (b.high - b.low), 0) / lb;
-    const av = rbs.reduce((s, b) => s + b.volume, 0) / lb;
-    for (const b of rbs) {
-      const br = b.high - b.low;
-      if (b.volume > av * 1.5 && br < ar * 0.5) {
-        al = (b.high + b.low) / 2;
-        break;
+    // 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 { bp, ap, pi, sb: hc >= 3, sa: lc >= 3, al };
+    return null;
   }
 
-  // Analyze Microstructure
-  am(bs) {
-    const lb = Math.min(50, bs.length);
-    if (lb < 10) return { kl: 0, rs: 0, es: 0, rv: 0, nr: 0.5 };
-
-    const rbs = bs.slice(-lb);
-    const pc = [], vs = [];
-
-    for (let i = 1; i < rbs.length; i++) {
-      pc.push(rbs[i].close - rbs[i - 1].close);
-      vs.push(rbs[i].volume);
-    }
-
-    // Kyle's Lambda
-    let kl = 0;
-    if (pc.length > 5) {
-      const mp = pc.reduce((a, b) => a + b, 0) / pc.length;
-      const mv = vs.reduce((a, b) => a + b, 0) / vs.length;
-      let cv = 0, vv = 0;
-      for (let i = 0; i < pc.length; i++) {
-        cv += (pc[i] - mp) * (vs[i] - mv);
-        vv += Math.pow(vs[i] - mv, 2);
-      }
-      cv /= pc.length;
-      vv /= pc.length;
-      kl = vv > 0 ? Math.abs(cv / vv) : 0;
-    }
-
-    // Roll's Spread
-    let rs = 0;
-    if (pc.length > 2) {
-      const c1 = pc.slice(1), c0 = pc.slice(0, -1);
-      const m1 = c1.reduce((a, b) => a + b, 0) / c1.length;
-      const m0 = c0.reduce((a, b) => a + b, 0) / c0.length;
-      let ac = 0;
-      for (let i = 0; i < c1.length; i++) ac += (c1[i] - m1) * (c0[i] - m0);
-      ac /= c1.length;
-      rs = Math.sqrt(Math.max(0, -ac)) * 2;
-    }
-
-    const es = rbs.reduce((s, b) => s + (b.high - b.low), 0) / lb;
-
-    // Realized volatility
-    const rt = [];
-    for (let i = 1; i < rbs.length; i++) {
-      if (rbs[i - 1].close > 0) rt.push(Math.log(rbs[i].close / rbs[i - 1].close));
-    }
-    let rv = 0;
-    if (rt.length > 0) {
-      const mr = rt.reduce((a, b) => a + b, 0) / rt.length;
-      const va = rt.reduce((s, r) => s + Math.pow(r - mr, 2), 0) / rt.length;
-      rv = Math.sqrt(va) * Math.sqrt(252 * 390);
+  /**
+   * 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; }
     }
 
-    // Noise ratio
-    const sv = pc.length >= 10 ? Math.sqrt(pc.slice(-10).reduce((s, p) => s + p * p, 0) / 10) : 0;
-    const lv = pc.length > 0 ? Math.sqrt(pc.reduce((s, p) => s + p * p, 0) / pc.length) : 1;
-    const nr = lv > 0 ? Math.min(1, sv / lv) : 0.5;
-
-    return { kl, rs, es, rv, nr };
+    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 Volume Profile
-  avp(bs, c, cp) {
-    const lb = Math.min(100, bs.length);
-    if (lb < 10) return { poc: cp, vah: cp, val: cp, hvn: [], lvn: [] };
-
-    const rbs = bs.slice(-lb);
-    const vap = new Map();
-
-    for (const b of rbs) {
-      const br = b.high - b.low;
-      const nl = Math.max(1, Math.round(br / this.ts));
-      const vpl = b.volume / nl;
-      let p = b.low;
-      while (p <= b.high) {
-        const r = Math.round(p / this.ts) * this.ts;
-        vap.set(r, (vap.get(r) || 0) + vpl);
-        p += this.ts;
-      }
-    }
-
-    if (vap.size === 0) return { poc: cp, vah: cp, val: cp, hvn: [], lvn: [] };
-
-    // POC
-    let poc = cp, mv = 0;
-    for (const [p, v] of vap) {
-      if (v > mv) { mv = v; poc = p; }
+  /**
+   * 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);
     }
 
-    // Value Area
-    const tv = Array.from(vap.values()).reduce((a, b) => a + b, 0);
-    const tgv = tv * 0.7;
-    const sp = Array.from(vap.keys()).sort((a, b) => a - b);
-    const pi = sp.indexOf(poc);
-    let vv = vap.get(poc) || 0, li = pi, hi = pi;
-
-    while (vv < tgv && (li > 0 || hi < sp.length - 1)) {
-      const lv = li > 0 ? (vap.get(sp[li - 1]) || 0) : 0;
-      const hv = hi < sp.length - 1 ? (vap.get(sp[hi + 1]) || 0) : 0;
-      if (lv >= hv && li > 0) { li--; vv += vap.get(sp[li]) || 0; }
-      else if (hi < sp.length - 1) { hi++; vv += vap.get(sp[hi]) || 0; }
-      else break;
+    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);
     }
-
-    const val = sp[li], vah = sp[hi];
-    const av = tv / vap.size;
-    const hvn = [], lvn = [];
-
-    for (const [p, v] of vap) {
-      if (v > av * 1.5) hvn.push(p);
-      if (v < av * 0.5) lvn.push(p);
-    }
-
-    return { poc, vah, val, hvn, lvn };
+    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 = computeZScore(prices);
+    const vpin = computeVPIN(volumes, this.vpinWindow);
+    const kyleLambda = computeKyleLambda(bars);
+    const kalmanEstimate = this._applyKalmanFilter(contractId, bar.close);
+    const { regime, params } = this._detectVolatilityRegime(contractId, bars);
+    const ofi = computeOrderFlowImbalance(bars, this.ofiLookback);
+
+    // === SIGNAL GENERATION ===
+    return this._generateSignal(contractId, bar.close, zscore, vpin, kyleLambda, kalmanEstimate, regime, params, ofi, bars);
   }
 
-  // Determine Direction
-  dd(v, o, d, p, cp) {
-    let ls = 0, ss = 0, st = 'mixed', ofc = false;
-
-    // VWAP Mean Reversion (0.8 std dev)
-    if (v.deviation < -0.8) {
-      ls += 2;
-      st = 'vr';
-      if (o.as === 'buy' || o.dd) ofc = true;
-    } else if (v.deviation > 0.8) {
-      ss += 2;
-      st = 'vr';
-      if (o.as === 'sell' || o.dd) ofc = true;
-    }
-
-    // Order flow strength
-    if (o.as === 'buy' && o.ir > 0.35) ls += 1;
-    else if (o.as === 'sell' && o.ir > 0.35) ss += 1;
-
-    // Delta Divergence
-    if (o.dd) {
-      if (o.cd < 0) { ls += 2; st = 'dv'; ofc = true; }
-      else { ss += 2; st = 'dv'; ofc = true; }
-    }
-
-    // DOM Pressure
-    if (d.pi > 0.35) ls += 1;
-    else if (d.pi < -0.35) ss += 1;
-
-    // Stacked Orders
-    if (d.sb) ls += 1;
-    if (d.sa) ss += 1;
-
-    // Volume Profile (POC attraction)
-    if (cp < p.poc - 5 * this.ts) ls += 1;
-    else if (cp > p.poc + 5 * this.ts) ss += 1;
-
-    // Decision
-    if (ls >= 2 && ls > ss) return { dir: 'long', st, ofc };
-    else if (ss >= 2 && ss > ls) return { dir: 'short', st, ofc };
-    else return { dir: 'none', st: 'none', ofc: false };
+  // ===========================================================================
+  // MODEL 4: KALMAN FILTER (uses shared state)
+  // ===========================================================================
+  _applyKalmanFilter(contractId, measurement) {
+    let state = this.kalmanStates.get(contractId);
+    const result = applyKalmanFilter(state, measurement, this.kalmanProcessNoise, this.kalmanMeasurementNoise);
+    this.kalmanStates.set(contractId, result.state);
+    return result.estimate;
   }
 
-  // Calculate ATR
-  catr(bs) {
-    if (bs.length < this.ap + 1) return this.ba;
-
-    const tv = [];
-    for (let i = bs.length - this.ap; i < bs.length; i++) {
-      const b = bs[i];
-      const pc = bs[i - 1].close;
-      const tr = Math.max(b.high - b.low, Math.abs(b.high - pc), Math.abs(b.low - pc));
-      tv.push(tr);
-    }
-
-    const a = tv.reduce((a, b) => a + b, 0) / tv.length;
-    this.ah.push(a);
-    if (this.ah.length > 500) this.ah.shift();
-
-    return a;
+  // ===========================================================================
+  // MODEL 5: VOLATILITY REGIME (uses shared state)
+  // ===========================================================================
+  _detectVolatilityRegime(contractId, bars) {
+    const atr = 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();
+    return detectVolatilityRegime(atrHist, atr);
   }
 
-  // Get Adaptive Params
-  gap(bs) {
-    const a = this.catr(bs);
-    const at = a / this.ts;
-
-    let ap = 0.5;
-    if (this.ah.length >= 20) ap = this.ah.filter(x => x <= a).length / this.ah.length;
-
-    let rg, vm;
-    if (ap < 0.25) { rg = 'low'; vm = 0.9; }
-    else if (ap < 0.70) { rg = 'normal'; vm = 1.0; }
-    else if (ap < 0.90) { rg = 'high'; vm = 1.15; }
-    else { rg = 'extreme'; vm = 1.25; }
+  // ===========================================================================
+  // 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
+    };
 
-    const pm = this.gpm();
+    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;
 
-    // Stop: 6 ticks base, scale 5-8
-    const bs6 = 6;
-    let spt = Math.round(bs6 * vm);
-    spt = Math.max(5, Math.min(8, spt));
+    const confidence = Math.min(1.0, scores.composite + volParams.confidenceBonus);
+    if (confidence < 0.55) return null;
 
-    // Target: 8 ticks base, scale 6-10
-    const bt8 = 8;
-    let tgt = Math.round(bt8 * vm);
-    tgt = Math.max(6, Math.min(10, tgt));
+    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));
 
-    if (tgt / spt < 1.2) tgt = Math.round(spt * 1.33);
+    let stopLoss, takeProfit, beBreakeven, profitLockLevel;
+    if (direction === 'long') {
+      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 = currentPrice + actualStopTicks * this.tickSize;
+      takeProfit = currentPrice - actualTargetTicks * this.tickSize;
+      beBreakeven = currentPrice - this.breakevenTicks * this.tickSize;
+      profitLockLevel = currentPrice - (actualTargetTicks * this.profitLockPct) * this.tickSize;
+    }
 
-    // Trailing
-    const ttt = Math.max(3, Math.min(5, Math.round(tgt * 0.5)));
-    const tdt = Math.max(2, Math.min(3, Math.round(spt * 0.35)));
+    const riskReward = actualTargetTicks / actualStopTicks;
+    const trailTriggerTicks = Math.round(actualTargetTicks * 0.5);
+    const trailDistanceTicks = Math.round(actualStopTicks * 0.4);
 
-    // Confidence threshold
-    const bc = 0.45;
-    const ra = { low: 0.05, normal: 0.0, high: 0.03, extreme: 0.10 };
-    let ct = bc + ra[rg];
-    ct = Math.min(0.65, ct * pm);
+    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;
 
-    // Partials
-    const p1t = Math.round(tgt * 0.5);
-    const p2t = Math.round(tgt * 0.75);
+    const winProb = 0.5 + (confidence - 0.5) * 0.4;
+    const edge = winProb * Math.abs(takeProfit - currentPrice) - (1 - winProb) * Math.abs(currentPrice - stopLoss);
 
-    return { spt, tgt, ct, ttt, tdt, p1t, p2t, rg, at, vm };
+    return {
+      id: uuidv4(),
+      timestamp: Date.now(),
+      symbol: extractBaseSymbol(contractId),
+      contractId,
+      side: direction === 'long' ? OrderSide.BID : OrderSide.ASK,
+      direction,
+      strategy: 'HQX_ULTRA_SCALPING',
+      strength,
+      edge,
+      confidence,
+      entry: currentPrice,
+      entryPrice: currentPrice,
+      stopLoss,
+      takeProfit,
+      riskReward,
+      stopTicks: actualStopTicks,
+      targetTicks: actualTargetTicks,
+      trailTriggerTicks,
+      trailDistanceTicks,
+      beBreakeven,
+      profitLockLevel,
+      zScore: zscore,
+      zScoreExit: this.zscoreExitThreshold,
+      vpinValue: vpin,
+      kyleLambda,
+      kalmanEstimate,
+      volatilityRegime: regime,
+      ofiValue: ofi,
+      models: scores
+    };
   }
 
-  // Performance Multiplier
-  gpm() {
-    if (this.rt.length === 0) return 1.0;
-
-    const r = this.rt.slice(-20);
-    const w = r.filter(t => t.netPnl > 0).length;
-    const wr = w / r.length;
-
-    let m = 1.0;
-
-    if (this.ls >= 2) {
-      m += 0.05 * this.ls;
-      m = Math.min(m, 1.3);
-    }
-
-    if (r.length >= 5 && wr < 0.40) m *= 1.1;
-    if (this.ws >= 4 && wr > 0.50) m *= 0.95;
-
-    return Math.max(0.9, Math.min(1.3, m));
+  /**
+   * Check if should exit by Z-Score
+   */
+  shouldExitByZScore(contractId) {
+    const prices = this.priceBuffer.get(contractId);
+    if (!prices || prices.length < 50) return false;
+    const zscore = computeZScore(prices);
+    return Math.abs(zscore) < this.zscoreExitThreshold;
   }
 
-  getBarHistory(c) { return this.bh.get(c) || []; }
-  reset(c) { this.bh.set(c, []); this.lsd = null; this.vc.reset(c); }
-  getStats() { return this.st; }
-
-  getAnalysisState(c, cp) {
-    const bs = this.bh.get(c) || [];
-    if (bs.length < 10) return { ready: false, message: 'Collecting...' };
-
-    const va = this.vc.an(c, cp, this.ts);
-    const of = this.aof(bs);
-    const pm = this.gap(bs);
+  /**
+   * Get current model values
+   */
+  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 {
-      ready: true,
-      vwap: va?.vwap || 0,
-      zScore: va?.deviation || 0,
-      orderFlow: of.as,
-      ratio: of.ir,
-      regime: pm.rg,
-      stopTicks: pm.spt,
-      targetTicks: pm.tgt,
-      barsProcessed: bs.length
+      zscore: computeZScore(prices).toFixed(2),
+      vpin: (computeVPIN(volumes, this.vpinWindow) * 100).toFixed(1) + '%',
+      ofi: (computeOrderFlowImbalance(bars, this.ofiLookback) * 100).toFixed(1) + '%',
+      bars: bars.length
     };
   }
-}
 
-// =============================================================================
-// M1 - STRATEGY WRAPPER
-// =============================================================================
+  /**
+   * Record trade result
+   */
+  recordTradeResult(pnl) {
+    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; }
+  }
 
-class M1 extends EventEmitter {
-  constructor(cfg = {}) {
-    super();
-    this.cfg = cfg;
-    this.s = new S1(cfg);
-    this.s.on('signal', (sig) => {
-      this.emit('signal', {
-        side: sig.direction === 'long' ? 'buy' : 'sell',
-        action: 'open',
-        reason: `Z=${sig.zScore.toFixed(2)}, cf=${(sig.confidence * 100).toFixed(0)}%`,
-        ...sig
-      });
-    });
+  /**
+   * Get bar history
+   */
+  getBarHistory(contractId) {
+    return this.barHistory.get(contractId) || [];
   }
 
-  processTick(t) { return this.s.processTick(t); }
-  onTick(t) { return this.processTick(t); }
-  processBar(c, b) { return this.s.processBar(c, b); }
-  onTrade(t) {
-    this.s.processTick({
-      contractId: t.contractId || t.symbol,
-      price: t.price,
-      volume: t.size || t.volume || 1,
-      side: t.side,
-      timestamp: t.timestamp || Date.now()
-    });
+  /**
+   * Reset strategy
+   */
+  reset(contractId) {
+    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 });
   }
-  initialize(c, ts, tv) { this.s.initialize(c, ts, tv); }
-  getAnalysisState(c, p) { return this.s.getAnalysisState(c, p); }
-  recordTradeResult(p) { this.s.recordTradeResult(p); }
-  reset(c) { this.s.reset(c); this.emit('log', { type: 'info', message: 'Reset' }); }
-  getStats() { return this.s.getStats(); }
-  generateSignal(p) { return null; }
 }
 
-module.exports = { S1, M1, VC, OS, SS };
+// Singleton instance
+const M1 = new HQXUltraScalpingStrategy();
+
+module.exports = { M1, HQXUltraScalpingStrategy, OrderSide, SignalStrength };