hedgequantx 2.6.58 → 2.6.60

package/package.json

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

package/src/config/settings.js

@@ -143,11 +143,15 @@ const FAST_SCALPING = {
   MAX_HOLD_MS: 60000,           // 60 seconds failsafe (force exit if stuck)
   
   // Exit targets (in ticks) - defaults, override per symbol
-  TARGET_TICKS: 16,             // Take profit target
-  STOP_TICKS: 20,               // Stop loss
+  TARGET_TICKS: 16,             // Take profit target (+$80 on NQ)
+  STOP_TICKS: 20,               // Stop loss (-$100 on NQ)
+  
+  // Breakeven (BE) - move SL to entry price after profit threshold
+  BREAKEVEN_ACTIVATION_TICKS: 6, // Activate BE after +6 ticks profit (+$30 on NQ)
+  BREAKEVEN_OFFSET_TICKS: 1,     // BE at entry + 1 tick (small profit lock)
   
   // Trailing stop (activates after MIN_HOLD + profit threshold)
-  TRAILING_ACTIVATION_TICKS: 8, // Start trailing after +8 ticks profit
+  TRAILING_ACTIVATION_TICKS: 8, // Start trailing after +8 ticks profit (+$40 on NQ)
   TRAILING_DISTANCE_TICKS: 4,   // Trail 4 ticks behind high/low
   
   // Position monitoring

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

@@ -315,68 +315,57 @@ 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`);
-    });
-    
-    // DEBUG: Listen for raw order notifications from Rithmic
-    service.on('orderAccepted', (data) => {
-      algoLogger.info(ui, 'ORDER ACCEPTED', `tag=${data.orderTag} basket=${data.basketId}`);
+    positionManager.on('breakevenActivated', ({ orderTag, position, breakevenPrice, pnlTicks }) => {
+      algoLogger.info(ui, 'BE', `Breakeven activated @ ${breakevenPrice} | +${pnlTicks} ticks`);
     });
     
-    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}`);
-      }
+    positionManager.on('exitOrderFired', ({ orderTag, exitReason, latencyMs }) => {
+      // Don't log here - exitFilled will log the result
     });
     
-    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 +528,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 +548,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');

package/src/services/position-manager.js

@@ -58,6 +58,8 @@ const WEIGHTS = {
  * @property {number} lowWaterMark - Lowest price since entry (for trailing)
  * @property {string} status - 'pending' | 'active' | 'holding' | 'exiting' | 'closed'
  * @property {boolean} holdComplete - True after MIN_HOLD_MS elapsed
+ * @property {boolean} breakevenActive - True after BE threshold reached
+ * @property {number|null} breakevenPrice - Price at which BE stop is set
  * @property {Object|null} exitReason - Why position was exited
  * @property {number} tickSize - Tick size from API
  * @property {number} tickValue - Tick value from API
@@ -214,6 +216,8 @@ class PositionManager extends EventEmitter {
       lowWaterMark: null,
       status: 'pending', // Waiting for fill confirmation
       holdComplete: false,
+      breakevenActive: false, // BE not yet activated
+      breakevenPrice: null,   // Will be set when BE activates
       exitReason: null,
       latencyMs,
       // Contract info from API (NOT hardcoded)
@@ -483,18 +487,64 @@ class PositionManager extends EventEmitter {
       return { type: 'target', reason: 'Target reached', pnlTicks };
     }
     
-    // 2. STOP HIT - Always exit at stop
-    if (pnlTicks <= -stopTicks) {
+    // 2. BREAKEVEN CHECK - If BE is active, use BE price as stop
+    if (position.breakevenActive && position.breakevenPrice !== null) {
+      const tickSize = this._getTickSize(position);
+      if (tickSize) {
+        // Check if price hit breakeven stop
+        if (position.side === 0) { // Long
+          if (currentPrice <= position.breakevenPrice) {
+            return { type: 'breakeven', reason: 'Breakeven stop hit', pnlTicks };
+          }
+        } else { // Short
+          if (currentPrice >= position.breakevenPrice) {
+            return { type: 'breakeven', reason: 'Breakeven stop hit', pnlTicks };
+          }
+        }
+      }
+    }
+    
+    // 3. STOP HIT - Only if BE not active (original stop)
+    if (!position.breakevenActive && pnlTicks <= -stopTicks) {
       return { type: 'stop', reason: 'Stop loss hit', pnlTicks };
     }
     
-    // 3. VPIN DANGER - Informed traders detected (from strategy)
+    // 4. ACTIVATE BREAKEVEN - Move stop to entry after profit threshold
+    if (!position.breakevenActive && pnlTicks >= FAST_SCALPING.BREAKEVEN_ACTIVATION_TICKS) {
+      const tickSize = this._getTickSize(position);
+      if (tickSize && position.entryPrice) {
+        // Set BE price at entry + offset (small profit lock)
+        const offset = FAST_SCALPING.BREAKEVEN_OFFSET_TICKS * tickSize;
+        if (position.side === 0) { // Long
+          position.breakevenPrice = position.entryPrice + offset;
+        } else { // Short
+          position.breakevenPrice = position.entryPrice - offset;
+        }
+        position.breakevenActive = true;
+        
+        log.info('BREAKEVEN ACTIVATED', {
+          symbol: position.symbol,
+          entryPrice: position.entryPrice,
+          bePrice: position.breakevenPrice,
+          pnlTicks,
+        });
+        
+        this.emit('breakevenActivated', {
+          orderTag: position.orderTag,
+          position,
+          breakevenPrice: position.breakevenPrice,
+          pnlTicks,
+        });
+      }
+    }
+    
+    // 5. VPIN DANGER - Informed traders detected (from strategy)
     const vpin = this._getVPIN(position);
     if (vpin !== null && vpin > MOMENTUM.VPIN_DANGER) {
       return { type: 'vpin', reason: `VPIN spike ${(vpin * 100).toFixed(0)}% - informed traders`, pnlTicks, vpin };
     }
     
-    // 4. TRAILING STOP (only if in profit above threshold)
+    // 6. TRAILING STOP (only if in profit above threshold)
     if (pnlTicks >= FAST_SCALPING.TRAILING_ACTIVATION_TICKS) {
       const trailingPnl = this._calculateTrailingPnl(position, currentPrice);
       if (trailingPnl !== null && trailingPnl <= -FAST_SCALPING.TRAILING_DISTANCE_TICKS) {
@@ -502,7 +552,7 @@ class PositionManager extends EventEmitter {
       }
     }
     
-    // 5. MOMENTUM-BASED EXIT (using strategy's math models)
+    // 7. MOMENTUM-BASED EXIT (using strategy's math models)
     const momentum = this._calculateMomentum(position);
     
     if (momentum !== null) {