hedgequantx 2.6.161 → 2.6.163

package/src/services/position-manager.js

@@ -9,112 +9,44 @@
  * - 60 second failsafe exit (NON-NEGOTIABLE)
  * - VPIN protection filter
  * 
- * USES EXISTING MATH MODELS from HQX Ultra Scalping Strategy:
- * - OFI (Order Flow Imbalance)
- * - Kalman Filter with velocity tracking
- * - Z-Score Mean Reversion
- * - VPIN for toxicity detection
- * 
  * Data source: Rithmic ORDER_PLANT (fills), PNL_PLANT (positions), TICKER_PLANT (prices)
  */
 
 const EventEmitter = require('events');
-const { performance } = require('perf_hooks');
 const { FAST_SCALPING } = require('../config/settings');
 const { logger } = require('../utils/logger');
+const { MOMENTUM, WEIGHTS } = require('./position-constants');
+const { checkExitConditions, checkBreakevenActivation, calculatePnlTicks } = require('./position-exit-logic');
 
 const log = logger.scope('PositionMgr');
 
-// =============================================================================
-// MOMENTUM THRESHOLDS (from analysis)
-// =============================================================================
-const MOMENTUM = {
-  STRONG_FAVORABLE: 0.5,   // momentum > 0.5 + profit → HOLD
-  WEAK_THRESHOLD: 0.2,     // momentum < 0.2 + profit → EXIT with profit
-  ADVERSE_THRESHOLD: -0.3, // momentum < -0.3 → EXIT immediately
-  VPIN_DANGER: 0.7,        // VPIN > 0.7 → informed traders = EXIT
-};
-
-// Momentum weights
-const WEIGHTS = {
-  OFI: 0.50,      // Order Flow Imbalance - 50%
-  KALMAN: 0.25,   // Kalman Velocity - 25%
-  ZSCORE: 0.25,   // Z-Score progression - 25%
-};
-
-/**
- * Position state for tracking
- * @typedef {Object} ManagedPosition
- * @property {string} orderTag - Entry order correlation ID
- * @property {string} accountId - Account ID
- * @property {string} symbol - Trading symbol (e.g., NQH5)
- * @property {string} exchange - Exchange (e.g., CME)
- * @property {number} side - 0=Long, 1=Short
- * @property {number} size - Position size
- * @property {number} entryPrice - Average fill price
- * @property {number} entryTime - Entry timestamp (ms)
- * @property {number} fillTime - When fill was confirmed (ms)
- * @property {number} highWaterMark - Highest price since entry (for trailing)
- * @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
- * @property {string} contractId - Contract ID for strategy lookups
- */
-
 /**
  * Position Manager Service
  * Handles position lifecycle for fast scalping strategy
  */
 class PositionManager extends EventEmitter {
-  /**
-   * @param {RithmicService} rithmicService - Connected Rithmic service
-   * @param {Object} strategy - HQX Ultra Scalping strategy instance (M1)
-   */
   constructor(rithmicService, strategy = null) {
     super();
     this.rithmic = rithmicService;
-    this.strategy = strategy; // Reference to HQX Ultra Scalping strategy
+    this.strategy = strategy;
     
-    /** @type {Map<string, ManagedPosition>} orderTag -> position */
     this.positions = new Map();
-    
-    /** @type {Map<string, number>} symbol -> latest price */
     this.latestPrices = new Map();
-    
-    /** @type {Map<string, Object>} symbol -> contract info (tickSize, tickValue) */
     this.contractInfo = new Map();
     
-    /** @type {NodeJS.Timer|null} */
     this._monitorInterval = null;
-    
-    /** @type {boolean} */
     this._isRunning = false;
     
-    // Bind event handlers
     this._onOrderFilled = this._onOrderFilled.bind(this);
     this._onPriceUpdate = this._onPriceUpdate.bind(this);
     this._onPositionUpdate = this._onPositionUpdate.bind(this);
   }
 
-  /**
-   * Set the strategy reference (for accessing math models)
-   * @param {Object} strategy - HQX Ultra Scalping strategy instance
-   */
   setStrategy(strategy) {
     this.strategy = strategy;
     log.debug('Strategy reference set');
   }
 
-  /**
-   * Set contract info from API (tick size, tick value)
-   * @param {string} symbol - Trading symbol
-   * @param {Object} info - { tickSize, tickValue, contractId }
-   */
   setContractInfo(symbol, info) {
     this.contractInfo.set(symbol, {
       tickSize: info.tickSize,
@@ -124,10 +56,6 @@ class PositionManager extends EventEmitter {
     log.debug('Contract info set', { symbol, tickSize: info.tickSize, tickValue: info.tickValue });
   }
 
-  /**
-   * Start the position manager
-   * Attaches to Rithmic service events
-   */
   start() {
     if (this._isRunning) return;
     
@@ -139,12 +67,10 @@ class PositionManager extends EventEmitter {
       momentumWeights: WEIGHTS,
     });
     
-    // Subscribe to Rithmic events
     this.rithmic.on('orderFilled', this._onOrderFilled);
     this.rithmic.on('priceUpdate', this._onPriceUpdate);
     this.rithmic.on('positionUpdate', this._onPositionUpdate);
     
-    // Start monitoring loop
     this._monitorInterval = setInterval(() => {
       this._monitorPositions();
     }, FAST_SCALPING.MONITOR_INTERVAL_MS);
@@ -153,21 +79,15 @@ class PositionManager extends EventEmitter {
     log.debug('Position manager started');
   }
 
-  /**
-   * Stop the position manager
-   * Removes event listeners and stops monitoring
-   */
   stop() {
     if (!this._isRunning) return;
     
     log.info('Stopping position manager');
     
-    // Remove event listeners
     this.rithmic.off('orderFilled', this._onOrderFilled);
     this.rithmic.off('priceUpdate', this._onPriceUpdate);
     this.rithmic.off('positionUpdate', this._onPositionUpdate);
     
-    // Stop monitoring
     if (this._monitorInterval) {
       clearInterval(this._monitorInterval);
       this._monitorInterval = null;
@@ -177,15 +97,6 @@ class PositionManager extends EventEmitter {
     log.debug('Position manager stopped');
   }
 
-  /**
-   * Register a new entry order
-   * Called immediately after fastEntry() to track the position
-   * 
-   * @param {Object} entryResult - Result from fastEntry()
-   * @param {Object} orderData - Original order data
-   * @param {Object} contractInfo - { tickSize, tickValue, contractId } from API
-   * @returns {string} orderTag for tracking
-   */
   registerEntry(entryResult, orderData, contractInfo = null) {
     if (!entryResult.success) {
       log.warn('Cannot register failed entry', { error: entryResult.error });
@@ -194,33 +105,30 @@ class PositionManager extends EventEmitter {
     
     const { orderTag, entryTime, latencyMs } = entryResult;
     
-    // Get contract info from cache or parameter
     const info = contractInfo || this.contractInfo.get(orderData.symbol) || {
       tickSize: null,
       tickValue: null,
       contractId: orderData.contractId || orderData.symbol,
     };
     
-    /** @type {ManagedPosition} */
     const position = {
       orderTag,
       accountId: orderData.accountId,
       symbol: orderData.symbol,
       exchange: orderData.exchange || 'CME',
-      side: orderData.side, // 0=Long, 1=Short
+      side: orderData.side,
       size: orderData.size,
-      entryPrice: null, // Will be filled from order notification (async)
+      entryPrice: null,
       entryTime,
       fillTime: null,
       highWaterMark: null,
       lowWaterMark: null,
-      status: 'pending', // Waiting for fill confirmation
+      status: 'pending',
       holdComplete: false,
-      breakevenActive: false, // BE not yet activated
-      breakevenPrice: null,   // Will be set when BE activates
+      breakevenActive: false,
+      breakevenPrice: null,
       exitReason: null,
       latencyMs,
-      // Contract info from API (NOT hardcoded)
       tickSize: info.tickSize,
       tickValue: info.tickValue,
       contractId: info.contractId,
@@ -240,45 +148,17 @@ class PositionManager extends EventEmitter {
     return orderTag;
   }
 
-  /**
-   * Handle order fill notification from Rithmic (templateId: 351)
-   * This is ASYNC - does not block fastEntry()
-   * @private
-   */
   _onOrderFilled(fillInfo) {
-    const { orderTag, avgFillPrice, totalFillQuantity, symbol, transactionType, localTimestamp } = fillInfo;
+    const { orderTag, avgFillPrice, symbol } = fillInfo;
     
     if (!orderTag) return;
     
     const position = this.positions.get(orderTag);
     if (!position) {
-      // Could be an exit order fill - check if any position is exiting
+      // Check if this is an exit fill
       for (const [tag, pos] of this.positions) {
         if (pos.status === 'exiting' && pos.symbol === symbol) {
-          // This is likely our exit fill
-          pos.status = 'closed';
-          const holdDuration = Date.now() - pos.fillTime;
-          const pnlTicks = this._calculatePnlTicks(pos, avgFillPrice);
-          
-          log.info('EXIT FILLED', {
-            orderTag: tag,
-            symbol,
-            exitPrice: avgFillPrice,
-            entryPrice: pos.entryPrice,
-            pnlTicks,
-            holdDurationMs: holdDuration,
-            reason: pos.exitReason,
-          });
-          
-          this.emit('exitFilled', {
-            orderTag: tag,
-            position: pos,
-            exitPrice: avgFillPrice,
-            pnlTicks,
-            holdDurationMs: holdDuration,
-          });
-          
-          this.positions.delete(tag);
+          this._handleExitFill(tag, pos, avgFillPrice);
           return;
         }
       }
@@ -287,90 +167,72 @@ class PositionManager extends EventEmitter {
     }
     
     if (position.status === 'pending') {
-      // Entry fill confirmed - UPDATE with real fill price
-      position.entryPrice = avgFillPrice;
-      position.fillTime = Date.now();
-      position.highWaterMark = avgFillPrice;
-      position.lowWaterMark = avgFillPrice;
-      position.status = 'holding'; // Now in holding period
-      
-      const fillLatency = position.fillTime - position.entryTime;
-      
-      log.info('ENTRY FILLED', {
-        orderTag,
-        symbol,
-        side: position.side === 0 ? 'LONG' : 'SHORT',
-        size: position.size,
-        price: avgFillPrice,
-        entryLatencyMs: position.latencyMs,
-        fillLatencyMs: fillLatency,
-      });
-      
-      this.emit('entryFilled', {
-        orderTag,
-        position,
-        fillLatencyMs: fillLatency,
-      });
-      
-      // Schedule hold completion check
-      setTimeout(() => {
-        this._onHoldComplete(orderTag);
-      }, FAST_SCALPING.MIN_HOLD_MS);
-      
-      // Schedule 60s failsafe (NON-NEGOTIABLE)
-      setTimeout(() => {
-        this._failsafeExit(orderTag);
-      }, FAST_SCALPING.MAX_HOLD_MS);
-      
+      this._handleEntryFill(orderTag, position, avgFillPrice);
     } else if (position.status === 'exiting') {
-      // Exit fill confirmed
-      position.status = 'closed';
-      
-      const holdDuration = Date.now() - position.fillTime;
-      const pnlTicks = this._calculatePnlTicks(position, avgFillPrice);
-      
-      log.info('EXIT FILLED', {
-        orderTag,
-        symbol,
-        exitPrice: avgFillPrice,
-        entryPrice: position.entryPrice,
-        pnlTicks,
-        holdDurationMs: holdDuration,
-        reason: position.exitReason,
-      });
-      
-      this.emit('exitFilled', {
-        orderTag,
-        position,
-        exitPrice: avgFillPrice,
-        pnlTicks,
-        holdDurationMs: holdDuration,
-      });
-      
-      // Clean up
-      this.positions.delete(orderTag);
+      this._handleExitFill(orderTag, position, avgFillPrice);
     }
   }
 
-  /**
-   * 60 second failsafe exit (NON-NEGOTIABLE)
-   * Forces market exit if position still open
-   * @private
-   */
+  _handleEntryFill(orderTag, position, avgFillPrice) {
+    position.entryPrice = avgFillPrice;
+    position.fillTime = Date.now();
+    position.highWaterMark = avgFillPrice;
+    position.lowWaterMark = avgFillPrice;
+    position.status = 'holding';
+    
+    const fillLatency = position.fillTime - position.entryTime;
+    
+    log.info('ENTRY FILLED', {
+      orderTag,
+      symbol: position.symbol,
+      side: position.side === 0 ? 'LONG' : 'SHORT',
+      size: position.size,
+      price: avgFillPrice,
+      entryLatencyMs: position.latencyMs,
+      fillLatencyMs: fillLatency,
+    });
+    
+    this.emit('entryFilled', { orderTag, position, fillLatencyMs: fillLatency });
+    
+    setTimeout(() => this._onHoldComplete(orderTag), FAST_SCALPING.MIN_HOLD_MS);
+    setTimeout(() => this._failsafeExit(orderTag), FAST_SCALPING.MAX_HOLD_MS);
+  }
+
+  _handleExitFill(orderTag, position, avgFillPrice) {
+    position.status = 'closed';
+    const holdDuration = Date.now() - position.fillTime;
+    const pnlTicks = this._calculatePnlTicks(position, avgFillPrice);
+    
+    log.info('EXIT FILLED', {
+      orderTag,
+      symbol: position.symbol,
+      exitPrice: avgFillPrice,
+      entryPrice: position.entryPrice,
+      pnlTicks,
+      holdDurationMs: holdDuration,
+      reason: position.exitReason,
+    });
+    
+    this.emit('exitFilled', {
+      orderTag,
+      position,
+      exitPrice: avgFillPrice,
+      pnlTicks,
+      holdDurationMs: holdDuration,
+    });
+    
+    this.positions.delete(orderTag);
+  }
+
   _failsafeExit(orderTag) {
     const position = this.positions.get(orderTag);
     if (!position) return;
     
-    // Only force exit if still active (not already exiting/closed)
     if (position.status === 'holding' || position.status === 'active') {
       const currentPrice = this.latestPrices.get(position.symbol);
       const pnlTicks = currentPrice ? this._calculatePnlTicks(position, currentPrice) : 0;
       
-      log.warn('FAILSAFE EXIT - 60s max hold exceeded', {
-        orderTag,
-        symbol: position.symbol,
-        pnlTicks,
-      });
+      log.warn('FAILSAFE EXIT - 60s max hold exceeded', { orderTag, symbol: position.symbol, pnlTicks });
       
       this._executeExit(orderTag, {
         type: 'failsafe',
@@ -380,49 +242,33 @@ class PositionManager extends EventEmitter {
     }
   }
 
-  /**
-   * Handle price update from market data
-   * @private
-   */
   _onPriceUpdate(priceData) {
-    const { symbol, price, timestamp } = priceData;
+    const { symbol, price } = priceData;
     
     this.latestPrices.set(symbol, price);
     
-    // Update high/low water marks for active positions
-    for (const [orderTag, position] of this.positions) {
+    for (const [, position] of this.positions) {
       if (position.symbol === symbol && (position.status === 'holding' || position.status === 'active') && position.entryPrice) {
-        if (position.side === 0) { // Long
+        if (position.side === 0) {
           position.highWaterMark = Math.max(position.highWaterMark, price);
-        } else { // Short
+        } else {
           position.lowWaterMark = Math.min(position.lowWaterMark, price);
         }
       }
     }
   }
 
-  /**
-   * Handle position update from PNL_PLANT
-   * @private
-   */
   _onPositionUpdate(posData) {
-    log.debug('Position update from PNL_PLANT', {
-      symbol: posData?.symbol,
-      qty: posData?.quantity,
-    });
+    log.debug('Position update from PNL_PLANT', { symbol: posData?.symbol, qty: posData?.quantity });
   }
 
-  /**
-   * Called when minimum hold period is complete
-   * @private
-   */
   _onHoldComplete(orderTag) {
     const position = this.positions.get(orderTag);
     if (!position) return;
     
     if (position.status === 'holding') {
       position.holdComplete = true;
-      position.status = 'active'; // Now eligible for exit
+      position.status = 'active';
       
       log.info('Hold complete - now monitoring for exit', {
         orderTag,
@@ -434,15 +280,10 @@ class PositionManager extends EventEmitter {
     }
   }
 
-  /**
-   * Main monitoring loop - runs every MONITOR_INTERVAL_MS
-   * @private
-   */
   _monitorPositions() {
     const now = Date.now();
     
     for (const [orderTag, position] of this.positions) {
-      // Skip if not ready to exit
       if (position.status !== 'active') continue;
       
       const currentPrice = this.latestPrices.get(position.symbol);
@@ -451,75 +292,10 @@ class PositionManager extends EventEmitter {
       const holdDuration = now - position.fillTime;
       const pnlTicks = this._calculatePnlTicks(position, currentPrice);
       
-      // Check exit conditions
-      const exitReason = this._checkExitConditions(position, currentPrice, pnlTicks, holdDuration);
-      
-      if (exitReason) {
-        this._executeExit(orderTag, exitReason);
-      }
-    }
-  }
-
-  /**
-   * Check if position should be exited
-   * Uses momentum calculation with OFI/Kalman/Z-Score from strategy
-   * 
-   * Data sources:
-   * - pnlTicks: Calculated from entryPrice (Rithmic fill) and currentPrice (market data)
-   * - VPIN: Strategy's computeVPIN()
-   * - Momentum: Strategy's OFI, Kalman, Z-Score
-   * 
-   * @private
-   * @returns {Object|null} Exit reason or null
-   */
-  _checkExitConditions(position, currentPrice, pnlTicks, holdDuration) {
-    // Cannot evaluate exit conditions without PnL data
-    if (pnlTicks === null) {
-      log.debug('Cannot check exit - no PnL data', { symbol: position.symbol });
-      return null;
-    }
-    
-    const targetTicks = FAST_SCALPING.TARGET_TICKS;
-    const stopTicks = FAST_SCALPING.STOP_TICKS;
-    
-    // 1. TARGET HIT - Always exit at target
-    if (pnlTicks >= targetTicks) {
-      return { type: 'target', reason: 'Target reached', pnlTicks };
-    }
-    
-    // 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 };
-    }
-    
-    // 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;
-        }
+      // Check for breakeven activation
+      const beActivation = checkBreakevenActivation(position, pnlTicks, (p) => this._getTickSize(p));
+      if (beActivation) {
+        position.breakevenPrice = beActivation.breakevenPrice;
         position.breakevenActive = true;
         
         log.info('BREAKEVEN ACTIVATED', {
@@ -536,250 +312,24 @@ class PositionManager extends EventEmitter {
           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 };
-    }
-    
-    // 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) {
-        return { type: 'trailing', reason: 'Trailing stop triggered', pnlTicks, trailingPnl };
-      }
-    }
-    
-    // 7. MOMENTUM-BASED EXIT (using strategy's math models)
-    const momentum = this._calculateMomentum(position);
-    
-    if (momentum !== null) {
-      // Strong favorable momentum + profit → HOLD (let it run)
-      if (momentum > MOMENTUM.STRONG_FAVORABLE && pnlTicks > 4) {
-        // Don't exit - momentum is strong in our favor
-        return null;
-      }
       
-      // Weak momentum + profit → EXIT (secure profit)
-      if (momentum < MOMENTUM.WEAK_THRESHOLD && pnlTicks > 0) {
-        return { type: 'momentum_weak', reason: 'Weak momentum - securing profit', pnlTicks, momentum };
-      }
+      // Check exit conditions
+      const exitReason = checkExitConditions({
+        position,
+        currentPrice,
+        pnlTicks,
+        holdDuration,
+        strategy: this.strategy,
+        getTickSize: (p) => this._getTickSize(p),
+        latestPrices: this.latestPrices,
+      });
       
-      // Adverse momentum → EXIT immediately
-      if (momentum < MOMENTUM.ADVERSE_THRESHOLD) {
-        return { type: 'momentum_adverse', reason: 'Adverse momentum detected', pnlTicks, momentum };
-      }
-    }
-    
-    return null;
-  }
-
-  /**
-   * Calculate momentum score using strategy's existing math models
-   * Weighted: OFI (50%) + Kalman Velocity (25%) + Z-Score (25%)
-   * 
-   * Data sources:
-   * - OFI: Strategy's computeOrderFlowImbalance()
-   * - Kalman: Strategy's kalmanStates
-   * - Z-Score: Strategy's computeZScore()
-   * 
-   * @private
-   * @param {ManagedPosition} position
-   * @returns {number|null} Momentum score [-1 to 1], positive = favorable, null if insufficient data
-   */
-  _calculateMomentum(position) {
-    if (!this.strategy) {
-      return null;
-    }
-    
-    // Get individual model values (all from API/strategy, not invented)
-    const ofi = this._getOFI(position);
-    const velocity = this._getKalmanVelocity(position);
-    const zscore = this._getZScore(position);
-    
-    // Count how many models have data
-    let availableModels = 0;
-    let totalWeight = 0;
-    let weightedSum = 0;
-    
-    // 1. OFI (50%) - Order Flow Imbalance
-    if (ofi !== null) {
-      // For long: positive OFI = favorable, For short: negative OFI = favorable
-      const favorableOfi = position.side === 0 ? ofi : -ofi;
-      const ofiScore = Math.min(1, Math.max(-1, favorableOfi));
-      weightedSum += ofiScore * WEIGHTS.OFI;
-      totalWeight += WEIGHTS.OFI;
-      availableModels++;
-    }
-    
-    // 2. Kalman Velocity (25%)
-    if (velocity !== null) {
-      const tickSize = this._getTickSize(position);
-      if (tickSize !== null) {
-        // Normalize velocity: favorable direction = positive
-        const favorableVelocity = position.side === 0 ? velocity : -velocity;
-        // Normalize to [-1, 1]: 4 ticks of velocity = 1.0 score
-        const normalizedVelocity = favorableVelocity / (tickSize * 4);
-        const velocityScore = Math.min(1, Math.max(-1, normalizedVelocity));
-        weightedSum += velocityScore * WEIGHTS.KALMAN;
-        totalWeight += WEIGHTS.KALMAN;
-        availableModels++;
-      }
-    }
-    
-    // 3. Z-Score (25%) - Progression toward mean
-    if (zscore !== null) {
-      let zscoreScore;
-      if (position.side === 0) {
-        // Long: entered when Z < -threshold, improving = Z moving toward 0
-        // Z > -0.5 means close to mean = favorable
-        zscoreScore = zscore > -0.5 ? 0.5 : -0.5;
-      } else {
-        // Short: entered when Z > threshold, improving = Z moving toward 0
-        // Z < 0.5 means close to mean = favorable
-        zscoreScore = zscore < 0.5 ? 0.5 : -0.5;
-      }
-      weightedSum += zscoreScore * WEIGHTS.ZSCORE;
-      totalWeight += WEIGHTS.ZSCORE;
-      availableModels++;
-    }
-    
-    // Need at least 1 model with data to calculate momentum
-    if (availableModels === 0 || totalWeight === 0) {
-      return null;
-    }
-    
-    // Normalize by actual total weight (in case some models unavailable)
-    const momentum = weightedSum / totalWeight;
-    
-    // Clamp to [-1, 1]
-    return Math.min(1, Math.max(-1, momentum));
-  }
-
-  /**
-   * Get OFI (Order Flow Imbalance) from strategy
-   * Data source: Strategy's computeOrderFlowImbalance() or getModelValues()
-   * @private
-   * @returns {number|null} OFI value [-1, 1] or null if unavailable
-   */
-  _getOFI(position) {
-    if (!this.strategy) return null;
-    
-    const contractId = position.contractId || position.symbol;
-    
-    // Try strategy's computeOrderFlowImbalance (direct calculation from bars)
-    if (typeof this.strategy.computeOrderFlowImbalance === 'function') {
-      const bars = this.strategy.getBarHistory?.(contractId);
-      if (bars && bars.length >= 20) {
-        try {
-          return this.strategy.computeOrderFlowImbalance(bars);
-        } catch (error) {
-          log.debug('OFI calculation failed', { error: error.message });
-        }
-      }
-    }
-    
-    // Try getModelValues (pre-calculated values)
-    const modelValues = this.strategy.getModelValues?.(contractId);
-    if (modelValues && modelValues.rawOfi !== undefined) {
-      return modelValues.rawOfi;
-    }
-    
-    return null;
-  }
-
-  /**
-   * Get Kalman velocity from strategy's Kalman filter
-   * Data source: Strategy's kalmanStates or kalmanFilterManager
-   * @private
-   * @returns {number|null} Velocity value or null if unavailable
-   */
-  _getKalmanVelocity(position) {
-    if (!this.strategy) return null;
-    
-    const contractId = position.contractId || position.symbol;
-    
-    // Try to access kalmanStates from strategy
-    if (this.strategy.kalmanStates) {
-      const state = this.strategy.kalmanStates.get(contractId);
-      if (state && typeof state.estimate === 'number') {
-        const currentPrice = this.latestPrices.get(position.symbol);
-        if (currentPrice !== undefined && currentPrice !== null) {
-          // Velocity = price difference from Kalman estimate
-          // Positive = price above estimate (upward momentum)
-          return currentPrice - state.estimate;
-        }
-      }
-    }
-    
-    return null;
-  }
-
-  /**
-   * Get Z-Score from strategy
-   * Data source: Strategy's computeZScore() or priceBuffer
-   * @private
-   * @returns {number|null} Z-Score value or null if unavailable
-   */
-  _getZScore(position) {
-    if (!this.strategy) return null;
-    
-    const contractId = position.contractId || position.symbol;
-    
-    // Try strategy's computeZScore (direct calculation from price buffer)
-    if (typeof this.strategy.computeZScore === 'function') {
-      const prices = this.strategy.priceBuffer?.get(contractId);
-      if (prices && prices.length >= 50) {
-        try {
-          return this.strategy.computeZScore(prices);
-        } catch (error) {
-          log.debug('Z-Score calculation failed', { error: error.message });
-        }
-      }
-    }
-    
-    return null;
-  }
-
-  /**
-   * Get VPIN from strategy
-   * Data source: Strategy's computeVPIN() or volumeBuffer
-   * @private
-   * @returns {number|null} VPIN value [0, 1] or null if unavailable
-   */
-  _getVPIN(position) {
-    if (!this.strategy) return null;
-    
-    const contractId = position.contractId || position.symbol;
-    
-    // Try strategy's computeVPIN (direct calculation from volume buffer)
-    if (typeof this.strategy.computeVPIN === 'function') {
-      const volumes = this.strategy.volumeBuffer?.get(contractId);
-      if (volumes && volumes.length >= 50) {
-        try {
-          return this.strategy.computeVPIN(volumes);
-        } catch (error) {
-          log.debug('VPIN calculation failed', { error: error.message });
-        }
+      if (exitReason) {
+        this._executeExit(orderTag, exitReason);
       }
     }
-    
-    // Try getModelValues (pre-calculated, stored as 1 - vpin for scoring)
-    const modelValues = this.strategy.getModelValues?.(contractId);
-    if (modelValues && typeof modelValues.vpin === 'number') {
-      // modelValues.vpin is normalized score (1 - vpin), convert back
-      return 1 - modelValues.vpin;
-    }
-    
-    return null;
   }
 
-  /**
-   * Execute exit order
-   * @private
-   */
   _executeExit(orderTag, exitReason) {
     const position = this.positions.get(orderTag);
     if (!position || position.status === 'exiting' || position.status === 'closed') return;
@@ -795,8 +345,7 @@ class PositionManager extends EventEmitter {
       momentum: exitReason.momentum,
     });
     
-    // Fire exit order (opposite side)
-    const exitSide = position.side === 0 ? 1 : 0; // Reverse: Long->Sell, Short->Buy
+    const exitSide = position.side === 0 ? 1 : 0;
     
     const exitResult = this.rithmic.fastExit({
       accountId: position.accountId,
@@ -820,41 +369,26 @@ class PositionManager extends EventEmitter {
         latencyMs: exitResult.latencyMs,
       });
     } else {
-      log.error('Exit order FAILED', {
-        orderTag,
-        error: exitResult.error,
-      });
-      // Reset status to try again next cycle
+      log.error('Exit order FAILED', { orderTag, error: exitResult.error });
       position.status = 'active';
       position.exitReason = null;
     }
   }
 
-  /**
-   * Get tick size for position (from API, not hardcoded)
-   * @private
-   */
   _getTickSize(position) {
-    // First try position's stored tickSize (from API)
     if (position.tickSize !== null && position.tickSize !== undefined) {
       return position.tickSize;
     }
     
-    // Then try contract info cache
     const info = this.contractInfo.get(position.symbol);
     if (info && info.tickSize) {
       return info.tickSize;
     }
     
-    // Last resort: log warning and return null (will cause issues)
     log.warn('No tick size available for symbol', { symbol: position.symbol });
     return null;
   }
 
-  /**
-   * Get tick value for position (from API, not hardcoded)
-   * @private
-   */
   _getTickValue(position) {
     if (position.tickValue !== null && position.tickValue !== undefined) {
       return position.tickValue;
@@ -869,85 +403,20 @@ class PositionManager extends EventEmitter {
     return null;
   }
 
-  /**
-   * Calculate P&L in ticks from entry
-   * Data source: position.entryPrice (from Rithmic fill), tickSize (from API)
-   * @private
-   * @returns {number|null} PnL in ticks, null if cannot calculate
-   */
   _calculatePnlTicks(position, currentPrice) {
-    if (position.entryPrice === null || position.entryPrice === undefined) {
-      return null;
-    }
-    
-    if (currentPrice === null || currentPrice === undefined) {
-      return null;
-    }
-    
-    const tickSize = this._getTickSize(position);
-    if (tickSize === null || tickSize === undefined) {
-      log.error('Cannot calculate PnL - no tick size from API', { symbol: position.symbol });
-      return null;
-    }
-    
-    const priceDiff = currentPrice - position.entryPrice;
-    const signedDiff = position.side === 0 ? priceDiff : -priceDiff;
-    
-    return Math.round(signedDiff / tickSize);
-  }
-
-  /**
-   * Calculate trailing P&L from high/low water mark
-   * Data source: position water marks (from price updates), tickSize (from API)
-   * @private
-   * @returns {number|null} Trailing PnL in ticks, null if cannot calculate
-   */
-  _calculateTrailingPnl(position, currentPrice) {
-    const tickSize = this._getTickSize(position);
-    if (tickSize === null || tickSize === undefined) {
-      return null;
-    }
-    
-    if (position.side === 0) { // Long
-      if (position.highWaterMark === null || position.highWaterMark === undefined) {
-        return null;
-      }
-      const dropFromHigh = position.highWaterMark - currentPrice;
-      return -Math.round(dropFromHigh / tickSize);
-    } else { // Short
-      if (position.lowWaterMark === null || position.lowWaterMark === undefined) {
-        return null;
-      }
-      const riseFromLow = currentPrice - position.lowWaterMark;
-      return -Math.round(riseFromLow / tickSize);
-    }
+    return calculatePnlTicks(position, currentPrice, (p) => this._getTickSize(p));
   }
 
-  /**
-   * Get all active positions
-   * @returns {Array<ManagedPosition>}
-   */
   getActivePositions() {
     return Array.from(this.positions.values()).filter(
       p => p.status === 'holding' || p.status === 'active'
     );
   }
 
-  /**
-   * Get position by order tag
-   * @param {string} orderTag 
-   * @returns {ManagedPosition|null}
-   */
   getPosition(orderTag) {
     return this.positions.get(orderTag) || null;
   }
 
-  /**
-   * Check if we can enter a new position
-   * (no existing position in same symbol - 1 position at a time)
-   * @param {string} symbol 
-   * @returns {boolean}
-   */
   canEnter(symbol) {
     for (const position of this.positions.values()) {
       if (position.symbol === symbol && position.status !== 'closed') {
@@ -957,18 +426,10 @@ class PositionManager extends EventEmitter {
     return true;
   }
 
-  /**
-   * Get momentum thresholds (for UI display)
-   * @returns {Object}
-   */
   getMomentumThresholds() {
     return { ...MOMENTUM };
   }
 
-  /**
-   * Get momentum weights (for UI display)
-   * @returns {Object}
-   */
   getMomentumWeights() {
     return { ...WEIGHTS };
   }