hedgequantx 2.6.145 → 2.6.146

package/package.json

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

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

@@ -32,7 +32,21 @@ const USE_HFT_STRATEGY = true;
 const aiService = require('../../services/ai');
 const StrategySupervisor = require('../../services/ai/strategy-supervisor');
 
-
+/**
+ * Format price to avoid floating point errors
+ * Uses the tick size to round properly
+ * @param {number} price - Raw price
+ * @param {number} tickSize - Tick size (default 0.25)
+ * @returns {string} - Formatted price string
+ */
+const formatPrice = (price, tickSize = 0.25) => {
+  if (price === null || price === undefined || isNaN(price)) return '--';
+  // Round to nearest tick, then format
+  const rounded = Math.round(price / tickSize) * tickSize;
+  // Determine decimal places from tick size
+  const decimals = tickSize < 1 ? Math.max(0, -Math.floor(Math.log10(tickSize))) : 0;
+  return rounded.toFixed(decimals);
+};
 
 /**
  * Check if service supports fast path (Rithmic direct)
@@ -456,8 +470,9 @@ const launchAlgo = async (service, account, contract, config) => {
       stats.entryLatencies.push(fillLatencyMs);
       stats.avgFillLatency = stats.entryLatencies.reduce((a, b) => a + b, 0) / stats.entryLatencies.length;
       const side = position.side === 0 ? 'LONG' : 'SHORT';
+      const priceStr = formatPrice(position.entryPrice, tickSize || 0.25);
       // Use 'filled' type for colored FILL icon
-      ui.addLog('filled', `${side} ${position.size}x ${symbolName} @ ${parseFloat(position.entryPrice.toFixed(6))} | ${fillLatencyMs}ms`);
+      ui.addLog('filled', `${side} ${position.size}x ${symbolName} @ ${priceStr} | ${fillLatencyMs}ms`);
     });
     
     positionManager.on('exitFilled', ({ orderTag, exitPrice, pnlTicks, holdDurationMs }) => {
@@ -493,10 +508,12 @@ const launchAlgo = async (service, account, contract, config) => {
         
         if (pnlDollars >= 0) {
           stats.wins++;
-          ui.addLog('win', `+$${pnlDollars.toFixed(2)} @ ${parseFloat(exitPrice.toFixed(6))} | ${holdSec}s`);
+          const priceStr = formatPrice(exitPrice, tickSize || 0.25);
+          ui.addLog('win', `+$${pnlDollars.toFixed(2)} @ ${priceStr} | ${holdSec}s`);
         } else {
           stats.losses++;
-          ui.addLog('loss', `-$${Math.abs(pnlDollars).toFixed(2)} @ ${parseFloat(exitPrice.toFixed(6))} | ${holdSec}s`);
+          const priceStr = formatPrice(exitPrice, tickSize || 0.25);
+          ui.addLog('loss', `-$${Math.abs(pnlDollars).toFixed(2)} @ ${priceStr} | ${holdSec}s`);
         }
       } else {
         // Log with ticks only if tickValue unavailable
@@ -521,7 +538,8 @@ const launchAlgo = async (service, account, contract, config) => {
     
     positionManager.on('breakevenActivated', ({ orderTag, position, breakevenPrice, pnlTicks }) => {
       // Use 'be' type for yellow BE icon
-      ui.addLog('be', `Breakeven @ ${parseFloat(breakevenPrice.toFixed(6))} | +${pnlTicks} ticks`)
+      const priceStr = formatPrice(breakevenPrice, tickSize || 0.25);
+      ui.addLog('be', `Breakeven @ ${priceStr} | +${pnlTicks} ticks`)
     });
     
     positionManager.on('exitOrderFired', ({ orderTag, exitReason, latencyMs }) => {
@@ -1557,7 +1575,8 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
       stats.entryLatencies.push(fillLatencyMs);
       stats.avgFillLatency = stats.entryLatencies.reduce((a, b) => a + b, 0) / stats.entryLatencies.length;
       const side = position.side === 0 ? 'LONG' : 'SHORT';
-      ui.addLog('filled', `[${symbolName}] ${side} ${position.size}x @ ${parseFloat(position.entryPrice.toFixed(6))} | ${fillLatencyMs}ms`);
+      const priceStr = formatPrice(position.entryPrice, tickSize || 0.25);
+      ui.addLog('filled', `[${symbolName}] ${side} ${position.size}x @ ${priceStr} | ${fillLatencyMs}ms`);
       stats.symbolStats[symbolName].position = position.side === 0 ? position.size : -position.size;
       ui.render(stats);
     });
@@ -1597,11 +1616,13 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
         if (pnlDollars >= 0) {
           stats.wins++;
           stats.symbolStats[symbolName].wins++;
-          ui.addLog('win', `[${symbolName}] +$${pnlDollars.toFixed(2)} @ ${parseFloat(exitPrice.toFixed(6))} | ${holdSec}s`);
+          const priceStr = formatPrice(exitPrice, tickSize || 0.25);
+          ui.addLog('win', `[${symbolName}] +$${pnlDollars.toFixed(2)} @ ${priceStr} | ${holdSec}s`);
         } else {
           stats.losses++;
           stats.symbolStats[symbolName].losses++;
-          ui.addLog('loss', `[${symbolName}] -$${Math.abs(pnlDollars).toFixed(2)} @ ${parseFloat(exitPrice.toFixed(6))} | ${holdSec}s`);
+          const priceStr = formatPrice(exitPrice, tickSize || 0.25);
+          ui.addLog('loss', `[${symbolName}] -$${Math.abs(pnlDollars).toFixed(2)} @ ${priceStr} | ${holdSec}s`);
           // Symbol can trade again - no disable, continue until Target/Risk reached
         }
       } else if (pnlTicks !== null) {
@@ -1632,7 +1653,8 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
     });
     
     pm.on('breakevenActivated', ({ breakevenPrice, pnlTicks }) => {
-      ui.addLog('be', `[${symbolName}] BE @ ${parseFloat(breakevenPrice.toFixed(6))} | +${pnlTicks} ticks`);
+      const priceStr = formatPrice(breakevenPrice, tickSize || 0.25);
+      ui.addLog('be', `[${symbolName}] BE @ ${priceStr} | +${pnlTicks} ticks`);
     });
     
     // ═══════════════════════════════════════════════════════════════════════
@@ -2080,9 +2102,22 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
     await Promise.race([disconnectPromise, timeoutPromise]);
   } catch {}
   
-  // Cleanup keyboard
+  // Cleanup keyboard FIRST - restore stdin to normal mode
   try { if (cleanupKeys) cleanupKeys(); } catch {}
   
+  // Force stdin back to normal mode (critical for waitForEnter to work)
+  try {
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+    // Remove all listeners to prevent interference
+    process.stdin.removeAllListeners('keypress');
+    process.stdin.resume();
+  } catch {}
+  
+  // Small delay to let stdin settle
+  await new Promise(r => setTimeout(r, 100));
+  
   // Calculate duration before closeLog
   const durationMs = Date.now() - stats.startTime;
   const hours = Math.floor(durationMs / 3600000);
@@ -2099,17 +2134,13 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
   
   try { ui.cleanup(); } catch {}
   
-  try {
-    if (process.stdin.isTTY) process.stdin.setRawMode(false);
-    process.stdin.resume();
-  } catch {}
-  
   // ═══════════════════════════════════════════════════════════════════════════
   // SESSION SUMMARY (duration already calculated above)
   // ═══════════════════════════════════════════════════════════════════════════
   // Render multi-symbol summary with same style as single-symbol
   renderMultiSymbolSummary(stats, stopReason, stats.symbolStats);
   
+  // Wait for user to press Enter before returning to menu
   await prompts.waitForEnter();
 };
 

package/src/pages/algo/smart-logs.js

@@ -1,401 +1,592 @@
 /**
  * =============================================================================
- * Smart Logging System - Non-repetitive, contextual, varied messages
+ * HQX INSTITUTIONAL SMART LOGGING SYSTEM
  * =============================================================================
- * Copied from HQX-TG smart-logs.ts
- * - Uses message pools to avoid repetition
- * - Tracks recent messages to ensure variety
- * - Provides market-context-aware messages
+ * HedgeFund-grade execution logs with full market microstructure context
+ * 
+ * SHOWS:
+ * - Order Flow Imbalance (OFI) with directional bias
+ * - Cumulative Delta & Volume Profile
+ * - Z-Score deviation from fair value
+ * - Momentum vectors & acceleration
+ * - Liquidity depth & spread dynamics
+ * - Position Greeks: Ticks to SL/TP, R-multiple, hold time
+ * - Flow alignment score (position vs market flow)
+ * - Tick-by-tick execution latency
  */
 
 'use strict';
 
-// Track recently used messages to avoid repetition
+// =============================================================================
+// STATE TRACKING
+// =============================================================================
+
 const recentMessages = new Map();
 const MAX_RECENT = 5;
 
-/**
- * Get a message from a pool, avoiding recent ones
- */
+// Market microstructure state
+const microstructure = {
+  ofi: 0,                    // Order Flow Imbalance (-1 to +1)
+  cumDelta: 0,               // Cumulative Delta
+  delta: 0,                  // Current bar delta
+  zscore: 0,                 // Z-Score from VWAP/mean
+  momentum: 0,               // Price momentum
+  acceleration: 0,           // Momentum change rate
+  spread: 0,                 // Bid-ask spread in ticks
+  bidDepth: 0,               // Bid side liquidity
+  askDepth: 0,               // Ask side liquidity
+  imbalance: 0,              // Book imbalance ratio
+  vwap: 0,                   // Volume Weighted Avg Price
+  poc: 0,                    // Point of Control
+  atr: 0,                    // Average True Range
+  tps: 0,                    // Ticks per second
+  buyVol: 0,                 // Buy volume
+  sellVol: 0,                // Sell volume
+  lastUpdate: Date.now(),
+};
+
+// Position state for Greeks calculation
+const position = {
+  side: null,                // 'LONG' | 'SHORT'
+  symbol: '',
+  size: 0,
+  entryPrice: 0,
+  currentPrice: 0,
+  stopLoss: 0,
+  takeProfit: 0,
+  entryTime: 0,
+  unrealizedPnl: 0,
+  tickSize: 0.25,
+  tickValue: 12.50,
+};
+
+// =============================================================================
+// HELPER FUNCTIONS
+// =============================================================================
+
 function getVariedMessage(category, pool, defaultMsg) {
   const recent = recentMessages.get(category) || [];
-
-  // Filter out recently used messages
   const available = pool.filter(msg => !recent.includes(msg));
-
-  // If all messages were recently used, reset
   if (available.length === 0) {
     recentMessages.set(category, []);
     return pool[Math.floor(Math.random() * pool.length)] || defaultMsg;
   }
-
-  // Pick a random available message
   const chosen = available[Math.floor(Math.random() * available.length)] || defaultMsg;
-
-  // Track it
   recent.push(chosen);
   if (recent.length > MAX_RECENT) recent.shift();
   recentMessages.set(category, recent);
-
   return chosen;
 }
 
-// =============================================================================
-// MESSAGE POOLS - Market Flow
-// =============================================================================
-
-const LONG_BIAS_MESSAGES = [
-  'Bullish bias detected',
-  'Buyers in control',
-  'Long-side pressure',
-  'Bid accumulation',
-  'Buy programs active',
-];
-
-const SHORT_BIAS_MESSAGES = [
-  'Bearish bias detected',
-  'Sellers in control',
-  'Short-side pressure',
-  'Offer distribution',
-  'Sell programs active',
-];
+function formatNumber(n, decimals = 2) {
+  if (n === undefined || n === null || isNaN(n)) return '--';
+  const num = parseFloat(n);
+  const sign = num >= 0 ? '+' : '';
+  return sign + num.toFixed(decimals);
+}
 
-const FLAT_BIAS_MESSAGES = [
-  'Market balanced',
-  'Two-way flow',
-  'Consolidation mode',
-  'No clear direction',
-  'Mixed signals',
-];
+function formatPnl(pnl) {
+  if (pnl === undefined || pnl === null) return '--';
+  return pnl >= 0 ? `+$${pnl.toFixed(2)}` : `-$${Math.abs(pnl).toFixed(2)}`;
+}
 
 // =============================================================================
-// MESSAGE POOLS - Trading Events
+// INSTITUTIONAL MESSAGE POOLS
 // =============================================================================
 
-const SIGNAL_LONG_MESSAGES = [
-  'Buy signal generated',
-  'Long opportunity detected',
-  'Bullish setup confirmed',
-  'Entry signal: LONG',
-  'Buy zone activated',
+// Flow Analysis - HF Grade
+const FLOW_AGGRESSIVE_BUY = [
+  'Aggressive lifting offers',
+  'Heavy buy-side absorption',
+  'Institutional accumulation',
+  'Delta surge positive',
+  'Bid stacking detected',
+  'Buy programs sweeping',
 ];
 
-const SIGNAL_SHORT_MESSAGES = [
-  'Sell signal generated',
-  'Short opportunity detected',
-  'Bearish setup confirmed',
-  'Entry signal: SHORT',
-  'Sell zone activated',
+const FLOW_AGGRESSIVE_SELL = [
+  'Aggressive hitting bids',
+  'Heavy sell-side distribution',
+  'Institutional liquidation',
+  'Delta surge negative',
+  'Offer stacking detected',
+  'Sell programs sweeping',
 ];
 
-const ENTRY_LONG_MESSAGES = [
-  'Long position opened',
-  'Buy order filled',
-  'Entered long',
-  'Long initiated',
-  'Position: LONG',
+const FLOW_BALANCED = [
+  'Two-sided flow equilibrium',
+  'Balanced book rotation',
+  'Fair value discovery',
+  'Neutral order flow',
+  'Market making zone',
 ];
 
-const ENTRY_SHORT_MESSAGES = [
-  'Short position opened',
-  'Sell order filled',
-  'Entered short',
-  'Short initiated',
-  'Position: SHORT',
+// Mean Reversion - HF Grade
+const MR_OVERBOUGHT = [
+  'Extended above VWAP band',
+  'Z-score overbought extreme',
+  'Mean reversion fade setup',
+  'Exhaustion at upper band',
+  'Stretched deviation short',
 ];
 
-const EXIT_PROFIT_MESSAGES = [
-  'Target reached',
-  'Profit taken',
-  'Winner closed',
-  'TP hit',
-  'Profit locked',
+const MR_OVERSOLD = [
+  'Extended below VWAP band',
+  'Z-score oversold extreme',
+  'Mean reversion bounce setup',
+  'Capitulation at lower band',
+  'Stretched deviation long',
 ];
 
-const EXIT_LOSS_MESSAGES = [
-  'Stop triggered',
-  'Loss taken',
-  'Loser closed',
-  'SL hit',
-  'Risk contained',
+// Momentum - HF Grade
+const MOM_ACCELERATING_UP = [
+  'Momentum acceleration +',
+  'Velocity vector bullish',
+  'Trend thrust positive',
+  'Breakout momentum confirmed',
+  'Impulse wave up',
 ];
 
-// =============================================================================
-// MESSAGE POOLS - Analysis
-// =============================================================================
-
-const MOMENTUM_UP_MESSAGES = [
-  'Momentum building up',
-  'Price accelerating',
-  'Bullish momentum',
-  'Upward thrust',
-  'Buying momentum',
+const MOM_ACCELERATING_DOWN = [
+  'Momentum acceleration -',
+  'Velocity vector bearish',
+  'Trend thrust negative',
+  'Breakdown momentum confirmed',
+  'Impulse wave down',
 ];
 
-const MOMENTUM_DOWN_MESSAGES = [
-  'Momentum building down',
-  'Price declining',
-  'Bearish momentum',
-  'Downward thrust',
-  'Selling momentum',
+// Volatility - HF Grade
+const VOL_EXPANSION = [
+  'Volatility expansion cycle',
+  'ATR breakout detected',
+  'Range expansion phase',
+  'Vol regime shift high',
+  'Gamma event potential',
 ];
 
-const OVERBOUGHT_MESSAGES = [
-  'Overbought condition',
-  'Extended to upside',
-  'Mean reversion setup (short)',
-  'Exhaustion detected',
-  'Stretched high',
+const VOL_COMPRESSION = [
+  'Volatility compression cycle',
+  'ATR contraction detected',
+  'Range compression phase',
+  'Vol regime shift low',
+  'Coiling for breakout',
 ];
 
-const OVERSOLD_MESSAGES = [
-  'Oversold condition',
-  'Extended to downside',
-  'Mean reversion setup (long)',
-  'Capitulation detected',
-  'Stretched low',
+// Position Status - HF Grade
+const POS_PROFIT_RUNNING = [
+  'P&L positive running',
+  'Trade thesis confirmed',
+  'Alpha capture in progress',
+  'Edge realization phase',
+  'Position working target',
 ];
 
-const HIGH_VOLATILITY_MESSAGES = [
-  'Volatility elevated',
-  'High ATR detected',
-  'Wide swings',
-  'Market volatile',
-  'Increased range',
+const POS_LOSS_MANAGING = [
+  'Adverse excursion mgmt',
+  'Drawdown within params',
+  'Risk budget consuming',
+  'Position under pressure',
+  'Defending stop level',
 ];
 
-const LOW_VOLATILITY_MESSAGES = [
-  'Low volatility',
-  'Tight range',
-  'Compressed action',
-  'Market quiet',
-  'Narrow swings',
+const POS_NEAR_TARGET = [
+  'Approaching profit target',
+  'Near TP execution zone',
+  'Exit liquidity scanning',
+  'Target strike imminent',
+  'Profit capture pending',
 ];
 
-// =============================================================================
-// MESSAGE POOLS - Status
-// =============================================================================
-
-const SCANNING_MESSAGES = [
-  'Scanning market...',
-  'Analyzing flow...',
-  'Monitoring price action...',
-  'Watching for setups...',
-  'Evaluating conditions...',
+const POS_NEAR_STOP = [
+  'Near stop execution zone',
+  'SL liquidity scanning',
+  'Risk threshold proximity',
+  'Stop strike imminent',
+  'Loss containment pending',
 ];
 
-const WAITING_MESSAGES = [
-  'Waiting for confirmation...',
-  'Pending trigger...',
-  'Standby mode...',
-  'Awaiting signal...',
-  'Ready to act...',
-];
-
-const IN_POSITION_PROFIT_MESSAGES = [
-  'Running profit',
-  'In the money',
-  'Trade working',
-  'Position profitable',
-  'Gains accumulating',
-];
-
-const IN_POSITION_LOSS_MESSAGES = [
-  'Managing drawdown',
-  'Underwater',
-  'Holding through',
-  'Defending position',
-  'Monitoring risk',
+// Scanning - HF Grade
+const SCANNING_ACTIVE = [
+  'Scanning microstructure',
+  'Analyzing order book',
+  'Evaluating flow signals',
+  'Pattern recognition active',
+  'Setup detection running',
 ];
 
 // =============================================================================
-// SMART LOG GENERATORS
+// MAIN LOG GENERATORS - HF GRADE
 // =============================================================================
 
 /**
- * Get a market bias log
+ * Update microstructure state from strategy model values
  */
-function getMarketBiasLog(direction, delta, ofi) {
-  let pool;
-  switch (direction) {
-    case 'LONG':
-      pool = LONG_BIAS_MESSAGES;
-      break;
-    case 'SHORT':
-      pool = SHORT_BIAS_MESSAGES;
-      break;
-    default:
-      pool = FLAT_BIAS_MESSAGES;
-  }
-
-  const message = getVariedMessage(`bias_${direction}`, pool, `${direction} bias`);
-  const arrow = direction === 'LONG' ? '▲' : direction === 'SHORT' ? '▼' : '=';
-
-  let details;
-  if (delta !== undefined && ofi !== undefined) {
-    const deltaStr = delta >= 0 ? `+${delta}` : `${delta}`;
-    details = `${arrow} Δ=${deltaStr} | OFI=${ofi.toFixed(2)}`;
+function updateMicrostructure(data) {
+  if (data.ofi !== undefined) microstructure.ofi = data.ofi;
+  if (data.delta !== undefined) microstructure.delta = data.delta;
+  if (data.cumDelta !== undefined) microstructure.cumDelta = data.cumDelta;
+  if (data.zscore !== undefined) microstructure.zscore = data.zscore;
+  if (data.momentum !== undefined) {
+    microstructure.acceleration = data.momentum - microstructure.momentum;
+    microstructure.momentum = data.momentum;
   }
-
-  return { message, details };
+  if (data.spread !== undefined) microstructure.spread = data.spread;
+  if (data.atr !== undefined) microstructure.atr = data.atr;
+  if (data.tps !== undefined) microstructure.tps = data.tps;
+  if (data.buyVol !== undefined) microstructure.buyVol = data.buyVol;
+  if (data.sellVol !== undefined) microstructure.sellVol = data.sellVol;
+  if (data.vwap !== undefined) microstructure.vwap = data.vwap;
+  microstructure.lastUpdate = Date.now();
 }
 
 /**
- * Get a momentum log
+ * Update position state
  */
-function getMomentumLog(momentum, zscore) {
-  // Handle undefined/NaN values
-  const mom = typeof momentum === 'number' && !isNaN(momentum) ? momentum : 0;
-  const z = typeof zscore === 'number' && !isNaN(zscore) ? zscore : 0;
-  
-  const isUp = mom > 0;
-  const pool = isUp ? MOMENTUM_UP_MESSAGES : MOMENTUM_DOWN_MESSAGES;
-  const category = isUp ? 'mom_up' : 'mom_down';
-  const message = getVariedMessage(category, pool, isUp ? 'Momentum up' : 'Momentum down');
-  const arrow = isUp ? '▲' : '▼';
-
-  return {
-    message: `${arrow} ${message}`,
-    details: `Mom=${mom.toFixed(1)} | Z=${z.toFixed(2)}`,
-  };
+function updatePosition(data) {
+  if (data.side !== undefined) position.side = data.side;
+  if (data.symbol !== undefined) position.symbol = data.symbol;
+  if (data.size !== undefined) position.size = data.size;
+  if (data.entryPrice !== undefined) position.entryPrice = data.entryPrice;
+  if (data.currentPrice !== undefined) position.currentPrice = data.currentPrice;
+  if (data.stopLoss !== undefined) position.stopLoss = data.stopLoss;
+  if (data.takeProfit !== undefined) position.takeProfit = data.takeProfit;
+  if (data.entryTime !== undefined) position.entryTime = data.entryTime;
+  if (data.unrealizedPnl !== undefined) position.unrealizedPnl = data.unrealizedPnl;
+  if (data.tickSize !== undefined) position.tickSize = data.tickSize;
+  if (data.tickValue !== undefined) position.tickValue = data.tickValue;
 }
 
 /**
- * Get a mean reversion log
+ * Clear position state when flat
  */
-function getMeanReversionLog(zscore) {
-  // Handle undefined/NaN values
-  const z = typeof zscore === 'number' && !isNaN(zscore) ? zscore : 0;
-  
-  const isOverbought = z > 0;
-  const pool = isOverbought ? OVERBOUGHT_MESSAGES : OVERSOLD_MESSAGES;
-  const category = isOverbought ? 'mr_overbought' : 'mr_oversold';
-  const message = getVariedMessage(category, pool, isOverbought ? 'Overbought' : 'Oversold');
-  const arrow = isOverbought ? '▼' : '▲'; // Opposite - looking for reversal
-
-  return {
-    message: `${arrow} ${message}`,
-    details: `Z-Score: ${z.toFixed(2)} | Looking for ${isOverbought ? 'SHORT' : 'LONG'}`,
-  };
+function clearPosition() {
+  position.side = null;
+  position.symbol = '';
+  position.size = 0;
+  position.entryPrice = 0;
+  position.currentPrice = 0;
+  position.stopLoss = 0;
+  position.takeProfit = 0;
+  position.entryTime = 0;
+  position.unrealizedPnl = 0;
 }
 
 /**
- * Get a signal log
+ * GET MARKET FLOW LOG - When NOT in position
+ * Shows: OFI | Delta | Z-Score | Momentum | Volume Ratio
  */
-function getSignalLog(direction, symbol, confidence, strategy) {
-  const pool = direction === 'LONG' ? SIGNAL_LONG_MESSAGES : SIGNAL_SHORT_MESSAGES;
-  const message = getVariedMessage(`signal_${direction}`, pool, `${direction} signal`);
-  const arrow = direction === 'LONG' ? '▲' : '▼';
-
-  return {
-    message: `${arrow} ${message}`,
-    details: `${symbol} | ${confidence.toFixed(0)}% | ${strategy}`,
-  };
+function getMarketFlowLog() {
+  const { ofi, delta, zscore, momentum, buyVol, sellVol, tps, atr } = microstructure;
+  
+  const absOfi = Math.abs(ofi || 0);
+  const absZ = Math.abs(zscore || 0);
+  const absMom = Math.abs(momentum || 0);
+  
+  // Determine primary signal
+  let pool, category, signal;
+  
+  // Priority: Mean Reversion > OFI > Momentum
+  if (absZ > 2.0) {
+    pool = zscore > 0 ? MR_OVERBOUGHT : MR_OVERSOLD;
+    category = zscore > 0 ? 'mr_short' : 'mr_long';
+    signal = 'MEAN_REV';
+  } else if (absOfi > 0.4) {
+    pool = ofi > 0 ? FLOW_AGGRESSIVE_BUY : FLOW_AGGRESSIVE_SELL;
+    category = ofi > 0 ? 'flow_buy' : 'flow_sell';
+    signal = ofi > 0 ? 'BUY_FLOW' : 'SELL_FLOW';
+  } else if (absMom > 3) {
+    pool = momentum > 0 ? MOM_ACCELERATING_UP : MOM_ACCELERATING_DOWN;
+    category = momentum > 0 ? 'mom_up' : 'mom_down';
+    signal = momentum > 0 ? 'MOM_UP' : 'MOM_DOWN';
+  } else {
+    pool = SCANNING_ACTIVE;
+    category = 'scanning';
+    signal = 'SCANNING';
+  }
+  
+  const message = getVariedMessage(category, pool, 'Analyzing...');
+  
+  // Build HF-grade metrics string
+  const ofiStr = `OFI:${formatNumber(ofi, 2)}`;
+  const deltaStr = `Δ:${formatNumber(delta, 0)}`;
+  const zStr = `Z:${formatNumber(zscore, 2)}`;
+  const momStr = `Mom:${formatNumber(momentum, 1)}`;
+  
+  // Volume ratio
+  const totalVol = (buyVol || 0) + (sellVol || 0);
+  const buyPct = totalVol > 0 ? Math.round((buyVol / totalVol) * 100) : 50;
+  const volStr = `B/S:${buyPct}/${100 - buyPct}`;
+  
+  const details = `${ofiStr} | ${deltaStr} | ${zStr} | ${momStr} | ${volStr}`;
+  
+  return { message, details, signal };
 }
 
 /**
- * Get an entry log
+ * GET POSITION CONTEXT LOG - When IN position
+ * Shows: Side | P&L | Ticks to SL/TP | Hold Time | R-Multiple | Flow Alignment
  */
-function getEntryLog(direction, symbol, size, price) {
-  const pool = direction === 'LONG' ? ENTRY_LONG_MESSAGES : ENTRY_SHORT_MESSAGES;
-  const message = getVariedMessage(`entry_${direction}`, pool, `${direction} entry`);
-  const arrow = direction === 'LONG' ? '▲' : '▼';
-
-  return {
-    message: `${arrow} ${message}`,
-    details: `${size}x ${symbol} @ ${price.toFixed(2)}`,
-  };
+function getPositionContextLog() {
+  const { side, size, entryPrice, currentPrice, stopLoss, takeProfit, entryTime, unrealizedPnl, tickSize, tickValue } = position;
+  const { ofi, momentum, delta } = microstructure;
+  
+  if (!side) return getMarketFlowLog();
+  
+  // Calculate position Greeks
+  const holdMs = Date.now() - (entryTime || Date.now());
+  const holdSec = Math.floor(holdMs / 1000);
+  const holdStr = holdSec >= 60 ? `${Math.floor(holdSec / 60)}m${holdSec % 60}s` : `${holdSec}s`;
+  
+  // Ticks from entry
+  const ticksFromEntry = tickSize > 0 
+    ? Math.round((currentPrice - entryPrice) / tickSize) * (side === 'LONG' ? 1 : -1)
+    : 0;
+  
+  // Distance to SL/TP in ticks
+  let ticksToSL = 0, ticksToTP = 0, riskTicks = 0, rewardTicks = 0;
+  if (side === 'LONG' && stopLoss && takeProfit && tickSize > 0) {
+    ticksToSL = Math.round((currentPrice - stopLoss) / tickSize);
+    ticksToTP = Math.round((takeProfit - currentPrice) / tickSize);
+    riskTicks = Math.round((entryPrice - stopLoss) / tickSize);
+    rewardTicks = Math.round((takeProfit - entryPrice) / tickSize);
+  } else if (side === 'SHORT' && stopLoss && takeProfit && tickSize > 0) {
+    ticksToSL = Math.round((stopLoss - currentPrice) / tickSize);
+    ticksToTP = Math.round((currentPrice - takeProfit) / tickSize);
+    riskTicks = Math.round((stopLoss - entryPrice) / tickSize);
+    rewardTicks = Math.round((entryPrice - takeProfit) / tickSize);
+  }
+  
+  // R-Multiple (how many R's of profit/loss)
+  const rMultiple = riskTicks > 0 ? (ticksFromEntry / riskTicks) : 0;
+  
+  // Flow alignment score (-1 to +1)
+  let flowScore = 0;
+  if (side === 'LONG') {
+    flowScore = ((ofi || 0) + (momentum > 0 ? 0.3 : momentum < 0 ? -0.3 : 0) + (delta > 0 ? 0.2 : delta < 0 ? -0.2 : 0));
+  } else {
+    flowScore = (-(ofi || 0) + (momentum < 0 ? 0.3 : momentum > 0 ? -0.3 : 0) + (delta < 0 ? 0.2 : delta > 0 ? -0.2 : 0));
+  }
+  flowScore = Math.max(-1, Math.min(1, flowScore));
+  
+  // Determine status message
+  let pool, category;
+  const pnl = unrealizedPnl || 0;
+  
+  if (ticksToTP > 0 && ticksToTP <= 4) {
+    pool = POS_NEAR_TARGET;
+    category = 'near_tp';
+  } else if (ticksToSL > 0 && ticksToSL <= 4) {
+    pool = POS_NEAR_STOP;
+    category = 'near_sl';
+  } else if (pnl > 0) {
+    pool = POS_PROFIT_RUNNING;
+    category = 'pos_profit';
+  } else {
+    pool = POS_LOSS_MANAGING;
+    category = 'pos_loss';
+  }
+  
+  const statusMsg = getVariedMessage(category, pool, pnl >= 0 ? 'Running profit' : 'Managing risk');
+  
+  // Build message
+  const arrow = side === 'LONG' ? '▲' : '▼';
+  const message = `${arrow} ${side} ${size}x | ${statusMsg}`;
+  
+  // Build HF-grade details
+  const pnlStr = formatPnl(pnl);
+  const ticksStr = ticksFromEntry >= 0 ? `+${ticksFromEntry}t` : `${ticksFromEntry}t`;
+  const slStr = ticksToSL > 0 ? `SL:${ticksToSL}t` : 'SL:--';
+  const tpStr = ticksToTP > 0 ? `TP:${ticksToTP}t` : 'TP:--';
+  const rStr = `R:${rMultiple >= 0 ? '+' : ''}${rMultiple.toFixed(2)}`;
+  const flowStr = `Flow:${flowScore >= 0 ? '+' : ''}${flowScore.toFixed(2)}`;
+  
+  const details = `${pnlStr} (${ticksStr}) | ${slStr} ${tpStr} | ${rStr} | ${flowStr} | ${holdStr}`;
+  
+  return { message, details };
 }
 
 /**
- * Get an exit log
+ * GET VOLATILITY LOG
+ * Shows: ATR | Volatility Regime | Range Context
  */
-function getExitLog(isProfit, symbol, size, price, pnl) {
-  const pool = isProfit ? EXIT_PROFIT_MESSAGES : EXIT_LOSS_MESSAGES;
-  const category = isProfit ? 'exit_profit' : 'exit_loss';
-  const message = getVariedMessage(category, pool, isProfit ? 'Profit taken' : 'Loss taken');
-  const pnlStr = pnl >= 0 ? `+$${pnl.toFixed(2)}` : `-$${Math.abs(pnl).toFixed(2)}`;
-
-  return {
-    message,
-    details: `${size}x ${symbol} @ ${price.toFixed(2)} | ${pnlStr}`,
-  };
+function getVolatilityLog() {
+  const { atr, tps } = microstructure;
+  
+  const isHigh = tps > 40 || atr > 2.0;
+  const isLow = tps < 10 || atr < 0.5;
+  
+  let pool, category;
+  if (isHigh) {
+    pool = VOL_EXPANSION;
+    category = 'vol_high';
+  } else if (isLow) {
+    pool = VOL_COMPRESSION;
+    category = 'vol_low';
+  } else {
+    return { message: 'Normal volatility regime', details: `ATR:${atr?.toFixed(2) || '--'} | ${tps || '--'} tps` };
+  }
+  
+  const message = getVariedMessage(category, pool, isHigh ? 'Vol expansion' : 'Vol compression');
+  const details = `ATR:${atr?.toFixed(2) || '--'} | ${tps || '--'} ticks/sec`;
+  
+  return { message, details };
 }
 
 /**
- * Get a volatility log
+ * GET FLOW ANALYSIS LOG - Detailed order flow breakdown
+ * Shows: OFI | Delta | Cumulative Delta | Volume Breakdown
  */
-function getVolatilityLog(isHigh, atr) {
-  const pool = isHigh ? HIGH_VOLATILITY_MESSAGES : LOW_VOLATILITY_MESSAGES;
-  const category = isHigh ? 'vol_high' : 'vol_low';
-  const message = getVariedMessage(category, pool, isHigh ? 'High volatility' : 'Low volatility');
-
-  return {
-    message,
-    details: atr ? `ATR: ${atr.toFixed(2)}` : undefined,
-  };
+function getFlowAnalysisLog() {
+  const { ofi, delta, cumDelta, buyVol, sellVol } = microstructure;
+  
+  const absOfi = Math.abs(ofi || 0);
+  let pool, category;
+  
+  if (absOfi > 0.5) {
+    pool = ofi > 0 ? FLOW_AGGRESSIVE_BUY : FLOW_AGGRESSIVE_SELL;
+    category = ofi > 0 ? 'flow_agg_buy' : 'flow_agg_sell';
+  } else if (absOfi > 0.2) {
+    pool = ofi > 0 ? FLOW_AGGRESSIVE_BUY : FLOW_AGGRESSIVE_SELL;
+    category = ofi > 0 ? 'flow_mod_buy' : 'flow_mod_sell';
+  } else {
+    pool = FLOW_BALANCED;
+    category = 'flow_balanced';
+  }
+  
+  const message = getVariedMessage(category, pool, 'Analyzing flow');
+  
+  // Volume breakdown
+  const totalVol = (buyVol || 0) + (sellVol || 0);
+  const buyPct = totalVol > 0 ? Math.round((buyVol / totalVol) * 100) : 50;
+  
+  const ofiStr = `OFI:${formatNumber(ofi, 2)}`;
+  const deltaStr = `Δ:${formatNumber(delta, 0)}`;
+  const cumStr = `ΣΔ:${formatNumber(cumDelta, 0)}`;
+  const volStr = `Vol B/S:${buyPct}/${100 - buyPct}%`;
+  
+  const details = `${ofiStr} | ${deltaStr} | ${cumStr} | ${volStr}`;
+  
+  return { message, details };
 }
 
 /**
- * Get a scanning/waiting log
+ * GET SCANNING LOG
  */
-function getScanningLog(isScanning) {
-  const pool = isScanning ? SCANNING_MESSAGES : WAITING_MESSAGES;
-  const category = isScanning ? 'scanning' : 'waiting';
-  const message = getVariedMessage(category, pool, isScanning ? 'Scanning...' : 'Waiting...');
-
+function getScanningLog(isScanning = true) {
+  const pool = SCANNING_ACTIVE;
+  const message = getVariedMessage('scanning', pool, 'Scanning...');
   return { message, details: undefined };
 }
 
 /**
- * Get position update log with varied messaging
+ * MAIN ENTRY POINT: getSmartLog
+ * Automatically determines context and returns appropriate HF-grade log
  */
-function getPositionUpdateLog(side, size, unrealizedPnL, entryPrice, currentPrice, holdTime) {
-  const arrow = side === 'LONG' ? '▲' : '▼';
-  const pnlStr = unrealizedPnL >= 0 ? `+$${unrealizedPnL.toFixed(2)}` : `-$${Math.abs(unrealizedPnL).toFixed(2)}`;
-  const isProfit = unrealizedPnL >= 0;
+function getSmartLog(data = {}) {
+  // Update states if data provided
+  if (data.ofi !== undefined || data.delta !== undefined || data.zscore !== undefined) {
+    updateMicrostructure(data);
+  }
+  if (data.side !== undefined || data.entryPrice !== undefined) {
+    updatePosition(data);
+  }
   
-  const pool = isProfit ? IN_POSITION_PROFIT_MESSAGES : IN_POSITION_LOSS_MESSAGES;
-  const category = isProfit ? 'pos_profit' : 'pos_loss';
-  const prefix = getVariedMessage(category, pool, isProfit ? 'In profit' : 'Managing');
-
-  return {
-    message: `${arrow} ${side} ${size}x`,
-    details: `${prefix} ${pnlStr} @ ${currentPrice.toFixed(2)} | ${holdTime}s`,
-  };
+  // Return appropriate log based on position state
+  if (data.inPosition || position.side) {
+    return getPositionContextLog();
+  } else {
+    return getMarketFlowLog();
+  }
 }
 
 /**
- * Get market state log based on model values
+ * GET MARKET STATE LOG - Legacy compatibility
+ * Wrapper around getMarketFlowLog
  */
 function getMarketStateLog(ofi, zscore, momentum, delta) {
-  // Determine primary market state
-  const absZ = Math.abs(zscore);
-  const absOfi = Math.abs(ofi);
-  const absMom = Math.abs(momentum);
-  
-  // Priority: Mean reversion > OFI pressure > Momentum
-  if (absZ > 1.5) {
-    return getMeanReversionLog(zscore);
-  } else if (absOfi > 0.3) {
-    const direction = ofi > 0 ? 'LONG' : 'SHORT';
-    return getMarketBiasLog(direction, delta, ofi);
-  } else if (absMom > 2) {
-    return getMomentumLog(momentum, zscore);
-  } else {
-    return getScanningLog(true);
-  }
+  updateMicrostructure({ ofi, zscore, momentum, delta });
+  return getMarketFlowLog();
 }
 
+// =============================================================================
+// LEGACY API - Backward Compatibility
+// =============================================================================
+
+const getMarketBiasLog = (direction, delta, ofi) => {
+  updateMicrostructure({ delta, ofi });
+  return getMarketFlowLog();
+};
+
+const getMomentumLog = (momentum, zscore) => {
+  updateMicrostructure({ momentum, zscore });
+  return getMarketFlowLog();
+};
+
+const getMeanReversionLog = (zscore) => {
+  updateMicrostructure({ zscore: zscore * 2.5 }); // Amplify to trigger MR message
+  return getMarketFlowLog();
+};
+
+const getPositionUpdateLog = (side, size, unrealizedPnL, entryPrice, currentPrice, holdTime) => {
+  updatePosition({ side, size, unrealizedPnl: unrealizedPnL, entryPrice, currentPrice, entryTime: Date.now() - holdTime * 1000 });
+  return getPositionContextLog();
+};
+
+const getSignalLog = (direction, symbol, confidence, strategy) => {
+  const pool = direction === 'LONG' ? FLOW_AGGRESSIVE_BUY : FLOW_AGGRESSIVE_SELL;
+  const message = getVariedMessage(`signal_${direction}`, pool, `${direction} signal`);
+  const arrow = direction === 'LONG' ? '▲' : '▼';
+  return {
+    message: `${arrow} ${message}`,
+    details: `${symbol} | Conf:${confidence.toFixed(0)}% | ${strategy}`,
+  };
+};
+
+const getEntryLog = (direction, symbol, size, price) => {
+  const arrow = direction === 'LONG' ? '▲' : '▼';
+  return {
+    message: `${arrow} ${direction} initiated`,
+    details: `${size}x ${symbol} @ ${price.toFixed(2)}`,
+  };
+};
+
+const getExitLog = (isProfit, symbol, size, price, pnl) => {
+  return {
+    message: isProfit ? 'Profit captured' : 'Loss contained',
+    details: `${size}x ${symbol} @ ${price.toFixed(2)} | ${formatPnl(pnl)}`,
+  };
+};
+
+const getVolatilityLog_legacy = (isHigh, atr) => {
+  updateMicrostructure({ atr });
+  return getVolatilityLog();
+};
+
+// =============================================================================
+// EXPORTS
+// =============================================================================
+
 module.exports = {
+  // HF-Grade API
+  getSmartLog,
+  getMarketFlowLog,
+  getPositionContextLog,
+  getFlowAnalysisLog,
+  getVolatilityLog,
+  getScanningLog,
+  
+  // State management
+  updateMicrostructure,
+  updatePosition,
+  clearPosition,
+  
+  // Legacy API (backward compatible)
+  getMarketStateLog,
   getMarketBiasLog,
   getMomentumLog,
   getMeanReversionLog,
+  getPositionUpdateLog,
   getSignalLog,
   getEntryLog,
   getExitLog,
-  getVolatilityLog,
-  getScanningLog,
-  getPositionUpdateLog,
-  getMarketStateLog,
 };