hedgequantx 2.9.153 → 2.9.154

package/package.json

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

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

@@ -188,68 +188,59 @@ const QUANT = {
     `[${d.sym}] Sharpe estimation | ${d.bars} bars | Risk-adjusted return`,
   ]),
 
-  zones: (d) => {
-    const z = (Math.abs(d.delta) / 8).toFixed(2);
-    return pick([
-      `[${d.sym}] ${d.price} | Z: ${z}σ | VPIN elevated | ${d.zones} factors converging`,
-      `[${d.sym}] ${d.price} | Statistical edge forming | Z-score: ${z}σ | OFI: ${d.delta}`,
-      `[${d.sym}] Factor alignment | ${d.zones}/${d.zones + 2} criteria | Threshold proximity`,
-      `[${d.sym}] ${d.price} | Multi-factor consensus: ${d.zones} | Z: ${z}σ approaching`,
-      `[${d.sym}] Edge probability rising | Z: ${z}σ | VPIN: elevated | OFI: ${d.delta}`,
-      `[${d.sym}] ${d.price} | Regime shift detected | ${d.zones} factors | Z: ${z}σ`,
-      `[${d.sym}] Information ratio spike | ${d.price} | ${d.zones} signals converging`,
-      `[${d.sym}] ${d.price} | Alpha opportunity | Z: ${z}σ | Mispricing detected`,
-      `[${d.sym}] Signal strength: ${d.zones}/5 | ${d.price} | Z approaching ${z}σ`,
-      `[${d.sym}] ${d.price} | Factor model alert | ${d.zones} criteria met | Z: ${z}σ`,
-      `[${d.sym}] Convergence detected | ${d.price} | OFI: ${d.delta} | Threshold: ${z}σ`,
-      `[${d.sym}] ${d.price} | Statistical tension | ${d.zones} factors | Snap expected`,
-      `[${d.sym}] Edge forming @ ${d.price} | Z: ${z}σ | ${d.zones} confirmations`,
-      `[${d.sym}] ${d.price} | Model confidence rising | ${d.zones} factors aligned`,
-      `[${d.sym}] Fair value divergence | ${d.price} | Z: ${z}σ | Reversion setup`,
-    ]);
-  },
+  zones: (d) => pick([
+    `[${d.sym}] ${d.price} | Z: ${d.zScore}σ | VPIN: ${d.vpin}% | Factors converging`,
+    `[${d.sym}] ${d.price} | Statistical edge forming | Z: ${d.zScore}σ | OFI: ${d.ofi}`,
+    `[${d.sym}] Factor alignment | ${d.ticks} ticks | Z: ${d.zScore}σ | Threshold proximity`,
+    `[${d.sym}] ${d.price} | Multi-factor scan | Z: ${d.zScore}σ | VPIN: ${d.vpin}%`,
+    `[${d.sym}] Edge probability rising | Z: ${d.zScore}σ | VPIN: ${d.vpin}% | OFI: ${d.ofi}`,
+    `[${d.sym}] ${d.price} | Regime analysis | Z: ${d.zScore}σ | ${d.ticks} observations`,
+    `[${d.sym}] Information ratio calc | ${d.price} | Z: ${d.zScore}σ | Converging`,
+    `[${d.sym}] ${d.price} | Alpha scan | Z: ${d.zScore}σ | VPIN: ${d.vpin}%`,
+    `[${d.sym}] Signal strength building | ${d.price} | Z: ${d.zScore}σ | OFI: ${d.ofi}`,
+    `[${d.sym}] ${d.price} | Factor model active | Z: ${d.zScore}σ | VPIN: ${d.vpin}%`,
+    `[${d.sym}] Convergence scan | ${d.price} | OFI: ${d.ofi} | Z: ${d.zScore}σ`,
+    `[${d.sym}] ${d.price} | Statistical tension | Z: ${d.zScore}σ | Snap pending`,
+    `[${d.sym}] Edge forming @ ${d.price} | Z: ${d.zScore}σ | ${d.ticks} ticks`,
+    `[${d.sym}] ${d.price} | Model confidence: ${d.vpin}% VPIN | Z: ${d.zScore}σ`,
+    `[${d.sym}] Fair value analysis | ${d.price} | Z: ${d.zScore}σ | OFI: ${d.ofi}`,
+  ]),
 
-  bull: (d) => {
-    const z = (Math.abs(d.delta) / 8).toFixed(2);
-    return pick([
-      `[${d.sym}] ${d.price} | Z: +${z}σ | OFI: +${Math.abs(d.delta)} | BUY edge detected`,
-      `[${d.sym}] ${d.price} | VPIN buy signal | Toxic sell absorbed | Delta: +${Math.abs(d.delta)}`,
-      `[${d.sym}] Statistical long | Z: +${z}σ | Mean reversion BUY | ${d.ticks} tick confirm`,
-      `[${d.sym}] ${d.price} | Factor model: LONG | OFI/VPIN/Z aligned | Positive expectancy`,
-      `[${d.sym}] Microstructure bullish | Z: +${z}σ | Order toxicity clearing`,
-      `[${d.sym}] ${d.price} | Positive alpha | Z: +${z}σ | Long bias confirmed`,
-      `[${d.sym}] Momentum factor bullish | ${d.price} | OFI: +${Math.abs(d.delta)} | Signal: BUY`,
-      `[${d.sym}] ${d.price} | Information ratio: positive | Z: +${z}σ | Long edge`,
-      `[${d.sym}] Mean below price | ${d.price} | Z: +${z}σ | Bullish regime`,
-      `[${d.sym}] ${d.price} | Buy signal confidence | Delta: +${Math.abs(d.delta)} | Z: +${z}σ`,
-      `[${d.sym}] Regime: bullish | ${d.price} | OFI: +${Math.abs(d.delta)} | Factor aligned`,
-      `[${d.sym}] ${d.price} | Positive skew | Z: +${z}σ | Upside distribution`,
-      `[${d.sym}] Alpha extraction: long | ${d.price} | OFI/Z positive | Execute`,
-      `[${d.sym}] ${d.price} | Model output: BUY | Z: +${z}σ | ${d.zones} factors`,
-      `[${d.sym}] Statistical momentum | ${d.price} | Delta: +${Math.abs(d.delta)} | Bullish`,
-    ]);
-  },
+  bull: (d) => pick([
+    `[${d.sym}] ${d.price} | Z: +${d.zScoreAbs}σ | OFI: ${d.ofi} | BUY edge detected`,
+    `[${d.sym}] ${d.price} | VPIN: ${d.vpin}% buy | Z: +${d.zScoreAbs}σ | Bullish`,
+    `[${d.sym}] Statistical long | Z: +${d.zScoreAbs}σ | Mean reversion BUY | ${d.ticks} ticks`,
+    `[${d.sym}] ${d.price} | Factor model: LONG | Z/VPIN/OFI aligned | +EV`,
+    `[${d.sym}] Microstructure bullish | Z: +${d.zScoreAbs}σ | VPIN: ${d.vpin}%`,
+    `[${d.sym}] ${d.price} | Positive alpha | Z: +${d.zScoreAbs}σ | OFI: ${d.ofi}`,
+    `[${d.sym}] Momentum factor bullish | ${d.price} | OFI: ${d.ofi} | Z: +${d.zScoreAbs}σ`,
+    `[${d.sym}] ${d.price} | Info ratio: positive | Z: +${d.zScoreAbs}σ | Long edge`,
+    `[${d.sym}] Mean below price | ${d.price} | Z: +${d.zScoreAbs}σ | VPIN: ${d.vpin}%`,
+    `[${d.sym}] ${d.price} | Buy confidence | OFI: ${d.ofi} | Z: +${d.zScoreAbs}σ`,
+    `[${d.sym}] Regime: bullish | ${d.price} | Z: +${d.zScoreAbs}σ | VPIN: ${d.vpin}%`,
+    `[${d.sym}] ${d.price} | Positive skew | Z: +${d.zScoreAbs}σ | OFI: ${d.ofi}`,
+    `[${d.sym}] Alpha extraction: long | ${d.price} | Z/OFI positive`,
+    `[${d.sym}] ${d.price} | Model: BUY | Z: +${d.zScoreAbs}σ | VPIN: ${d.vpin}%`,
+    `[${d.sym}] Statistical momentum | ${d.price} | OFI: ${d.ofi} | Bullish`,
+  ]),
 
-  bear: (d) => {
-    const z = (Math.abs(d.delta) / 8).toFixed(2);
-    return pick([
-      `[${d.sym}] ${d.price} | Z: -${z}σ | OFI: ${d.delta} | SELL edge detected`,
-      `[${d.sym}] ${d.price} | VPIN sell signal | Toxic buy absorbed | Delta: ${d.delta}`,
-      `[${d.sym}] Statistical short | Z: -${z}σ | Mean reversion SELL | ${d.ticks} tick confirm`,
-      `[${d.sym}] ${d.price} | Factor model: SHORT | OFI/VPIN/Z aligned | Negative expectancy`,
-      `[${d.sym}] Microstructure bearish | Z: -${z}σ | Order toxicity rising`,
-      `[${d.sym}] ${d.price} | Negative alpha | Z: -${z}σ | Short bias confirmed`,
-      `[${d.sym}] Momentum factor bearish | ${d.price} | OFI: ${d.delta} | Signal: SELL`,
-      `[${d.sym}] ${d.price} | Information ratio: negative | Z: -${z}σ | Short edge`,
-      `[${d.sym}] Mean above price | ${d.price} | Z: -${z}σ | Bearish regime`,
-      `[${d.sym}] ${d.price} | Sell signal confidence | Delta: ${d.delta} | Z: -${z}σ`,
-      `[${d.sym}] Regime: bearish | ${d.price} | OFI: ${d.delta} | Factor aligned`,
-      `[${d.sym}] ${d.price} | Negative skew | Z: -${z}σ | Downside distribution`,
-      `[${d.sym}] Alpha extraction: short | ${d.price} | OFI/Z negative | Execute`,
-      `[${d.sym}] ${d.price} | Model output: SELL | Z: -${z}σ | ${d.zones} factors`,
-      `[${d.sym}] Statistical momentum | ${d.price} | Delta: ${d.delta} | Bearish`,
-    ]);
-  },
+  bear: (d) => pick([
+    `[${d.sym}] ${d.price} | Z: -${d.zScoreAbs}σ | OFI: ${d.ofi} | SELL edge detected`,
+    `[${d.sym}] ${d.price} | VPIN: ${d.vpin}% sell | Z: -${d.zScoreAbs}σ | Bearish`,
+    `[${d.sym}] Statistical short | Z: -${d.zScoreAbs}σ | Mean reversion SELL | ${d.ticks} ticks`,
+    `[${d.sym}] ${d.price} | Factor model: SHORT | Z/VPIN/OFI aligned | -EV`,
+    `[${d.sym}] Microstructure bearish | Z: -${d.zScoreAbs}σ | VPIN: ${d.vpin}%`,
+    `[${d.sym}] ${d.price} | Negative alpha | Z: -${d.zScoreAbs}σ | OFI: ${d.ofi}`,
+    `[${d.sym}] Momentum factor bearish | ${d.price} | OFI: ${d.ofi} | Z: -${d.zScoreAbs}σ`,
+    `[${d.sym}] ${d.price} | Info ratio: negative | Z: -${d.zScoreAbs}σ | Short edge`,
+    `[${d.sym}] Mean above price | ${d.price} | Z: -${d.zScoreAbs}σ | VPIN: ${d.vpin}%`,
+    `[${d.sym}] ${d.price} | Sell confidence | OFI: ${d.ofi} | Z: -${d.zScoreAbs}σ`,
+    `[${d.sym}] Regime: bearish | ${d.price} | Z: -${d.zScoreAbs}σ | VPIN: ${d.vpin}%`,
+    `[${d.sym}] ${d.price} | Negative skew | Z: -${d.zScoreAbs}σ | OFI: ${d.ofi}`,
+    `[${d.sym}] Alpha extraction: short | ${d.price} | Z/OFI negative`,
+    `[${d.sym}] ${d.price} | Model: SELL | Z: -${d.zScoreAbs}σ | VPIN: ${d.vpin}%`,
+    `[${d.sym}] Statistical momentum | ${d.price} | OFI: ${d.ofi} | Bearish`,
+  ]),
 
   neutral: (d) => pick([
     `[${d.sym}] ${d.price} | Z: 0σ | OFI: neutral | No statistical edge | HOLD`,
@@ -270,19 +261,20 @@ const QUANT = {
   ]),
 
   ready: (d) => {
-    const side = d.delta > 0 ? 'LONG' : 'SHORT';
-    const z = (Math.abs(d.delta) / 8).toFixed(2);
+    // Use real zScore for direction (rawZScore keeps the sign)
+    const side = d.rawZScore > 0 ? 'LONG' : 'SHORT';
+    const zSign = d.rawZScore > 0 ? '+' : '-';
     return pick([
-      `${chalk.green('■')} [${d.sym}] Z-SCORE BREACH | ${z}σ @ ${d.price} | EXECUTE ${side}`,
-      `${chalk.green('■')} [${d.sym}] FACTOR CONSENSUS | OFI: ${d.delta} | ${side} SIGNAL @ ${d.price}`,
-      `${chalk.green('■')} [${d.sym}] STATISTICAL TRIGGER | VPIN spike | Z: ${z}σ | ${side} ENTRY`,
-      `${chalk.green('■')} [${d.sym}] ALPHA DETECTED | ${d.price} | Multi-factor ${side} | EXECUTE`,
-      `${chalk.green('■')} [${d.sym}] REGIME CONFIRMED | Z: ${z}σ | ${side} @ ${d.price}`,
-      `${chalk.green('■')} [${d.sym}] MODEL SIGNAL | Factor alignment | ${side} TRIGGER | ${d.price}`,
-      `${chalk.green('■')} [${d.sym}] THRESHOLD BREACH | OFI: ${d.delta} | EXECUTE ${side} @ ${d.price}`,
-      `${chalk.green('■')} [${d.sym}] MEAN REVERSION | Z: ${z}σ | ${side} CONFIRMED | ${d.price}`,
-      `${chalk.green('■')} [${d.sym}] EDGE CONFIRMED | ${d.price} | ${side} | Expectancy: +`,
-      `${chalk.green('■')} [${d.sym}] FACTOR SIGNAL | Z: ${z}σ | OFI: ${d.delta} | ${side} ACTIVE`,
+      `${chalk.green('■')} [${d.sym}] Z-SCORE BREACH | ${zSign}${d.zScoreAbs}σ @ ${d.price} | EXECUTE ${side}`,
+      `${chalk.green('■')} [${d.sym}] FACTOR CONSENSUS | Z: ${zSign}${d.zScoreAbs}σ | OFI: ${d.ofi} | ${side} @ ${d.price}`,
+      `${chalk.green('■')} [${d.sym}] STATISTICAL TRIGGER | VPIN: ${d.vpin}% | Z: ${zSign}${d.zScoreAbs}σ | ${side}`,
+      `${chalk.green('■')} [${d.sym}] ALPHA DETECTED | ${d.price} | Z: ${zSign}${d.zScoreAbs}σ | EXECUTE ${side}`,
+      `${chalk.green('■')} [${d.sym}] REGIME CONFIRMED | Z: ${zSign}${d.zScoreAbs}σ | OFI: ${d.ofi} | ${side}`,
+      `${chalk.green('■')} [${d.sym}] MODEL SIGNAL | Z: ${zSign}${d.zScoreAbs}σ | VPIN: ${d.vpin}% | ${side} TRIGGER`,
+      `${chalk.green('■')} [${d.sym}] THRESHOLD BREACH | Z: ${zSign}${d.zScoreAbs}σ | OFI: ${d.ofi} | ${side} @ ${d.price}`,
+      `${chalk.green('■')} [${d.sym}] MEAN REVERSION | Z: ${zSign}${d.zScoreAbs}σ | ${side} CONFIRMED | ${d.price}`,
+      `${chalk.green('■')} [${d.sym}] EDGE CONFIRMED | ${d.price} | Z: ${zSign}${d.zScoreAbs}σ | OFI: ${d.ofi} | ${side}`,
+      `${chalk.green('■')} [${d.sym}] FACTOR SIGNAL | Z: ${zSign}${d.zScoreAbs}σ | VPIN: ${d.vpin}% | ${side} ACTIVE`,
     ]);
   },
 };
@@ -301,12 +293,6 @@ class SmartLogsEngine {
 
   setSymbol(s) { this.symbolCode = s; }
 
-  _phase(st) {
-    if (st.setupForming && st.zones > 0) return 'ready';
-    if (st.zones > 0 || st.swings >= 2) return 'zones';
-    return 'building';
-  }
-
   _unique(gen, d) {
     let msg, i = 0;
     do { msg = gen(d); i++; } while (this.recent.includes(msg) && i < 15);
@@ -318,18 +304,23 @@ class SmartLogsEngine {
   getLog(state = {}) {
     this.counter++;
     const { trend = 'neutral', position = 0, zones = 0, swings = 0, bars = 0,
-            price = 0, delta = 0, buyPct = 50, tickCount = 0 } = state;
+            price = 0, delta = 0, buyPct = 50, tickCount = 0,
+            zScore = 0, vpin = 0, ofi = 0, setupForming = false } = state;
 
-    const phase = this._phase(state);
-    const bull = trend === 'bullish' || buyPct > 55;
-    const bear = trend === 'bearish' || buyPct < 45;
-    const T = this.strategyId === 'hqx-2b' ? HQX2B : QUANT;
+    const isQuant = this.strategyId !== 'hqx-2b';
+    const T = isQuant ? QUANT : HQX2B;
 
     const d = {
       sym: getSym(this.symbolCode),
       price: price > 0 ? price.toFixed(2) : '-.--',
       delta, zones, swings, bars,
       ticks: tickCount > 1000 ? `${(tickCount/1000).toFixed(0)}k` : String(tickCount),
+      // Real QUANT metrics from strategy (keep sign for direction)
+      zScore: zScore.toFixed(2),
+      zScoreAbs: Math.abs(zScore).toFixed(2),
+      vpin: (vpin * 100).toFixed(0),
+      ofi: ofi > 0 ? `+${ofi.toFixed(0)}` : ofi.toFixed(0),
+      rawZScore: zScore,  // For direction calculation
     };
 
     if (position !== 0) {
@@ -342,14 +333,38 @@ class SmartLogsEngine {
       };
     }
 
-    // Priority: ready > building > bull/bear > zones > neutral
+    // Determine phase and message type based on strategy
     let gen, type;
-    if (phase === 'ready') { gen = T.ready; type = 'signal'; }
-    else if (phase === 'building') { gen = T.building; type = 'system'; }
-    else if (bull) { gen = T.bull; type = 'bullish'; }
-    else if (bear) { gen = T.bear; type = 'bearish'; }
-    else if (phase === 'zones') { gen = T.zones; type = 'analysis'; }
-    else { gen = T.neutral; type = 'analysis'; }
+    
+    if (isQuant) {
+      // QUANT: tick-based, uses zScore/vpin/ofi
+      const minTicks = 50;
+      const isBuilding = bars < minTicks;
+      const bull = trend === 'bullish' || zScore > 1.5 || buyPct > 58;
+      const bear = trend === 'bearish' || zScore < -1.5 || buyPct < 42;
+      const ready = Math.abs(zScore) > 2.0 && setupForming;
+      
+      if (ready) { gen = T.ready; type = 'signal'; }
+      else if (isBuilding) { gen = T.building; type = 'system'; }
+      else if (bull) { gen = T.bull; type = 'bullish'; }
+      else if (bear) { gen = T.bear; type = 'bearish'; }
+      else { gen = T.zones; type = 'analysis'; }  // zones = analysis for QUANT
+    } else {
+      // HQX-2B: bar-based, uses zones/swings
+      const minBars = 3;
+      const isBuilding = bars < minBars;
+      const hasZones = zones > 0 || swings >= 2;
+      const bull = trend === 'bullish' || buyPct > 55;
+      const bear = trend === 'bearish' || buyPct < 45;
+      const ready = setupForming && zones > 0;
+      
+      if (ready) { gen = T.ready; type = 'signal'; }
+      else if (isBuilding) { gen = T.building; type = 'system'; }
+      else if (bull) { gen = T.bull; type = 'bullish'; }
+      else if (bear) { gen = T.bear; type = 'bearish'; }
+      else if (hasZones) { gen = T.zones; type = 'analysis'; }
+      else { gen = T.neutral; type = 'analysis'; }
+    }
 
     return { 
       type, 

package/src/pages/algo/algo-executor.js

@@ -224,6 +224,7 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   let ticksPerSecond = 0, lastTickSecond = Math.floor(Date.now() / 1000);
   let lastBiasLogSecond = 0, lastStateLogSecond = 0;
   let buyVolume = 0, sellVolume = 0, lastTickTime = 0, tickLatencies = [];
+  let runningDelta = 0, runningBuyPct = 50; // For live logs
   
   marketFeed.on('tick', (tick) => {
     tickCount++;
@@ -271,6 +272,8 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
       const totalVol = buyVolume + sellVolume;
       const buyPressure = totalVol > 0 ? (buyVolume / totalVol) * 100 : 50;
       lastBias = buyPressure > 55 ? 'LONG' : buyPressure < 45 ? 'SHORT' : 'FLAT';
+      runningDelta = buyVolume - sellVolume;
+      runningBuyPct = buyPressure;
       sessionLogger.log('TICK', `count=${tickCount} last=${price?.toFixed(2)} bias=${lastBias} vol=${totalVol}`);
       buyVolume = 0; sellVolume = 0;
     }
@@ -294,9 +297,10 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
     lastAsk = ask;
     
     // Only process tick if we have a valid price
+    // IMPORTANT: Always use our contractId for consistency with getAnalysisState
     if (price && price > 0) {
       strategy.processTick({
-        contractId: tick.contractId || contractId,
+        contractId: contractId,
         price: price, bid: bid, ask: ask,
         volume: volume, 
         side: tick.side || tick.lastTradeSide || 'unknown',
@@ -437,7 +441,13 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
       setupForming: state?.ready && state?.activeZones > 0,
       position: currentPosition,
       price: lastPrice || 0,
+      delta: runningDelta,
+      buyPct: runningBuyPct,
       tickCount,
+      // QUANT strategy metrics (real from strategy)
+      zScore: state?.zScore || 0,
+      vpin: state?.vpin || 0,
+      ofi: state?.ofi || 0,
     };
     
     const log = logsEngine.getLog(logState);

package/src/pages/algo/multi-symbol-executor.js

@@ -56,7 +56,11 @@ const executeMultiSymbol = async ({ service, account, contracts, config, strateg
         losses: 0,
         tickCount: 0,
         lastPrice: null,
-        position: 0
+        position: 0,
+        buyVolume: 0,
+        sellVolume: 0,
+        runningDelta: 0,
+        runningBuyPct: 50
       },
       pendingOrder: false,
       startingPnL: null
@@ -219,6 +223,27 @@ const executeMultiSymbol = async ({ service, account, contracts, config, strateg
     
     data.stats.lastPrice = price;
     
+    // Track buy/sell volume for delta calculation
+    if (tick.side === 'buy' || tick.aggressor === 1) {
+      data.stats.buyVolume += volume;
+    } else if (tick.side === 'sell' || tick.aggressor === 2) {
+      data.stats.sellVolume += volume;
+    } else if (price && data.stats.lastPrice) {
+      if (price > data.stats.lastPrice) data.stats.buyVolume += volume;
+      else if (price < data.stats.lastPrice) data.stats.sellVolume += volume;
+    }
+    
+    // Update running delta/buyPct every 1000 ticks
+    if (data.stats.tickCount % 1000 === 0) {
+      const totalVol = data.stats.buyVolume + data.stats.sellVolume;
+      if (totalVol > 0) {
+        data.stats.runningDelta = data.stats.buyVolume - data.stats.sellVolume;
+        data.stats.runningBuyPct = (data.stats.buyVolume / totalVol) * 100;
+      }
+      data.stats.buyVolume = 0;
+      data.stats.sellVolume = 0;
+    }
+    
     // Process tick through strategy
     if (price && price > 0) {
       data.strategy.processTick({
@@ -363,16 +388,23 @@ const executeMultiSymbol = async ({ service, account, contracts, config, strateg
     if (!data) return;
     
     const state = data.strategy.getAnalysisState?.(symbolCode, data.stats.lastPrice);
+    const buyPct = data.stats.runningBuyPct || 50;
     const logState = {
       bars: state?.barsProcessed || 0,
       swings: state?.swingsDetected || 0,
       zones: state?.activeZones || 0,
-      trend: 'neutral',
+      trend: buyPct > 55 ? 'bullish' : buyPct < 45 ? 'bearish' : 'neutral',
       nearZone: (state?.nearestSupport || state?.nearestResistance) ? true : false,
       setupForming: state?.ready && state?.activeZones > 0,
       position: data.stats.position || 0,
       price: data.stats.lastPrice || 0,
+      delta: data.stats.runningDelta || 0,
+      buyPct: buyPct,
       tickCount: data.stats.tickCount || 0,
+      // QUANT metrics - REAL values from strategy
+      zScore: state?.zScore || 0,
+      vpin: state?.vpin || 0,
+      ofi: state?.ofi || 0,
     };
     
     // Only log if we have meaningful data