hedgequantx 2.9.122 → 2.9.124

package/package.json

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

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

@@ -277,11 +277,18 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
       else if (price < lastPrice) sellVolume += volume;
     }
     
-    // Log first tick
+    // Log first tick and periodic tick count
     if (tickCount === 1) {
       ui.addLog('connected', `First tick @ ${price?.toFixed(2) || 'N/A'}`);
     }
     
+    // Log tick count every 10 seconds to confirm data flow
+    if (tickCount % 1000 === 0 || (currentSecond % 10 === 0 && currentSecond !== lastLogSecond)) {
+      const state = strategy.getAnalysisState?.(contractId, price);
+      const bars = state?.barsProcessed || 0;
+      ui.addLog('debug', `Ticks: ${tickCount} | Bars: ${bars} | Price: ${price?.toFixed(2)}`);
+    }
+    
     // === SMART LOGS - REDUCED FREQUENCY ===
     if (currentSecond !== lastLogSecond && tickCount > 1) {
       lastLogSecond = currentSecond;
@@ -291,12 +298,15 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
       const delta = buyVolume - sellVolume;
       
       let bias = buyPressure > 55 ? 'LONG' : buyPressure < 45 ? 'SHORT' : 'FLAT';
-      const strongSignal = Math.abs(delta) > 20 || buyPressure > 65 || buyPressure < 35;
-      if (bias !== lastBias || (strongSignal && currentSecond % 5 === 0) || (!strongSignal && currentSecond % 15 === 0)) {
+      // Log bias every 5 seconds or when it changes
+      if (bias !== lastBias || currentSecond % 5 === 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;
+        // Reset volume after logging
+        buyVolume = 0;
+        sellVolume = 0;
       }
       
       // Strategy state log every 30 seconds (reduced frequency)
@@ -329,28 +339,8 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
         }
       }
       
-      // Scanning log every 20 seconds
-      if (currentSecond % 20 === 0 && currentPosition === 0) ui.addLog('system', smartLogs.getScanningLog(true).message);
-      // Tick flow log every 45 seconds
-      if (currentSecond % 45 === 0) { const t = smartLogs.getTickFlowLog(tickCount, ticksPerSecond); ui.addLog('debug', `${t.message} ${t.details}`); }
-      // AI Agents status 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 Supervision active: ${agentNames} (${status.availableAgents} agents monitoring)`);
-      }
-      
-      // Strategy health status every 2 minutes (confirms strategy is working)
-      if (currentSecond % 120 === 0 && strategy.getHealthStatus) {
-        const health = strategy.getHealthStatus(contractId);
-        const uptime = Math.floor(health.uptime / 60000);
-        const status = health.healthy ? 'OK' : 'WARMING';
-        ui.addLog('ready', `HEALTH: ${status} | Bars: ${health.barsTotal} | Zones: ${health.zonesTotal} (R:${health.zonesResistance}/S:${health.zonesSupport}) | Swings: ${health.swingsTotal} | Uptime: ${uptime}m`);
-      }
-      
-      // Reset volume counters
-      buyVolume = 0;
-      sellVolume = 0;
+      // AI status every 60s
+      if (currentSecond % 60 === 0 && supervisionEnabled && supervisionEngine) ui.addLog('analysis', `AI: ${supervisionEngine.getStatus().agents.map(a => a.name.split(' ')[0]).join(', ')}`);
     }
     
     lastPrice = price;

package/src/services/rithmic/index.js

@@ -98,6 +98,18 @@ class RithmicService extends EventEmitter {
 
       await this.orderConn.connect(config);
       this.orderConn.on('message', createOrderHandler(this));
+      
+      // Auto-reconnect on disconnect
+      this.orderConn.on('disconnected', async ({ code, reason }) => {
+        log.warn('ORDER_PLANT disconnected', { code, reason });
+        this.emit('disconnected', { plant: 'ORDER', code, reason });
+        
+        // Auto-reconnect if we have credentials (not manual disconnect)
+        if (this.credentials && code !== 1000) {
+          log.info('Attempting auto-reconnect in 3s...');
+          setTimeout(() => this._autoReconnect(), 3000);
+        }
+      });
 
       return new Promise((resolve) => {
         const timeout = setTimeout(() => {
@@ -163,6 +175,13 @@ class RithmicService extends EventEmitter {
 
       await this.pnlConn.connect(config);
       this.pnlConn.on('message', createPnLHandler(this));
+      
+      // Auto-reconnect PnL on disconnect
+      this.pnlConn.on('disconnected', ({ code }) => {
+        if (this.credentials && code !== 1000) {
+          setTimeout(() => this.connectPnL(this.credentials.username, this.credentials.password), 3000);
+        }
+      });
 
       return new Promise((resolve) => {
         const timeout = setTimeout(() => resolve(false), TIMEOUTS.RITHMIC_PNL);
@@ -200,6 +219,13 @@ class RithmicService extends EventEmitter {
       };
 
       await this.tickerConn.connect(config);
+      
+      // Auto-reconnect Ticker on disconnect
+      this.tickerConn.on('disconnected', ({ code }) => {
+        if (this.credentials && code !== 1000) {
+          setTimeout(() => this.connectTicker(this.credentials.username, this.credentials.password), 3000);
+        }
+      });
 
       return new Promise((resolve) => {
         const timeout = setTimeout(() => {
@@ -383,9 +409,42 @@ class RithmicService extends EventEmitter {
     return { isOpen: true, message: 'Market is open' };
   }
 
+  // ==================== AUTO-RECONNECT ====================
+
+  async _autoReconnect() {
+    if (!this.credentials) {
+      log.warn('Cannot auto-reconnect: no credentials');
+      return;
+    }
+    
+    const { username, password } = this.credentials;
+    log.info('Auto-reconnecting...');
+    this.emit('reconnecting');
+    
+    try {
+      const result = await this.login(username, password);
+      if (result.success) {
+        log.info('Auto-reconnect successful');
+        this.emit('reconnected', { accounts: result.accounts });
+      } else {
+        log.warn('Auto-reconnect failed', { error: result.error });
+        this.emit('reconnectFailed', { error: result.error });
+        // Retry in 10s
+        setTimeout(() => this._autoReconnect(), 10000);
+      }
+    } catch (err) {
+      log.error('Auto-reconnect error', { error: err.message });
+      this.emit('reconnectFailed', { error: err.message });
+      // Retry in 10s
+      setTimeout(() => this._autoReconnect(), 10000);
+    }
+  }
+
   // ==================== CLEANUP ====================
 
   async disconnect() {
+    // Clear credentials to prevent auto-reconnect on manual disconnect
+    this.credentials = null;
     const connections = [this.orderConn, this.pnlConn, this.tickerConn];
     
     for (const conn of connections) {