hedgequantx 2.9.151 → 2.9.152

package/package.json

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

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

@@ -1,436 +1,365 @@
 /**
- * =============================================================================
- * Smart Logs Engine - HFT-Grade Real-Time Market Analysis
- * =============================================================================
- * Professional algorithmic trading logging engine
- * - Institutional-grade market microstructure analysis
- * - Strategy-adaptive message generation
- * - Non-repetitive rotation with 50+ messages per context
+ * Smart Logs Engine - Institutional HFT Terminal
+ * Professional hedge fund terminology with extensive message variety
  */
 
 'use strict';
 
 const chalk = require('chalk');
 
-// =============================================================================
-// ENGINE CONFIGURATION
-// =============================================================================
+const CONFIG = { MAX_RECENT: 80, SESSION_LOG_INTERVAL: 10 };
 
-const CONFIG = {
-  MAX_RECENT: 50,
-  SESSION_LOG_INTERVAL: 10,
+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',
 };
 
+function getSym(s) {
+  if (!s) return 'FUT';
+  const b = s.split(':')[0].replace(/[FGHJKMNQUVXZ]\d{1,2}$/, '').toUpperCase();
+  return SYMBOLS[b] || b;
+}
 
+function pick(arr) { return arr[Math.floor(Math.random() * arr.length)]; }
 
 // =============================================================================
-// STRATEGY-SPECIFIC HFT CONFIGURATIONS
+// HQX-2B: LIQUIDITY SWEEP STRATEGY
 // =============================================================================
 
-const STRATEGIES = {
-  'hqx-2b': {
-    name: 'HQX-2B Liquidity Sweep',
-    desc: '2B reversal pattern with institutional liquidity sweep detection',
-    phases: {
-      building: [
-        'Constructing swing point topology from OHLC data',
-        'Mapping institutional stop cluster zones',
-        'Identifying liquidity pool concentrations',
-        'Analyzing swing failure pattern potential',
-        'Building support/resistance zone matrix',
-        'Detecting false breakout trigger levels',
-        'Processing pivot point sequence data',
-        'Mapping stop-hunt probability zones',
-        'Computing swing point strength metrics',
-        'Analyzing zone touch count statistics',
-        'Building institutional footprint map',
-        'Detecting order block formation areas',
-        'Processing market structure hierarchy',
-        'Mapping liquidity void regions',
-        'Computing zone confluence metrics',
-        'Analyzing price rejection patterns',
-        'Building sweep trigger level database',
-        'Detecting retail stop cluster areas',
-        'Processing swing momentum data',
-        'Mapping reversal probability zones',
-      ],
-      scanning: [
-        'Liquidity zone proximity alert active',
-        'Monitoring stop cluster for sweep trigger',
-        'Zone boundary penetration imminent',
-        'Institutional sweep setup developing',
-        'Price approaching mapped liquidity pool',
-        'Stop-hunt zone in execution range',
-        'Monitoring for false breakout trigger',
-        'Zone touch detected - sweep probability rising',
-        'Liquidity sweep conditions aligning',
-        'Retail stops visible below/above zone',
-        'Institutional intent detected near zone',
-        'Sweep velocity threshold approaching',
-        'Zone penetration depth monitoring active',
-        'False breakout pattern probability high',
-        'Liquidity pool vulnerable to sweep',
-        'Stop cluster triggering imminent',
-        'Monitoring zone rejection momentum',
-        'Sweep confirmation criteria pending',
-        'Institutional trap setup forming',
-        'Zone defense level under pressure',
-      ],
-      ready: [
-        'Liquidity sweep confirmed - reversal imminent',
-        '2B pattern triggered - institutional trap complete',
-        'Stop-hunt executed - reversal momentum building',
-        'Zone penetration + rejection = entry signal',
-        'False breakout confirmed - reversal validated',
-        'Institutional sweep complete - entry window open',
-        'Retail stops triggered - smart money reversing',
-        '2B reversal confirmation on volume',
-        'Sweep velocity threshold exceeded - signal active',
-        'Zone rejection momentum above threshold',
-        'Institutional reversal footprint confirmed',
-        'Stop-hunt + rejection = high probability entry',
-        'False breakout trap executed successfully',
-        'Reversal momentum acceleration detected',
-        '2B pattern completion - execution ready',
-        'Liquidity sweep + volume = entry criteria met',
-        'Institutional buying/selling post-sweep',
-        'Reversal confirmation candle forming',
-        'Entry trigger threshold reached',
-        'Setup validation complete - signal active',
-      ],
-    },
-  },
-  'ultra-scalping': {
-    name: 'Ultra Scalping',
-    desc: 'Statistical microstructure edge detection with VPIN/Z-Score',
-    phases: {
-      building: [
-        'Computing tick-by-tick Z-Score distribution',
-        'Calculating VPIN toxicity flow metric',
-        'Building order flow imbalance model',
-        'Processing Level 2 microstructure data',
-        'Computing statistical arbitrage factors',
-        'Analyzing bid-ask spread dynamics',
-        'Building multi-factor signal matrix',
-        'Processing real-time covariance data',
-        'Computing momentum factor coefficients',
-        'Analyzing cross-asset correlation matrix',
-        'Building volatility regime classifier',
-        'Processing tick imbalance statistics',
-        'Computing mean reversion z-scores',
-        'Analyzing order arrival rate patterns',
-        'Building execution probability model',
-        'Processing quote stuffing detection',
-        'Computing adverse selection metrics',
-        'Analyzing market maker inventory',
-        'Building price impact estimator',
-        'Processing HFT signal aggregation',
-      ],
-      scanning: [
-        'Z-Score approaching entry threshold',
-        'VPIN toxicity level rising - alert active',
-        'Order flow imbalance building momentum',
-        'Statistical edge probability increasing',
-        'Factor model scores converging',
-        'Microstructure anomaly developing',
-        'Volatility regime shift detected',
-        'Tick imbalance ratio above normal',
-        'Mean reversion signal strengthening',
-        'Cross-factor correlation aligning',
-        'Execution window approaching',
-        'Signal-to-noise ratio improving',
-        'Statistical threshold proximity alert',
-        'Factor consensus building',
-        'Edge detection confidence rising',
-        'Microstructure pattern forming',
-        'Quantitative signal developing',
-        'Multi-factor alignment in progress',
-        'Entry criteria approaching threshold',
-        'Statistical anomaly probability high',
-      ],
-      ready: [
-        'Z-Score threshold breached - signal active',
-        'VPIN spike confirmed - toxic flow detected',
-        'Order flow imbalance confirmed - entry valid',
-        'Statistical edge threshold exceeded',
-        'Multi-factor consensus achieved - execute',
-        'Microstructure signal confirmed',
-        'Volatility regime optimal for entry',
-        'Tick imbalance ratio at extreme',
-        'Mean reversion entry criteria met',
-        'Cross-factor alignment confirmed',
-        'Execution window open - signal hot',
-        'Signal-to-noise ratio optimal',
-        'Statistical threshold exceeded',
-        'Factor model confidence maximum',
-        'Edge detection confirmed - entry',
-        'Microstructure pattern validated',
-        'Quantitative signal triggered',
-        'Multi-factor entry criteria satisfied',
-        'Statistical anomaly confirmed',
-        'HFT-grade entry opportunity active',
-      ],
-    },
-  },
-};
+const HQX2B = {
+  building: (d) => pick([
+    `[${d.sym}] Microstructure scan | ${d.bars} bars | ${d.swings} swing pivots | Zone mapping active`,
+    `[${d.sym}] Order block detection | ${d.ticks} ticks | Institutional footprint analysis`,
+    `[${d.sym}] Liquidity topology build | ${d.swings} pivots | Stop cluster identification`,
+    `[${d.sym}] Structure analysis | ${d.bars} OHLC | Delta profile: ${d.delta > 0 ? '+' : ''}${d.delta}`,
+    `[${d.sym}] Sweep zone calibration | ${d.ticks} tick sample | ${d.swings} swing nodes`,
+    `[${d.sym}] Institutional level mapping | ${d.bars} bars processed | Awaiting zone formation`,
+    `[${d.sym}] Market structure parse | ${d.swings} pivots detected | Liquidity map loading`,
+    `[${d.sym}] Price action decomposition | ${d.ticks} ticks | Swing point extraction`,
+    `[${d.sym}] DOM reconstruction | ${d.ticks} ticks | Depth analysis initializing`,
+    `[${d.sym}] Volume profile build | ${d.bars} bars | POC/VAH/VAL computation`,
+    `[${d.sym}] Iceberg detection scan | ${d.ticks} tick flow | Hidden liquidity search`,
+    `[${d.sym}] Stop cluster triangulation | ${d.swings} swings | Sweep target identification`,
+    `[${d.sym}] Auction theory analysis | ${d.bars} bars | Value area computation`,
+    `[${d.sym}] Order flow calibration | ${d.ticks} ticks | Aggressor tagging active`,
+    `[${d.sym}] Footprint initialization | ${d.bars} bars | Delta/volume decomposition`,
+    `[${d.sym}] Swing structure mapping | ${d.swings} pivots | HH/HL/LH/LL detection`,
+    `[${d.sym}] Liquidity heatmap build | ${d.ticks} observations | Cluster density calc`,
+    `[${d.sym}] Market profile loading | ${d.bars} TPOs | Distribution analysis`,
+    `[${d.sym}] Absorption scan | ${d.ticks} ticks | Passive order detection`,
+    `[${d.sym}] Momentum calibration | ${d.bars} bars | Velocity/acceleration calc`,
+  ]),
+
+  zones: (d) => pick([
+    `[${d.sym}] ${d.price} | ${d.zones} liquidity zones active | Sweep probability elevated`,
+    `[${d.sym}] ${d.price} | Stop cluster proximity | ${d.zones} institutional levels in range`,
+    `[${d.sym}] Zone convergence | ${d.zones} sweep targets | OFI: ${d.delta > 0 ? '+' : ''}${d.delta}`,
+    `[${d.sym}] ${d.price} | Liquidity pool vulnerable | ${d.zones} zones | Monitoring penetration`,
+    `[${d.sym}] Institutional zone active | ${d.zones} levels | ${d.swings} swing confirmation`,
+    `[${d.sym}] ${d.price} | ${d.zones} stop clusters mapped | Sweep trigger watch`,
+    `[${d.sym}] ${d.price} | High volume node proximity | ${d.zones} zones defended`,
+    `[${d.sym}] Resting liquidity detected | ${d.zones} pools | ${d.price} approach vector`,
+    `[${d.sym}] ${d.price} | ${d.zones} absorption zones | Delta: ${d.delta > 0 ? '+' : ''}${d.delta}`,
+    `[${d.sym}] Stop hunt proximity | ${d.zones} targets | Price: ${d.price}`,
+    `[${d.sym}] ${d.price} | Iceberg cluster ${d.zones} levels | Sweep imminent`,
+    `[${d.sym}] Liquidity vacuum ahead | ${d.zones} zones | Acceleration expected`,
+    `[${d.sym}] ${d.price} | ${d.zones} institutional traps | OFI shift monitoring`,
+    `[${d.sym}] POC rejection zone | ${d.price} | ${d.zones} confluences active`,
+    `[${d.sym}] ${d.price} | Value area boundary | ${d.zones} levels | Breakout watch`,
+    `[${d.sym}] Delta divergence @ ${d.price} | ${d.zones} zones | Reversal setup`,
+    `[${d.sym}] ${d.price} | Trapped traders ${d.zones} levels | Squeeze potential`,
+    `[${d.sym}] Order block test | ${d.price} | ${d.zones} institutional zones`,
+    `[${d.sym}] ${d.price} | Liquidity grab zone | ${d.zones} stops vulnerable`,
+    `[${d.sym}] Fair value gap ${d.price} | ${d.zones} imbalances | Fill expected`,
+  ]),
+
+  bull: (d) => pick([
+    `[${d.sym}] ${d.price} | OFI: +${Math.abs(d.delta)} | Bid absorption | Shorts vulnerable`,
+    `[${d.sym}] ${d.price} | Delta +${Math.abs(d.delta)} | Institutional bid | ${d.zones} support zones`,
+    `[${d.sym}] Bullish microstructure | OFI +${Math.abs(d.delta)} | Stop hunt below pending`,
+    `[${d.sym}] ${d.price} | Positive delta divergence | Offer exhaustion detected`,
+    `[${d.sym}] ${d.price} | Buy imbalance +${Math.abs(d.delta)} | ${d.zones} zones defended`,
+    `[${d.sym}] Bid stack reinforcement | Delta +${Math.abs(d.delta)} | Sweep below imminent`,
+    `[${d.sym}] ${d.price} | Aggressive buyers | OFI +${Math.abs(d.delta)} | Momentum building`,
+    `[${d.sym}] Sell absorption complete | ${d.price} | Delta: +${Math.abs(d.delta)} | Longs loading`,
+    `[${d.sym}] ${d.price} | Bullish order flow | +${Math.abs(d.delta)} delta | Shorts trapped`,
+    `[${d.sym}] Passive bid detected | ${d.price} | OFI: +${Math.abs(d.delta)} | Accumulation`,
+    `[${d.sym}] ${d.price} | Offer depletion | Delta +${Math.abs(d.delta)} | Breakout setup`,
+    `[${d.sym}] Institutional buying | ${d.price} | +${Math.abs(d.delta)} imbalance | Trend continuation`,
+    `[${d.sym}] ${d.price} | Bullish footprint | OFI +${Math.abs(d.delta)} | ${d.zones} zones held`,
+    `[${d.sym}] Buy program detected | ${d.price} | Delta: +${Math.abs(d.delta)} | Momentum`,
+    `[${d.sym}] ${d.price} | Positive tick | +${Math.abs(d.delta)} OFI | Upside acceleration`,
+    `[${d.sym}] Short squeeze setup | ${d.price} | Delta +${Math.abs(d.delta)} | Covering expected`,
+    `[${d.sym}] ${d.price} | Bid aggression | OFI: +${Math.abs(d.delta)} | Offers lifted`,
+    `[${d.sym}] Bullish absorption | ${d.price} | +${Math.abs(d.delta)} delta | Continuation`,
+    `[${d.sym}] ${d.price} | Buy pressure | Delta: +${Math.abs(d.delta)} | Resistance test`,
+    `[${d.sym}] Demand zone active | ${d.price} | OFI +${Math.abs(d.delta)} | Support confirmed`,
+  ]),
+
+  bear: (d) => pick([
+    `[${d.sym}] ${d.price} | OFI: ${d.delta} | Offer absorption | Longs vulnerable`,
+    `[${d.sym}] ${d.price} | Delta ${d.delta} | Institutional offer | ${d.zones} resistance zones`,
+    `[${d.sym}] Bearish microstructure | OFI ${d.delta} | Stop hunt above pending`,
+    `[${d.sym}] ${d.price} | Negative delta divergence | Bid exhaustion detected`,
+    `[${d.sym}] ${d.price} | Sell imbalance ${d.delta} | ${d.zones} zones pressured`,
+    `[${d.sym}] Offer stack reinforcement | Delta ${d.delta} | Sweep above imminent`,
+    `[${d.sym}] ${d.price} | Aggressive sellers | OFI ${d.delta} | Momentum building`,
+    `[${d.sym}] Buy absorption complete | ${d.price} | Delta: ${d.delta} | Shorts loading`,
+    `[${d.sym}] ${d.price} | Bearish order flow | ${d.delta} delta | Longs trapped`,
+    `[${d.sym}] Passive offer detected | ${d.price} | OFI: ${d.delta} | Distribution`,
+    `[${d.sym}] ${d.price} | Bid depletion | Delta ${d.delta} | Breakdown setup`,
+    `[${d.sym}] Institutional selling | ${d.price} | ${d.delta} imbalance | Trend continuation`,
+    `[${d.sym}] ${d.price} | Bearish footprint | OFI ${d.delta} | ${d.zones} zones failed`,
+    `[${d.sym}] Sell program detected | ${d.price} | Delta: ${d.delta} | Momentum`,
+    `[${d.sym}] ${d.price} | Negative tick | ${d.delta} OFI | Downside acceleration`,
+    `[${d.sym}] Long squeeze setup | ${d.price} | Delta ${d.delta} | Liquidation expected`,
+    `[${d.sym}] ${d.price} | Offer aggression | OFI: ${d.delta} | Bids hit`,
+    `[${d.sym}] Bearish absorption | ${d.price} | ${d.delta} delta | Continuation`,
+    `[${d.sym}] ${d.price} | Sell pressure | Delta: ${d.delta} | Support test`,
+    `[${d.sym}] Supply zone active | ${d.price} | OFI ${d.delta} | Resistance confirmed`,
+  ]),
+
+  neutral: (d) => pick([
+    `[${d.sym}] ${d.price} | Delta neutral | Bilateral liquidity | Sweep catalyst pending`,
+    `[${d.sym}] ${d.price} | OFI balanced | ${d.zones} zones intact | Range compression`,
+    `[${d.sym}] Equilibrium @ ${d.price} | Stops accumulating both sides | ${d.ticks} ticks`,
+    `[${d.sym}] ${d.price} | No directional flow | ${d.zones} liquidity pools stable`,
+    `[${d.sym}] Range consolidation | ${d.price} | Awaiting institutional catalyst`,
+    `[${d.sym}] ${d.price} | Balanced book | ${d.zones} zones | Breakout + sweep imminent`,
+    `[${d.sym}] ${d.price} | Rotation mode | OFI flat | ${d.zones} levels holding`,
+    `[${d.sym}] Chop zone | ${d.price} | Delta: ${d.delta} | No edge detected`,
+    `[${d.sym}] ${d.price} | Two-sided flow | ${d.zones} zones | Expansion pending`,
+    `[${d.sym}] Value area rotation | ${d.price} | Balanced auction | ${d.ticks} ticks`,
+    `[${d.sym}] ${d.price} | Inside bar structure | ${d.zones} zones | Coiling`,
+    `[${d.sym}] Consolidation | ${d.price} | OFI: ${d.delta} | Range-bound`,
+    `[${d.sym}] ${d.price} | Balanced delta | Awaiting volume | ${d.zones} zones`,
+    `[${d.sym}] Low conviction | ${d.price} | Delta neutral | Patience mode`,
+    `[${d.sym}] ${d.price} | Tight range | ${d.zones} zones | Volatility compression`,
+    `[${d.sym}] Mean reversion zone | ${d.price} | No trend | ${d.ticks} ticks`,
+    `[${d.sym}] ${d.price} | Symmetric flow | ${d.zones} liquidity balanced`,
+    `[${d.sym}] Absorption both sides | ${d.price} | OFI: ${d.delta} | Standoff`,
+    `[${d.sym}] ${d.price} | Bracket forming | ${d.zones} levels | Expansion watch`,
+    `[${d.sym}] Balance area | ${d.price} | No aggression | ${d.ticks} ticks observed`,
+  ]),
 
-// Default fallback strategy
-const DEFAULT_STRATEGY = {
-  name: 'Algorithmic Strategy',
-  desc: 'Generic algorithmic trading framework',
-  phases: {
-    building: [
-      'Processing market data feed',
-      'Building signal detection model',
-      'Analyzing price action structure',
-      'Computing entry criteria metrics',
-      'Processing indicator calculations',
-    ],
-    scanning: [
-      'Monitoring entry conditions',
-      'Signal probability rising',
-      'Setup conditions developing',
-      'Entry criteria approaching',
-      'Pattern formation in progress',
-    ],
-    ready: [
-      'Entry signal confirmed',
-      'Setup criteria satisfied',
-      'Execution window active',
-      'Signal validation complete',
-      'Entry conditions met',
-    ],
+  ready: (d) => {
+    const side = d.delta > 0 ? 'LONG' : d.delta < 0 ? 'SHORT' : 'REVERSAL';
+    return pick([
+      `${chalk.green('■')} [${d.sym}] SWEEP EXECUTED @ ${d.price} | ${d.zones} stops triggered | ${side} SIGNAL`,
+      `${chalk.green('■')} [${d.sym}] 2B CONFIRMED | Liquidity taken @ ${d.price} | OFI shift | EXECUTE ${side}`,
+      `${chalk.green('■')} [${d.sym}] INSTITUTIONAL TRAP @ ${d.price} | Zone rejection | ${side} ENTRY`,
+      `${chalk.green('■')} [${d.sym}] STOP HUNT COMPLETE | ${d.price} | Delta reversal | ${side} TRIGGER`,
+      `${chalk.green('■')} [${d.sym}] LIQUIDITY GRAB @ ${d.price} | ${d.zones} zones swept | ${side} ACTIVE`,
+      `${chalk.green('■')} [${d.sym}] ZONE PENETRATION | ${d.price} | OFI: ${d.delta} | EXECUTE ${side}`,
+      `${chalk.green('■')} [${d.sym}] TRAP REVERSAL @ ${d.price} | Stops taken | ${side} CONFIRMED`,
+      `${chalk.green('■')} [${d.sym}] SWEEP COMPLETE | ${d.zones} levels hit @ ${d.price} | ${side}`,
+      `${chalk.green('■')} [${d.sym}] BREAKOUT FAILURE @ ${d.price} | Reversal confirmed | ${side} SIGNAL`,
+      `${chalk.green('■')} [${d.sym}] FALSE BREAK @ ${d.price} | Liquidity swept | TRIGGER ${side}`,
+    ]);
   },
 };
 
 // =============================================================================
-// SYMBOL PROFILES - Trading Floor Terminology per Asset Class
+// QUANT: STATISTICAL ARBITRAGE
 // =============================================================================
 
-const SYMBOLS = {
-  // Nasdaq
-  NQ: { name: 'NQ', floor: 'Nasdaq', asset: 'tech', slang: 'NQ futures' },
-  MNQ: { name: 'MNQ', floor: 'Micro Nasdaq', asset: 'tech', slang: 'mini tech' },
-  // S&P
-  ES: { name: 'ES', floor: 'Spooz', asset: 'index', slang: 'the Spooz' },
-  MES: { name: 'MES', floor: 'Micro S&P', asset: 'index', slang: 'micro spooz' },
-  // Dow
-  YM: { name: 'YM', floor: 'Dow', asset: 'index', slang: 'the Dow' },
-  MYM: { name: 'MYM', floor: 'Micro Dow', asset: 'index', slang: 'mini Dow' },
-  // Crude
-  CL: { name: 'CL', floor: 'Crude', asset: 'energy', slang: 'oil' },
-  MCL: { name: 'MCL', floor: 'Micro Crude', asset: 'energy', slang: 'micro crude' },
-  // Gold
-  GC: { name: 'GC', floor: 'Gold', asset: 'metals', slang: 'yellow metal' },
-  MGC: { name: 'MGC', floor: 'Micro Gold', asset: 'metals', slang: 'micro gold' },
-  '1OZ': { name: '1OZ', floor: 'Micro Gold', asset: 'metals', slang: '1oz gold' },
-  // Silver
-  SI: { name: 'SI', floor: 'Silver', asset: 'metals', slang: 'silver' },
-  SIL: { name: 'SIL', floor: 'Micro Silver', asset: 'metals', slang: 'micro silver' },
-  // Bonds
-  ZB: { name: 'ZB', floor: 'Bonds', asset: 'rates', slang: 'long bond' },
-  ZN: { name: 'ZN', floor: '10Y', asset: 'rates', slang: 'tens' },
-  // Russell
-  RTY: { name: 'RTY', floor: 'Russell', asset: 'index', slang: 'small caps' },
-  M2K: { name: 'M2K', floor: 'Micro Russell', asset: 'index', slang: 'micro russell' },
-  // Default
-  DEFAULT: { name: 'Contract', floor: 'Futures', asset: 'futures', slang: 'contract' }
-};
+const QUANT = {
+  building: (d) => pick([
+    `[${d.sym}] Factor model calibration | ${d.ticks} observations | Z-score baseline`,
+    `[${d.sym}] VPIN computation | ${d.ticks} tick volume | Toxicity threshold loading`,
+    `[${d.sym}] OFI model update | ${d.bars} bars | Imbalance coefficient: ${d.delta}`,
+    `[${d.sym}] Statistical baseline | ${d.ticks} samples | Multi-factor initialization`,
+    `[${d.sym}] Microstructure model | ${d.ticks} ticks | Kyle lambda estimation`,
+    `[${d.sym}] Tick imbalance scan | ${d.bars} bars | Factor weights calibrating`,
+    `[${d.sym}] Covariance matrix build | ${d.ticks} observations | PCA decomposition`,
+    `[${d.sym}] Volatility clustering | ${d.bars} bars | GARCH initialization`,
+    `[${d.sym}] Return distribution fit | ${d.ticks} samples | Tail risk calibration`,
+    `[${d.sym}] Cross-correlation scan | ${d.bars} bars | Lead-lag detection`,
+    `[${d.sym}] Mean reversion test | ${d.ticks} ticks | Half-life estimation`,
+    `[${d.sym}] Information ratio calc | ${d.bars} bars | Alpha extraction`,
+    `[${d.sym}] Regime detection | ${d.ticks} samples | HMM state probability`,
+    `[${d.sym}] Spread decomposition | ${d.bars} bars | Fair value model`,
+    `[${d.sym}] Momentum factor | ${d.ticks} ticks | Signal extraction`,
+    `[${d.sym}] Liquidity measure | ${d.bars} bars | Amihud ratio computation`,
+    `[${d.sym}] Autocorrelation test | ${d.ticks} samples | Serial dependence`,
+    `[${d.sym}] Kurtosis estimation | ${d.bars} bars | Fat tail adjustment`,
+    `[${d.sym}] Beta calibration | ${d.ticks} ticks | Systematic risk model`,
+    `[${d.sym}] Sharpe estimation | ${d.bars} bars | Risk-adjusted return`,
+  ]),
 
-// Get symbol profile from contract code (MNQH6:CME → MNQ)
-function getSymbolProfile(symbol) {
-  if (!symbol) return SYMBOLS.DEFAULT;
-  const afterSplit = symbol.split(':')[0];
-  const base = afterSplit.replace(/[FGHJKMNQUVXZ]\d{1,2}$/, '').toUpperCase();
-  return SYMBOLS[base] || SYMBOLS.DEFAULT;
-}
+  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`,
+    ]);
+  },
+
+  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`,
+    ]);
+  },
+
+  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`,
+    ]);
+  },
+
+  neutral: (d) => pick([
+    `[${d.sym}] ${d.price} | Z: 0σ | OFI: neutral | No statistical edge | HOLD`,
+    `[${d.sym}] ${d.price} | VPIN: normal | Factors inconclusive | Awaiting signal`,
+    `[${d.sym}] Factor model: FLAT | Z/VPIN/OFI within bounds | ${d.ticks} ticks`,
+    `[${d.sym}] ${d.price} | No alpha detected | Statistical threshold not met`,
+    `[${d.sym}] Microstructure neutral | No toxic flow | Edge probability: LOW`,
+    `[${d.sym}] ${d.price} | Model output: FLAT | Insufficient signal strength`,
+    `[${d.sym}] Regime: uncertain | ${d.price} | Factors divergent | No trade`,
+    `[${d.sym}] ${d.price} | Z within bounds | OFI: ${d.delta} | No edge`,
+    `[${d.sym}] Fair value @ ${d.price} | No mispricing | ${d.ticks} observations`,
+    `[${d.sym}] ${d.price} | Information ratio: flat | No alpha opportunity`,
+    `[${d.sym}] Statistical noise | ${d.price} | Delta: ${d.delta} | No signal`,
+    `[${d.sym}] ${d.price} | Model confidence: LOW | Factors unconverged`,
+    `[${d.sym}] Mean reversion pause | ${d.price} | Z centered | Waiting`,
+    `[${d.sym}] ${d.price} | No regime detected | OFI balanced | HOLD`,
+    `[${d.sym}] Factor equilibrium | ${d.price} | No edge | ${d.ticks} ticks`,
+  ]),
+
+  ready: (d) => {
+    const side = d.delta > 0 ? 'LONG' : 'SHORT';
+    const z = (Math.abs(d.delta) / 8).toFixed(2);
+    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`,
+    ]);
+  },
+};
 
 // =============================================================================
-// SMART LOGS ENGINE CLASS
+// ENGINE
 // =============================================================================
 
 class SmartLogsEngine {
   constructor(strategyId, symbol) {
-    this.strategyId = strategyId || 'default';
-    this.strategy = STRATEGIES[this.strategyId] || DEFAULT_STRATEGY;
-    this.symbol = getSymbolProfile(symbol);
-    this.recent = new Map();
+    this.strategyId = strategyId || 'hqx-2b';
+    this.symbolCode = symbol;
     this.counter = 0;
+    this.recent = [];
   }
 
-  /** Update symbol for the engine */
-  setSymbol(symbol) {
-    this.symbol = getSymbolProfile(symbol);
-  }
+  setSymbol(s) { this.symbolCode = s; }
 
-  /** Get strategy metadata */
-  getInfo() {
-    return { id: this.strategyId, name: this.strategy.name, desc: this.strategy.desc };
+  _phase(st) {
+    if (st.setupForming && st.zones > 0) return 'ready';
+    if (st.zones > 0 || st.swings >= 2) return 'zones';
+    return 'building';
   }
 
-  /** Get non-repetitive message from pool */
-  _pick(category, pool) {
-    const key = `${this.strategyId}_${category}`;
-    let used = this.recent.get(key) || [];
-    let available = pool.filter(m => !used.includes(m));
-    
-    if (available.length === 0) {
-      used = [];
-      available = pool;
-    }
-    
-    const msg = available[Math.floor(Math.random() * available.length)];
-    used.push(msg);
-    if (used.length > CONFIG.MAX_RECENT) used.shift();
-    this.recent.set(key, used);
-    
+  _unique(gen, d) {
+    let msg, i = 0;
+    do { msg = gen(d); i++; } while (this.recent.includes(msg) && i < 15);
+    this.recent.push(msg);
+    if (this.recent.length > CONFIG.MAX_RECENT) this.recent.shift();
     return msg;
   }
 
-  /** Determine strategy phase from state */
-  _phase(state) {
-    const { bars = 0, swings = 0, zones = 0, setupForming = false } = state;
-    if (setupForming && zones > 0) return 'ready';
-    if (zones > 0 || swings >= 2) return 'scanning';
-    return 'building';
-  }
-
-  /**
-   * Generate HFT-grade log with REAL market data embedded in PRO phrases
-   * @param {Object} state - Market/strategy state with real data
-   * @returns {Object} { type, message, logToSession }
-   */
   getLog(state = {}) {
     this.counter++;
-    const { 
-      trend = 'neutral', position = 0, zones = 0, swings = 0, bars = 0,
-      price = 0, lastPrice = 0, bid = 0, ask = 0,
-      delta = 0, buyPct = 50, ticksPerSec = 0, tickCount = 0, volume = 0
-    } = state;
+    const { trend = 'neutral', position = 0, zones = 0, swings = 0, bars = 0,
+            price = 0, delta = 0, buyPct = 50, tickCount = 0 } = state;
 
     const phase = this._phase(state);
-    const p = price > 0 ? price.toFixed(2) : '---';
-    const isBull = trend === 'bullish' || trend === 'LONG' || buyPct > 55;
-    const isBear = trend === 'bearish' || trend === 'SHORT' || buyPct < 45;
+    const bull = trend === 'bullish' || buyPct > 55;
+    const bear = trend === 'bearish' || buyPct < 45;
+    const T = this.strategyId === 'hqx-2b' ? HQX2B : QUANT;
+
+    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),
+    };
 
-    // Position active
     if (position !== 0) {
       const side = position > 0 ? 'LONG' : 'SHORT';
+      const pnl = (position > 0 && delta > 0) || (position < 0 && delta < 0) ? 'FAVOR' : 'ADVERSE';
       return {
         type: 'trade',
-        message: `▶ ${side} position active at ${p} - monitoring P&L targets and stop levels`,
+        message: `▶ [${d.sym}] ${side} ACTIVE @ ${d.price} | OFI: ${delta > 0 ? '+' : ''}${delta} | Flow: ${pnl}`,
         logToSession: this.counter % CONFIG.SESSION_LOG_INTERVAL === 0
       };
     }
 
-    // Professional phrases with real data - non-repetitive via counter rotation
-    const templates = this._getTemplates(state, phase, p, isBull, isBear);
-    const idx = this.counter % templates.length;
-    const { type, message } = templates[idx];
+    // Priority: ready > building > bull/bear > zones > neutral
+    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'; }
 
-    return { type, message, logToSession: this.counter % CONFIG.SESSION_LOG_INTERVAL === 0 };
+    return { 
+      type, 
+      message: this._unique(gen, d), 
+      logToSession: this.counter % CONFIG.SESSION_LOG_INTERVAL === 0 
+    };
   }
 
-  /** Trading floor HFT templates - authentic institutional language with colors */
-  _getTemplates(state, phase, p, isBull, isBear) {
-    const { zones = 0, swings = 0, bars = 0, delta = 0, buyPct = 50, ticksPerSec = 0, tickCount = 0, bid = 0, ask = 0 } = state;
-    const s = this.symbol; // Symbol profile
-    const isHQX2B = this.strategyId === 'hqx-2b';
-    
-    // Computed metrics
-    const spd = (ask > 0 && bid > 0) ? ((ask - bid) * 4).toFixed(0) : '1';
-    const d = delta > 0 ? `+${delta}` : `${delta}`;
-    const ofi = (delta * 1.3).toFixed(0);
-    const vpin = (0.4 + Math.abs(50 - buyPct) / 100).toFixed(2);
-    const tps = ticksPerSec || Math.max(1, Math.floor(tickCount / 30));
-    const zs = ((buyPct - 50) / 15).toFixed(1);
-    const imb = buyPct.toFixed(0);
-    
-    // Colored elements
-    const P = chalk.yellow(p); // Price
-    const S = chalk.white.bold(s.floor); // Symbol floor name
-    const SL = chalk.gray(s.slang); // Symbol slang
-    const D = delta > 0 ? chalk.cyan(`δ${d}`) : delta < 0 ? chalk.magenta(`δ${d}`) : chalk.gray(`δ${d}`);
-    const OFI = delta > 0 ? chalk.cyan(`OFI ${ofi}`) : chalk.magenta(`OFI ${ofi}`);
-    const VPIN = chalk.yellow(`VPIN ${vpin}`);
-    const ZS = chalk.yellow(`Z ${zs}σ`);
-    const IMB = isBull ? chalk.cyan(`${imb}%`) : isBear ? chalk.magenta(`${imb}%`) : chalk.gray(`${imb}%`);
-    
-    const t = [];
-    
-    // === HQX-2B: Liquidity Sweep Strategy ===
-    if (isHQX2B) {
-      if (phase === 'ready' && zones > 0) {
-        t.push({ type: 'signal', message: `${chalk.green.bold('SWEEP')} ${S} ${P} | ${zones} stops triggered | Reversal confirmed` });
-        t.push({ type: 'signal', message: `${chalk.green.bold('2B TRAP')} ${SL} ${P} | Retail hunted | ${swings} pivots` });
-        t.push({ type: 'signal', message: `${chalk.green.bold('GRAB')} ${S} ${P} | ${zones} zones swept | Institutional reversal` });
-      } else if (phase === 'scanning' && zones > 0) {
-        t.push({ type: 'analysis', message: `${S} ${P} approaching liquidity | ${zones} clusters mapped | Sweep imminent` });
-        t.push({ type: 'analysis', message: `Stop hunt setup ${SL} ${P} | ${swings} swings | Watching penetration` });
-        t.push({ type: 'analysis', message: `${S} zone test at ${P} | ${zones} targets | Monitoring rejection` });
-      } else if (isBull) {
-        t.push({ type: 'bullish', message: `${S} ${P} bid absorption | ${D} | Stops below being hunted` });
-        t.push({ type: 'bullish', message: `${SL} liquidity building at ${P} | Sweep setup forming | ${swings} pivots` });
-        t.push({ type: 'bullish', message: `Institutional bid ${S} ${P} | ${OFI} | Retail shorts trapped` });
-        t.push({ type: 'bullish', message: `${S} false breakdown at ${P} | ${D} | Smart money buying dip` });
-      } else if (isBear) {
-        t.push({ type: 'bearish', message: `${S} ${P} offer absorption | ${D} | Stops above being hunted` });
-        t.push({ type: 'bearish', message: `${SL} liquidity building at ${P} | Sweep setup forming | ${swings} pivots` });
-        t.push({ type: 'bearish', message: `Institutional offer ${S} ${P} | ${OFI} | Retail longs trapped` });
-        t.push({ type: 'bearish', message: `${S} false breakout at ${P} | ${D} | Smart money selling rally` });
-      } else {
-        t.push({ type: 'system', message: `Mapping ${S} structure at ${P} | ${bars} bars | ${swings} swings` });
-        t.push({ type: 'system', message: `${SL} scanning zones at ${P} | ${tickCount} ticks | Detecting clusters` });
-        t.push({ type: 'analysis', message: `${S} ${P} consolidating | ${D} | Liquidity pooling at extremes` });
-        t.push({ type: 'analysis', message: `${SL} range at ${P} | Stops accumulating | Sweep pending` });
-      }
-    }
-    // === ULTRA-SCALPING: Quant/Stats Strategy ===
-    else {
-      if (phase === 'ready') {
-        t.push({ type: 'signal', message: `${chalk.green.bold('EDGE')} ${S} ${P} | ${ZS} breach | ${VPIN} | Execute` });
-        t.push({ type: 'signal', message: `${chalk.green.bold('TRIGGER')} ${SL} ${P} | Multi-factor consensus | ${OFI}` });
-        t.push({ type: 'signal', message: `${chalk.green.bold('ALPHA')} ${S} ${P} | Model convergence | ${D} | Entry` });
-      } else if (phase === 'scanning') {
-        t.push({ type: 'analysis', message: `${S} ${P} factors building | ${ZS} | Threshold proximity` });
-        t.push({ type: 'analysis', message: `${SL} edge forming at ${P} | ${VPIN} | Monitoring` });
-        t.push({ type: 'analysis', message: `Statistical setup ${S} ${P} | ${OFI} | Alignment ${IMB}` });
-      } else if (isBull) {
-        t.push({ type: 'bullish', message: `${S} ${P} heavy paper bid | ${D} | ${VPIN} rising` });
-        t.push({ type: 'bullish', message: `${SL} ${P} ${ZS} bullish | ${OFI} | Mean reversion long` });
-        t.push({ type: 'bullish', message: `${S} momentum ${P} | ${IMB} buy | Quant signal building` });
-      } else if (isBear) {
-        t.push({ type: 'bearish', message: `${S} ${P} heavy paper offer | ${D} | ${VPIN} rising` });
-        t.push({ type: 'bearish', message: `${SL} ${P} ${ZS} bearish | ${OFI} | Mean reversion short` });
-        t.push({ type: 'bearish', message: `${S} momentum ${P} | ${IMB} sell | Quant signal building` });
-      } else {
-        t.push({ type: 'system', message: `Calibrating ${S} models at ${P} | ${bars} bars | Computing factors` });
-        t.push({ type: 'system', message: `${SL} tick analysis at ${P} | ${tickCount} samples | ${tps} tps` });
-        t.push({ type: 'analysis', message: `${S} ${P} neutral | ${ZS} | ${VPIN} | Awaiting edge` });
-        t.push({ type: 'analysis', message: `${SL} range at ${P} | ${D} | Statistical mean reversion` });
-      }
-    }
-    
-    return t;
-  }
-
-  /** Reset for new session */
-  reset() {
-    this.recent.clear();
-    this.counter = 0;
-  }
-}
-
-// =============================================================================
-// FACTORY & EXPORTS
-// =============================================================================
-
-function createEngine(strategyId, symbol) {
-  return new SmartLogsEngine(strategyId, symbol);
-}
-
-function getStrategies() {
-  return Object.entries(STRATEGIES).map(([id, s]) => ({ id, name: s.name, desc: s.desc }));
+  reset() { this.recent = []; this.counter = 0; }
 }
 
-module.exports = { SmartLogsEngine, createEngine, getStrategies, STRATEGIES, CONFIG };
+function createEngine(strategyId, symbol) { return new SmartLogsEngine(strategyId, symbol); }
+module.exports = { SmartLogsEngine, createEngine, CONFIG };