hedgequantx 2.9.229 → 2.9.231

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

@@ -197,69 +197,94 @@ class HQXUltraScalpingStrategy extends EventEmitter {
   }
   
   /**
-   * Emit status log with QUANT metrics
+   * Emit status log with QUANT metrics - shows exactly WHY we're not entering
+   * No repetition - only emits if message changed
    */
   _emitStatusLog(contractId, currentPrice) {
     const prices = this.priceBuffer.get(contractId) || [];
     const volumes = this.volumeBuffer.get(contractId) || [];
     const bars = this.barHistory.get(contractId) || [];
     
-    if (prices.length < 20) return; // Not enough data yet
-    
-    // Compute current metrics
-    const zscore = computeZScore(prices);
-    const vpin = volumes.length >= 10 ? computeVPIN(volumes, this.vpinWindow) : 0;
-    const ofi = bars.length >= 10 ? computeOrderFlowImbalance(bars, this.ofiLookback) : 0;
-    
-    // Determine market state
-    const absZ = Math.abs(zscore);
-    let zState = 'normal';
-    if (absZ >= 2.0) zState = 'EXTREME';
-    else if (absZ >= 1.5) zState = 'HIGH';
-    else if (absZ >= 1.0) zState = 'building';
-    
-    // Determine direction bias
-    let bias = 'neutral';
-    if (zscore < -1.5 && ofi > 0.1) bias = 'LONG setup';
-    else if (zscore > 1.5 && ofi < -0.1) bias = 'SHORT setup';
-    else if (zscore < -1.0) bias = 'oversold';
-    else if (zscore > 1.0) bias = 'overbought';
-    
     // Extract symbol
-    const sym = (contractId || '').replace(/[A-Z]\d+$/, '');
+    const sym = extractBaseSymbol(contractId);
+    const priceStr = currentPrice.toFixed(2);
     
-    // Build message based on state
     let message;
-    if (!this.tradingEnabled) {
-      message = `[${sym}] ${currentPrice.toFixed(2)} | PAUSED (${this.lossStreak} losses) | Cooldown active`;
-    } else if (absZ >= 2.0) {
-      const dir = zscore < 0 ? 'LONG' : 'SHORT';
-      const ofiPct = (Math.abs(ofi) * 100).toFixed(0);
-      const ofiConfirm = (zscore < 0 && ofi > 0.15) || (zscore > 0 && ofi < -0.15);
-      if (ofiConfirm) {
-        message = `[${sym}] ${currentPrice.toFixed(2)} | Z: ${zscore.toFixed(1)}σ ${zState} | ${dir} | OFI ${ofiPct}% confirms`;
-      } else {
-        message = `[${sym}] ${currentPrice.toFixed(2)} | Z: ${zscore.toFixed(1)}σ ${zState} | ${dir} signal | OFI ${ofiPct}% pending`;
-      }
-    } else if (absZ >= 1.5) {
-      message = `[${sym}] ${currentPrice.toFixed(2)} | Z: ${zscore.toFixed(1)}σ ${zState} | ${bias} | Monitoring`;
-    } else if (absZ >= 1.0) {
-      message = `[${sym}] ${currentPrice.toFixed(2)} | Z: ${zscore.toFixed(1)}σ ${zState} | Awaiting extremity`;
+    let state; // Used to detect state changes
+    
+    // Not enough data yet
+    if (prices.length < 20) {
+      const pct = Math.round((prices.length / 50) * 100);
+      state = `warmup-${Math.floor(pct / 10) * 10}`;
+      message = `[${sym}] ${priceStr} | Warming up... ${prices.length}/50 bars (${pct}%)`;
+    } else if (bars.length < 50) {
+      const pct = Math.round((bars.length / 50) * 100);
+      state = `building-${Math.floor(pct / 10) * 10}`;
+      message = `[${sym}] ${priceStr} | Building history... ${bars.length}/50 bars (${pct}%)`;
     } else {
-      // Normal state - show different context messages
+      // Compute current metrics
+      const zscore = computeZScore(prices);
+      const vpin = volumes.length >= 10 ? computeVPIN(volumes, this.vpinWindow) : 0;
+      const ofi = bars.length >= 10 ? computeOrderFlowImbalance(bars, this.ofiLookback) : 0;
+      const absZ = Math.abs(zscore);
+      const ofiPct = (ofi * 100).toFixed(0);
       const vpinPct = (vpin * 100).toFixed(0);
-      const contexts = [
-        `VPIN ${vpinPct}% | Mean reversion scan`,
-        `OFI balanced | Price discovery`,
-        `Z normalized | Statistical scan`,
-        `Tick flow stable | Edge detection`,
-        `Volatility normal | Alpha scan`,
-      ];
-      const ctx = contexts[Math.floor(Date.now() / 5000) % contexts.length];
-      message = `[${sym}] ${currentPrice.toFixed(2)} | Z: ${zscore.toFixed(1)}σ | ${ctx}`;
+      const zRounded = Math.round(zscore * 10) / 10; // Round to 0.1
+      
+      // Check cooldown
+      const now = Date.now();
+      const timeSinceLastSignal = now - this.lastSignalTime;
+      const cooldownRemaining = Math.max(0, this.signalCooldownMs - timeSinceLastSignal);
+      
+      // Trading disabled?
+      if (!this.tradingEnabled) {
+        state = 'paused';
+        message = `[${sym}] ${priceStr} | PAUSED - ${this.lossStreak} losses | Cooldown active`;
+      }
+      // In cooldown?
+      else if (cooldownRemaining > 0 && this.lastSignalTime > 0) {
+        const secs = Math.ceil(cooldownRemaining / 1000);
+        state = `cooldown-${secs}`;
+        message = `[${sym}] ${priceStr} | Cooldown ${secs}s | Z:${zRounded}σ OFI:${ofiPct}%`;
+      }
+      // VPIN toxic?
+      else if (vpin > this.vpinToxicThreshold) {
+        state = 'vpin-toxic';
+        message = `[${sym}] ${priceStr} | VPIN toxic ${vpinPct}% > 70% | No entry - informed traders active`;
+      }
+      else {
+        // Determine what's needed for entry
+        const zThreshold = 1.5;
+        const needMoreZ = absZ < zThreshold;
+        const direction = zscore < 0 ? 'LONG' : 'SHORT';
+        const ofiConfirms = (direction === 'LONG' && ofi > 0.15) || (direction === 'SHORT' && ofi < -0.15);
+        
+        // Z-score too low - main reason for no entry
+        if (needMoreZ) {
+          const needed = (zThreshold - absZ).toFixed(1);
+          const dir = zscore < 0 ? 'oversold' : zscore > 0 ? 'overbought' : 'neutral';
+          state = `zscore-low-${zRounded}-${ofiPct}`;
+          message = `[${sym}] ${priceStr} | Z:${zRounded}σ ${dir} | Need ${needed}σ more for signal | OFI:${ofiPct}%`;
+        }
+        // Z-score high enough but OFI doesn't confirm
+        else if (!ofiConfirms) {
+          const ofiNeedStr = direction === 'LONG' ? '>15%' : '<-15%';
+          state = `ofi-pending-${zRounded}-${ofiPct}`;
+          message = `[${sym}] ${priceStr} | Z:${zRounded}σ ${direction} ready | OFI:${ofiPct}% needs ${ofiNeedStr} to confirm`;
+        }
+        // All conditions met!
+        else {
+          state = `signal-${direction}`;
+          message = `[${sym}] ${priceStr} | Z:${zRounded}σ | OFI:${ofiPct}% | ${direction} SIGNAL CONDITIONS MET`;
+        }
+      }
     }
     
-    this.emit('log', { type: 'info', message });
+    // Only emit if state changed (no repetition)
+    if (state !== this._lastLogState) {
+      this._lastLogState = state;
+      this.emit('log', { type: 'info', message });
+    }
   }
 
   /**

package/package.json

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

package/src/lib/smart-logs-engine.js

@@ -1,320 +1,242 @@
 /**
- * Smart Logs Engine - Unified Event-Driven Intelligent Logs
- * ==========================================================
+ * Smart Logs Engine - Professional HF-Grade Adaptive Logs
+ * ========================================================
  * 
- * UNIFIED SYSTEM for all CLI strategies:
- * - Same engine, same event detection logic
- * - Strategy-specific vocabulary (HQX-2B: bars/swings/zones, QUANT: ticks/Z-Score/VPIN/OFI)
- * - Uses smartLogs.getLiveAnalysisLog() for varied, non-repetitive messages
+ * PRINCIPLES:
+ * 1. NO repetitive messages - each log must be unique and meaningful
+ * 2. Adaptive to real market context - uses actual QUANT metrics
+ * 3. Professional HF language - precise, technical, actionable
+ * 4. Event-driven only - silence means scanning, no spam
  * 
- * Only logs when something SIGNIFICANT happens - no spam, no repetitive messages
- * 
- * COLOR SCHEME:
- * - Symbols: cyan (NQ, ES, CL, GC)
- * - Prices: white bold
- * - Bullish/Long: green
- * - Bearish/Short: red
- * - Neutral/System: gray/dim
- * - Signals: yellow/magenta
- * - Risk/Warnings: red bold
- * - Values: blue (Z-Score, VPIN, OFI numbers)
+ * This replaces the old rotating generic messages with
+ * intelligent, context-aware logs that reflect the actual
+ * algorithmic decision process.
  */
 
 'use strict';
 
 const chalk = require('chalk');
-const smartLogs = require('./smart-logs');
-const { getContextualMessage } = require('./smart-logs-context');
 
 // Color helpers for consistent styling
 const C = {
-  // Symbols & identifiers
   sym: (s) => chalk.cyan.bold(s),
-  
-  // Prices
   price: (p) => chalk.white.bold(p),
-  
-  // Direction
   long: (s) => chalk.green.bold(s),
   short: (s) => chalk.red.bold(s),
   bull: (s) => chalk.green(s),
   bear: (s) => chalk.red(s),
-  
-  // Values & metrics
   val: (v) => chalk.blue(v),
   valHigh: (v) => chalk.magenta.bold(v),
-  
-  // Status
   ok: (s) => chalk.green(s),
   warn: (s) => chalk.yellow(s),
   danger: (s) => chalk.red.bold(s),
-  
-  // System/neutral
   dim: (s) => chalk.dim(s),
   info: (s) => chalk.gray(s),
-  
-  // Special
   signal: (s) => chalk.yellow.bold(s),
-  zone: (s) => chalk.magenta(s),
-  regime: (s) => chalk.cyan(s),
 };
 
 const CONFIG = { 
-  SESSION_LOG_INTERVAL: 10,
-  // HQX-2B thresholds
-  PRICE_CHANGE_TICKS: 4,
-  DELTA_CHANGE_THRESHOLD: 200,
-  // QUANT thresholds
   Z_EXTREME: 2.0,
   Z_HIGH: 1.5,
   Z_BUILDING: 1.0,
+  OFI_STRONG: 0.20,
   OFI_THRESHOLD: 0.15,
-  VPIN_TOXIC: 0.6,
-  QUANT_WARMUP_TICKS: 250,
-  // Heartbeat interval - frequent updates in scanning mode
-  HEARTBEAT_MS: 5000,  // 5 seconds
-};
-
-const SYMBOLS = {
-  NQ: 'NQ', MNQ: 'MNQ', ES: 'ES', MES: 'MES', YM: 'YM', MYM: 'MYM',
-  CL: 'CL', MCL: 'MCL', GC: 'GC', MGC: 'MGC', SI: 'SI', SIL: 'SIL',
-  RTY: 'RTY', M2K: 'M2K', ZB: 'ZB', ZN: 'ZN',
+  VPIN_TOXIC: 0.65,
+  VPIN_ELEVATED: 0.50,
 };
 
 function getSym(s) {
   if (!s) return 'FUT';
   const b = s.split(':')[0].replace(/[FGHJKMNQUVXZ]\d{1,2}$/, '').toUpperCase();
-  return SYMBOLS[b] || b;
+  const map = { ENQ: 'NQ', EP: 'ES', RTY: 'RTY', EMD: 'EMD', MGC: 'GC', MCL: 'CL' };
+  return map[b] || b;
 }
 
 /**
- * Unified Smart Logs Engine
- * Works with any strategy - adapts vocabulary based on strategyId
+ * Professional HF Smart Logs Engine
  */
 class SmartLogsEngine {
   constructor(strategyId, symbol) {
-    this.strategyId = strategyId || 'hqx-2b';
+    this.strategyId = strategyId || 'ultra-scalping';
     this.symbolCode = symbol;
-    this.counter = 0;
-    this.lastState = null;
-    
-    // State tracking for event detection (both strategies)
-    this.lastBias = null;
-    this.warmupLogged = false;
+    this.lastLogHash = null;
+    this.lastLogTime = 0;
+    this.eventCounter = 0;
     
-    // HQX-2B specific
-    this.lastBars = 0;
-    this.lastSwings = 0;
-    this.lastZones = 0;
-    this.lastNearZone = false;
-    
-    // QUANT specific
-    this.lastZRegime = null;
-    this.lastVpinToxic = false;
+    // State tracking for change detection
+    this.prev = {
+      zRegime: null,
+      ofiDir: null,
+      vpinLevel: null,
+      position: 0,
+      ready: false,
+    };
   }
 
   setSymbol(s) { this.symbolCode = s; }
 
   /**
-   * Get log message - unified entry point
-   * Detects strategy and routes to appropriate handler
+   * Main entry - returns log only when meaningful event occurs
+   * Returns null for silence (professional: no news = scanning)
    */
   getLog(state = {}) {
-    this.counter++;
     const sym = getSym(this.symbolCode);
-    const price = state.price > 0 ? state.price.toFixed(2) : '-.--';
-    const { position = 0, delta = 0 } = state;
-
-    // Active position - same for all strategies
-    if (position !== 0) {
-      const isLong = position > 0;
-      const side = isLong ? C.long('LONG') : C.short('SHORT');
-      const flowFavor = (isLong && delta > 0) || (!isLong && delta < 0);
-      const flowLabel = flowFavor ? C.ok('FAVOR') : C.danger('ADVERSE');
-      const deltaStr = delta > 0 ? C.bull(`+${delta}`) : C.bear(`${delta}`);
+    const price = state.price > 0 ? state.price.toFixed(2) : null;
+    const { position = 0, zScore = 0, vpin = 0, ofi = 0, tickCount = 0, bars = 0 } = state;
+    
+    // Not enough data - still warming up
+    const dataPoints = tickCount || bars || 0;
+    if (dataPoints < 50 || !price) {
+      // Only log warmup progress at milestones
+      if (!this.prev.ready && dataPoints > 0) {
+        const pct = Math.min(100, Math.round((dataPoints / 50) * 100));
+        const milestone = Math.floor(pct / 25) * 25;
+        const lastMilestone = this._lastWarmupMilestone || 0;
+        if (milestone > lastMilestone) {
+          this._lastWarmupMilestone = milestone;
+          return {
+            type: 'system',
+            message: `[${C.sym(sym)}] Calibrating QUANT models... ${C.val(pct + '%')} (${dataPoints} samples)`,
+            logToSession: false
+          };
+        }
+      }
+      return null;
+    }
+    
+    // Mark as ready
+    if (!this.prev.ready) {
+      this.prev.ready = true;
       return {
-        type: 'trade',
-        message: `[${C.sym(sym)}] ${side} ACTIVE @ ${C.price(price)} | Delta: ${deltaStr} | Flow: ${flowLabel}`,
+        type: 'system',
+        message: `[${C.sym(sym)}] ${C.price(price)} | ${C.ok('QUANT models calibrated')} | Scanning for alpha`,
         logToSession: true
       };
     }
-
-    // Route to strategy-specific handler
-    if (this.strategyId === 'ultra-scalping') {
-      return this._getQuantLog(state, sym, price);
-    } else {
-      return this._getHqx2bLog(state, sym, price);
-    }
-  }
-
-  /**
-   * HQX-2B Liquidity Sweep - Bar/Swing/Zone based events
-   */
-  _getHqx2bLog(state, sym, price) {
-    const { bars = 0, swings = 0, zones = 0, nearZone = false, trend = 'neutral', delta = 0 } = state;
     
-    let event = null;
-    let logType = 'analysis';
-    let message = null;
-
-    // EVENT 1: Warmup complete (10+ bars)
-    if (bars >= 10 && !this.warmupLogged) {
-      this.warmupLogged = true;
-      event = 'warmup';
-      const warmupMsg = getContextualMessage(this.symbolCode, this.strategyId, 'warmup');
-      message = `[${C.sym(sym)}] ${C.ok('2B ready')} | ${C.val(bars)} bars | ${C.dim(warmupMsg)}`;
-      logType = 'system';
-    }
-    // EVENT 2: New zone created
-    else if (zones > this.lastZones && zones > 0) {
-      event = 'new_zone';
-      const signalMsg = getContextualMessage(this.symbolCode, this.strategyId, 'signal');
-      message = `[${C.sym(sym)}] ${C.price(price)} | ${C.zone('Zone #' + zones)} | ${C.signal(signalMsg)}`;
-      logType = 'signal';
-    }
-    // EVENT 3: New swing detected
-    else if (swings > this.lastSwings && swings > 0) {
-      event = 'new_swing';
-      const scanMsg = getContextualMessage(this.symbolCode, this.strategyId, 'scanning');
-      message = `[${C.sym(sym)}] ${C.price(price)} | ${C.info('Swing #' + swings)} | ${C.dim(scanMsg)}`;
-    }
-    // EVENT 4: Zone approach (price near zone)
-    else if (nearZone && !this.lastNearZone && zones > 0) {
-      event = 'zone_approach';
-      const signalMsg = getContextualMessage(this.symbolCode, this.strategyId, 'signal');
-      message = `[${C.sym(sym)}] ${C.price(price)} | ${C.warn('Zone approach')} | ${C.signal(signalMsg)}`;
-      logType = 'signal';
-    }
-    // EVENT 5: Bias flip
-    else if (this.lastBias && trend !== this.lastBias && trend !== 'neutral' && this.lastBias !== 'neutral') {
-      event = 'bias_flip';
-      const arrow = trend === 'bullish' ? C.bull('▲') : C.bear('▼');
-      const oldBias = this.lastBias === 'bullish' ? C.bull(this.lastBias) : C.bear(this.lastBias);
-      const newBias = trend === 'bullish' ? C.bull(trend) : C.bear(trend);
-      const flipMsg = getContextualMessage(this.symbolCode, this.strategyId, trend);
-      message = `[${C.sym(sym)}] ${arrow} ${oldBias} → ${newBias} | ${C.dim(flipMsg)}`;
-    }
-
-    // Update state tracking
-    this.lastBars = bars;
-    this.lastSwings = swings;
-    this.lastZones = zones;
-    this.lastNearZone = nearZone;
-    this.lastBias = trend;
-
-    if (event && message) {
-      return { type: logType, message, logToSession: event === 'new_zone' || event === 'bias_flip' };
+    // Active position - always show
+    if (position !== 0) {
+      const isLong = position > 0;
+      const side = isLong ? C.long('LONG') : C.short('SHORT');
+      const deltaFavor = (isLong && ofi > 0) || (!isLong && ofi < 0);
+      const flowLabel = deltaFavor ? C.ok('ALIGNED') : C.warn('ADVERSE');
+      const ofiStr = (ofi * 100).toFixed(0);
+      const zStr = zScore.toFixed(2);
+      
+      // Only log position updates when something changes
+      const posHash = `pos-${position}-${Math.round(ofi * 10)}`;
+      if (posHash !== this.lastLogHash) {
+        this.lastLogHash = posHash;
+        return {
+          type: 'trade',
+          message: `[${C.sym(sym)}] ${side} @ ${C.price(price)} | OFI:${ofiStr}% ${flowLabel} | Z:${zStr}σ`,
+          logToSession: true
+        };
+      }
+      return null;
     }
-    return null;
-  }
-
-  /**
-   * QUANT (HQX Ultra Scalping) - Tick/Z-Score/VPIN/OFI based events
-   */
-  _getQuantLog(state, sym, price) {
-    const { tickCount = 0, zScore = 0, vpin = 0, ofi = 0 } = state;
-    const ticks = tickCount || state.bars || 0;
     
+    // Compute current regimes
     const absZ = Math.abs(zScore);
-    const vpinToxic = vpin > CONFIG.VPIN_TOXIC;
-    const zRegime = absZ >= CONFIG.Z_EXTREME ? 'extreme' : absZ >= CONFIG.Z_HIGH ? 'high' : absZ >= CONFIG.Z_BUILDING ? 'building' : 'neutral';
-    const bias = ofi > CONFIG.OFI_THRESHOLD ? 'bullish' : ofi < -CONFIG.OFI_THRESHOLD ? 'bearish' : 'neutral';
-
+    const zRegime = absZ >= CONFIG.Z_EXTREME ? 'extreme' : 
+                    absZ >= CONFIG.Z_HIGH ? 'high' : 
+                    absZ >= CONFIG.Z_BUILDING ? 'building' : 'neutral';
+    const ofiDir = ofi > CONFIG.OFI_STRONG ? 'strong-bull' :
+                   ofi > CONFIG.OFI_THRESHOLD ? 'bull' :
+                   ofi < -CONFIG.OFI_STRONG ? 'strong-bear' :
+                   ofi < -CONFIG.OFI_THRESHOLD ? 'bear' : 'neutral';
+    const vpinLevel = vpin > CONFIG.VPIN_TOXIC ? 'toxic' :
+                      vpin > CONFIG.VPIN_ELEVATED ? 'elevated' : 'normal';
+    
+    // Detect events (changes in regime)
     let event = null;
-    let logType = 'analysis';
     let message = null;
-
-    // Helper for Z-Score color
-    const zColor = (z) => {
-      const absVal = Math.abs(z);
-      const formatted = `${z.toFixed(1)}σ`;
-      if (absVal >= CONFIG.Z_EXTREME) return C.valHigh(formatted);
-      if (absVal >= CONFIG.Z_HIGH) return C.warn(formatted);
-      if (absVal >= CONFIG.Z_BUILDING) return C.val(formatted);
-      return C.dim(formatted);
-    };
-
-    // EVENT 1: Warmup complete (250 ticks for QUANT models)
-    if (ticks >= CONFIG.QUANT_WARMUP_TICKS && !this.warmupLogged) {
-      this.warmupLogged = true;
-      event = 'warmup';
-      const warmupMsg = getContextualMessage(this.symbolCode, this.strategyId, 'warmup');
-      message = `[${C.sym(sym)}] ${C.ok('QUANT ready')} | ${C.val(ticks)} ticks | ${C.dim(warmupMsg)}`;
-      logType = 'system';
-    }
-    // EVENT 2: Z-Score regime change
-    else if (this.lastZRegime !== null && zRegime !== this.lastZRegime) {
+    let logType = 'analysis';
+    
+    const zColor = absZ >= CONFIG.Z_EXTREME ? C.valHigh : 
+                   absZ >= CONFIG.Z_HIGH ? C.warn : 
+                   absZ >= CONFIG.Z_BUILDING ? C.val : C.dim;
+    const zStr = zColor(`${zScore.toFixed(2)}σ`);
+    const ofiPct = (ofi * 100).toFixed(0);
+    const vpinPct = (vpin * 100).toFixed(0);
+    
+    // EVENT 1: Z-Score regime change (most important)
+    if (zRegime !== this.prev.zRegime && this.prev.zRegime !== null) {
       event = 'z_regime';
-      // Get instrument-specific market context message
-      const marketCtx = bias === 'bullish' ? 'bullish' : bias === 'bearish' ? 'bearish' : 'neutral';
-      const instrumentMsg = getContextualMessage(this.symbolCode, this.strategyId, marketCtx);
+      const dir = zScore < 0 ? 'LONG' : 'SHORT';
       
       if (zRegime === 'extreme') {
         logType = 'signal';
-        const dir = zScore < 0 ? C.long('LONG') : C.short('SHORT');
-        const signalMsg = getContextualMessage(this.symbolCode, this.strategyId, 'signal');
-        message = `[${C.sym(sym)}] ${C.price(price)} | Z: ${zColor(zScore)} ${C.signal('EXTREME')} | ${dir} | ${C.signal(signalMsg)}`;
+        const ofiConfirm = (zScore < 0 && ofi > CONFIG.OFI_THRESHOLD) || 
+                          (zScore > 0 && ofi < -CONFIG.OFI_THRESHOLD);
+        if (ofiConfirm) {
+          message = `[${C.sym(sym)}] ${C.price(price)} | Z:${zStr} ${C.signal('EXTREME')} | ${C.long(dir)} | OFI:${ofiPct}% ${C.ok('CONFIRMS')}`;
+        } else {
+          message = `[${C.sym(sym)}] ${C.price(price)} | Z:${zStr} ${C.signal('EXTREME')} | ${C.warn(dir + ' pending')} | OFI:${ofiPct}% awaiting`;
+        }
       } else if (zRegime === 'high') {
         logType = 'signal';
-        message = `[${C.sym(sym)}] ${C.price(price)} | Z: ${zColor(zScore)} ${C.warn('HIGH')} | ${C.dim(instrumentMsg)}`;
-      } else if (zRegime === 'building') {
-        message = `[${C.sym(sym)}] ${C.price(price)} | Z: ${zColor(zScore)} ${C.info('building')} | ${C.dim(instrumentMsg)}`;
-      } else {
-        const scanMsg = getContextualMessage(this.symbolCode, this.strategyId, 'scanning');
-        message = `[${C.sym(sym)}] ${C.price(price)} | Z: ${C.ok('normalized')} | ${C.dim(scanMsg)}`;
+        message = `[${C.sym(sym)}] ${C.price(price)} | Z:${zStr} ${C.warn('building')} | ${dir} setup forming | OFI:${ofiPct}%`;
+      } else if (zRegime === 'building' && this.prev.zRegime === 'neutral') {
+        message = `[${C.sym(sym)}] ${C.price(price)} | Z:${zStr} | Deviation detected | Monitoring`;
+      } else if (zRegime === 'neutral' && (this.prev.zRegime === 'high' || this.prev.zRegime === 'extreme')) {
+        message = `[${C.sym(sym)}] ${C.price(price)} | Z:${C.ok('normalized')} | Mean reversion complete`;
       }
     }
-    // EVENT 3: Bias flip (OFI direction change)
-    else if (this.lastBias !== null && bias !== this.lastBias && bias !== 'neutral' && this.lastBias !== 'neutral') {
-      event = 'bias_flip';
-      const arrow = bias === 'bullish' ? C.bull('▲') : C.bear('▼');
-      const oldBias = this.lastBias === 'bullish' ? C.bull(this.lastBias) : C.bear(this.lastBias);
-      const newBias = bias === 'bullish' ? C.bull(bias) : C.bear(bias);
-      const flipMsg = getContextualMessage(this.symbolCode, this.strategyId, bias);
-      message = `[${C.sym(sym)}] ${arrow} OFI: ${oldBias} → ${newBias} | ${C.dim(flipMsg)}`;
+    // EVENT 2: OFI direction flip (significant)
+    else if (ofiDir !== this.prev.ofiDir && this.prev.ofiDir !== null && 
+             ofiDir !== 'neutral' && this.prev.ofiDir !== 'neutral') {
+      event = 'ofi_flip';
+      const wasLong = this.prev.ofiDir.includes('bull');
+      const nowLong = ofiDir.includes('bull');
+      if (wasLong !== nowLong) {
+        const arrow = nowLong ? C.bull('▲') : C.bear('▼');
+        const newDir = nowLong ? C.bull('BUY') : C.bear('SELL');
+        message = `[${C.sym(sym)}] ${C.price(price)} | ${arrow} OFI flip → ${newDir} pressure | ${ofiPct}% | Z:${zStr}`;
+      }
     }
-    // EVENT 4: VPIN toxicity change
-    else if (this.lastVpinToxic !== null && vpinToxic !== this.lastVpinToxic) {
-      event = 'vpin';
-      const vpinPct = (vpin * 100).toFixed(0);
-      if (vpinToxic) {
-        message = `[${C.sym(sym)}] ${C.price(price)} | VPIN: ${C.danger(vpinPct + '%')} ${C.danger('TOXIC')} - informed flow`;
+    // EVENT 3: VPIN level change (toxicity warning)
+    else if (vpinLevel !== this.prev.vpinLevel && this.prev.vpinLevel !== null) {
+      event = 'vpin_change';
+      if (vpinLevel === 'toxic') {
         logType = 'risk';
-      } else {
-        message = `[${C.sym(sym)}] ${C.price(price)} | VPIN: ${C.ok(vpinPct + '%')} ${C.ok('clean')} - normal flow`;
+        message = `[${C.sym(sym)}] ${C.price(price)} | VPIN:${C.danger(vpinPct + '% TOXIC')} | Informed flow detected | Hold`;
+      } else if (vpinLevel === 'elevated' && this.prev.vpinLevel === 'normal') {
+        message = `[${C.sym(sym)}] ${C.price(price)} | VPIN:${C.warn(vpinPct + '%')} elevated | Monitoring toxicity`;
+      } else if (vpinLevel === 'normal' && this.prev.vpinLevel === 'toxic') {
+        message = `[${C.sym(sym)}] ${C.price(price)} | VPIN:${C.ok(vpinPct + '%')} normalized | Flow clean`;
       }
     }
-
+    
     // Update state tracking
-    this.lastZRegime = zRegime;
-    this.lastBias = bias;
-    this.lastVpinToxic = vpinToxic;
-
+    this.prev.zRegime = zRegime;
+    this.prev.ofiDir = ofiDir;
+    this.prev.vpinLevel = vpinLevel;
+    this.prev.position = position;
+    
+    // Return event or null (silence = professional scanning)
     if (event && message) {
-      return { type: logType, message, logToSession: event === 'z_regime' || event === 'bias_flip' };
+      this.lastLogHash = `${event}-${zRegime}-${ofiDir}-${vpinLevel}`;
+      return { type: logType, message, logToSession: logType === 'signal' || logType === 'risk' };
     }
     
-    // EVENT-DRIVEN ONLY: No spam, no repetitive logs
-    // Silence = system is scanning, nothing notable happening
-    // This is professional HF behavior
     return null;
   }
 
   reset() { 
-    this.lastState = null;
-    this.counter = 0;
-    this.lastBias = null;
-    this.warmupLogged = false;
-    // HQX-2B
-    this.lastBars = 0;
-    this.lastSwings = 0;
-    this.lastZones = 0;
-    this.lastNearZone = false;
-    // QUANT
-    this.lastZRegime = null;
-    this.lastVpinToxic = false;
+    this.lastLogHash = null;
+    this.lastLogTime = 0;
+    this.eventCounter = 0;
+    this._lastWarmupMilestone = 0;
+    this.prev = {
+      zRegime: null,
+      ofiDir: null,
+      vpinLevel: null,
+      position: 0,
+      ready: false,
+    };
   }
 }
 
 function createEngine(strategyId, symbol) { return new SmartLogsEngine(strategyId, symbol); }
-module.exports = { SmartLogsEngine, createEngine, CONFIG };
+module.exports = { SmartLogsEngine, createEngine, CONFIG, C };