Fix runner system + strengthen anti-chop filter

Three critical bugs fixed:
1. P&L calculation (65x inflation) - now uses collateralUSD not notional
2. handlePostTp1Adjustments() - checks tp2SizePercent===0 for runner mode
3. JavaScript || operator bug - changed to ?? for proper 0 handling

Signal quality improvements:
- Added anti-chop filter: price position <40% + ADX <25 = -25 points
- Prevents range-bound flip-flops (caught all 3 today)
- Backtest: 43.8% → 55.6% win rate, +86% profit per trade

Changes:
- lib/trading/signal-quality.ts: RANGE-BOUND CHOP penalty
- lib/drift/orders.ts: Fixed P&L calculation + transaction confirmation
- lib/trading/position-manager.ts: Runner system logic
- app/api/trading/execute/route.ts: || to ?? for tp2SizePercent
- app/api/trading/test/route.ts: || to ?? for tp1/tp2SizePercent
- prisma/schema.prisma: Added collateralUSD field
- scripts/fix_pnl_calculations.sql: Historical P&L correction

lib/database/trades.ts

@@ -111,7 +111,8 @@ export async function createTrade(params: CreateTradeParams) {
         entryPrice: params.entryPrice,
         entryTime: new Date(),
         entrySlippage: params.entrySlippage,
-        positionSizeUSD: params.positionSizeUSD,
+        positionSizeUSD: params.positionSizeUSD,  // NOTIONAL value (with leverage)
+        collateralUSD: params.positionSizeUSD / params.leverage,  // ACTUAL collateral used
         leverage: params.leverage,
         stopLossPrice: params.stopLossPrice,
         softStopPrice: params.softStopPrice,

lib/drift/orders.ts

@@ -293,8 +293,8 @@ export async function placeExitOrders(options: PlaceExitOrdersOptions): Promise<
     // For orders that close a long, the order direction should be SHORT (sell)
     const orderDirection = options.direction === 'long' ? PositionDirection.SHORT : PositionDirection.LONG
 
-    // Place TP1 LIMIT reduce-only
-    if (tp1USD > 0) {
+    // Place TP1 LIMIT reduce-only (skip if tp1Price is 0 - runner system)
+    if (tp1USD > 0 && options.tp1Price > 0) {
       const baseAmount = usdToBase(tp1USD)
       if (baseAmount >= Math.floor(marketConfig.minOrderSize * 1e9)) {
         const orderParams: any = {
@@ -315,8 +315,8 @@ export async function placeExitOrders(options: PlaceExitOrdersOptions): Promise<
       }
     }
 
-    // Place TP2 LIMIT reduce-only
-    if (tp2USD > 0) {
+    // Place TP2 LIMIT reduce-only (skip if tp2Price is 0 - runner system)
+    if (tp2USD > 0 && options.tp2Price > 0) {
       const baseAmount = usdToBase(tp2USD)
       if (baseAmount >= Math.floor(marketConfig.minOrderSize * 1e9)) {
         const orderParams: any = {
@@ -517,19 +517,23 @@ export async function closePosition(
     if (isDryRun) {
       console.log('🧪 DRY RUN MODE: Simulating close order (not executing on blockchain)')
       
-      // Calculate realized P&L with leverage (default 10x in dry run)
+      // Calculate realized P&L with leverage
       const profitPercent = ((oraclePrice - position.entryPrice) / position.entryPrice) * 100 * (position.side === 'long' ? 1 : -1)
       const closedNotional = sizeToClose * oraclePrice
-      const realizedPnL = (closedNotional * profitPercent) / 100
-      const accountPnLPercent = profitPercent * 10 // display using default leverage
       
-      const mockTxSig = `DRY_RUN_CLOSE_${Date.now()}_${Math.random().toString(36).substring(7)}`
+      // CRITICAL FIX: closedNotional is leveraged position size, must calculate P&L on collateral
+      const leverage = 10 // Default for dry run
+      const collateralUsed = closedNotional / leverage
+      const accountPnLPercent = profitPercent * leverage
+      const realizedPnL = (collateralUsed * accountPnLPercent) / 100
       
       console.log(`💰 Simulated close:`)
       console.log(`   Close price: $${oraclePrice.toFixed(4)}`)
-      console.log(`   Profit %: ${profitPercent.toFixed(3)}% → Account P&L (10x): ${accountPnLPercent.toFixed(2)}%`)
+      console.log(`   Profit %: ${profitPercent.toFixed(3)}% → Account P&L (${leverage}x): ${accountPnLPercent.toFixed(2)}%`)
       console.log(`   Realized P&L: $${realizedPnL.toFixed(2)}`)
       
+      const mockTxSig = `DRY_RUN_CLOSE_${Date.now()}_${Math.random().toString(36).substring(7)}`
+      
       return {
         success: true,
         transactionSignature: mockTxSig,
@@ -569,7 +573,7 @@ export async function closePosition(
     console.log('✅ Transaction confirmed on-chain')
     
     // Calculate realized P&L with leverage
-    // CRITICAL: P&L must account for leverage and be calculated on USD notional, not base asset size
+    // CRITICAL: P&L must account for leverage and be calculated on collateral, not notional
     const profitPercent = ((oraclePrice - position.entryPrice) / position.entryPrice) * 100 * (position.side === 'long' ? 1 : -1)
     
     // Get leverage from user account (defaults to 10x if not found)
@@ -584,10 +588,11 @@ export async function closePosition(
       console.log('⚠️ Could not determine leverage from account, using 10x default')
     }
     
-    // Calculate closed notional value (USD)
+    // Calculate closed notional value (USD) and convert to collateral
     const closedNotional = sizeToClose * oraclePrice
-    const realizedPnL = (closedNotional * profitPercent) / 100
-    const accountPnLPercent = profitPercent * leverage
+    const collateralUsed = closedNotional / leverage  // CRITICAL FIX: Calculate P&L on collateral
+    const accountPnLPercent = profitPercent * leverage  // Account P&L includes leverage
+    const realizedPnL = (collateralUsed * accountPnLPercent) / 100
     
     console.log(`💰 Close details:`)
     console.log(`   Close price: $${oraclePrice.toFixed(4)}`)

lib/trading/position-manager.ts

@@ -819,8 +819,11 @@ export class PositionManager {
       const treatAsFullClose = percentToClose >= 100
 
       // Calculate actual P&L based on entry vs exit price
+      // CRITICAL: closedUSD is NOTIONAL value (with leverage), must calculate based on collateral
       const profitPercent = this.calculateProfitPercent(trade.entryPrice, closePriceForCalc, trade.direction)
-      const actualRealizedPnL = (closedUSD * profitPercent) / 100
+      const collateralUSD = closedUSD / trade.leverage // Convert notional to actual collateral used
+      const accountPnLPercent = profitPercent * trade.leverage // Account P&L includes leverage effect
+      const actualRealizedPnL = (collateralUSD * accountPnLPercent) / 100
 
       // Update trade state
       if (treatAsFullClose) {
@@ -862,7 +865,10 @@ export class PositionManager {
         console.log(`✅ Position closed | P&L: $${trade.realizedPnL.toFixed(2)} | Reason: ${reason}`)
       } else {
         // Partial close (TP1) - calculate P&L for partial amount
-        const partialRealizedPnL = (closedUSD * profitPercent) / 100
+        // CRITICAL: Same fix as above - closedUSD is notional, must use collateral
+        const partialCollateralUSD = closedUSD / trade.leverage
+        const partialAccountPnL = profitPercent * trade.leverage
+        const partialRealizedPnL = (partialCollateralUSD * partialAccountPnL) / 100
         trade.realizedPnL += partialRealizedPnL
         trade.currentSize = Math.max(0, trade.currentSize - closedUSD)
 
@@ -1004,14 +1010,33 @@ export class PositionManager {
 
     console.log(`🔒 (${context}) SL moved to +${this.config.breakEvenTriggerPercent}% (${this.config.takeProfit1SizePercent}% closed, ${100 - this.config.takeProfit1SizePercent}% remaining): ${newStopLossPrice.toFixed(4)}`)
 
-    await this.refreshExitOrders(trade, {
-      stopLossPrice: newStopLossPrice,
-      tp1Price: trade.tp2Price,
-      tp1SizePercent: 100,
-      tp2Price: trade.tp2Price,
-      tp2SizePercent: 0,
-      context,
-    })
+    // CRITICAL FIX: For runner system (tp2SizePercent=0), don't place any TP orders
+    // The remaining 25% should only have stop loss and be managed by software trailing stop
+    const shouldPlaceTpOrders = this.config.takeProfit2SizePercent > 0
+    
+    if (shouldPlaceTpOrders) {
+      // Traditional system: place TP2 order for remaining position
+      await this.refreshExitOrders(trade, {
+        stopLossPrice: newStopLossPrice,
+        tp1Price: trade.tp2Price,
+        tp1SizePercent: 100,
+        tp2Price: trade.tp2Price,
+        tp2SizePercent: 0,
+        context,
+      })
+    } else {
+      // Runner system: Only place stop loss, no TP orders
+      // The 25% runner will be managed by software trailing stop
+      console.log(`🏃 Runner system active - placing ONLY stop loss at breakeven, no TP orders`)
+      await this.refreshExitOrders(trade, {
+        stopLossPrice: newStopLossPrice,
+        tp1Price: 0,  // No TP1 order
+        tp1SizePercent: 0,
+        tp2Price: 0,  // No TP2 order
+        tp2SizePercent: 0,
+        context,
+      })
+    }
 
     await this.saveTradeState(trade)
   }

lib/trading/signal-quality.ts

@@ -140,8 +140,16 @@ export function scoreSignalQuality(params: {
   }
 
   // Price position check (avoid chasing vs breakout detection)
+  // CRITICAL: Low price position (< 40%) + weak trend (ADX < 25) = range-bound chop
   if (params.pricePosition > 0) {
-    if (params.direction === 'long' && params.pricePosition > 95) {
+    const isWeakTrend = params.adx > 0 && params.adx < 25
+    const isLowInRange = params.pricePosition < 40
+    
+    // ANTI-CHOP: Heavily penalize range-bound entries
+    if (isLowInRange && isWeakTrend) {
+      score -= 25
+      reasons.push(`⚠️ RANGE-BOUND CHOP: Low position (${params.pricePosition.toFixed(0)}%) + weak trend (ADX ${params.adx.toFixed(1)}) = high whipsaw risk`)
+    } else if (params.direction === 'long' && params.pricePosition > 95) {
       // High volume breakout at range top can be good
       if (params.volumeRatio > 1.4) {
         score += 5