hedgequantx 2.4.7 → 2.4.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.4.7",
+  "version": "2.4.8",
   "description": "HedgeQuantX - Prop Futures Trading CLI",
   "main": "src/app.js",
   "bin": {
@@ -9,10 +9,7 @@
   },
   "scripts": {
     "start": "node bin/cli.js",
-    "dev": "node bin/cli.js",
-    "build": "node scripts/build.js",
-    "publish:safe": "node scripts/publish.js",
-    "prepublishOnly": "npm run build"
+    "dev": "node bin/cli.js"
   },
   "keywords": [
     "trading",
@@ -40,11 +37,11 @@
   },
   "files": [
     "bin/",
-    "dist/lib/",
     "protos/",
     "src/app.js",
     "src/api/",
     "src/config/",
+    "src/lib/",
     "src/menus/",
     "src/pages/",
     "src/security/",

package/src/lib/data.js

@@ -0,0 +1,286 @@
+/**
+ * =============================================================================
+ * MARKET DATA FEED - SignalR Real-Time Data
+ * =============================================================================
+ * Connects to ProjectX Gateway RTC for real-time market data
+ * 
+ * Events emitted:
+ * - tick: Quote/trade updates (price, bid, ask, volume)
+ * - quote: Quote updates only
+ * - trade: Trade executions only
+ * - depth: DOM/Level 2 updates
+ * - connected: Connection established
+ * - disconnected: Connection lost
+ * - error: Connection error
+ * 
+ * SOURCE: Based on ProjectX Gateway RTC API
+ */
+
+'use strict';
+
+const EventEmitter = require('events');
+const { HubConnectionBuilder, HttpTransportType, LogLevel } = require('@microsoft/signalr');
+
+// Inline PROPFIRMS config for RTC URLs (standalone module)
+const PROPFIRMS = {
+  topstep: { gatewayApi: 'api.topstepx.com' },
+  alpha_futures: { gatewayApi: 'api.alphafutures.projectx.com' },
+  tickticktrader: { gatewayApi: 'api.tickticktrader.projectx.com' },
+  bulenox: { gatewayApi: 'api.bulenox.projectx.com' },
+  tradeday: { gatewayApi: 'api.tradeday.projectx.com' },
+  blusky: { gatewayApi: 'api.blusky.projectx.com' },
+  goat_futures: { gatewayApi: 'api.goatfutures.projectx.com' },
+  futures_desk: { gatewayApi: 'api.thefuturesdesk.projectx.com' },
+  daytraders: { gatewayApi: 'api.daytraders.projectx.com' },
+  e8_futures: { gatewayApi: 'api.e8futures.projectx.com' },
+  blue_guardian: { gatewayApi: 'api.blueguardianfutures.projectx.com' },
+  futures_elite: { gatewayApi: 'api.futureselite.projectx.com' },
+  fxify: { gatewayApi: 'api.fxify.projectx.com' },
+  hola_prime: { gatewayApi: 'api.holaprime.projectx.com' },
+  top_one_futures: { gatewayApi: 'api.toponefutures.projectx.com' },
+  funding_futures: { gatewayApi: 'api.fundingfutures.projectx.com' },
+  tx3_funding: { gatewayApi: 'api.tx3funding.projectx.com' },
+  lucid_trading: { gatewayApi: 'api.lucidtrading.projectx.com' },
+  tradeify: { gatewayApi: 'api.tradeify.projectx.com' }
+};
+
+// =============================================================================
+// MARKET DATA FEED CLASS
+// =============================================================================
+
+class MarketDataFeed extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.propfirmKey = (options.propfirm || 'topstep').toLowerCase().replace(/\s+/g, '_');
+    this.connection = null;
+    this.connected = false;
+    this.subscriptions = new Set();
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 5;
+  }
+
+  /**
+   * Get market hub URL for propfirm
+   */
+  _getMarketHubUrl(propfirmKey) {
+    const propfirm = PROPFIRMS[propfirmKey] || PROPFIRMS.topstep;
+    
+    if (propfirm.rtcApi) {
+      return `https://${propfirm.rtcApi}/hubs/market`;
+    }
+    
+    if (propfirm.gatewayApi) {
+      const rtcHost = propfirm.gatewayApi.replace('gateway-api', 'gateway-rtc');
+      return `https://${rtcHost}/hubs/market`;
+    }
+    
+    return 'https://gateway-rtc-demo.s2f.projectx.com/hubs/market';
+  }
+
+  /**
+   * Connect to market data hub
+   */
+  async connect(token, propfirmKey, contractId = null) {
+    if (this.connected) return;
+
+    this.propfirmKey = propfirmKey || this.propfirmKey;
+    const hubUrl = this._getMarketHubUrl(this.propfirmKey);
+    
+    try {
+      this.connection = new HubConnectionBuilder()
+        .withUrl(hubUrl, {
+          skipNegotiation: true,
+          transport: HttpTransportType.WebSockets,
+          accessTokenFactory: () => token,
+          timeout: 30000,
+        })
+        .withAutomaticReconnect({
+          nextRetryDelayInMilliseconds: (ctx) => {
+            if (ctx.previousRetryCount >= this.maxReconnectAttempts) return null;
+            return Math.min(1000 * Math.pow(2, ctx.previousRetryCount), 30000);
+          }
+        })
+        .configureLogging(LogLevel.Warning)
+        .build();
+
+      this._setupEventHandlers();
+      await this.connection.start();
+      
+      this.connected = true;
+      this.reconnectAttempts = 0;
+      this.emit('connected');
+
+      if (contractId) {
+        await this.subscribe(null, contractId);
+      }
+    } catch (error) {
+      this.emit('error', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Setup SignalR event handlers
+   */
+  _setupEventHandlers() {
+    if (!this.connection) return;
+
+    // Quote updates
+    this.connection.on('GatewayQuote', (quote) => {
+      const tick = {
+        type: 'quote',
+        contractId: quote.symbol || quote.symbolId,
+        symbol: quote.symbolName || quote.symbol,
+        price: quote.lastPrice,
+        bid: quote.bestBid,
+        ask: quote.bestAsk,
+        change: quote.change,
+        changePercent: quote.changePercent,
+        open: quote.open,
+        high: quote.high,
+        low: quote.low,
+        volume: quote.volume,
+        timestamp: quote.timestamp ? new Date(quote.timestamp).getTime() : Date.now()
+      };
+      this.emit('tick', tick);
+      this.emit('quote', tick);
+    });
+
+    // Trade executions
+    this.connection.on('GatewayTrade', (trade) => {
+      const tick = {
+        type: 'trade',
+        contractId: trade.symbolId,
+        price: trade.price,
+        volume: trade.volume,
+        side: trade.type === 0 ? 'buy' : 'sell',
+        lastTradeSide: trade.type === 0 ? 'buy' : 'sell',
+        timestamp: trade.timestamp ? new Date(trade.timestamp).getTime() : Date.now()
+      };
+      this.emit('tick', tick);
+      this.emit('trade', tick);
+    });
+
+    // DOM updates
+    this.connection.on('GatewayDepth', (depth) => {
+      const domUpdate = {
+        type: 'depth',
+        price: depth.price,
+        volume: depth.volume,
+        currentVolume: depth.currentVolume,
+        side: depth.type === 0 ? 'bid' : 'ask',
+        timestamp: depth.timestamp ? new Date(depth.timestamp).getTime() : Date.now()
+      };
+      this.emit('depth', domUpdate);
+      this.emit('dom', domUpdate);
+    });
+
+    // Connection state
+    this.connection.onreconnecting((error) => {
+      this.connected = false;
+      this.emit('reconnecting', error);
+    });
+
+    this.connection.onreconnected((connectionId) => {
+      this.connected = true;
+      this.reconnectAttempts = 0;
+      this.emit('reconnected', connectionId);
+      this._resubscribeAll();
+    });
+
+    this.connection.onclose((error) => {
+      this.connected = false;
+      this.emit('disconnected', error);
+    });
+  }
+
+  /**
+   * Subscribe to contract market data
+   */
+  async subscribe(symbol, contractId) {
+    if (!this.connection || !this.connected) {
+      throw new Error('Not connected');
+    }
+
+    const id = contractId || symbol;
+    
+    try {
+      await this.connection.invoke('SubscribeContractQuotes', id);
+      await this.connection.invoke('SubscribeContractTrades', id);
+      await this.connection.invoke('SubscribeContractMarketDepth', id);
+      this.subscriptions.add(id);
+      this.emit('subscribed', { symbol, contractId: id });
+    } catch (error) {
+      this.emit('error', new Error(`Subscribe failed: ${error.message}`));
+      throw error;
+    }
+  }
+
+  /**
+   * Unsubscribe from contract
+   */
+  async unsubscribe(contractId) {
+    if (!this.connection || !this.connected) return;
+
+    try {
+      await this.connection.invoke('UnsubscribeContractQuotes', contractId);
+      await this.connection.invoke('UnsubscribeContractTrades', contractId);
+      await this.connection.invoke('UnsubscribeContractMarketDepth', contractId);
+      this.subscriptions.delete(contractId);
+      this.emit('unsubscribed', { contractId });
+    } catch (error) {
+      // Silently handle
+    }
+  }
+
+  /**
+   * Resubscribe after reconnect
+   */
+  async _resubscribeAll() {
+    for (const contractId of this.subscriptions) {
+      try {
+        await this.connection.invoke('SubscribeContractQuotes', contractId);
+        await this.connection.invoke('SubscribeContractTrades', contractId);
+        await this.connection.invoke('SubscribeContractMarketDepth', contractId);
+      } catch (error) {
+        // Continue
+      }
+    }
+  }
+
+  /**
+   * Disconnect
+   */
+  async disconnect() {
+    if (this.connection) {
+      try {
+        for (const contractId of this.subscriptions) {
+          await this.unsubscribe(contractId);
+        }
+        await this.connection.stop();
+      } catch (error) {
+        // Ignore
+      }
+      this.connection = null;
+      this.connected = false;
+      this.subscriptions.clear();
+    }
+  }
+
+  /**
+   * Check connection status
+   */
+  isConnected() {
+    return this.connected && this.connection?.state === 'Connected';
+  }
+
+  /**
+   * Get active subscriptions
+   */
+  getSubscriptions() {
+    return Array.from(this.subscriptions);
+  }
+}
+
+module.exports = { MarketDataFeed };

package/src/lib/m/s1.js

@@ -0,0 +1,521 @@
+/**
+ * =============================================================================
+ * 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');
+
+// =============================================================================
+// 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
+// =============================================================================
+
+class HQXUltraScalpingStrategy extends EventEmitter {
+  constructor() {
+    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;
+  }
+
+  /**
+   * 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 });
+  }
+
+  /**
+   * Process a tick - aggregates into bars then runs strategy
+   */
+  processTick(tick) {
+    const contractId = tick.contractId;
+    
+    if (!this.barHistory.has(contractId)) {
+      this.initialize(contractId);
+    }
+
+    // Add tick to buffer
+    let ticks = this.tickBuffer.get(contractId);
+    ticks.push(tick);
+
+    // 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;
+  }
+
+  /**
+   * 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; }
+    }
+
+    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
+    };
+  }
+
+  /**
+   * 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);
+    }
+
+    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);
+  }
+
+  // ===========================================================================
+  // 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;
+  }
+
+  // ===========================================================================
+  // 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;
+  }
+
+  // ===========================================================================
+  // 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);
+  }
+
+  // ===========================================================================
+  // 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;
+  }
+
+  // ===========================================================================
+  // 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;
+    }
+
+    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 {
+      regime = 'high';
+      params = { stopMultiplier: 1.3, targetMultiplier: 1.2, zscoreThreshold: 2.0, confidenceBonus: -0.05 };
+    }
+    return { regime, params };
+  }
+
+  _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);
+    }
+    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;
+      }
+    }
+    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 = 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;
+    }
+
+    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,
+      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
+    };
+  }
+
+  /**
+   * Check if should exit by Z-Score
+   */
+  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;
+  }
+
+  /**
+   * 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 {
+      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.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; }
+  }
+
+  /**
+   * Get bar history
+   */
+  getBarHistory(contractId) {
+    return this.barHistory.get(contractId) || [];
+  }
+
+  /**
+   * 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 });
+  }
+}
+
+// Singleton instance
+const M1 = new HQXUltraScalpingStrategy();
+
+module.exports = { M1, HQXUltraScalpingStrategy, OrderSide, SignalStrength };

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

@@ -11,9 +11,9 @@ const { AlgoUI, renderSessionSummary } = require('./ui');
 const { prompts } = require('../../utils');
 const { checkMarketHours } = require('../../services/projectx/market');
 
-// Strategy & Market Data (from compiled bytecode)
-const { M1 } = require('../../../dist/lib/m/mod1');
-const { MarketDataFeed } = require('../../../dist/lib/data');
+// Strategy & Market Data
+const { M1 } = require('../../lib/m/s1');
+const { MarketDataFeed } = require('../../lib/data');
 
 
 

package/dist/lib/api.js

@@ -1 +0,0 @@
-'use strict';require('bytenode');module.exports=require('./api.jsc');

package/dist/lib/api2.js

@@ -1 +0,0 @@
-'use strict';require('bytenode');module.exports=require('./api2.jsc');

package/dist/lib/core.js

@@ -1 +0,0 @@
-'use strict';require('bytenode');module.exports=require('./core.jsc');

package/dist/lib/core2.js

@@ -1 +0,0 @@
-'use strict';require('bytenode');module.exports=require('./core2.jsc');

package/dist/lib/data.js

@@ -1 +0,0 @@
-'use strict';require('bytenode');module.exports=require('./data.jsc');

package/dist/lib/data2.js

@@ -1 +0,0 @@
-'use strict';require('bytenode');module.exports=require('./data2.jsc');

package/dist/lib/decoder.js

@@ -1 +0,0 @@
-'use strict';require('bytenode');module.exports=require('./decoder.jsc');

package/dist/lib/m/mod1.js

@@ -1 +0,0 @@
-'use strict';require('bytenode');module.exports=require('./mod1.jsc');

package/dist/lib/m/mod2.js

@@ -1 +0,0 @@
-'use strict';require('bytenode');module.exports=require('./mod2.jsc');

package/dist/lib/n/r1.js

@@ -1 +0,0 @@
-'use strict';require('bytenode');module.exports=require('./r1.jsc');

package/dist/lib/n/r2.js

@@ -1 +0,0 @@
-'use strict';require('bytenode');module.exports=require('./r2.jsc');

package/dist/lib/n/r3.js

@@ -1 +0,0 @@
-'use strict';require('bytenode');module.exports=require('./r3.jsc');

package/dist/lib/n/r4.js

@@ -1 +0,0 @@
-'use strict';require('bytenode');module.exports=require('./r4.jsc');

package/dist/lib/n/r5.js

@@ -1 +0,0 @@
-'use strict';require('bytenode');module.exports=require('./r5.jsc');

package/dist/lib/n/r6.js

@@ -1 +0,0 @@
-'use strict';require('bytenode');module.exports=require('./r6.jsc');

package/dist/lib/n/r7.js

@@ -1 +0,0 @@
-'use strict';require('bytenode');module.exports=require('./r7.jsc');

package/dist/lib/o/util1.js

@@ -1 +0,0 @@
-'use strict';require('bytenode');module.exports=require('./util1.jsc');

package/dist/lib/o/util2.js

@@ -1 +0,0 @@
-'use strict';require('bytenode');module.exports=require('./util2.jsc');