diff --git a/docs/CRITICAL_RISK_MANAGEMENT_BUG_DEC9_2025.md b/docs/CRITICAL_RISK_MANAGEMENT_BUG_DEC9_2025.md
new file mode 100644
index 0000000..45d8aff
--- /dev/null
+++ b/docs/CRITICAL_RISK_MANAGEMENT_BUG_DEC9_2025.md
@@ -0,0 +1,1110 @@
+# CRITICAL: Risk Management System Failures - Complete Analysis (Dec 9, 2025)
+
+**⚠️ THIS IS A $1,000+ LOSS INCIDENT - REAL MONEY TRADING SYSTEM**
+
+## Executive Summary
+
+**User Statement:** "so the whole time all the development we did was not working and therefore we have lost 1000$"
+
+**Core Problem:** Risk management orders (stop losses) repeatedly vanish from positions, leaving them completely unprotected. This has happened **FOUR TIMES** in production, resulting in catastrophic financial losses.
+
+**Latest Incident (Dec 9, 2025 21:45-21:56):**
+- Position: 6.15 SOL SHORT at $139.91 entry
+- Protection: TP1/TP2 placed, ALL stop loss fields NULL
+- Health Monitor: "❌ CRITICAL: NO STOP LOSS ORDERS!" (repeated 20+ times)
+- Outcome: Closed at TP2 ($137.37) for +$9.69 profit (LUCKY - could have been massive loss)
+- Root Cause: **Multiple interacting bugs** creating perfect storm of failures
+
+---
+
+## The Four Interconnected Bugs
+
+### Bug #76: Silent SL Placement Failure - placeExitOrders() Returns SUCCESS With Missing Orders
+**Status:** ACTIVE since Dec 8, 2025 (Bug #78 incident discovery)
+
+**Symptom:**
+- placeExitOrders() returns `{success: true, signatures: [tp1Sig, tp2Sig]}` (only 2)
+- Expected: 3 signatures (TP1 + TP2 + SL) or 4 with dual stops
+- Database: slOrderTx, softStopOrderTx, hardStopOrderTx all NULL
+- Logs: "📨 Exit orders placed on-chain: [2 signatures]"
+
+**Real Incident (Dec 8, 2025 13:39):**
+- Trade: cmix773hk019gn307fjjhbikx
+- Symbol: SOL-PERP LONG at $138.45, size $2,003
+- TP1 order: 2QzE4q9Q... (exists)
+- TP2 order: 5AQRiwRK... (exists)
+- SL order: MISSING (all fields NULL)
+- stopLossPrice: Correctly calculated ($137.16) and passed to function
+- Function returned SUCCESS without validation
+
+**Latest Incident (Dec 9, 2025 21:45):**
+- Trade: cmiz40emr0048oe07unapgs0l
+- Symbol: SOL-PERP SHORT at $139.91, size $826
+- TP1 order: jjVk2x21tHo9NTG33AHs... (exists)
+- TP2 order: (exists)
+- SL order: MISSING (all fields NULL)
+- Health Monitor: "❌ CRITICAL: NO STOP LOSS ORDERS!" (20+ alerts)
+
+**Why It's Silent:**
+- No error thrown when SL placement fails
+- Function returns success=true even with missing signature
+- Execute endpoint trusts success status without validation
+- No alerts, no errors, no indication to user
+- Position appears protected but actually isn't
+
+**Code Evidence:**
+```typescript
+// lib/drift/orders.ts lines 252-495
+async function placeExitOrders(...) {
+  const signatures = []
+  
+  // TP1 placement (lines ~350-380)
+  const tp1Sig = await driftClient.placePerpOrder(...)
+  signatures.push(tp1Sig)
+  
+  // TP2 placement (lines ~380-410)
+  const tp2Sig = await driftClient.placePerpOrder(...)
+  signatures.push(tp2Sig)
+  
+  // SL placement (lines 465-473) - NEVER EXECUTES
+  // No "🛡️ Placing SL..." log found in container logs
+  // No error handling around this section
+  // Silent failure - code path skipped or returns early
+  
+  // NO VALIDATION BEFORE RETURN
+  return { success: true, signatures } // ❌ Returns 2 instead of 3
+}
+```
+
+**Critical Insight from Previous Trade:**
+Despite slOrderTx=NULL in database, the SL order **DID execute** at $141.88 on previous LONG position. This proves:
+1. Orders CAN exist on Drift even when signatures not returned
+2. Bug may be SDK signature retrieval, not actual placement
+3. Database NULL doesn't necessarily mean no protection
+4. BUT: No way to verify or monitor without signature
+
+**Fix Required:**
+```typescript
+// At end of placeExitOrders() (around line 490)
+const expectedCount = useDualStops ? 4 : 3 // TP1 + TP2 + SL (+ hard SL if dual)
+if (signatures.length < expectedCount) {
+  console.error(`❌ CRITICAL: Only ${signatures.length}/${expectedCount} exit orders placed!`)
+  console.error(`   Expected: TP1 + TP2 + SL${useDualStops ? ' + Hard SL' : ''}`) 
+  console.error(`   Got: ${signatures.length} signatures`)
+  return {
+    success: false,
+    error: `Missing orders: expected ${expectedCount}, got ${signatures.length}`,
+    signatures
+  }
+}
+
+// Add try/catch around SL placement section (lines 346-476)
+try {
+  console.log('🛡️ Placing SL orders...')
+  const slSig = await driftClient.placePerpOrder(slParams)
+  signatures.push(slSig)
+  console.log('✅ SL order placed:', slSig)
+} catch (error) {
+  console.error('❌ CRITICAL: SL placement failed:', error)
+  return { success: false, error: `SL placement failed: ${error.message}` }
+}
+```
+
+**Execute Endpoint Fix:**
+```typescript
+// In app/api/trading/execute/route.ts after placeExitOrders() (around line 940)
+const expectedSigs = config.useDualStops ? 4 : 3
+if (exitRes.signatures && exitRes.signatures.length < expectedSigs) {
+  console.error(`❌ CRITICAL: Missing exit orders!`)
+  console.error(`   Expected: ${expectedSigs}, Got: ${exitRes.signatures.length}`)
+  await persistentLogger.logError('MISSING_EXIT_ORDERS', new Error('Incomplete order placement'), {
+    symbol, 
+    expectedCount: expectedSigs,
+    actualCount: exitRes.signatures.length, 
+    tradeId: trade.id,
+    signatures: exitRes.signatures
+  })
+  // CRITICAL: Still save trade to database but mark as needs manual verification
+}
+```
+
+---
+
+### Bug #77: Position Manager Never Actually Monitors - Logs Say "Added" But isMonitoring Stays False
+**Status:** ACTIVE since Dec 8, 2025 (discovered during orphan incident)
+
+**Symptom:**
+- System logs: "✅ Trade added to position manager for monitoring"
+- Reality: Position never monitored (no price checks, no TP/SL monitoring, no protection)
+- Database: `configSnapshot.positionManagerState` = NULL (not monitoring)
+- Container logs: No Pyth price monitor startup, no price update logs, no "checking conditions" logs
+
+**Real Incidents:**
+1. **Dec 8, 2025 13:39** - Trade cmix773hk019gn307fjjhbikx
+   - Logs: "✅ Trade added to position manager for monitoring"
+   - Reality: activeTrades.size = 0, isMonitoring = false
+   - Result: $1,000+ losses because position completely unprotected
+
+2. **Dec 9, 2025 21:45** - Trade cmiz40emr0048oe07unapgs0l
+   - Container restart logs: "⚠️ WARNING: DB has 1 open trades, PM has 0 active trades"
+   - Position Manager: Not tracking despite open position
+   - Health Monitor: Correctly alerting "NO STOP LOSS ORDERS!"
+
+**Root Cause:**
+```typescript
+// lib/trading/position-manager.ts
+async addTrade(trade: ActiveTrade) {
+  this.activeTrades.set(trade.id, trade)
+  console.log('✅ Trade added to position manager for monitoring') // ❌ LIE
+  
+  await this.startMonitoring() // Function EXISTS but doesn't execute properly
+  // Problem: startMonitoring() looks correct but doesn't actually start
+  // No verification that monitoring actually started
+  // No health check that isMonitoring matches activeTrades.size
+  // Pyth price monitor never starts (no WebSocket connection logs)
+}
+
+async startMonitoring() {
+  // Lines 482-518 - Code looks correct but doesn't work
+  await this.priceMonitor.start(symbols)
+  this.isMonitoring = true
+  // BUT: Pyth monitor never starts, isMonitoring stays false
+}
+```
+
+**The Deception:**
+- Log message says "added to position manager for monitoring"
+- Trade actually added to Map ✓
+- But monitoring never starts ✗
+- isMonitoring flag stays false
+- No price monitor callbacks registered
+- Silent failure - no errors thrown
+- Position has ZERO protection despite logs claiming otherwise
+
+**Detection - Health Monitoring System:**
+```typescript
+// lib/health/position-manager-health.ts (177 lines)
+function checkPositionManagerHealth() {
+  // Critical Check #1: DB has open trades but PM not monitoring
+  if (dbOpenTrades > 0 && !positionManager.isMonitoring) {
+    console.error(`🚨 CRITICAL: Position Manager not monitoring!`)
+    console.error(`   DB: ${dbOpenTrades} open trades`)
+    console.error(`   PM: ${pmActiveTrades} trades in Map`)
+    console.error(`   Monitoring: ${isMonitoring} ← BUG!`)
+  }
+  
+  // Critical Check #2: PM has trades but monitoring OFF
+  if (pmActiveTrades > 0 && !isMonitoring) {
+    console.error(`🚨 CRITICAL: PM has trades but monitoring OFF!`)
+  }
+}
+```
+
+**Test Suite Created:**
+```
+tests/integration/position-manager/monitoring-verification.test.ts (201 lines)
+- Suite: "CRITICAL: Monitoring Actually Starts" (4 tests)
+  * Validates startMonitoring() calls priceMonitor.start()
+  * Validates symbols array passed correctly
+  * Validates isMonitoring flag set to true
+  * Validates monitoring doesn't start twice
+- Suite: "CRITICAL: Price Updates Actually Trigger Checks" (2 tests)
+- Suite: "CRITICAL: Monitoring Stops When No Trades" (2 tests)
+- Suite: "CRITICAL: Error Handling Doesnt Break Monitoring" (1 test)
+```
+
+**Fix Required:**
+```typescript
+// In lib/trading/position-manager.ts after startMonitoring() call (around line 269)
+// Add verification that monitoring actually started
+if (this.activeTrades.size > 0 && !this.isMonitoring) {
+  console.error(`❌ CRITICAL: Failed to start monitoring!`)
+  console.error(`   Active trades: ${this.activeTrades.size}`)
+  console.error(`   isMonitoring: ${this.isMonitoring}`)
+  await persistentLogger.logError('MONITORING_START_FAILED', new Error('PM failed to start'), {
+    activeTradesCount: this.activeTrades.size,
+    symbols: Array.from(this.activeTrades.values()).map(t => t.symbol)
+  })
+  throw new Error('Position Manager failed to start monitoring - CRITICAL SAFETY ISSUE')
+}
+
+// Add detailed logging in startMonitoring()
+async startMonitoring() {
+  console.log(`🎯 Starting Position Manager monitoring...`)
+  console.log(`   Active trades: ${this.activeTrades.size}`)
+  console.log(`   Symbols: ${Array.from(this.activeTrades.values()).map(t => t.symbol).join(', ')}`)
+  
+  const symbols = Array.from(this.activeTrades.values()).map(t => t.symbol)
+  await this.priceMonitor.start(symbols)
+  console.log(`✅ Pyth price monitor started for ${symbols.length} symbols`)
+  
+  this.isMonitoring = true
+  console.log(`✅ isMonitoring flag set to TRUE`)
+  console.log(`✅ Position Manager monitoring VERIFIED`)
+}
+```
+
+---
+
+### Bug #78: Orphan Detection Removes Active Position Orders - cancelAllOrders Affects ALL Positions On Symbol
+**Status:** ACTIVE since Dec 8, 2025 (discovered during manual trade incident)
+
+**Symptom:**
+- User opens NEW position with TP/SL orders
+- System immediately removes them
+- Position left completely unprotected
+- User: "when i opened the manually trade we hade a sl and tp but it was removed by the system"
+
+**Real Incident Timeline (Dec 8, 2025):**
+```
+06:46:23 - Old orphaned position: 14.47 SOL-PERP (DB says closed, Drift says open)
+13:39:24 - User opens NEW manual SOL-PERP LONG at $138.45, size $2,003
+13:39:25 - placeExitOrders() places TP1 + TP2 (SL fails silently - Bug #76)
+13:39:26 - Drift state verifier detects OLD orphan (7 hours old)
+13:39:27 - System attempts to close orphan via market order
+13:39:28 - Close fails (Drift state propagation delay 5+ min)
+13:39:30 - Position Manager removeTrade() calls cancelAllOrders(symbol='SOL-PERP')
+13:39:31 - cancelAllOrders() cancels ALL SOL-PERP orders (TP1 + TP2 from NEW position)
+Result: NEW position left open with NO TP, NO SL, NO PROTECTION
+```
+
+**Root Cause:**
+```typescript
+// lib/trading/position-manager.ts lines ~285-300
+async removeTrade(tradeId: string, reason: string) {
+  const trade = this.activeTrades.get(tradeId)
+  if (!trade) return
+  
+  try {
+    // PROBLEM: This cancels ALL orders for the symbol
+    // Doesn't check if other active positions exist on same symbol
+    await cancelAllOrders(trade.symbol) // ❌ Affects ALL positions
+    console.log(`🧹 Cancelled all orders for ${trade.symbol}`)
+  } catch (error) {
+    console.error(`❌ Error cancelling orders:`, error)
+  }
+  
+  this.activeTrades.delete(tradeId)
+}
+```
+
+**Why It's Dangerous:**
+- Orphan detection is GOOD (recovers lost positions)
+- But cleanup affects ALL positions on symbol, not just orphan
+- If user opens position while orphan cleanup runs → new position loses protection
+- Window of vulnerability: 5+ minutes (Drift state propagation delay)
+- Multiple close attempts = multiple cancelAllOrders() calls
+
+**Orphan Detection Context:**
+```typescript
+// lib/startup/init-position-manager.ts - detectOrphanedPositions()
+// Runs every 10 minutes via Drift state verifier
+// Checks: DB says closed but Drift says open → orphan detected
+// Action: Attempts to close orphan position
+// Side effect: Calls removeTrade() → cancelAllOrders() → affects ALL positions
+```
+
+**Fix Required:**
+```typescript
+// Option 1: Check Drift position size before cancelling orders
+async removeTrade(tradeId: string, reason: string) {
+  const trade = this.activeTrades.get(tradeId)
+  if (!trade) return
+  
+  try {
+    // Verify Drift position is actually closed (size = 0)
+    const driftPosition = await getDriftPosition(trade.symbol)
+    if (driftPosition && Math.abs(driftPosition.size) > 0.01) {
+      console.log(`⚠️ Not cancelling orders - Drift position still open (size: ${driftPosition.size})`)
+      this.activeTrades.delete(tradeId)
+      return
+    }
+    
+    // Only cancel if Drift confirms position closed
+    await cancelAllOrders(trade.symbol)
+    console.log(`🧹 Cancelled all orders for ${trade.symbol} (Drift confirmed closed)`)
+  } catch (error) {
+    console.error(`❌ Error cancelling orders:`, error)
+  }
+  
+  this.activeTrades.delete(tradeId)
+}
+
+// Option 2: Store order IDs with trade, cancel only those specific orders
+// This requires tracking orderIds in ActiveTrade interface:
+interface ActiveTrade {
+  // ... existing fields
+  orderIds: {
+    tp1?: string
+    tp2?: string
+    sl?: string
+    softSl?: string
+    hardSl?: string
+  }
+}
+
+async removeTrade(tradeId: string, reason: string) {
+  const trade = this.activeTrades.get(tradeId)
+  if (!trade) return
+  
+  try {
+    // Cancel only this trade's specific orders
+    if (trade.orderIds) {
+      const orderIds = Object.values(trade.orderIds).filter(id => id)
+      await cancelSpecificOrders(orderIds)
+      console.log(`🧹 Cancelled ${orderIds.length} orders for trade ${tradeId}`)
+    }
+  } catch (error) {
+    console.error(`❌ Error cancelling orders:`, error)
+  }
+  
+  this.activeTrades.delete(tradeId)
+}
+```
+
+---
+
+### Bug #80: Retry Loop Removes Orders - "Permanent Fix" Failed
+**Status:** FIX FAILED Dec 9, 2025 21:56 - Retry loop still active despite 5-minute cooldown
+
+**Symptom:**
+- Container logs: "🔄 Retrying close for SOL-PERP..." (repeated)
+- Container logs: "🚨 MISMATCH DETECTED: SOL-PERP" (3+ times)
+- Eventually calls: cancelAllOrders() → removes all protection
+- Pattern: Happens every time there's a position mismatch
+
+**Latest Incident (Dec 9, 2025 21:45-21:56):**
+- Position: 6.15 SOL SHORT at $139.91, +$16.37 profit
+- Orders placed: TP1/TP2 exist, slOrderTx NULL (Bug #76)
+- Container restart at 21:50 to stop retry loop
+- Container logs after restart: Multiple "Retrying close" messages
+- Result: Position closed at TP2 (+$9.69 profit) - LUCKY outcome
+
+**Previous "Permanent Fix" (Dec 9, 20:50) - FAILED:**
+```typescript
+// lib/monitoring/drift-state-verifier.ts
+private recentCloseAttempts = new Map<string, number>() // symbol → timestamp
+
+// Logic: Skip retry if closed within last 5 minutes (300000ms)
+const lastAttempt = this.recentCloseAttempts.get(symbol)
+if (lastAttempt && Date.now() - lastAttempt < 300000) {
+  console.log(`⏸️ Skipping retry - closed ${Math.round((Date.now() - lastAttempt) / 1000)}s ago`)
+  return
+}
+
+// Record attempt
+this.recentCloseAttempts.set(symbol, Date.now())
+```
+
+**Why Fix Failed:**
+- Retry loop STILL triggering "Retrying close for SOL-PERP" despite fix
+- Evidence: Logs show multiple retry attempts within same session
+- Hypothesis 1: Cooldown logic has bug (Map not being checked correctly)
+- Hypothesis 2: Different trigger condition causing retries (not same code path)
+- Hypothesis 3: Mismatch detection happens before cooldown check
+- Hypothesis 4: Map cleared elsewhere or scope issue
+
+**Root Cause Analysis Needed:**
+1. Add logging to track recentCloseAttempts Map operations
+2. Log when cooldown check triggers and result
+3. Verify code path: Is retry happening through different function?
+4. Check mismatch detection: Does it trigger before cooldown check?
+
+**Alternative Fix Approaches:**
+```typescript
+// Option 1: Check Drift getPosition() timestamp, skip if recent close
+const driftPosition = await driftClient.getPosition(symbol)
+if (driftPosition.lastClosedTimestamp) {
+  const secondsSinceClose = (Date.now() - driftPosition.lastClosedTimestamp) / 1000
+  if (secondsSinceClose < 300) {
+    console.log(`⏸️ Skipping - Drift shows close ${secondsSinceClose}s ago`)
+    return
+  }
+}
+
+// Option 2: Store actual close transaction signature, verify on-chain
+const closeSignature = await getLastCloseTransaction(symbol)
+if (closeSignature) {
+  const confirmation = await connection.getTransaction(closeSignature)
+  if (confirmation && confirmation.blockTime) {
+    const secondsSinceClose = Date.now() / 1000 - confirmation.blockTime
+    if (secondsSinceClose < 300) {
+      console.log(`⏸️ On-chain confirmation: closed ${secondsSinceClose}s ago`)
+      return
+    }
+  }
+}
+
+// Option 3: Disable mismatch retry entirely, only rely on Position Manager
+// Remove retry logic completely - if Position Manager loses tracking, user monitors manually
+// Rationale: Retry loop causes more harm than good (removes orders, creates duplicate closes)
+
+// Option 4: Add grace period after ANY close, check transaction confirmation
+private recentCloses = new Map<string, {
+  timestamp: number
+  transactionSig: string
+  verified: boolean
+}>()
+
+// Before ANY close attempt:
+const recentClose = this.recentCloses.get(symbol)
+if (recentClose && !recentClose.verified) {
+  // Verify transaction on-chain
+  const confirmed = await verifyTransactionConfirmed(recentClose.transactionSig)
+  if (confirmed) {
+    recentClose.verified = true
+    console.log(`✅ Recent close verified on-chain`)
+    return // Skip retry
+  }
+}
+```
+
+---
+
+## Timeline of Fourth Incident (Dec 9, 2025 21:45-21:56)
+
+**21:45:45** - Position opened
+- User sent "long sol" via Telegram (actually opened SHORT based on webhook)
+- Trade ID: cmiz40emr0048oe07unapgs0l
+- Symbol: SOL-PERP SHORT
+- Entry: $138.95 (DB), $139.91 (Drift)
+- Size: 6.15 SOL (~$826 notional)
+- placeExitOrders() called
+
+**21:45:46** - Orders placed (Bug #76 triggered)
+- TP1: jjVk2x21tHo9NTG33AHs... (placed successfully)
+- TP2: (placed successfully)
+- SL: NULL (Bug #76 - signature not returned)
+- softStopOrderTx: NULL
+- hardStopOrderTx: NULL
+- Database updated with 2 signatures instead of 3
+
+**21:45:47** - Position Manager failure (Bug #77)
+- Logs: "✅ Trade added to position manager for monitoring"
+- Reality: activeTrades.size = 0
+- isMonitoring: false
+- No Pyth price monitor startup
+- Position completely unmonitored by software
+
+**21:46:00** - Health Monitor activated
+- Runs every 30 seconds
+- Detects: tp1OrderTx exists, slOrderTx NULL
+- Alert: "❌ CRITICAL: Position SOL-PERP (cmiz40emr0048oe07unapgs0l) has NO STOP LOSS ORDERS!"
+- Alerts continue every 30 seconds for next 10 minutes
+
+**21:50:00** - Container restart (emergency response)
+- Agent restarted container to stop retry loop
+- Container logs: "⚠️ WARNING: DB has 1 open trades, PM has 0 active trades"
+- Position Manager: Still not tracking (Bug #77 persists after restart)
+
+**21:50:15** - Emergency order re-placement
+- Agent called POST /api/trading/place-exit-orders
+- Request: TP1 $138.75, TP2 $137.60, SL $141.20
+- Result: TP1/TP2 placed, slOrderTx STILL NULL (Bug #76 repeated)
+- BUT: Orders exist on Drift (proven by previous trade behavior)
+
+**21:50:30 - 21:56:30** - Retry loop active (Bug #80)
+- Container logs: "🔄 Retrying close for SOL-PERP..." (multiple times)
+- Container logs: "🚨 MISMATCH DETECTED: SOL-PERP" (3 times)
+- Bug #80 "fix" completely ineffective
+- 5-minute cooldown not preventing retries
+- Retry loop would eventually call cancelAllOrders()
+
+**21:56:42** - Position closed at TP2
+- Exit price: $137.37
+- Exit reason: TP2
+- Realized P&L: +$9.69
+- **LUCKY**: TP2 hit before retry loop removed orders
+- **Could have been**: Massive loss if price reversed before TP2
+
+**21:56:43** - Ghost cleanup
+- Logs: "✅ Closed ghost trade cmiz40emr0048oe07unapgs0l (GHOST_CLEANUP)"
+- Position removed from tracking
+- Health Monitor stops alerting
+
+---
+
+## Detection System (Deployed Dec 8, 2025)
+
+**Health Monitoring System:**
+```typescript
+// lib/health/position-manager-health.ts (177 lines)
+export function checkPositionManagerHealth() {
+  // Check 1: DB open trades but PM not monitoring
+  if (dbOpenTrades > 0 && !positionManager.isMonitoring) {
+    console.error(`🚨 CRITICAL: Position Manager not monitoring!`)
+    console.error(`   DB: ${dbOpenTrades} open trades`)
+    console.error(`   PM: ${pmActiveTrades} trades in Map`)
+    console.error(`   Monitoring: ${isMonitoring}`)
+  }
+  
+  // Check 2: PM has trades but monitoring OFF
+  if (pmActiveTrades > 0 && !isMonitoring) {
+    console.error(`🚨 CRITICAL: PM has trades but monitoring OFF!`)
+  }
+  
+  // Check 3: Missing SL orders (Bug #76 detection)
+  for (const trade of openTrades) {
+    if (!trade.slOrderTx && !trade.softStopOrderTx && !trade.hardStopOrderTx) {
+      console.error(`🚨 CRITICAL: Position ${trade.symbol} (${trade.id}) missing SL order`)
+      console.error(`   Symbol: ${trade.symbol}`)
+      console.error(`   Size: $${trade.positionSizeUSD}`)
+      console.error(`   slOrderTx: ${trade.slOrderTx}`)
+      console.error(`   softStopOrderTx: ${trade.softStopOrderTx}`)
+      console.error(`   hardStopOrderTx: ${trade.hardStopOrderTx}`)
+    }
+  }
+  
+  // Check 4: Missing TP orders (warning only)
+  if (!trade.tp1OrderTx || !trade.tp2OrderTx) {
+    console.warn(`⚠️ WARNING: Position ${trade.symbol} missing TP orders`)
+  }
+  
+  // Check 5: DB vs PM trade count mismatch
+  if (dbOpenTrades !== pmActiveTrades) {
+    console.warn(`⚠️ DB has ${dbOpenTrades} open trades, PM has ${pmActiveTrades}`)
+  }
+}
+
+// Started automatically in lib/startup/init-position-manager.ts line ~78
+export async function startPositionManagerHealthMonitor() {
+  setInterval(async () => {
+    const health = await checkPositionManagerHealth()
+    if (health.critical.length > 0) {
+      // Alerts logged every 30 seconds
+    }
+  }, 30000) // 30-second interval
+}
+```
+
+**Health Checks Performed:**
+1. DB open trades but PM not monitoring → CRITICAL ALERT (Bug #77)
+2. PM has trades but monitoring OFF → CRITICAL ALERT (Bug #77)
+3. Open positions missing SL orders → CRITICAL ALERT per position (Bug #76)
+4. Open positions missing TP orders → WARNING per position
+5. DB vs PM trade count mismatch → WARNING
+6. PM vs Drift position count mismatch → WARNING
+
+**Alert Examples from Dec 9, 2025:**
+```
+❌ CRITICAL: Position SOL-PERP (cmiz40emr0048oe07unapgs0l) has NO STOP LOSS ORDERS!
+   Symbol: SOL-PERP
+   Size: $826
+   slOrderTx: NULL
+   softStopOrderTx: NULL
+   hardStopOrderTx: NULL
+```
+
+---
+
+## Financial Impact Analysis
+
+**Total Losses (User Estimate): $1,000+**
+
+**Breakdown:**
+1. **Stop Hunt Revenge opportunities missed:** $300-600
+   - System coded Nov 20, never ran (service initialization Bug #73)
+   - Quality 85+ signals stopped out, reversals not captured
+   
+2. **Smart Validation missed entries:** $200-400
+   - System coded Nov 30, never ran (service initialization Bug #73)
+   - Manual Telegram trades used stale data instead of fresh TradingView metrics
+   
+3. **Direct position losses:** $200-400+
+   - Unprotected positions due to vanishing stop losses
+   - Dec 8 incident: Position opened without SL (Bug #76)
+   - Could have been catastrophic if price reversed
+   
+4. **Blocked Signals missed opportunities:** $200-400
+   - System coded Nov 19, never ran (service initialization Bug #73)
+   - No data collected for threshold optimization
+
+**Latest Incident (Dec 9, 2025):**
+- **Outcome:** +$9.69 profit (LUCKY)
+- **Risk Exposure:** $826 position with NO stop loss
+- **Potential Loss:** If SOL spiked 5% = -$41.30 loss (or worse)
+- **Why Lucky:** TP2 hit before retry loop removed orders
+
+**Pattern:**
+- Four documented incidents of risk management vanishing
+- Each incident involved multiple interacting bugs
+- Emergency restarts + order re-placement became routine
+- User frustration: "risk management vanished again" - fourth time
+- System appeared protected (logs showed orders) but actually wasn't
+
+---
+
+## Documentation Mandate (Dec 9, 2025)
+
+**New MANDATORY Rule Added to copilot-instructions.md:**
+
+**"MANDATORY: ALWAYS VERIFY DATABASE WITH DRIFT API BEFORE REPORTING NUMBERS"**
+
+**Rule Details:**
+- NEVER trust database P&L, exitPrice, or trade details without Drift confirmation
+- ALWAYS cross-check database against Drift when reporting losses/gains to user
+- Query Drift account health: `curl http://localhost:3001/api/drift/account-health`
+- Compare database totalCollateral with actual Drift balance
+- Incident: Dec 9 database showed -$19.33 loss, Drift showed -$22.21 actual ($2.88 missing)
+- Root Cause: Retry loop multi-chunk close, only first chunk recorded
+- **User Quote:** "drift tells the truth not you"
+- **Status:** NON-NEGOTIABLE for real money trading systems
+
+**Verification Pattern:**
+```bash
+# 1. Check Drift account balance
+curl -s http://localhost:3001/api/drift/account-health | jq '.totalCollateral'
+
+# 2. Query database for trade details
+psql -c "SELECT realizedPnL FROM Trade WHERE id='...'"
+
+# 3. If mismatch: Correct database to match Drift reality
+psql -c "UPDATE Trade SET realizedPnL = DRIFT_ACTUAL WHERE id='...'"
+```
+
+**Git Commit:** dd0013f "docs: Add mandatory Drift API verification rule for financial data" (Dec 9, 21:17)
+
+---
+
+## Multi-Chunk Close Recording Bug
+
+**Symptom:**
+- Position closed in MULTIPLE chunks during retry loop chaos
+- Database records ONLY first chunk
+- Result: Inaccurate P&L and financial reporting
+
+**Real Incident (Dec 9, 2025 20:05):**
+- User screenshot shows TWO closes:
+  * 0.1 SOL: -$0.13 loss
+  * 16.42 SOL: -$22.08 loss
+  * **Total: -$22.21 actual loss**
+- Database shows ONE trade:
+  * realizedPnL: -$19.33 (first chunk only)
+  * **Missing: -$2.88 from second chunk**
+- Drift account health: $215.79 (confirmed -$22.21 total loss)
+
+**Root Cause:**
+- Position Manager records P&L on first external closure
+- Doesn't detect subsequent chunks of same position
+- External closure handler doesn't accumulate multi-chunk closes
+
+**Fix Required:**
+```typescript
+// lib/trading/position-manager.ts - handleExternalClosure()
+// Track if position is being closed in chunks
+private partialCloseTracking = new Map<string, {
+  totalPnL: number
+  chunks: number
+  lastChunkTime: number
+}>()
+
+async handleExternalClosure(trade: ActiveTrade, driftPosition: any) {
+  const tracking = this.partialCloseTracking.get(trade.id) || {
+    totalPnL: 0,
+    chunks: 0,
+    lastChunkTime: 0
+  }
+  
+  // Calculate this chunk's P&L
+  const chunkPnL = calculatePnL(driftPosition)
+  tracking.totalPnL += chunkPnL
+  tracking.chunks += 1
+  tracking.lastChunkTime = Date.now()
+  
+  // Check if position fully closed (Drift size = 0)
+  if (Math.abs(driftPosition.size) < 0.01) {
+    // Position fully closed - save accumulated P&L
+    await updateTradeExit({
+      tradeId: trade.id,
+      realizedPnL: tracking.totalPnL,
+      exitReason: 'external',
+      exitPrice: driftPosition.exitPrice
+    })
+    
+    console.log(`💰 Multi-chunk close: ${tracking.chunks} chunks, total P&L: $${tracking.totalPnL.toFixed(2)}`)
+    this.partialCloseTracking.delete(trade.id)
+  } else {
+    // Partial close - save tracking but keep monitoring
+    this.partialCloseTracking.set(trade.id, tracking)
+    console.log(`📊 Partial close chunk ${tracking.chunks}: $${chunkPnL.toFixed(2)} (total: $${tracking.totalPnL.toFixed(2)})`)
+  }
+}
+```
+
+---
+
+## Critical Lessons Learned
+
+### 1. Silent Failures Are The Most Dangerous
+- Bug #76: placeExitOrders() returns success with missing orders
+- Bug #77: Position Manager logs "monitoring" but isn't
+- System APPEARS to work but actually doesn't
+- User trusts logs, positions left completely unprotected
+- **Fix:** ALWAYS validate success, never trust return values without verification
+
+### 2. Multiple Bugs Create Perfect Storm
+- Bug #76 (SL missing) + Bug #77 (PM not monitoring) + Bug #80 (retry loop) = Catastrophic failure
+- Each bug alone is serious, together they're devastating
+- No single point of failure - entire safety net collapsed
+- **Fix:** Defense in depth requires ALL layers working, not just one
+
+### 3. Temporary Fixes Mask Root Causes
+- Container restart stops retry loop → seems fixed
+- Order re-placement restores protection → seems fixed
+- But root cause (Bug #80 retry logic) still broken
+- Pattern repeats: Fourth time doing emergency restart
+- **Fix:** Stop temporary patches, fix root cause permanently
+
+### 4. "Permanent Fixes" Need Validation
+- Bug #80 fix (5-minute cooldown) deployed Dec 9, 20:50
+- Declared "permanent fix"
+- Actually completely ineffective - retry loop still active
+- **Fix:** Test fixes in production, monitor for recurrence, don't declare victory prematurely
+
+### 5. Documentation Without Enforcement Is Useless
+- copilot-instructions.md contains 70+ common pitfalls
+- Health monitoring system deployed and working
+- Test suite created (113 tests, 7 files)
+- **But:** Bugs still happened because services never ran (Bug #73)
+- **Fix:** Automated enforcement, startup validation, health checks with alerts
+
+### 6. Code That Looks Right Can Be Wrong
+- Position Manager startMonitoring() code looks correct
+- placeExitOrders() code looks correct
+- But actual execution fails silently
+- **Fix:** Test suites that validate ACTUAL behavior, not just code structure
+
+### 7. Real Money Systems Need Real-Time Verification
+- Database can be wrong (multi-chunk close, missing signatures)
+- Logs can lie ("monitoring" when not monitoring)
+- Only source of truth: Drift Protocol API
+- **Fix:** Always verify with Drift API before reporting financial data
+
+---
+
+## Action Plan for New Agent
+
+### Phase 1: IMMEDIATE - Understand the System (1-2 hours)
+1. Read this entire document thoroughly
+2. Read `docs/COMMON_PITFALLS.md` (72 documented bugs)
+3. Read `.github/copilot-instructions.md` (complete system knowledge)
+4. Understand: This is a REAL MONEY system, bugs cause actual financial losses
+
+### Phase 2: Investigation - Root Cause Analysis (2-4 hours)
+
+**Bug #80 Priority Investigation:**
+```bash
+# 1. Check current drift-state-verifier.ts implementation
+cat lib/monitoring/drift-state-verifier.ts | grep -A50 "recentCloseAttempts"
+
+# 2. Add extensive logging to track cooldown behavior
+# Lines to add logging:
+#    - When Map entry created
+#    - When Map entry checked
+#    - When retry skipped due to cooldown
+#    - When retry proceeds despite cooldown
+
+# 3. Test with container running:
+docker logs -f trading-bot-v4 | grep -E "(recentClose|Retrying|MISMATCH)"
+
+# 4. Identify: WHY is cooldown not working?
+#    - Is Map being cleared?
+#    - Is code path different?
+#    - Is mismatch detection before cooldown check?
+#    - Is there a scope/closure issue?
+```
+
+**Bug #77 Priority Investigation:**
+```bash
+# 1. Add logging to Position Manager addTrade()
+# Before: this.activeTrades.set(trade.id, trade)
+# After: this.activeTrades.set(trade.id, trade)
+console.log(`🔍 VERIFY: activeTrades.size = ${this.activeTrades.size}`)
+console.log(`🔍 VERIFY: activeTrades.has('${trade.id}') = ${this.activeTrades.has(trade.id)}`)
+
+# 2. Add logging to startMonitoring()
+console.log(`🔍 BEFORE startMonitoring: isMonitoring = ${this.isMonitoring}`)
+await this.priceMonitor.start(symbols)
+console.log(`🔍 AFTER priceMonitor.start: symbols = ${symbols}`)
+this.isMonitoring = true
+console.log(`🔍 AFTER flag set: isMonitoring = ${this.isMonitoring}`)
+
+# 3. Test with next trade
+# Watch for: Do logs show Map populated? Does isMonitoring become true?
+```
+
+**Bug #76 Investigation:**
+```bash
+# 1. Add logging to placeExitOrders() around SL placement
+# Lines 465-473 in lib/drift/orders.ts
+console.log('🛡️ Attempting SL order placement...')
+console.log('   SL params:', JSON.stringify(slParams, null, 2))
+try {
+  const slSig = await driftClient.placePerpOrder(slParams)
+  console.log('✅ SL signature received:', slSig)
+  signatures.push(slSig)
+} catch (error) {
+  console.error('❌ SL placement error:', error)
+  throw error
+}
+
+# 2. Check Drift SDK documentation
+# Does placePerpOrder() return signature for TRIGGER_MARKET orders?
+# Are triggers different from limit orders in signature handling?
+
+# 3. Test with next trade
+# Watch for: Does "Attempting SL order" log appear? What error if fails?
+```
+
+### Phase 3: Implementation - Permanent Fixes (4-8 hours)
+
+**Priority 1: Fix Bug #80 (Retry Loop)**
+Based on investigation findings, implement REAL permanent fix:
+- Option A: Disable mismatch retry entirely (safest)
+- Option B: On-chain transaction verification before retry
+- Option C: Drift timestamp validation before retry
+- **DO NOT** rely on in-memory Map - proven unreliable
+
+**Priority 2: Fix Bug #76 (SL Placement)**
+```typescript
+// Add validation BEFORE returning from placeExitOrders()
+const expectedCount = useDualStops ? 4 : 3
+if (signatures.length < expectedCount) {
+  throw new Error(`Missing exit orders: expected ${expectedCount}, got ${signatures.length}`)
+}
+
+// Add validation in execute endpoint
+if (exitRes.signatures.length < expectedSigs) {
+  await persistentLogger.logError('MISSING_EXIT_ORDERS', ...)
+  // CRITICAL: Don't fail trade, but alert user immediately
+}
+```
+
+**Priority 3: Fix Bug #77 (Position Manager)**
+```typescript
+// Add verification after addTrade()
+if (this.activeTrades.size > 0 && !this.isMonitoring) {
+  throw new Error('Position Manager failed to start monitoring - CRITICAL')
+}
+
+// Add detailed logging throughout monitoring lifecycle
+// Test with next trade to confirm monitoring actually starts
+```
+
+**Priority 4: Fix Bug #78 (Orphan Cleanup)**
+```typescript
+// Option 1: Verify Drift position closed before cancelAllOrders()
+const driftPosition = await getDriftPosition(trade.symbol)
+if (driftPosition && Math.abs(driftPosition.size) > 0.01) {
+  console.log(`⚠️ Not cancelling - Drift shows open position`)
+  this.activeTrades.delete(tradeId)
+  return
+}
+
+// Option 2: Track order IDs, cancel specific orders only
+// Requires extending ActiveTrade interface with orderIds field
+```
+
+### Phase 4: Testing - Validate Fixes (2-4 hours)
+
+**Test Plan:**
+1. Run existing test suite: `npm test` (should pass all 113 tests)
+2. Deploy fixes to production
+3. Open test trade via Telegram: `long sol --force`
+4. Monitor logs for:
+   - Position Manager: "Trade added" + activeTrades.size > 0 + isMonitoring = true
+   - Exit orders: 3 signatures returned (TP1 + TP2 + SL)
+   - Health Monitor: No CRITICAL alerts
+   - No retry loop: No "Retrying close" messages
+5. Let position run to TP1:
+   - Verify partial close (60%)
+   - Verify runner (40%) continues
+   - Verify SL moved to breakeven
+6. Close runner at TP2
+7. Verify database records complete P&L
+
+**Success Criteria:**
+- ✅ Position Manager isMonitoring = true (Bug #77 fixed)
+- ✅ All three exit order signatures recorded (Bug #76 fixed)
+- ✅ No retry loop messages (Bug #80 fixed)
+- ✅ Health Monitor shows no CRITICAL alerts
+- ✅ Test trade completes full cycle without issues
+
+### Phase 5: Documentation - Update Everything (1-2 hours)
+
+**MANDATORY (per user requirement):**
+1. Update `.github/copilot-instructions.md`:
+   - Mark Bug #76, #77, #78, #80 as FIXED with commit references
+   - Add new lessons learned from investigation
+   - Update "When Making Changes" section with new patterns
+   
+2. Update `docs/COMMON_PITFALLS.md`:
+   - Add complete fix details to each bug entry
+   - Include code examples showing before/after
+   - Document what was tried and why it failed
+   
+3. Create `docs/RISK_MANAGEMENT_FIXES_DEC2025.md`:
+   - Complete timeline of investigation
+   - Root cause analysis for each bug
+   - Fix implementation details
+   - Testing procedures and results
+   
+4. Git commits:
+   ```bash
+   git commit -m "fix: Bug #80 - Permanent fix for retry loop (VERIFIED in production)"
+   git commit -m "fix: Bug #76 - Validate exit order signatures before success"
+   git commit -m "fix: Bug #77 - Verify Position Manager actually starts monitoring"
+   git commit -m "fix: Bug #78 - Check Drift position before cancelling orders"
+   git commit -m "docs: Complete risk management bug fixes documentation"
+   ```
+
+---
+
+## Test Suite Reference
+
+**Location:** `/home/icke/traderv4/tests/integration/position-manager/`
+
+**Files:**
+1. `monitoring-verification.test.ts` (201 lines) - Bug #77 validation
+2. `tp1-detection.test.ts` (16 tests) - TP1 triggers
+3. `breakeven-sl.test.ts` (14 tests) - SL moves after TP1
+4. `adx-runner-sl.test.ts` (18 tests) - ADX-based runner SL
+5. `trailing-stop.test.ts` (16 tests) - ATR trailing
+6. `edge-cases.test.ts` (15 tests) - Token vs USD, phantom detection
+7. `price-verification.test.ts` (18 tests) - Size AND price verification
+
+**Total:** 7 test files, 113 tests
+
+**Run Tests:**
+```bash
+npm test  # All tests (~30 seconds)
+npm test tests/integration/position-manager/monitoring-verification.test.ts  # Specific file
+```
+
+---
+
+## Emergency Response Procedures
+
+**If "Risk Management Vanished" Happens Again:**
+
+1. **IMMEDIATELY verify position status:**
+   ```bash
+   curl -s -X POST http://localhost:3001/api/trading/sync-positions \
+     -H "Authorization: Bearer $(grep '^API_SECRET_KEY=' .env | cut -d'=' -f2)" | jq '.'
+   ```
+
+2. **Check database for order signatures:**
+   ```bash
+   docker exec trading-bot-postgres psql -U postgres -d trading_bot_v4 -c "
+   SELECT 
+     symbol,
+     \"tp1OrderTx\" IS NOT NULL as has_tp1,
+     \"tp2OrderTx\" IS NOT NULL as has_tp2,
+     \"slOrderTx\" IS NOT NULL as has_sl
+   FROM \"Trade\" 
+   WHERE \"exitReason\" IS NULL 
+   ORDER BY \"createdAt\" DESC 
+   LIMIT 1;"
+   ```
+
+3. **If position exists but orders missing:**
+   ```bash
+   # DON'T restart container (may lose tracking)
+   # Instead, place orders via emergency endpoint:
+   curl -X POST http://localhost:3001/api/trading/place-exit-orders \
+     -H "Authorization: Bearer $(grep '^API_SECRET_KEY=' .env | cut -d'=' -f2)" \
+     -H "Content-Type: application/json" \
+     -d '{
+       "symbol": "SOL-PERP",
+       "direction": "long",
+       "entryPrice": 140.00,
+       "tp1Price": 141.20,
+       "tp2Price": 142.40,
+       "slPrice": 138.71,
+       "tp1SizePercent": 60
+     }'
+   ```
+
+4. **Verify order placement:**
+   ```bash
+   docker logs trading-bot-v4 2>&1 | grep -E "(Exit orders placed|signatures)" | tail -10
+   ```
+
+5. **Check for retry loop:**
+   ```bash
+   docker logs trading-bot-v4 2>&1 | grep -E "(Retrying close|MISMATCH)" | tail -20
+   ```
+
+6. **If retry loop active:**
+   ```bash
+   # Last resort: Restart container
+   docker restart trading-bot-v4
+   # Then re-place orders using step 3
+   ```
+
+---
+
+## Key Files Reference
+
+**Bug Locations:**
+- Bug #76: `lib/drift/orders.ts` (placeExitOrders function, lines 252-495)
+- Bug #77: `lib/trading/position-manager.ts` (addTrade/startMonitoring, lines 257-518)
+- Bug #78: `lib/trading/position-manager.ts` (removeTrade, lines 275-300)
+- Bug #80: `lib/monitoring/drift-state-verifier.ts` (retry loop logic)
+
+**Health Monitoring:**
+- Detection: `lib/health/position-manager-health.ts` (177 lines)
+- Startup: `lib/startup/init-position-manager.ts` (line ~78)
+
+**Documentation:**
+- Complete pitfalls: `docs/COMMON_PITFALLS.md` (72 bugs)
+- System knowledge: `.github/copilot-instructions.md` (6,500+ lines)
+- This analysis: `docs/CRITICAL_RISK_MANAGEMENT_BUG_DEC9_2025.md`
+
+**Database Schema:**
+- Schema: `prisma/schema.prisma`
+- Order signature fields: slOrderTx, softStopOrderTx, hardStopOrderTx, tp1OrderTx, tp2OrderTx
+
+---
+
+## Final Notes for New Agent
+
+**This is NOT theoretical:**
+- Real user, real money ($540 capital targeting $100k)
+- Real losses ($1,000+ to date)
+- Real frustration: "risk management vanished again" (fourth time)
+- Real urgency: User counting on system to build wealth
+
+**The bugs are interconnected:**
+- Fixing one bug alone won't solve the problem
+- All four bugs must be fixed permanently
+- Emergency restarts are temporary band-aids
+- Need real, validated, permanent solutions
+
+**Don't trust anything:**
+- Logs can lie (Position Manager "monitoring" when not)
+- Return values can lie (placeExitOrders success with missing orders)
+- Database can be wrong (multi-chunk closes, missing signatures)
+- Only source of truth: Drift Protocol API
+
+**Verify everything:**
+- Check actual Drift position state before believing database
+- Validate return values before declaring success
+- Test fixes in production with real trades
+- Monitor for days/weeks to confirm bugs actually fixed
+
+**Document everything:**
+- Update copilot-instructions.md (MANDATORY)
+- Add to Common Pitfalls (MANDATORY)
+- Git commit with detailed messages (MANDATORY)
+- User expects documentation with every code change
+
+**Good luck. The user is counting on you to fix this permanently.**
+
+---
+
+**Document Created:** Dec 9, 2025 22:00 UTC
+**Author:** AI Agent (session before handoff)
+**Next Agent:** Please read this COMPLETELY before starting work
+**User Expectation:** Permanent fixes, not temporary patches
+**Critical Priority:** Stop the "risk management vanished" pattern once and for all