hedgequantx 2.6.59 → 2.6.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.6.59",
+  "version": "2.6.61",
   "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/copy-trading.js

@@ -877,12 +877,14 @@ const launchCopyTrading = async (config) => {
     platform: lead.type === 'rithmic' ? 'Rithmic' : 'ProjectX',
     startTime: Date.now(),
     aiSupervision: false,
-    aiMode: null
+    aiMode: null,
+    agentCount: 0          // Number of AI agents active
   };
 
   // Initialize AI Supervisor - only if user enabled it
   if (enableAI) {
     const aiAgents = aiService.getAgents();
+    stats.agentCount = aiAgents.length;
     if (aiAgents.length > 0) {
       const supervisorResult = StrategySupervisor.initialize(null, aiAgents, lead.service, lead.account.accountId);
       stats.aiSupervision = supervisorResult.success;

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

@@ -269,6 +269,7 @@ const launchAlgo = async (service, account, contract, config) => {
     startTime: Date.now(),
     aiSupervision: false,
     aiMode: null,
+    agentCount: 0,         // Number of AI agents active
     // Fast path stats
     fastPath: useFastPath,
     avgEntryLatency: 0,
@@ -356,6 +357,10 @@ const launchAlgo = async (service, account, contract, config) => {
       algoLogger.info(ui, 'READY', `Hold complete - monitoring exit`);
     });
     
+    positionManager.on('breakevenActivated', ({ orderTag, position, breakevenPrice, pnlTicks }) => {
+      algoLogger.info(ui, 'BE', `Breakeven activated @ ${breakevenPrice} | +${pnlTicks} ticks`);
+    });
+    
     positionManager.on('exitOrderFired', ({ orderTag, exitReason, latencyMs }) => {
       // Don't log here - exitFilled will log the result
     });
@@ -450,6 +455,7 @@ const launchAlgo = async (service, account, contract, config) => {
   if (config.enableAI) {
     const aiAgents = aiService.getAgents();
     aiAgentCount = aiAgents.length;
+    stats.agentCount = aiAgentCount;
     if (aiAgents.length > 0) {
       const supervisorResult = StrategySupervisor.initialize(strategy, aiAgents, service, account.accountId);
       stats.aiSupervision = supervisorResult.success;

package/src/pages/algo/ui.js

@@ -239,6 +239,18 @@ class AlgoUI {
     const r4c2 = buildCell('PROPFIRM', stats.propfirm || 'N/A', chalk.cyan, colR);
     row(r4c1t + pad(colL - r4c1p.length), r4c2.padded);
     
+    this._line(chalk.cyan(GM));
+    
+    // Row 5: Connection | Agents
+    const connectionType = stats.platform || stats.connection || 'N/A';
+    const connectionColor = connectionType.toLowerCase().includes('rithmic') ? chalk.green : chalk.yellow;
+    const agentCount = stats.agentCount || 0;
+    const agentStr = agentCount > 0 ? `${agentCount} agent${agentCount > 1 ? 's' : ''} active` : 'None';
+    const agentColor = agentCount > 0 ? chalk.green : chalk.gray;
+    const r5c1 = buildCell('CONNECTION', connectionType, connectionColor, colL);
+    const r5c2 = buildCell('AGENTS', agentStr, agentColor, colR);
+    row(r5c1.padded, r5c2.padded);
+    
     this._line(chalk.cyan(GB));
   }
 

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) {