hedgequantx 2.9.74 → 2.9.76

package/package.json

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

package/src/lib/smart-logs.js

@@ -41,21 +41,21 @@ function getVariedMessage(category, pool, defaultMsg) {
 // =============================================================================
 
 const LONG_BIAS_MESSAGES = [
-  'Buyers taking control',
-  'Bid side absorbing',
-  'Bullish order flow detected',
-  'Buy programs active',
-  'Strong buyer presence',
-  'Accumulation pattern',
-  'Demand exceeding supply',
-  'Buyers stepping up',
-  'Long-side momentum building',
-  'Bid accumulation detected',
-  'Bullish delta divergence',
-  'Buy-side imbalance',
-  'Institutional buying detected',
-  'Aggressive bid lifting',
-  'Bullish tape reading',
+  'Buyers taking control of the tape',
+  'Bid side absorbing sell pressure',
+  'Bullish order flow detected on sweep',
+  'Buy programs actively lifting offers',
+  'Strong buyer presence at current levels',
+  'Accumulation pattern forming on volume',
+  'Demand exceeding supply at bid',
+  'Buyers stepping up with size',
+  'Long-side momentum building steadily',
+  'Bid accumulation detected at support',
+  'Bullish delta divergence confirmed',
+  'Buy-side imbalance driving price higher',
+  'Institutional buying detected on tape',
+  'Aggressive bid lifting through offers',
+  'Bullish tape reading with strong delta',
 ];
 
 // =============================================================================
@@ -63,21 +63,21 @@ const LONG_BIAS_MESSAGES = [
 // =============================================================================
 
 const SHORT_BIAS_MESSAGES = [
-  'Sellers taking control',
-  'Offer side absorbing',
-  'Bearish order flow detected',
-  'Sell programs active',
-  'Strong seller presence',
-  'Distribution pattern',
-  'Supply exceeding demand',
-  'Sellers stepping in',
-  'Short-side momentum building',
-  'Offer distribution detected',
-  'Bearish delta divergence',
-  'Sell-side imbalance',
-  'Institutional selling detected',
-  'Aggressive offer hitting',
-  'Bearish tape reading',
+  'Sellers taking control of the tape',
+  'Offer side absorbing buy pressure',
+  'Bearish order flow detected on sweep',
+  'Sell programs actively hitting bids',
+  'Strong seller presence at current levels',
+  'Distribution pattern forming on volume',
+  'Supply exceeding demand at offer',
+  'Sellers stepping in with size',
+  'Short-side momentum building steadily',
+  'Offer distribution detected at resistance',
+  'Bearish delta divergence confirmed',
+  'Sell-side imbalance driving price lower',
+  'Institutional selling detected on tape',
+  'Aggressive offer hitting through bids',
+  'Bearish tape reading with weak delta',
 ];
 
 // =============================================================================

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

@@ -219,10 +219,14 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   let sellVolume = 0;
   let barCount = 0;
   
+  // Track tick arrival times for latency estimation
+  let lastTickTime = 0;
+  let tickLatencies = [];
+  
   marketFeed.on('tick', (tick) => {
     tickCount++;
-    const latencyStart = Date.now();
-    const currentSecond = Math.floor(Date.now() / 1000);
+    const now = Date.now();
+    const currentSecond = Math.floor(now / 1000);
     
     // Count ticks per second
     if (currentSecond === lastTickSecond) {
@@ -266,16 +270,17 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
       if (buyPressure > 55) bias = 'LONG';
       else if (buyPressure < 45) bias = 'SHORT';
       
-      // Log bias only when it changes or every 10 seconds
-      if (bias !== lastBias || currentSecond % 10 === 0) {
+      // Log bias when it changes, or every 5 seconds if strong signal
+      const strongSignal = Math.abs(delta) > 20 || buyPressure > 65 || buyPressure < 35;
+      if (bias !== lastBias || (strongSignal && currentSecond % 5 === 0) || (!strongSignal && currentSecond % 15 === 0)) {
         const biasLog = smartLogs.getMarketBiasLog(bias, delta, buyPressure);
         const biasType = bias === 'LONG' ? 'bullish' : bias === 'SHORT' ? 'bearish' : 'analysis';
         ui.addLog(biasType, `${biasLog.message} ${biasLog.details || ''}`);
         lastBias = bias;
       }
       
-      // Strategy state log every 10 seconds
-      if (currentSecond % 10 === 0) {
+      // Strategy state log every 30 seconds (reduced frequency)
+      if (currentSecond % 30 === 0) {
         const state = strategy.getAnalysisState?.(contractId, price);
         if (state) {
           if (!state.ready) {
@@ -283,42 +288,43 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
           } else {
             const resStr = state.nearestResistance ? state.nearestResistance.toFixed(2) : '--';
             const supStr = state.nearestSupport ? state.nearestSupport.toFixed(2) : '--';
-            ui.addLog('analysis', `Bars: ${state.barsProcessed} | Zones: ${state.activeZones} | Swings: ${state.swingsDetected}`);
-            ui.addLog('analysis', `Resistance: ${resStr} | Support: ${supStr}`);
             
-            // Explain why no trade
+            // Combined single line for zones info
+            ui.addLog('analysis', `Zones: ${state.activeZones} | R: ${resStr} | S: ${supStr} | Swings: ${state.swingsDetected}`);
+            
+            // Strategy status - what we're waiting for
             if (state.activeZones === 0) {
-              ui.addLog('risk', 'No zones detected - waiting for swing points');
+              ui.addLog('risk', 'Scanning for swing points to build liquidity zones...');
             } else if (!state.nearestSupport && !state.nearestResistance) {
-              ui.addLog('risk', 'Zones too far from price - waiting');
+              ui.addLog('risk', 'Zones detected but too far from current price level');
             } else if (!state.nearestSupport) {
-              ui.addLog('risk', 'No support zone - only SHORT sweeps possible');
+              ui.addLog('analysis', 'Watching resistance for HIGH SWEEP entry (SHORT)');
             } else if (!state.nearestResistance) {
-              ui.addLog('risk', 'No resistance zone - only LONG sweeps possible');
+              ui.addLog('analysis', 'Watching support for LOW SWEEP entry (LONG)');
             } else {
-              ui.addLog('ready', 'Zones active - waiting for sweep signal');
+              ui.addLog('ready', 'Both zones active - monitoring for liquidity sweep');
             }
           }
         }
       }
       
-      // Scanning log every 7 seconds (when no position)
-      if (currentSecond % 7 === 0 && currentPosition === 0) {
+      // Scanning log every 20 seconds (when no position)
+      if (currentSecond % 20 === 0 && currentPosition === 0) {
         const scanLog = smartLogs.getScanningLog(true);
         ui.addLog('system', scanLog.message);
       }
       
-      // Tick flow log every 15 seconds
-      if (currentSecond % 15 === 0) {
+      // Tick flow log every 45 seconds (less frequent)
+      if (currentSecond % 45 === 0) {
         const tickLog = smartLogs.getTickFlowLog(tickCount, ticksPerSecond);
         ui.addLog('debug', `${tickLog.message} ${tickLog.details}`);
       }
       
-      // AI Agents status log every 20 seconds
-      if (currentSecond % 20 === 0 && supervisionEnabled && supervisionEngine) {
+      // AI Agents status log every 60 seconds
+      if (currentSecond % 60 === 0 && supervisionEnabled && supervisionEngine) {
         const status = supervisionEngine.getStatus();
         const agentNames = status.agents.map(a => a.name.split(' ')[0]).join(', ');
-        ui.addLog('analysis', `AI Agents (${status.availableAgents}): ${agentNames} - watching...`);
+        ui.addLog('analysis', `AI Supervision active: ${agentNames} (${status.availableAgents} agents monitoring)`);
       }
       
       // Reset volume counters
@@ -338,16 +344,30 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
       timestamp: tick.timestamp || Date.now()
     });
     
-    // Calculate network latency from tick timestamp (if available)
+    // Calculate latency based on tick timestamp or inter-tick timing
     if (tick.timestamp) {
       const tickTime = typeof tick.timestamp === 'number' ? tick.timestamp : Date.parse(tick.timestamp);
-      if (!isNaN(tickTime)) {
-        stats.latency = Math.max(0, Date.now() - tickTime);
+      if (!isNaN(tickTime) && tickTime > 1000000000000) { // Valid millisecond timestamp
+        stats.latency = Math.max(0, now - tickTime);
       }
+    } else if (tick.ssboe && tick.usecs) {
+      // Rithmic sends ssboe (seconds since epoch) and usecs (microseconds)
+      const tickTimeMs = tick.ssboe * 1000 + Math.floor(tick.usecs / 1000);
+      stats.latency = Math.max(0, now - tickTimeMs);
     } else {
-      // Fallback: processing latency
-      stats.latency = Date.now() - latencyStart;
+      // Estimate latency from tick frequency - if we're getting real-time data, latency should be low
+      if (lastTickTime > 0) {
+        const timeSinceLastTick = now - lastTickTime;
+        // If ticks are coming frequently, latency is low
+        if (timeSinceLastTick < 100) {
+          tickLatencies.push(timeSinceLastTick);
+          if (tickLatencies.length > 20) tickLatencies.shift();
+          // Average of recent inter-tick times as proxy for latency
+          stats.latency = Math.round(tickLatencies.reduce((a, b) => a + b, 0) / tickLatencies.length);
+        }
+      }
     }
+    lastTickTime = now;
   });
   
   marketFeed.on('connected', () => {