hedgequantx 2.6.58 → 2.6.59

package/package.json

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

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

@@ -315,68 +315,53 @@ const launchAlgo = async (service, account, contract, config) => {
     
     positionManager.start();
     
-    // Listen for position manager events
+    // Listen for position manager events - CLEAN LOGS (no verbose order status)
     positionManager.on('entryFilled', ({ orderTag, position, fillLatencyMs }) => {
       stats.entryLatencies.push(fillLatencyMs);
       stats.avgFillLatency = stats.entryLatencies.reduce((a, b) => a + b, 0) / stats.entryLatencies.length;
-      algoLogger.info(ui, 'FAST FILL', `${fillLatencyMs}ms | avg=${stats.avgFillLatency.toFixed(1)}ms`);
+      const side = position.side === 0 ? 'LONG' : 'SHORT';
+      algoLogger.info(ui, 'FILLED', `${side} ${position.size}x ${symbolName} @ ${position.entryPrice} | ${fillLatencyMs}ms`);
     });
     
     positionManager.on('exitFilled', ({ orderTag, exitPrice, pnlTicks, holdDurationMs }) => {
+      const holdSec = (holdDurationMs / 1000).toFixed(1);
       // Calculate PnL in dollars only if tickValue is available from API
       if (pnlTicks !== null && tickValue !== null) {
         const pnlDollars = pnlTicks * tickValue;
         stats.sessionPnl += pnlDollars; // Track session P&L
         if (pnlDollars >= 0) {
           stats.wins++;
-          algoLogger.targetHit(ui, symbolName, exitPrice, pnlDollars);
+          algoLogger.info(ui, 'WIN', `+$${pnlDollars.toFixed(2)} @ ${exitPrice} | ${holdSec}s`);
         } else {
           stats.losses++;
-          algoLogger.stopHit(ui, symbolName, exitPrice, Math.abs(pnlDollars));
+          algoLogger.info(ui, 'LOSS', `-$${Math.abs(pnlDollars).toFixed(2)} @ ${exitPrice} | ${holdSec}s`);
         }
       } else {
         // Log with ticks only if tickValue unavailable
         if (pnlTicks !== null && pnlTicks >= 0) {
           stats.wins++;
-          algoLogger.info(ui, 'TARGET', `+${pnlTicks} ticks`);
+          algoLogger.info(ui, 'WIN', `+${pnlTicks} ticks | ${holdSec}s`);
         } else if (pnlTicks !== null) {
           stats.losses++;
-          algoLogger.info(ui, 'STOP', `${pnlTicks} ticks`);
+          algoLogger.info(ui, 'LOSS', `${pnlTicks} ticks | ${holdSec}s`);
         }
       }
       stats.trades++;
       currentPosition = 0;
       stats.position = 0; // Reset UI position display
       pendingOrder = false;
-      algoLogger.info(ui, 'HOLD TIME', `${(holdDurationMs / 1000).toFixed(1)}s`);
     });
     
     positionManager.on('holdComplete', ({ orderTag, position }) => {
-      algoLogger.info(ui, 'HOLD COMPLETE', `${FAST_SCALPING.MIN_HOLD_MS / 1000}s minimum reached`);
+      algoLogger.info(ui, 'READY', `Hold complete - monitoring exit`);
     });
     
     positionManager.on('exitOrderFired', ({ orderTag, exitReason, latencyMs }) => {
-      algoLogger.info(ui, 'EXIT FIRED', `${exitReason.reason} | ${latencyMs.toFixed(1)}ms`);
+      // Don't log here - exitFilled will log the result
     });
     
-    // DEBUG: Listen for raw order notifications from Rithmic
-    service.on('orderAccepted', (data) => {
-      algoLogger.info(ui, 'ORDER ACCEPTED', `tag=${data.orderTag} basket=${data.basketId}`);
-    });
-    
-    service.on('orderNotification', (data) => {
-      const status = data.status || 'unknown';
-      const fillQty = data.fillQuantity || data.totalFillQuantity || 0;
-      if (fillQty > 0) {
-        algoLogger.info(ui, 'ORDER FILL', `tag=${data.orderTag} qty=${fillQty} @ ${data.avgFillPrice}`);
-      } else {
-        algoLogger.info(ui, 'ORDER STATUS', `tag=${data.orderTag} status=${status}`);
-      }
-    });
-    
-    service.on('orderFilled', (data) => {
-      algoLogger.info(ui, 'FILL CONFIRMED', `${data.transactionType === 1 ? 'BUY' : 'SELL'} ${data.fillQuantity}x @ ${data.avgFillPrice}`);
-    });
+    // NOTE: Removed verbose DEBUG logs (ORDER ACCEPTED, ORDER STATUS, ORDER FILL, FILL CONFIRMED)
+    // Entry/Exit fills are logged by positionManager events (entryFilled, exitFilled)
   }
   
   // ═══════════════════════════════════════════════════════════════════════════
@@ -539,11 +524,11 @@ const launchAlgo = async (service, account, contract, config) => {
     }
     
     const riskPct = Math.round((riskAmount / maxRisk) * 100);
-    algoLogger.positionSized(ui, contracts, kelly, riskAmount, riskPct);
     
     // Place order via API
     pendingOrder = true;
     const orderSide = direction === 'long' ? 0 : 1; // 0=Buy, 1=Sell
+    const sideStr = direction === 'long' ? 'LONG' : 'SHORT';
     
     try {
       // ═══════════════════════════════════════════════════════════════
@@ -559,49 +544,29 @@ const launchAlgo = async (service, account, contract, config) => {
         };
         
         // CRITICAL: Use rithmicAccountId (original) not accountId (hash) for Rithmic orders
-        // The accountId field is hashed for display, but Rithmic API needs the original
         if (account.rithmicAccountId) {
           orderData.accountId = account.rithmicAccountId;
         }
         
-        // Log order details before sending
-        algoLogger.info(ui, 'ORDER DATA', `acct=${orderData.accountId} sym=${orderData.symbol} side=${orderData.side} qty=${orderData.size}`);
+        // Log entry attempt (single line)
+        algoLogger.info(ui, 'ENTRY', `${sideStr} ${contracts}x ${symbolName} | risk: $${riskAmount} (${riskPct}%)`);
         
         // Fire-and-forget entry (no await on fill)
         const entryResult = service.fastEntry(orderData);
         
-        // Log the order tag for tracking
-        algoLogger.info(ui, 'ORDER TAG', `${entryResult.orderTag} | success=${entryResult.success}`);
-        
         if (entryResult.success) {
           // Register with position manager for lifecycle tracking
-          // Pass contract info from API (NOT hardcoded)
-          const contractInfo = {
-            tickSize,
-            tickValue,
-            contractId,
-          };
+          const contractInfo = { tickSize, tickValue, contractId };
           positionManager.registerEntry(entryResult, orderData, contractInfo);
           
           currentPosition = direction === 'long' ? contracts : -contracts;
-          const sideStr = direction === 'long' ? 'BUY' : 'SELL';
-          
-          // Log with latency
-          const latencyColor = entryResult.latencyMs < FAST_SCALPING.LATENCY_TARGET_MS 
-            ? chalk.green 
-            : entryResult.latencyMs < FAST_SCALPING.LATENCY_WARN_MS 
-              ? chalk.yellow 
-              : chalk.red;
           
+          // Update avg entry latency
           stats.avgEntryLatency = stats.entryLatencies.length > 0 
             ? (stats.avgEntryLatency * stats.entryLatencies.length + entryResult.latencyMs) / (stats.entryLatencies.length + 1)
             : entryResult.latencyMs;
           
-          algoLogger.info(ui, 'FAST ENTRY', `${sideStr} ${contracts}x ${symbolName} | ${latencyColor(entryResult.latencyMs.toFixed(2) + 'ms')}`);
-          algoLogger.info(ui, 'HOLD START', `Min ${FAST_SCALPING.MIN_HOLD_MS / 1000}s before exit`);
-          
-          // Note: NO bracket orders in fast path
-          // PositionManager handles exit logic after 10s hold
+          // Note: Fill confirmation logged by positionManager.on('entryFilled')
           
         } else {
           algoLogger.orderRejected(ui, symbolName, entryResult.error || 'Fast entry failed');