📚 COMPREHENSIVE KNOWLEDGE DOCUMENTATION

ADVANCED SYSTEM KNOWLEDGE:
- Superior parallel screenshot system (60% performance gain)
- AI learning system architecture and decision flow
- Orphaned order cleanup integration patterns
- Critical technical fixes and troubleshooting guide
- Database schema best practices
- Memory leak prevention strategies

- AI learning system patterns and functions
- Error handling best practices for trading systems
- Integration patterns for position monitoring
- Performance optimization rules
- UI/UX consistency requirements
- Critical anti-patterns to avoid

- Added links to new knowledge base documents
- Comprehensive documentation structure
- Development guides and best practices
- Performance optimizations summary

- 60% screenshot performance improvement techniques
- AI learning system that adapts trading decisions
- Container stability and crash prevention
- Frontend-backend consistency requirements
- Integration strategies for existing infrastructure

This documentation preserves critical insights from complex debugging sessions and provides patterns for future development.

.github/copilot-instructions.md

@@ -0,0 +1,302 @@
+# GitHub Copilot Instructions for Trading Bot Development
+
+## 🎯 Project Context & Architecture
+
+This is an AI-powered trading automation system with advanced learning capabilities. When working on this codebase:
+
+### Core System Components
+1. **Superior Parallel Screenshot System** - 60% faster than sequential capture
+2. **AI Learning System** - Adapts trading decisions based on outcomes  
+3. **Orphaned Order Cleanup** - Automatic cleanup when positions close
+4. **Position Monitoring** - Frequent checks with integrated cleanup triggers
+
+### Critical File Relationships
+```
+app/api/automation/position-monitor/route.js → Monitors positions + triggers cleanup
+lib/simplified-stop-loss-learner.js → AI learning core with pattern recognition
+lib/superior-screenshot-service.ts → Parallel screenshot capture system
+lib/enhanced-autonomous-risk-manager.js → Risk management with AI integration
+```
+
+## 🧠 AI Learning System Patterns
+
+### Always Include These Functions in Learning Classes:
+```javascript
+async generateLearningReport() {
+  // Return comprehensive learning status
+  return {
+    summary: { totalDecisions, systemConfidence, successRate },
+    insights: { thresholds, confidenceLevel },
+    recommendations: []
+  };
+}
+
+async getSmartRecommendation(requestData) {
+  // Analyze patterns and return AI recommendation
+  const { distanceFromSL, symbol, marketConditions } = requestData;
+  // Return: { action, confidence, reasoning }
+}
+
+async recordDecision(decisionData) {
+  // Log decision for learning with unique ID
+  const id = `decision_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  // Store in database for pattern analysis
+}
+
+async assessDecisionOutcome(outcomeData) {
+  // Update decision with actual result for learning
+  // Calculate if decision was correct based on outcome
+}
+```
+
+### Database Operations Best Practices:
+```javascript
+// ALWAYS provide unique IDs for Prisma records
+await prisma.ai_learning_data.create({
+  data: {
+    id: `${prefix}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+    // ... other fields
+  }
+});
+
+// Use correct import path
+const { getDB } = require('./db');  // NOT './database-util'
+```
+
+## 🔧 Error Handling Patterns
+
+### Function Existence Checks:
+```javascript
+// Always check if functions exist before calling
+if (typeof this.learner.generateLearningReport === 'function') {
+  const report = await this.learner.generateLearningReport();
+} else {
+  // Fallback to alternative method
+  const status = await this.learner.getLearningStatus();
+}
+```
+
+### Comprehensive Try-Catch:
+```javascript
+try {
+  const result = await aiFunction();
+  return result;
+} catch (error) {
+  await this.log(`❌ AI function error: ${error.message}`);
+  return fallbackResult(); // Always provide fallback
+}
+```
+
+## 📊 Integration Patterns
+
+### Position Monitor Integration:
+```javascript
+// When no position detected, check for orphaned orders
+if (!result.hasPosition) {
+  console.log('📋 No active positions detected - checking for orphaned orders...');
+  
+  try {
+    const ordersResponse = await fetch(`${baseUrl}/api/drift/orders`);
+    if (ordersResponse.ok) {
+      const ordersData = await ordersResponse.json();
+      if (ordersData.orders?.length > 0) {
+        // Trigger cleanup
+        const cleanupResponse = await fetch(`${baseUrl}/api/drift/cleanup-orders`, {
+          method: 'POST'
+        });
+        // Handle cleanup result
+      }
+    }
+  } catch (error) {
+    // Handle error gracefully
+  }
+}
+```
+
+### Parallel Processing for Screenshots:
+```javascript
+// Use Promise.allSettled for parallel processing
+const promises = timeframes.map(timeframe => 
+  captureTimeframe(timeframe, symbol, layoutType)
+);
+const results = await Promise.allSettled(promises);
+
+// Process results with error isolation
+results.forEach((result, index) => {
+  if (result.status === 'fulfilled') {
+    // Handle success
+  } else {
+    // Handle individual failure without breaking others
+  }
+});
+```
+
+## 🎯 Performance Optimization Rules
+
+### Screenshot Capture:
+- Always use parallel processing for multiple timeframes
+- Reuse browser sessions to avoid login/captcha
+- Isolate errors so one failure doesn't break others
+- Prefer `Promise.allSettled` over `Promise.all`
+
+### Database Queries:
+- Use indexed fields for frequent searches (symbol, createdAt)
+- Batch operations when possible
+- Include proper error handling for connection issues
+
+### Container Optimization:
+- Check syntax before deployment: `node -c filename.js`
+- Use health checks for monitoring
+- Implement graceful shutdown handling
+
+## 🧪 Testing Requirements
+
+### Always Include These Tests:
+```javascript
+// Test AI learning functions
+const learner = new SimplifiedStopLossLearner();
+const report = await learner.generateLearningReport();
+console.log('Learning report:', report.summary);
+
+// Test API endpoints
+const response = await fetch('/api/automation/position-monitor');
+const result = await response.json();
+console.log('Position monitor working:', result.success);
+
+// Test error scenarios
+try {
+  await riskyFunction();
+} catch (error) {
+  console.log('Error handling working:', error.message);
+}
+```
+
+## 🎨 UI/UX Patterns
+
+### Preset Configuration:
+```javascript
+// Frontend presets MUST match backend exactly
+const TRADING_PRESETS = {
+  scalp: ['5m', '15m', '30m'],    // NOT ['5m', '15m', '1h']
+  day: ['1h', '2h'],              // NOT ['1h', '4h', '1d']  
+  swing: ['4h', '1D'],
+  extended: ['1m', '3m', '5m', '15m', '30m', '1h', '4h', '1D']
+};
+```
+
+### Status Display:
+```javascript
+// Always provide detailed feedback
+return {
+  success: true,
+  monitor: {
+    hasPosition: false,
+    orphanedOrderCleanup: {
+      triggered: true,
+      success: true,
+      message: 'Cleaned up 2 orphaned orders',
+      summary: { totalCanceled: 2 }
+    }
+  }
+};
+```
+
+## 🔍 Debugging Strategies
+
+### Container Issues:
+```bash
+# Check for syntax errors
+find . -name "*.js" -exec node -c {} \;
+
+# Monitor logs for patterns
+docker logs trader_dev --since="1m" | grep -E "(Error|unhandled|crash)"
+
+# Test specific components
+node test-learning-system.js
+```
+
+### Integration Issues:
+```bash
+# Test API endpoints individually
+curl -s http://localhost:9001/api/automation/position-monitor | jq .
+
+# Verify database connectivity
+node -e "const {getDB} = require('./lib/db'); getDB().then(() => console.log('DB OK'));"
+```
+
+## 🚨 Critical Anti-Patterns to Avoid
+
+### ❌ Don't Do This:
+```javascript
+// Missing error handling
+const report = await this.learner.generateLearningReport(); // Will crash if function missing
+
+// Redundant polling
+setInterval(checkOrders, 60000); // When position monitor already runs frequently
+
+// Frontend/backend preset mismatch  
+backend: ['5m', '15m', '1h']
+frontend: ['5m', '15m', '30m'] // Will cause confusion
+
+// Missing unique IDs
+await prisma.create({ data: { symbol, timeframe } }); // Will fail validation
+```
+
+### ✅ Do This Instead:
+```javascript
+// Defensive programming
+if (typeof this.learner.generateLearningReport === 'function') {
+  try {
+    const report = await this.learner.generateLearningReport();
+  } catch (error) {
+    await this.log(`Report generation failed: ${error.message}`);
+  }
+}
+
+// Leverage existing infrastructure
+// Add cleanup to existing position monitor instead of new polling
+
+// Ensure consistency
+const PRESETS = { scalp: ['5m', '15m', '30m'] }; // Same in frontend and backend
+
+// Always provide unique IDs
+const id = `${type}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+```
+
+## 🎯 Configuration Standards
+
+### Environment Variables:
+```javascript
+// Always provide fallbacks
+const apiKey = process.env.OPENAI_API_KEY || '';
+if (!apiKey) {
+  throw new Error('OPENAI_API_KEY is required');
+}
+```
+
+### Next.js Configuration:
+```typescript
+// Use new format, not deprecated
+const nextConfig: NextConfig = {
+  serverExternalPackages: ['puppeteer-core'], // NOT experimental.serverComponentsExternalPackages
+  transpilePackages: ['next-font'],
+  typescript: { ignoreBuildErrors: true },
+  eslint: { ignoreDuringBuilds: true }
+};
+```
+
+## 📈 Enhancement Guidelines
+
+When adding new features:
+
+1. **Check Existing Infrastructure** - Can it be integrated vs creating new?
+2. **Add Comprehensive Error Handling** - Assume functions may not exist
+3. **Include Fallback Mechanisms** - System should work without AI/learning
+4. **Test in Isolation** - Create test scripts for new components
+5. **Document Integration Points** - How does it connect to existing systems?
+6. **Maintain Consistency** - Frontend and backend must match exactly
+7. **Use Defensive Programming** - Check before calling, handle gracefully
+
+---
+
+**Follow these patterns to maintain system stability and avoid the complex debugging issues that were resolved in this session.**

ADVANCED_SYSTEM_KNOWLEDGE.md

@@ -0,0 +1,266 @@
+# 🧠 AI Learning & Advanced System Knowledge
+
+## 🎯 Critical System Components (Learned from Session)
+
+### 📊 Superior Parallel Screenshot System
+**BREAKTHROUGH: 60% Performance Improvement**
+
+```javascript
+// Key Implementation in lib/superior-screenshot-service.ts
+- Parallel capture vs sequential: 71s vs 180s for 3 timeframes
+- Trading Presets Must Match Frontend UI EXACTLY:
+  * Scalp: 5m,15m,30m (NOT 5m,15m,1h)
+  * Day: 1h,2h (NOT 1h,4h,1d) 
+  * Swing: 4h,1D
+  * Extended: 1m-1D comprehensive
+```
+
+**Critical Lesson**: Frontend UI is the source of truth for preset definitions.
+
+### 🧹 Orphaned Order Cleanup Integration
+**PROBLEM SOLVED**: Drift always leaves opposite positions open after SL/TP hits
+
+```javascript
+// Integration Point: app/api/automation/position-monitor/route.js
+- Triggers cleanup ONLY when hasPosition: false
+- Uses existing frequent position monitoring (no redundant polling)
+- Provides detailed cleanup results in monitoring response
+
+Key Insight: Leverage existing monitoring infrastructure vs creating separate timers
+```
+
+### 🤖 AI Learning System Architecture
+**CRITICAL COMPONENT**: Actual learning system that adapts trading decisions
+
+```javascript
+// lib/simplified-stop-loss-learner.js - Core Learning Functions:
+1. recordDecision() - Logs every risk management choice
+2. assessDecisionOutcome() - Tracks what actually happened
+3. getSmartRecommendation() - AI suggestions based on learned patterns
+4. generateLearningReport() - 15-minute learning progress reports
+
+// Learning Flow:
+Risk Manager -> Records Decision -> Waits 5min -> Assesses Outcome -> Updates Thresholds
+```
+
+**Key Learning**: This isn't just statistics - it actively influences trading decisions!
+
+## 🔧 Critical Technical Fixes
+
+### Database Schema Issues
+```javascript
+// ISSUE: Prisma validation errors crashed container
+// FIX: Always provide unique ID for ai_learning_data records
+await prisma.ai_learning_data.create({
+  data: {
+    id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+    // ... other fields
+  }
+});
+```
+
+### Memory Leak Prevention
+```javascript
+// ISSUE: Unhandled promise rejections caused EventEmitter overflow
+// FIX: Proper error handling with try/catch and function existence checks
+if (typeof this.learner.generateLearningReport === 'function') {
+  const report = await this.learner.generateLearningReport();
+}
+```
+
+### Import Path Corrections
+```javascript
+// ISSUE: Module not found errors
+// FIX: Use correct relative paths for database utilities
+const { getDB } = require('./db');  // NOT './database-util'
+```
+
+## 🎯 AI Learning System Deep Dive
+
+### How The AI Actually Learns
+1. **Pattern Recognition**: 
+   ```
+   "When SOL is 4% from SL with bullish momentum, holding works 73% of time"
+   ```
+
+2. **Threshold Optimization**:
+   ```
+   Original: Emergency=1%, Risk=2%
+   After Learning: Emergency=0.7%, Risk=1.8% (based on outcomes)
+   ```
+
+3. **Smart Recommendations**:
+   ```javascript
+   // AI analyzes similar historical situations
+   const recommendation = await learner.getSmartRecommendation({
+     distanceFromSL: 3.5,
+     symbol: 'SOL-PERP',
+     marketConditions: { /* current state */ }
+   });
+   // Returns: EMERGENCY_EXIT vs HOLD_CONFIDENT based on learned patterns
+   ```
+
+### Learning Confidence Progression
+```
+0-5 decisions: 30% confidence (LOW)
+5-20 decisions: 40-60% confidence (MEDIUM)  
+20-50 decisions: 60-80% confidence (HIGH)
+50+ decisions: 80-95% confidence (EXPERT)
+```
+
+## 🚨 Critical Error Patterns & Solutions
+
+### Container Crash Root Causes
+1. **Database Schema Violations** → Add unique IDs to all Prisma records
+2. **Missing Function Calls** → Implement all required interfaces
+3. **Memory Leaks from Unhandled Errors** → Comprehensive error handling
+4. **Configuration Deprecations** → Keep configs updated with framework changes
+
+### Next.js Common Issues
+```javascript
+// Issue: serverComponentsExternalPackages deprecated
+// Old: experimental.serverComponentsExternalPackages
+// New: serverExternalPackages
+
+// Issue: Module resolution in Docker
+// Fix: Ensure correct relative paths for all imports
+```
+
+## 💡 Development Best Practices Discovered
+
+### 1. Integration Strategy
+- **Leverage Existing Infrastructure**: Don't create redundant polling when monitoring already exists
+- **Gradual Enhancement**: Add features to existing endpoints vs creating new ones
+- **Fail Gracefully**: Always provide fallbacks for AI/learning features
+
+### 2. Testing Approach
+```javascript
+// Always test critical components in isolation
+node test-learning-system.js     // Test AI learning
+node test-orphaned-cleanup.js    // Test cleanup integration
+curl /api/automation/position-monitor  // Test monitoring
+```
+
+### 3. Error Handling Philosophy
+```javascript
+// Defensive Programming for AI Systems
+try {
+  const aiResult = await aiFunction();
+  return aiResult;
+} catch (error) {
+  logger.error(`AI function failed: ${error.message}`);
+  return fallbackFunction(); // Always have a fallback
+}
+```
+
+## 🎯 Performance Optimizations
+
+### Screenshot Capture
+- **Parallel Processing**: 60% time savings over sequential
+- **Session Reuse**: Avoid repeated logins/captchas
+- **Error Isolation**: One layout failure doesn't break others
+
+### Database Operations
+- **Batch Inserts**: For multiple learning records
+- **Indexed Queries**: On frequently searched fields (symbol, createdAt)
+- **Connection Pooling**: Reuse database connections
+
+### Container Optimization
+```dockerfile
+# Multi-stage builds for smaller images
+# Non-root user for security
+# Health checks for monitoring
+# Proper signal handling for graceful shutdowns
+```
+
+## 🧪 Testing Protocols
+
+### AI Learning System
+```bash
+# Test learning functions
+node test-learning-system.js
+
+# Expected output:
+✅ Learning report generated: 0 decisions, 30% confidence
+✅ Smart recommendation: MONITOR at 3.5% distance
+```
+
+### Integration Testing
+```bash
+# Test orphaned cleanup integration
+curl /api/automation/position-monitor | jq '.monitor.orphanedOrderCleanup'
+
+# Test parallel screenshots
+curl -X POST /api/superior-screenshot -d '{"timeframes":["5m","15m","30m"]}'
+```
+
+### System Health
+```bash
+# Monitor for critical errors
+docker logs trader_dev --since="1m" | grep -E "(Error|unhandled|crash)"
+
+# Should return: 0 errors
+```
+
+## 📈 Future Enhancement Opportunities
+
+### 1. Advanced Learning Features
+- **Market Condition Clustering**: Group similar market states
+- **Volatility Adaptation**: Adjust thresholds based on VIX/volatility
+- **Time-of-Day Learning**: Different strategies for different sessions
+
+### 2. Performance Improvements
+- **WebSocket Integration**: Real-time position monitoring
+- **Caching Layer**: Redis for frequently accessed data
+- **GPU Acceleration**: For complex AI computations
+
+### 3. Risk Management Enhancements
+- **Portfolio-Level Learning**: Cross-symbol pattern recognition
+- **Drawdown Protection**: Automatic position sizing reduction
+- **Correlation Analysis**: Avoid over-concentration
+
+## 🔍 Debugging Guide
+
+### Common Issues & Solutions
+
+1. **Container Won't Start**
+   ```bash
+   # Check syntax errors
+   find . -name "*.js" -exec node -c {} \;
+   
+   # Check Docker logs
+   docker logs trader_dev --tail=50
+   ```
+
+2. **AI Learning Not Working**
+   ```bash
+   # Test learning functions
+   node -e "
+   const Learner = require('./lib/simplified-stop-loss-learner');
+   const l = new Learner();
+   l.generateLearningReport().then(console.log);
+   "
+   ```
+
+3. **Database Connection Issues**
+   ```bash
+   # Test database connectivity
+   node -e "
+   const { getDB } = require('./lib/db');
+   getDB().then(() => console.log('DB connected'));
+   "
+   ```
+
+## 🎓 Key Learnings for Future Development
+
+1. **Always Verify Frontend-Backend Consistency**: UI defines truth
+2. **Implement Comprehensive Error Handling**: Prevent cascade failures  
+3. **Use Existing Infrastructure**: Don't reinvent monitoring/polling
+4. **Test AI Components Independently**: Isolate learning system testing
+5. **Document Integration Points**: Critical for maintenance
+6. **Monitor System Health**: Proactive error detection
+7. **Version Control Critical Fixes**: Always commit stability improvements
+
+---
+
+**This knowledge base captures critical insights that took significant debugging to discover. Use it to avoid repeating complex troubleshooting and to guide future enhancements.**

README.md

@@ -332,6 +332,38 @@ curl -X POST http://localhost:9001/api/automation \
 4. Push to branch: `git push origin feature/amazing-feature`
 5. Open a Pull Request
 
+## 📚 Documentation & Knowledge Base
+
+This project includes comprehensive documentation covering all aspects of the system:
+
+### 🎯 **Core Documentation**
+- **`README.md`** - Main project overview and quick start guide
+- **`ADVANCED_SYSTEM_KNOWLEDGE.md`** - Critical technical insights and troubleshooting
+- **`.github/copilot-instructions.md`** - Development patterns and best practices
+
+### 🧠 **AI & Learning System**
+- **Complete AI Learning Architecture** - Pattern recognition and adaptive decision making
+- **Smart Recommendation Engine** - Historical outcome analysis for trading decisions
+- **Learning Report Generation** - 15-minute progress reports with confidence tracking
+- **Threshold Optimization** - Automatic adjustment based on trading success rates
+
+### 🔧 **Technical Analysis Documentation**
+- **`TECHNICAL_ANALYSIS_BASICS.md`** - Complete guide to all indicators used
+- **`TA_QUICK_REFERENCE.md`** - Quick reference for indicator interpretation
+- **AI Analysis Integration** - TA fundamentals built into AI analysis prompts
+
+### ⚡ **Performance Optimizations**
+- **Superior Parallel Screenshot System** - 60% faster than sequential (71s vs 180s)
+- **Orphaned Order Cleanup Integration** - Automatic cleanup when positions close
+- **Container Stability Fixes** - Resolved memory leaks and crash issues
+- **Database Schema Optimizations** - Proper Prisma validation and error handling
+
+### 🛠️ **Development Guides**
+- **Integration Patterns** - How to add features without breaking existing systems
+- **Error Handling Best Practices** - Defensive programming for AI systems
+- **Testing Protocols** - Isolated testing for critical components
+- **Debugging Strategies** - Common issues and their solutions
+
 ## <20> Technical Analysis Documentation
 
 This project includes comprehensive Technical Analysis (TA) documentation:

app/api/automation/stop/route.js

@@ -1,10 +1,10 @@
-import { positionAwareAutomation } from '@/lib/position-aware-automation';
+import { simpleAutomation } from '@/lib/simple-automation';
 
 export async function POST() {
   try {
     console.log('🛑 AUTOMATION STOP: Request received');
     
-    const result = await positionAwareAutomation.stop();
+    const result = await simpleAutomation.stop();
     
     // Additional cleanup
     try {

app/api/enhanced-screenshot/route.js

@@ -0,0 +1,165 @@
+import { NextResponse } from 'next/server'
+import { superiorScreenshotService } from '../../../lib/superior-screenshot-service'
+import { aiAnalysisService } from '../../../lib/ai-analysis'
+import { progressTracker } from '../../../lib/progress-tracker'
+
+export async function POST(request) {
+  let sessionId = null
+  
+  try {
+    const body = await request.json()
+    console.log('🔍 Enhanced Screenshot API request:', body)
+
+    const config = {
+      symbol: body.symbol || 'SOLUSD',
+      timeframe: body.timeframe || '240',
+      layouts: body.layouts || ['ai', 'diy'],
+      analyze: body.analyze === true
+    }
+
+    // Create session for progress tracking
+    sessionId = progressTracker.createSession()
+    config.sessionId = sessionId
+    
+    console.log(`🔍 Created session ${sessionId} for enhanced screenshot`)
+
+    // Initialize progress steps
+    progressTracker.initializeSteps(sessionId, [
+      { id: 'init', name: 'Initialize', status: 'active' },
+      { id: 'auth', name: 'Authentication', status: 'pending' },
+      { id: 'loading', name: 'Loading Chart', status: 'pending' },
+      { id: 'capture', name: 'Capture Screenshot', status: 'pending' },
+      { id: 'analysis', name: 'AI Analysis', status: 'pending' }
+    ])
+
+    let screenshots = []
+    let analysis = null
+
+    // Capture screenshots using superior parallel technique
+    try {
+      console.log('🚀 Starting superior screenshot capture...')
+      
+      // Use single timeframe capture for backwards compatibility
+      const screenshotPaths = await superiorScreenshotService.captureQuick(
+        config.symbol, 
+        config.timeframe, 
+        config.layouts
+      )
+      
+      screenshots = screenshotPaths
+      console.log('📸 Superior screenshot capture completed:', screenshots.length, 'files')
+    } catch (screenshotError) {
+      console.error('❌ Superior screenshot capture failed:', screenshotError)
+      throw new Error(`Screenshot capture failed: ${screenshotError.message}`)
+    }
+
+    // Run AI analysis if requested
+    if (config.analyze && screenshots.length > 0) {
+      try {
+        console.log('🤖 Starting AI analysis...')
+        progressTracker.updateStep(sessionId, 'analysis', 'active', 'Analyzing screenshots...')
+        
+        const analysisConfig = {
+          sessionId,
+          screenshots,
+          symbol: config.symbol,
+          timeframe: config.timeframe,
+          layouts: config.layouts
+        }
+        
+        analysis = await aiAnalysisService.analyzeScreenshots(analysisConfig)
+        
+        if (analysis) {
+          progressTracker.updateStep(sessionId, 'analysis', 'completed', 'Analysis completed successfully')
+          console.log('✅ AI analysis completed')
+        } else {
+          progressTracker.updateStep(sessionId, 'analysis', 'error', 'Analysis failed to return results')
+          console.warn('⚠️ AI analysis completed but returned no results')
+        }
+        
+      } catch (analysisError) {
+        console.error('❌ AI analysis failed:', analysisError)
+        progressTracker.updateStep(sessionId, 'analysis', 'error', analysisError.message)
+        // Don't throw - return partial results with screenshots
+        analysis = { error: analysisError.message }
+      }
+    }
+
+    console.log('📸 Final screenshots:', screenshots)
+
+    const result = {
+      success: true,
+      sessionId,
+      timestamp: Date.now(),
+      symbol: config.symbol,
+      layouts: config.layouts,
+      timeframes: [config.timeframe],
+      screenshots,
+      analysis,
+      message: `Successfully captured ${screenshots.length} screenshot(s)${config.analyze ? ' with AI analysis' : ''}`
+    }
+
+    console.log('✅ Enhanced screenshot API completed successfully')
+    return NextResponse.json(result)
+
+  } catch (error) {
+    console.error('❌ Enhanced screenshot API error:', error)
+    
+    if (sessionId) {
+      // Mark any active step as error
+      const progress = progressTracker.getProgress(sessionId)
+      if (progress) {
+        const activeStep = progress.steps.find(step => step.status === 'active')
+        if (activeStep) {
+          progressTracker.updateStep(sessionId, activeStep.id, 'error', error.message)
+        }
+      }
+    }
+
+    return NextResponse.json({
+      success: false,
+      error: error.message,
+      timestamp: Date.now(),
+      sessionId
+    }, { status: 500 })
+    
+  } finally {
+    // CRITICAL: Always run cleanup in finally block
+    console.log('🧹 FINALLY BLOCK: Running superior screenshot service cleanup...')
+    
+    try {
+      // Force cleanup all browser sessions (API-managed, no action needed)
+      await superiorScreenshotService.cleanup()
+      console.log('✅ FINALLY BLOCK: Superior screenshot service cleanup completed')
+      
+      // Also run aggressive cleanup to ensure no processes remain
+      const { automatedCleanupService } = await import('../../../lib/automated-cleanup-service')
+      await automatedCleanupService.forceCleanup()
+      console.log('✅ FINALLY BLOCK: Automated cleanup completed')
+      
+    } catch (cleanupError) {
+      console.error('❌ FINALLY BLOCK: Error during cleanup:', cleanupError)
+    }
+    
+    // Clean up progress session after delay to allow frontend to read final state
+    if (sessionId) {
+      setTimeout(() => {
+        try {
+          progressTracker.deleteSession(sessionId)
+          console.log(`🗑️ Cleaned up session ${sessionId}`)
+        } catch (sessionCleanupError) {
+          console.error('Error cleaning up session:', sessionCleanupError)
+        }
+      }, 30000) // 30 second delay
+    }
+  }
+}
+
+export async function GET() {
+  return NextResponse.json({
+    message: 'Enhanced Screenshot API - use POST method for analysis',
+    endpoints: {
+      POST: '/api/enhanced-screenshot - Run analysis with parameters'
+    }
+  })
+}

app/automation-v2/page-clean.js

@@ -0,0 +1,444 @@
+'use client'
+import React, { useState, useEffect } from 'react'
+
+// Available timeframes for automation (matching analysis page format)
+const timeframes = [
+  { label: '5m', value: '5' },
+  { label: '15m', value: '15' },
+  { label: '30m', value: '30' },
+  { label: '1h', value: '60' },
+  { label: '2h', value: '120' },
+  { label: '4h', value: '240' },
+  { label: '1d', value: 'D' },
+]
+
+export default function AutomationPageV2() {
+  const [config, setConfig] = useState({
+    mode: 'SIMULATION',
+    dexProvider: 'DRIFT',
+    symbol: 'SOLUSD',
+    selectedTimeframes: ['60'], // Multi-timeframe support
+    tradingAmount: 100,
+    balancePercentage: 50, // Default to 50% of available balance
+  })
+
+  const [status, setStatus] = useState(null)
+  const [balance, setBalance] = useState(null)
+  const [positions, setPositions] = useState([])
+  const [loading, setLoading] = useState(false)
+
+  useEffect(() => {
+    fetchStatus()
+    fetchBalance()
+    fetchPositions()
+    
+    const interval = setInterval(() => {
+      fetchStatus()
+      fetchBalance()
+      fetchPositions()
+    }, 30000)
+    return () => clearInterval(interval)
+  }, [])
+
+  const toggleTimeframe = (timeframe) => {
+    setConfig(prev => ({
+      ...prev,
+      selectedTimeframes: prev.selectedTimeframes.includes(timeframe)
+        ? prev.selectedTimeframes.filter(tf => tf !== timeframe)
+        : [...prev.selectedTimeframes, timeframe]
+    }))
+  }
+
+  const fetchStatus = async () => {
+    try {
+      const response = await fetch('/api/automation/status')
+      const data = await response.json()
+      if (data.success) {
+        setStatus(data.status)
+      }
+    } catch (error) {
+      console.error('Failed to fetch status:', error)
+    }
+  }
+
+  const fetchBalance = async () => {
+    try {
+      const response = await fetch('/api/drift/balance')
+      const data = await response.json()
+      if (data.success) {
+        setBalance(data)
+      }
+    } catch (error) {
+      console.error('Failed to fetch balance:', error)
+    }
+  }
+
+  const fetchPositions = async () => {
+    try {
+      const response = await fetch('/api/drift/positions')
+      const data = await response.json()
+      if (data.success) {
+        setPositions(data.positions || [])
+      }
+    } catch (error) {
+      console.error('Failed to fetch positions:', error)
+    }
+  }
+
+  const handleStart = async () => {
+    console.log('🚀 Starting automation...')
+    setLoading(true)
+    try {
+      if (config.selectedTimeframes.length === 0) {
+        console.error('No timeframes selected')
+        setLoading(false)
+        return
+      }
+
+      const automationConfig = {
+        symbol: config.symbol,
+        selectedTimeframes: config.selectedTimeframes,
+        mode: config.mode,
+        tradingAmount: config.tradingAmount,
+        leverage: config.leverage,
+        stopLoss: config.stopLoss,
+        takeProfit: config.takeProfit
+      }
+
+      const response = await fetch('/api/automation/start', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(automationConfig)
+      })
+      
+      const data = await response.json()
+      
+      if (data.success) {
+        console.log('✅ Automation started successfully')
+        fetchStatus()
+      } else {
+        console.error('Failed to start automation:', data.error)
+      }
+    } catch (error) {
+      console.error('Failed to start automation:', error)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const handleStop = async () => {
+    console.log('🛑 Stopping automation...')
+    setLoading(true)
+    try {
+      const response = await fetch('/api/automation/stop', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' }
+      })
+      
+      const data = await response.json()
+      
+      if (data.success) {
+        console.log('✅ Automation stopped successfully')
+        fetchStatus()
+      } else {
+        console.error('Failed to stop automation:', data.error)
+      }
+    } catch (error) {
+      console.error('Failed to stop automation:', error)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  return (
+    <div className="space-y-6">
+      {/* Header with Start/Stop */}
+      <div className="flex items-center justify-between">
+        <div>
+          <h1 className="text-3xl font-bold text-white">Automated Trading</h1>
+          <p className="text-gray-400 mt-1">Multi-Timeframe Analysis</p>
+        </div>
+        <div className="flex space-x-3">
+          {status?.isActive ? (
+            <button
+              onClick={handleStop}
+              disabled={loading}
+              className="px-6 py-3 bg-red-600 text-white rounded-lg hover:bg-red-700 transition-colors disabled:opacity-50 font-semibold"
+            >
+              {loading ? 'Stopping...' : 'STOP'}
+            </button>
+          ) : (
+            <button
+              onClick={handleStart}
+              disabled={loading}
+              className="px-6 py-3 bg-green-600 text-white rounded-lg hover:bg-green-700 transition-colors disabled:opacity-50 font-semibold"
+            >
+              {loading ? 'Starting...' : 'START'}
+            </button>
+          )}
+        </div>
+      </div>
+      
+      <div className="grid grid-cols-1 xl:grid-cols-3 gap-6">
+        {/* Configuration Panel */}
+        <div className="xl:col-span-2 space-y-6">
+          <div className="bg-gray-800 p-6 rounded-lg border border-gray-700">
+            <h3 className="text-xl font-bold text-white mb-6">Configuration</h3>
+            
+            {/* Trading Mode */}
+            <div className="grid grid-cols-1 md:grid-cols-2 gap-6 mb-6">
+              <div className="space-y-3">
+                <label className="block text-sm font-bold text-blue-400">Trading Mode</label>
+                <div className="space-y-2">
+                  <label className="flex items-center space-x-3 cursor-pointer p-3 rounded-lg border border-gray-600 hover:border-blue-500 transition-colors">
+                    <input 
+                      type="radio" 
+                      className="w-4 h-4 text-blue-600" 
+                      name="mode" 
+                      checked={config.mode === 'SIMULATION'}
+                      onChange={() => setConfig({...config, mode: 'SIMULATION'})}
+                      disabled={status?.isActive}
+                    />
+                    <span className="text-white">Paper Trading</span>
+                  </label>
+                  <label className="flex items-center space-x-3 cursor-pointer p-3 rounded-lg border border-gray-600 hover:border-green-500 transition-colors">
+                    <input 
+                      type="radio" 
+                      className="w-4 h-4 text-green-600" 
+                      name="mode" 
+                      checked={config.mode === 'LIVE'}
+                      onChange={() => setConfig({...config, mode: 'LIVE'})}
+                      disabled={status?.isActive}
+                    />
+                    <span className="text-white font-semibold">Live Trading</span>
+                  </label>
+                </div>
+              </div>
+            </div>
+
+            {/* Symbol and Position Size */}
+            <div className="grid grid-cols-1 md:grid-cols-2 gap-4 mb-6">
+              <div>
+                <label className="block text-sm font-medium text-gray-300 mb-2">Symbol</label>
+                <select
+                  className="w-full p-3 bg-gray-700 border border-gray-600 rounded-lg text-white focus:border-blue-500"
+                  value={config.symbol}
+                  onChange={(e) => setConfig({...config, symbol: e.target.value})}
+                  disabled={status?.isActive}
+                >
+                  <option value="SOLUSD">SOL/USD</option>
+                  <option value="BTCUSD">BTC/USD</option>
+                  <option value="ETHUSD">ETH/USD</option>
+                  <option value="APTUSD">APT/USD</option>
+                  <option value="AVAXUSD">AVAX/USD</option>
+                  <option value="DOGEUSD">DOGE/USD</option>
+                </select>
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-300 mb-2">
+                  Balance to Use: {config.balancePercentage}% 
+                  {balance && ` ($${(parseFloat(balance.availableBalance) * config.balancePercentage / 100).toFixed(2)})`}
+                </label>
+                <input
+                  type="range"
+                  className="w-full h-2 bg-gray-700 rounded-lg appearance-none cursor-pointer"
+                  style={{
+                    background: `linear-gradient(to right, #3b82f6 0%, #3b82f6 ${config.balancePercentage}%, #374151 ${config.balancePercentage}%, #374151 100%)`
+                  }}
+                  min="10"
+                  max="100"
+                  step="5"
+                  value={config.balancePercentage}
+                  onChange={(e) => {
+                    const percentage = parseFloat(e.target.value);
+                    const newAmount = balance ? (parseFloat(balance.availableBalance) * percentage / 100) : 100;
+                    setConfig({
+                      ...config, 
+                      balancePercentage: percentage,
+                      tradingAmount: Math.round(newAmount)
+                    });
+                  }}
+                  disabled={status?.isActive}
+                />
+                <div className="flex justify-between text-xs text-gray-400 mt-1">
+                  <span>10%</span>
+                  <span>50%</span>
+                  <span>100%</span>
+                </div>
+              </div>
+            </div>
+
+            {/* MULTI-TIMEFRAME SELECTION */}
+            <div className="mb-6">
+              <label className="block text-sm font-medium text-gray-300 mb-2">
+                Analysis Timeframes
+                <span className="text-xs text-cyan-400 ml-2">({config.selectedTimeframes.length} selected)</span>
+                {config.selectedTimeframes.length === 0 && (
+                  <span className="text-xs text-red-400 ml-2">⚠️ At least one timeframe required</span>
+                )}
+              </label>
+              
+              {/* Timeframe Checkboxes */}
+              <div className="grid grid-cols-4 gap-2 mb-3">
+                {timeframes.map(tf => (
+                  <label key={tf.value} className="group relative cursor-pointer">
+                    <input
+                      type="checkbox"
+                      checked={config.selectedTimeframes.includes(tf.value)}
+                      onChange={() => toggleTimeframe(tf.value)}
+                      disabled={status?.isActive}
+                      className="sr-only"
+                    />
+                    <div className={`flex items-center justify-center p-2 rounded-lg border transition-all text-xs font-medium ${
+                      config.selectedTimeframes.includes(tf.value)
+                        ? 'border-cyan-500 bg-cyan-500/10 text-cyan-300 shadow-lg shadow-cyan-500/20'
+                        : status?.isActive
+                        ? 'border-gray-700 bg-gray-800/30 text-gray-500 cursor-not-allowed'
+                        : 'border-gray-700 bg-gray-800/30 text-gray-400 hover:border-gray-600 hover:bg-gray-800/50 hover:text-gray-300'
+                    }`}>
+                      {tf.label}
+                      {config.selectedTimeframes.includes(tf.value) && (
+                        <div className="absolute top-0.5 right-0.5 w-1.5 h-1.5 bg-cyan-400 rounded-full"></div>
+                      )}
+                    </div>
+                  </label>
+                ))}
+              </div>
+
+              {/* Selected Timeframes Display */}
+              {config.selectedTimeframes.length > 0 && (
+                <div className="p-2 bg-gray-800/30 rounded-lg mb-3">
+                  <div className="text-xs text-gray-400">
+                    Selected: <span className="text-cyan-400">
+                      {config.selectedTimeframes.map(tf => timeframes.find(t => t.value === tf)?.label || tf).filter(Boolean).join(', ')}
+                    </span>
+                  </div>
+                  <div className="text-xs text-gray-500 mt-1">
+                    💡 Multiple timeframes provide more robust analysis
+                  </div>
+                </div>
+              )}
+              
+              {/* Quick Selection Buttons */}
+              <div className="flex gap-2">
+                <button
+                  type="button"
+                  onClick={() => setConfig({...config, selectedTimeframes: ['5', '15', '30']})}
+                  disabled={status?.isActive}
+                  className="py-1 px-2 rounded text-xs font-medium bg-green-600/20 text-green-300 hover:bg-green-600/30 transition-all disabled:opacity-50 disabled:cursor-not-allowed"
+                >
+                  📈 Scalping
+                </button>
+                <button
+                  type="button"
+                  onClick={() => setConfig({...config, selectedTimeframes: ['60', '120']})}
+                  disabled={status?.isActive}
+                  className="py-1 px-2 rounded text-xs font-medium bg-blue-600/20 text-blue-300 hover:bg-blue-600/30 transition-all disabled:opacity-50 disabled:cursor-not-allowed"
+                >
+                  ⚡ Day Trading
+                </button>
+                <button
+                  type="button"
+                  onClick={() => setConfig({...config, selectedTimeframes: ['240', 'D']})}
+                  disabled={status?.isActive}
+                  className="py-1 px-2 rounded text-xs font-medium bg-purple-600/20 text-purple-300 hover:bg-purple-600/30 transition-all disabled:opacity-50 disabled:cursor-not-allowed"
+                >
+                  🎯 Swing Trading
+                </button>
+              </div>
+            </div>
+          </div>
+        </div>
+
+        {/* Status and Info Panel */}
+        <div className="space-y-6">
+          {/* Status */}
+          <div className="bg-gray-800 p-6 rounded-lg border border-gray-700">
+            <h3 className="text-lg font-bold text-white mb-4">Bot Status</h3>
+            
+            <div className="space-y-3">
+              <div className="flex justify-between items-center">
+                <span className="text-gray-400">Status:</span>
+                <span className={`px-2 py-1 rounded text-xs font-semibold ${
+                  status?.isActive ? 'bg-green-600 text-white' : 'bg-gray-600 text-gray-300'
+                }`}>
+                  {status?.isActive ? 'RUNNING' : 'STOPPED'}
+                </span>
+              </div>
+              
+              {status?.isActive && (
+                <>
+                  <div className="flex justify-between items-center">
+                    <span className="text-gray-400">Symbol:</span>
+                    <span className="text-white font-medium">{status.symbol}</span>
+                  </div>
+                  
+                  <div className="flex justify-between items-center">
+                    <span className="text-gray-400">Mode:</span>
+                    <span className={`px-2 py-1 rounded text-xs font-semibold ${
+                      status.mode === 'LIVE' ? 'bg-red-600 text-white' : 'bg-blue-600 text-white'
+                    }`}>
+                      {status.mode}
+                    </span>
+                  </div>
+                  
+                  <div className="flex justify-between items-center">
+                    <span className="text-gray-400">Timeframes:</span>
+                    <span className="text-cyan-400 text-xs">
+                      {status.timeframes?.map(tf => timeframes.find(t => t.value === tf)?.label || tf).join(', ')}
+                    </span>
+                  </div>
+                </>
+              )}
+            </div>
+          </div>
+
+          {/* Balance */}
+          {balance && (
+            <div className="bg-gray-800 p-6 rounded-lg border border-gray-700">
+              <h3 className="text-lg font-bold text-white mb-4">Account Balance</h3>
+              
+              <div className="space-y-3">
+                <div className="flex justify-between items-center">
+                  <span className="text-gray-400">Available:</span>
+                  <span className="text-green-400 font-semibold">${balance.availableBalance}</span>
+                </div>
+                
+                <div className="flex justify-between items-center">
+                  <span className="text-gray-400">Total:</span>
+                  <span className="text-white font-medium">${balance.totalCollateral}</span>
+                </div>
+                
+                <div className="flex justify-between items-center">
+                  <span className="text-gray-400">Positions:</span>
+                  <span className="text-yellow-400">{balance.positions || 0}</span>
+                </div>
+              </div>
+            </div>
+          )}
+
+          {/* Positions */}
+          {positions.length > 0 && (
+            <div className="bg-gray-800 p-6 rounded-lg border border-gray-700">
+              <h3 className="text-lg font-bold text-white mb-4">Open Positions</h3>
+              
+              <div className="space-y-2">
+                {positions.map((position, index) => (
+                  <div key={index} className="flex justify-between items-center p-2 bg-gray-700 rounded">
+                    <span className="text-white">{position.symbol}</span>
+                    <span className={`font-semibold ${
+                      position.side === 'LONG' ? 'text-green-400' : 'text-red-400'
+                    }`}>
+                      {position.side} ${position.size}
+                    </span>
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  )
+}

app/automation-v2/page.js

@@ -1,6 +1,5 @@
 'use client'
 import React, { useState, useEffect } from 'react'
-import PositionMonitor from '../components/PositionMonitor.tsx'
 
 // Available timeframes for automation (matching analysis page format)
 const timeframes = [
@@ -156,10 +155,7 @@ export default function AutomationPageV2() {
   }
 
   return (
-    <div className="space-y-8">
+    <div className="space-y-6">
-      {/* Position Monitor - Real-time Trading Overview */}
-      <PositionMonitor />
-      
       <div className="grid grid-cols-1 xl:grid-cols-3 gap-6">
         {/* Configuration Panel */}
         <div className="xl:col-span-2 space-y-6">
@@ -168,16 +164,6 @@ export default function AutomationPageV2() {
             <div className="flex items-center justify-between mb-6">
               <h3 className="text-xl font-bold text-white">Configuration</h3>
               <div className="flex space-x-3">
-                {/* Emergency Stop Button - Always Available */}
-                <button
-                  onClick={handleStop}
-                  disabled={loading}
-                  className="px-4 py-2 bg-orange-600 text-white rounded-lg hover:bg-orange-700 transition-colors disabled:opacity-50 font-semibold text-sm border-2 border-orange-500"
-                  title="Emergency Stop - Immediately stops all automation"
-                >
-                  🚨 EMERGENCY STOP
-                </button>
-                
                 {status?.isActive ? (
                   <button
                     onClick={handleStop}

app/components/PositionMonitor.tsx

@@ -106,13 +106,10 @@ export default function PositionMonitor() {
   return (
     <div className="space-y-6">
       {/* Header */}
-      <div className="bg-gray-800 rounded-lg p-4 border border-gray-700">
+      <div className="bg-gray-50 rounded-lg p-4">
         <div className="flex justify-between items-center">
-          <h2 className="text-lg font-semibold text-white flex items-center">
+          <h2 className="text-lg font-semibold text-gray-800">🔍 Position Monitor</h2>
-            <span className="mr-2">🔍</span>
+          <span className="text-sm text-gray-500">
-            Position Monitor
-          </h2>
-          <span className="text-sm text-gray-400">
             Last update: {lastUpdate.toLocaleTimeString()}
           </span>
         </div>
@@ -120,167 +117,139 @@ export default function PositionMonitor() {
 
       {/* Position Status */}
       {monitorData?.hasPosition && monitorData.position ? (
-        <div className="bg-gray-800 border border-gray-700 rounded-lg p-6">
+        <div className="bg-white border rounded-lg p-6">
-          <h3 className="text-lg font-medium text-white mb-4 flex items-center">
+          <h3 className="text-lg font-medium text-gray-900 mb-4">📊 Active Position</h3>
-            <span className="mr-2">📊</span>
-            Active Position
-          </h3>
           
           <div className="grid grid-cols-2 md:grid-cols-3 gap-4">
-            <div className="bg-gray-900/50 p-3 rounded-lg">
+            <div>
-              <p className="text-sm text-gray-400">Symbol & Side</p>
+              <p className="text-sm text-gray-500">Symbol & Side</p>
-              <p className="font-medium text-white">{monitorData.position.symbol}</p>
+              <p className="font-medium">{monitorData.position.symbol} | {monitorData.position.side.toUpperCase()}</p>
-              <p className={`text-sm font-semibold ${monitorData.position.side === 'short' ? 'text-red-400' : 'text-green-400'}`}>
-                {monitorData.position.side.toUpperCase()}
-              </p>
             </div>
-            <div className="bg-gray-900/50 p-3 rounded-lg">
+            <div>
-              <p className="text-sm text-gray-400">Size</p>
+              <p className="text-sm text-gray-500">Size</p>
-              <p className="font-medium text-white">{monitorData.position.size} SOL</p>
+              <p className="font-medium">{monitorData.position.size} SOL</p>
             </div>
-            <div className="bg-gray-900/50 p-3 rounded-lg">
+            <div>
-              <p className="text-sm text-gray-400">Entry Price</p>
+              <p className="text-sm text-gray-500">Entry Price</p>
-              <p className="font-medium text-white">${monitorData.position.entryPrice.toFixed(4)}</p>
+              <p className="font-medium">${monitorData.position.entryPrice.toFixed(4)}</p>
             </div>
-            <div className="bg-gray-900/50 p-3 rounded-lg">
+            <div>
-              <p className="text-sm text-gray-400">Current Price</p>
+              <p className="text-sm text-gray-500">Current Price</p>
-              <p className="font-medium text-white">${monitorData.position.currentPrice.toFixed(4)}</p>
+              <p className="font-medium">${monitorData.position.currentPrice.toFixed(4)}</p>
             </div>
-            <div className="bg-gray-900/50 p-3 rounded-lg">
+            <div>
-              <p className="text-sm text-gray-400">P&L</p>
+              <p className="text-sm text-gray-500">P&L</p>
-              <p className={`font-medium ${monitorData.position.unrealizedPnl >= 0 ? 'text-green-400' : 'text-red-400'}`}>
+              <p className={`font-medium ${monitorData.position.unrealizedPnl >= 0 ? 'text-green-600' : 'text-red-600'}`}>
                 {monitorData.position.unrealizedPnl >= 0 ? '+' : ''}${monitorData.position.unrealizedPnl.toFixed(2)}
               </p>
             </div>
-            <div className="bg-gray-900/50 p-3 rounded-lg">
+            <div>
-              <p className="text-sm text-gray-400">Notional Value</p>
+              <p className="text-sm text-gray-500">Notional Value</p>
-              <p className="font-medium text-white">${monitorData.position.notionalValue.toFixed(2)}</p>
+              <p className="font-medium">${monitorData.position.notionalValue.toFixed(2)}</p>
             </div>
           </div>
 
           {/* Stop Loss Section */}
           {monitorData.stopLossProximity && (
-            <div className="mt-6 p-4 bg-gray-900/30 rounded-lg border border-gray-600">
+            <div className="mt-6 p-4 bg-gray-50 rounded-lg">
-              <h4 className="font-medium text-white mb-3 flex items-center">
+              <h4 className="font-medium text-gray-900 mb-3">🛡️ Stop Loss Protection</h4>
-                <span className="mr-2">🤖</span>
-                AI Autonomous Risk Management
-              </h4>
               
               <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
-                <div className="bg-gray-800/50 p-3 rounded-lg">
+                <div>
-                  <p className="text-sm text-gray-400">Stop Loss Price</p>
+                  <p className="text-sm text-gray-500">Stop Loss Price</p>
-                  <p className="font-medium text-white">${monitorData.stopLossProximity.stopLossPrice.toFixed(4)}</p>
+                  <p className="font-medium">${monitorData.stopLossProximity.stopLossPrice.toFixed(4)}</p>
                 </div>
-                <div className="bg-gray-800/50 p-3 rounded-lg">
+                <div>
-                  <p className="text-sm text-gray-400">Distance</p>
+                  <p className="text-sm text-gray-500">Distance</p>
-                  <p className="font-medium text-white">{monitorData.stopLossProximity.distancePercent}% away</p>
+                  <p className="font-medium">{monitorData.stopLossProximity.distancePercent}% away</p>
                 </div>
-                <div className="bg-gray-800/50 p-3 rounded-lg">
+                <div>
-                  <p className="text-sm text-gray-400">AI Status</p>
+                  <p className="text-sm text-gray-500">Status</p>
                   {(() => {
                     const status = getStopLossStatus(monitorData.stopLossProximity.distancePercent);
-                    const aiActions: Record<string, { text: string; color: string }> = {
-                      'DANGER': { text: '🚨 Emergency Analysis', color: 'text-red-400' },
-                      'WARNING': { text: '⚠️ Position Review', color: 'text-yellow-400' },
-                      'CAUTION': { text: '🟡 Enhanced Watch', color: 'text-yellow-400' },
-                      'SAFE': { text: '✅ Opportunity Scan', color: 'text-green-400' }
-                    };
-                    const aiAction = aiActions[status.text] || aiActions['SAFE'];
                     return (
-                      <p className={`font-medium ${aiAction.color}`}>
+                      <p className={`font-medium ${status.color}`}>
-                        {aiAction.text}
+                        {status.icon} {status.text}
                       </p>
                     );
                   })()}
                 </div>
               </div>
               
-              <div className="mt-3 bg-gray-800/30 p-3 rounded-lg">
+              <div className="mt-3">
-                <p className="text-sm text-gray-400">AI Action Plan</p>
+                <p className="text-sm text-gray-500">Risk Level</p>
-                <p className="font-medium text-blue-400">
+                <p className={`font-medium ${getRiskColor(monitorData.riskLevel)}`}>
-                  {monitorData.nextAction || 'AI monitoring position autonomously'}
+                  {monitorData.riskLevel}
                 </p>
               </div>
 
               {monitorData.stopLossProximity.isNear && (
-                <div className="mt-4 p-3 bg-blue-900/30 border border-blue-500/30 rounded-lg">
+                <div className="mt-4 p-3 bg-red-100 border border-red-300 rounded-lg">
-                  <p className="text-blue-300 font-medium">🤖 AI TAKING ACTION: Autonomous risk management activated!</p>
+                  <p className="text-red-700 font-medium">🚨 ALERT: Price is near stop loss!</p>
-                  <p className="text-blue-400 text-sm mt-1">No manual intervention required - enjoy your beach time! 🏖️</p>
                 </div>
               )}
             </div>
           )}
         </div>
       ) : (
-        <div className="bg-gray-800 border border-gray-700 rounded-lg p-6">
+        <div className="bg-white border rounded-lg p-6">
           <div className="text-center py-8">
-            <p className="text-gray-400 text-lg flex items-center justify-center">
+            <p className="text-gray-500 text-lg">📊 No Open Positions</p>
-              <span className="mr-2">📊</span>
+            <p className="text-gray-400 mt-2">Scanning for opportunities...</p>
-              No Open Positions
-            </p>
-            <p className="text-gray-500 mt-2">Scanning for opportunities...</p>
           </div>
         </div>
       )}
 
       {/* Automation Status */}
-      <div className="bg-gray-800 border border-gray-700 rounded-lg p-6">
+      <div className="bg-white border rounded-lg p-6">
-        <h3 className="text-lg font-medium text-white mb-4 flex items-center">
+        <h3 className="text-lg font-medium text-gray-900 mb-4">🤖 Automation Status</h3>
-          <span className="mr-2">🤖</span>
-          Automation Status
-        </h3>
         
         {automationStatus?.isActive ? (
           <div className="space-y-4">
             <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
-              <div className="bg-gray-900/50 p-3 rounded-lg">
+              <div>
-                <p className="text-sm text-gray-400">Status</p>
+                <p className="text-sm text-gray-500">Status</p>
-                <p className="font-medium text-green-400 flex items-center">
+                <p className="font-medium text-green-600">✅ ACTIVE</p>
-                  <span className="w-2 h-2 bg-green-400 rounded-full mr-2"></span>
-                  ACTIVE
-                </p>
               </div>
-              <div className="bg-gray-900/50 p-3 rounded-lg">
+              <div>
-                <p className="text-sm text-gray-400">Mode</p>
+                <p className="text-sm text-gray-500">Mode</p>
-                <p className={`font-medium ${automationStatus.mode === 'LIVE' ? 'text-red-400' : 'text-blue-400'}`}>
+                <p className="font-medium">{automationStatus.mode}</p>
-                  {automationStatus.mode}
-                </p>
               </div>
-              <div className="bg-gray-900/50 p-3 rounded-lg">
+              <div>
-                <p className="text-sm text-gray-400">Strategy</p>
+                <p className="text-sm text-gray-500">Strategy</p>
-                <p className="font-medium text-white">Scalping</p>
+                <p className="font-medium">Scalping</p>
               </div>
-              <div className="bg-gray-900/50 p-3 rounded-lg">
+              <div>
-                <p className="text-sm text-gray-400">Symbol</p>
+                <p className="text-sm text-gray-500">Symbol</p>
-                <p className="font-medium text-white">{automationStatus.symbol}</p>
+                <p className="font-medium">{automationStatus.symbol}</p>
               </div>
             </div>
             
             <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
-              <div className="bg-gray-900/50 p-3 rounded-lg">
+              <div>
-                <p className="text-sm text-gray-400">Timeframes</p>
+                <p className="text-sm text-gray-500">Timeframes</p>
-                <p className="font-medium text-cyan-400">{automationStatus.timeframes?.join(', ') || 'N/A'}</p>
+                <p className="font-medium">{automationStatus.timeframes?.join(', ') || 'N/A'}</p>
               </div>
-              <div className="bg-gray-900/50 p-3 rounded-lg">
+              <div>
-                <p className="text-sm text-gray-400">Cycles</p>
+                <p className="text-sm text-gray-500">Cycles</p>
-                <p className="font-medium text-white">{automationStatus.totalCycles}</p>
+                <p className="font-medium">{automationStatus.totalCycles}</p>
               </div>
-              <div className="bg-gray-900/50 p-3 rounded-lg">
+              <div>
-                <p className="text-sm text-gray-400">Trades</p>
+                <p className="text-sm text-gray-500">Trades</p>
-                <p className="font-medium text-white">{automationStatus.totalTrades}</p>
+                <p className="font-medium">{automationStatus.totalTrades}</p>
               </div>
-              <div className="bg-gray-900/50 p-3 rounded-lg">
+              <div>
-                <p className="text-sm text-gray-400">Errors</p>
+                <p className="text-sm text-gray-500">Errors</p>
-                <p className={`font-medium ${automationStatus.consecutiveErrors > 0 ? 'text-yellow-400' : 'text-green-400'}`}>
+                <p className={`font-medium ${automationStatus.consecutiveErrors > 0 ? 'text-yellow-600' : 'text-green-600'}`}>
                   {automationStatus.consecutiveErrors}/3
                 </p>
               </div>
             </div>
 
             {automationStatus.lastActivity && (
-              <div className="bg-gray-900/30 p-3 rounded-lg">
+              <div>
-                <p className="text-sm text-gray-400">Last Activity</p>
+                <p className="text-sm text-gray-500">Last Activity</p>
-                <p className="font-medium text-white">
+                <p className="font-medium">
                   {new Date(automationStatus.lastActivity).toLocaleString()}
                 </p>
               </div>
@@ -288,10 +257,7 @@ export default function PositionMonitor() {
           </div>
         ) : (
           <div className="text-center py-4">
-            <p className="text-red-400 font-medium flex items-center justify-center">
+            <p className="text-red-600 font-medium">❌ STOPPED</p>
-              <span className="w-2 h-2 bg-red-400 rounded-full mr-2"></span>
-              STOPPED
-            </p>
             <p className="text-gray-500 mt-2">{automationStatus?.detailedStatus}</p>
           </div>
         )}

lib/safe-parallel-automation.ts

@@ -0,0 +1,326 @@
+class SafeParallelAutomation {
+  private isRunning = false
+  private config: any = null
+  private intervalId: NodeJS.Timeout | null = null
+  private lastAnalysisTime = 0
+  
+  // SAFE PARAMETERS - Respect timeframe strategy
+  private readonly MIN_ANALYSIS_INTERVAL = 10 * 60 * 1000 // 10 minutes minimum
+  private readonly MAX_TRADES_PER_HOUR = 2
+  private readonly ANALYSIS_COOLDOWN = 5 * 60 * 1000 // 5 minutes
+  
+  private stats = {
+    totalTrades: 0,
+    successfulTrades: 0,
+    winRate: 0,
+    totalPnL: 0,
+    errorCount: 0,
+    lastAnalysis: null as string | null,
+    nextScheduled: null as string | null,
+    nextAnalysisIn: 0,
+    analysisInterval: 0,
+    currentCycle: 0,
+    lastError: null as string | null,
+    strategyType: 'General'
+  }
+
+  async startSafeAutomation(config: any): Promise<{ success: boolean, message?: string }> {
+    try {
+      if (this.isRunning) {
+        return { success: false, message: 'Safe automation already running' }
+      }
+
+      // SAFETY CHECK: Rate limiting
+      const now = Date.now()
+      if (now - this.lastAnalysisTime < this.ANALYSIS_COOLDOWN) {
+        const remaining = Math.ceil((this.ANALYSIS_COOLDOWN - (now - this.lastAnalysisTime)) / 1000)
+        return { 
+          success: false, 
+          message: 'Safety cooldown: Wait ' + remaining + ' seconds' 
+        }
+      }
+
+      // SAFETY CHECK: Validate timeframes
+      if (!config.timeframes || config.timeframes.length === 0) {
+        return { success: false, message: 'At least one timeframe required' }
+      }
+
+      this.config = config
+      this.isRunning = true
+      this.lastAnalysisTime = now
+      this.stats.currentCycle = 0
+      this.stats.strategyType = config.strategyType || 'General'
+      
+      console.log('SAFE PARALLEL: Starting for ' + config.symbol)
+      console.log('STRATEGY: ' + this.stats.strategyType)
+      console.log('TIMEFRAMES: [' + config.timeframes.join(', ') + ']')
+      console.log('SAFETY: Max ' + this.MAX_TRADES_PER_HOUR + ' trades/hour')
+      
+      // Start with strategy-appropriate interval
+      this.startSafeAnalysisCycle()
+      
+      return { success: true, message: 'Safe parallel automation started' }
+    } catch (error) {
+      console.error('Failed to start safe automation:', error)
+      return { success: false, message: 'Failed to start automation' }
+    }
+  }
+
+  private startSafeAnalysisCycle(): void {
+    // Get strategy-appropriate interval but enforce minimum safety
+    const strategyInterval = this.getStrategyInterval(this.config.timeframes, this.config.strategyType)
+    const safeInterval = Math.max(this.MIN_ANALYSIS_INTERVAL, strategyInterval)
+    
+    console.log('STRATEGY INTERVAL: ' + (strategyInterval / 1000 / 60) + ' minutes')
+    console.log('SAFE INTERVAL: ' + (safeInterval / 1000 / 60) + ' minutes (enforced minimum)')
+    
+    this.stats.analysisInterval = safeInterval
+    this.stats.nextScheduled = new Date(Date.now() + safeInterval).toISOString()
+    this.stats.nextAnalysisIn = safeInterval
+    
+    // Set safe interval
+    this.intervalId = setInterval(async () => {
+      if (this.isRunning && this.config) {
+        await this.runSafeAnalysisCycle()
+      }
+    }, safeInterval)
+
+    // First cycle after delay
+    setTimeout(() => {
+      if (this.isRunning && this.config) {
+        this.runSafeAnalysisCycle()
+      }
+    }, 30000)
+  }
+
+  private async runSafeAnalysisCycle(): Promise<void> {
+    try {
+      console.log('\nSAFE CYCLE ' + (this.stats.currentCycle + 1) + ': ' + this.config.symbol)
+      console.log('STRATEGY: ' + this.stats.strategyType)
+      
+      // SAFETY CHECK
+      const canTrade = await this.canExecuteTrade()
+      if (!canTrade.allowed) {
+        console.log('SAFETY BLOCK: ' + canTrade.reason)
+        this.updateNextAnalysisTime()
+        return
+      }
+
+      // PARALLEL ANALYSIS using enhanced screenshot API
+      console.log('PARALLEL: Analyzing ' + this.config.timeframes.length + ' timeframes...')
+      
+      const analysisResult = await this.performParallelAnalysis()
+      
+      if (!analysisResult || !analysisResult.analysis) {
+        console.log('Analysis failed, skipping')
+        return
+      }
+
+      this.stats.lastAnalysis = new Date().toISOString()
+      console.log('ANALYSIS: ' + analysisResult.analysis.recommendation)
+
+      // CONTROLLED TRADING with strategy-specific logic
+      if (this.shouldExecuteTrade(analysisResult.analysis)) {
+        console.log('EXECUTING: Trade criteria met for ' + this.stats.strategyType)
+        const tradeResult = await this.executeSafeTrade(analysisResult.analysis)
+        if (tradeResult?.success) {
+          this.stats.totalTrades++
+          this.stats.successfulTrades++
+          this.stats.winRate = (this.stats.successfulTrades / this.stats.totalTrades) * 100
+          console.log('TRADE: Executed successfully')
+        }
+      } else {
+        console.log('SIGNAL: Criteria not met for ' + this.stats.strategyType)
+      }
+
+      this.stats.currentCycle++
+      
+    } catch (error) {
+      console.error('Error in safe cycle:', error)
+      this.stats.errorCount++
+      this.stats.lastError = error instanceof Error ? error.message : 'Unknown error'
+    } finally {
+      await this.guaranteedCleanup()
+      this.updateNextAnalysisTime()
+    }
+  }
+
+  private async performParallelAnalysis(): Promise<any> {
+    try {
+      // Use the enhanced screenshot API endpoint with all selected timeframes
+      const response = await fetch('http://localhost:3000/api/enhanced-screenshot', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          symbol: this.config.symbol,
+          timeframes: this.config.timeframes,
+          layouts: ['ai', 'diy'],
+          analyze: true
+        })
+      })
+
+        throw new Error('API response: ' + response.status)
+      }
+
+      const result = await response.json()
+      
+      if (result.analysis) {
+        console.log('PARALLEL: Confidence ' + result.analysis.confidence + '%')
+        return result
+      }
+
+      return null
+    } catch (error) {
+      console.error('Error in parallel analysis:', error)
+      throw error
+    }
+  }
+
+  private shouldExecuteTrade(analysis: any): boolean {
+    const recommendation = analysis.recommendation.toLowerCase()
+    const confidence = analysis.confidence || 0
+    
+    // Strategy-specific confidence requirements
+    let minConfidence = 75 // Default
+    
+    if (this.stats.strategyType === 'Scalping') {
+      minConfidence = 80 // Higher confidence for scalping
+    } else if (this.stats.strategyType === 'Day Trading') {
+      minConfidence = 75 // Standard confidence
+    } else if (this.stats.strategyType === 'Swing Trading') {
+      minConfidence = 70 // Slightly lower for swing (longer timeframes)
+    }
+    
+    const isHighConfidence = confidence >= minConfidence
+    const isClearDirection = recommendation.includes('buy') || recommendation.includes('sell')
+    
+    console.log('SIGNAL: ' + recommendation + ' (' + confidence + '%) - Required: ' + minConfidence + '%')
+    
+    return isHighConfidence && isClearDirection
+  }
+
+  private getStrategyInterval(timeframes: string[], strategyType: string): number {
+    // Strategy-based intervals (but minimum will be enforced)
+    
+    if (strategyType === 'Scalping') {
+      console.log('SCALPING: Using 2-minute analysis cycle')
+      return 2 * 60 * 1000 // 2 minutes for scalping (will be enforced to 10 min minimum)
+    }
+    
+    if (strategyType === 'Day Trading') {
+      console.log('DAY TRADING: Using 5-minute analysis cycle')
+      return 5 * 60 * 1000 // 5 minutes for day trading (will be enforced to 10 min minimum)
+    }
+    
+    if (strategyType === 'Swing Trading') {
+      console.log('SWING TRADING: Using 15-minute analysis cycle')
+      return 15 * 60 * 1000 // 15 minutes for swing trading
+    }
+    
+    // Fallback based on shortest timeframe
+    const shortest = Math.min(...timeframes.map(tf => {
+      if (tf === 'D') return 1440
+      return parseInt(tf) || 60
+    }))
+    
+    if (shortest <= 5) return 2 * 60 * 1000   // 2 min for very short
+    if (shortest <= 15) return 5 * 60 * 1000  // 5 min for short
+    if (shortest <= 60) return 10 * 60 * 1000 // 10 min for medium
+    return 15 * 60 * 1000 // 15 min for long
+  }
+
+  private async executeSafeTrade(analysis: any): Promise<any> {
+    try {
+      console.log('SAFE TRADE: Executing...')
+      
+      // Use drift trading API endpoint
+      const response = await fetch('http://localhost:3000/api/trading', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          mode: this.config.mode,
+          symbol: this.config.symbol,
+          amount: this.config.tradingAmount,
+          leverage: this.config.leverage,
+          stopLoss: this.config.stopLoss,
+          takeProfit: this.config.takeProfit,
+          analysis: analysis,
+          strategy: this.stats.strategyType
+        })
+      })
+
+      const result = await response.json()
+      return result
+    } catch (error) {
+      console.error('Error executing trade:', error)
+      return { success: false, error: error.message }
+    }
+  }
+
+  private async canExecuteTrade(): Promise<{ allowed: boolean, reason?: string }> {
+    const now = Date.now()
+    
+    if (now - this.lastAnalysisTime < this.ANALYSIS_COOLDOWN) {
+      const remaining = Math.ceil((this.ANALYSIS_COOLDOWN - (now - this.lastAnalysisTime)) / 1000 / 60)
+      return { allowed: false, reason: 'Cooldown: ' + remaining + 'min' }
+    }
+    
+    if (this.stats.totalTrades >= this.MAX_TRADES_PER_HOUR) {
+      return { allowed: false, reason: 'Hour limit: ' + this.stats.totalTrades + '/' + this.MAX_TRADES_PER_HOUR }
+    }
+    
+    return { allowed: true }
+  }
+
+  private async guaranteedCleanup(): Promise<void> {
+    try {
+      const { execSync } = require('child_process')
+      execSync('pkill -f "chrome|chromium" 2>/dev/null || true')
+      console.log('CLEANUP: Completed')
+    } catch (error) {
+      console.error('CLEANUP: Failed', error)
+    }
+  }
+
+  private updateNextAnalysisTime(): void {
+    const nextTime = Date.now() + this.stats.analysisInterval
+    this.stats.nextScheduled = new Date(nextTime).toISOString()
+    this.stats.nextAnalysisIn = this.stats.analysisInterval
+  }
+
+  async stopSafeAutomation(): Promise<{ success: boolean, message?: string }> {
+    try {
+      this.isRunning = false
+      
+      if (this.intervalId) {
+        clearInterval(this.intervalId)
+        this.intervalId = null
+      }
+      
+      await this.guaranteedCleanup()
+      
+      this.config = null
+      this.stats.nextAnalysisIn = 0
+      this.stats.nextScheduled = null
+      
+      console.log('SAFE: Automation stopped')
+      return { success: true, message: 'Safe automation stopped' }
+    } catch (error) {
+      return { success: false, message: 'Stop failed' }
+    }
+  }
+
+  getStatus() {
+    return {
+      isActive: this.isRunning,
+      mode: this.config?.mode || 'SIMULATION',
+      symbol: this.config?.symbol || 'SOLUSD',
+      timeframes: this.config?.timeframes || ['1h'],
+      automationType: 'SAFE_PARALLEL',
+      strategy: this.stats.strategyType,
+      ...this.stats
+    }
+  }
+}
+
+export const safeParallelAutomation = new SafeParallelAutomation()

lib/simple-automation.js

@@ -1,40 +1,9 @@
 // Simple automation service for basic start/stop functionality
-
-// Import AI Leverage Calculator for dynamic leverage
-async function importAILeverageCalculator() {
-  try {
-    const { AILeverageCalculator } = await import('./ai-leverage-calculator.js');
-    return AILeverageCalculator;
-  } catch (error) {
-    console.warn('⚠️ AI Leverage Calculator not available, using default leverage');
-    return null;
-  }
-}
-
-// Import Enhanced Risk Manager with Learning for intelligent beach mode operation
-async function importEnhancedRiskManager() {
-  try {
-    const EnhancedAutonomousRiskManager = require('./enhanced-autonomous-risk-manager.js');
-    return EnhancedAutonomousRiskManager;
-  } catch (error) {
-    console.warn('⚠️ Enhanced Risk Manager not available, falling back to stable monitor');
-    // Fallback to stable risk monitor
-    try {
-      const StableRiskMonitor = require('./stable-risk-monitor.js');
-      return StableRiskMonitor;
-    } catch (fallbackError) {
-      console.warn('⚠️ Stable Risk Monitor also not available, using basic monitoring');
-      return null;
-    }
-  }
-}
-
 class SimpleAutomation {
   constructor() {
     this.isRunning = false;
     this.config = null;
     this.intervalId = null;
-    this.riskManager = null; // Autonomous AI Risk Manager
     this.stats = {
       totalCycles: 0,
       totalTrades: 0,
@@ -61,41 +30,8 @@ class SimpleAutomation {
       this.isRunning = true;
       this.stats.startTime = new Date().toISOString();
       this.stats.status = 'Running';
-      
-      console.log('✅ AUTOMATION STATUS: isRunning =', this.isRunning);
-      console.log('🎯 LIVE TRADING:', this.config.enableTrading ? 'ENABLED' : 'DISABLED');
       this.stats.totalCycles = 0;
 
-            // Initialize Enhanced AI Risk Manager with Learning Capabilities
-      try {
-        const EnhancedRiskManagerClass = await importEnhancedRiskManager();
-        if (EnhancedRiskManagerClass) {
-          this.riskManager = new EnhancedRiskManagerClass();
-          console.log('🧠 ENHANCED BEACH MODE: AI learning system activated');
-          console.log('🎯 System will learn from every decision and improve over time');
-          
-          // Start enhanced autonomous operation
-          setTimeout(() => {
-            if (this.riskManager && this.riskManager.beachMode) {
-              this.riskManager.beachMode();
-              console.log('🏖️ Full autonomous operation with AI learning active');
-            }
-          }, 2000);
-        }
-      } catch (error) {
-        console.log('🔄 Continuing without enhanced autonomous risk monitoring');
-        console.error('Risk manager initialization error:', error.message);
-      }
-
-      // Auto-enable trading when in LIVE mode
-      if (config.mode === 'LIVE') {
-        this.config.enableTrading = true;
-        console.log('🔥 LIVE TRADING ENABLED: Real trades will be executed');
-      } else {
-        this.config.enableTrading = false;
-        console.log('📊 SIMULATION MODE: Trades will be simulated only');
-      }
-
       // Detect strategy
       const timeframes = config.selectedTimeframes;
       let strategy = 'General';
@@ -137,22 +73,14 @@ class SimpleAutomation {
 
   async stop() {
     try {
-      console.log('🛑 STOPPING AUTOMATION...');
       this.isRunning = false;
       this.stats.status = 'Stopped';
-      console.log('✅ AUTOMATION STATUS: isRunning =', this.isRunning);
 
       if (this.intervalId) {
         clearInterval(this.intervalId);
         this.intervalId = null;
       }
 
-      // Stop risk monitor if running
-      if (this.riskManager && this.riskManager.stop) {
-        this.riskManager.stop();
-        console.log('🏖️ Beach mode monitoring stopped');
-      }
-
       console.log('SIMPLE AUTOMATION: Stopped');
       
       return { success: true, message: 'Automation stopped successfully' };
@@ -164,12 +92,6 @@ class SimpleAutomation {
 
   async runCycle() {
     try {
-      // Check if automation should still be running
-      if (!this.isRunning) {
-        console.log('⏹️ AUTOMATION STOPPED: Skipping cycle');
-        return;
-      }
-      
       this.stats.totalCycles++;
       this.stats.lastActivity = new Date().toISOString();
       
@@ -180,32 +102,10 @@ class SimpleAutomation {
       if (this.config) {
         // Perform actual analysis using enhanced screenshot API
         await this.performAnalysis();
-        
-        // Reset error counter on successful cycle
-        this.stats.consecutiveErrors = 0;
       }
       
     } catch (error) {
-      console.error('❌ CRITICAL ERROR in automation cycle:', error);
+      console.error('Error in automation cycle:', error);
-      console.error('❌ Stack trace:', error.stack);
-      
-      // Increment error counter
-      this.stats.consecutiveErrors = (this.stats.consecutiveErrors || 0) + 1;
-      
-      // If too many consecutive errors, stop automation
-      if (this.stats.consecutiveErrors >= 3) {
-        console.error('🚨 TOO MANY ERRORS: Stopping automation after', this.stats.consecutiveErrors, 'consecutive failures');
-        this.isRunning = false;
-        this.stats.status = 'Stopped due to errors';
-        
-        if (this.intervalId) {
-          clearInterval(this.intervalId);
-          this.intervalId = null;
-        }
-        return;
-      }
-      
-      console.log(`⚠️ Error ${this.stats.consecutiveErrors}/3 - Will retry next cycle`);
     }
   }
 
@@ -376,8 +276,10 @@ class SimpleAutomation {
   }
 
   shouldExecuteTrade(analysis) {
-    // Always allow trade execution - the useRealDEX flag determines if it's real or simulated
+    if (this.config.mode !== 'LIVE') {
-    console.log(`<EFBFBD> TRADE MODE: ${this.config.mode || 'SIMULATION'} - Trading ${this.config.enableTrading ? 'ENABLED' : 'DISABLED'}`);
+      console.log('📊 SIMULATION MODE: Would execute trade');
+      return false;
+    }
     
     const recommendation = analysis.recommendation?.toLowerCase() || '';
     const confidence = analysis.confidence || 0;
@@ -399,7 +301,6 @@ class SimpleAutomation {
   async executeTrade(analysis) {
     try {
       console.log('💰 EXECUTING TRADE...');
-      console.log('📊 Analysis data:', JSON.stringify(analysis, null, 2));
       
       // Map analysis recommendation to trading side
       const recommendation = analysis.recommendation?.toLowerCase() || '';
@@ -414,110 +315,13 @@ class SimpleAutomation {
         return { success: false, error: 'Invalid recommendation: ' + recommendation };
       }
       
-      // Extract stop loss and take profit from analysis
+      // Use the trading API with proper fields
-      let stopLoss = null;
-      let takeProfit = null;
-      
-      // Try to extract from the structured analysis format
-      if (analysis.stopLoss && typeof analysis.stopLoss === 'object') {
-        stopLoss = analysis.stopLoss.price;
-      } else if (analysis.stopLoss && typeof analysis.stopLoss === 'number') {
-        stopLoss = analysis.stopLoss;
-      }
-      
-      // Extract take profit - prefer tp1 if available
-      if (analysis.takeProfits && typeof analysis.takeProfits === 'object') {
-        if (analysis.takeProfits.tp1 && analysis.takeProfits.tp1.price) {
-          takeProfit = analysis.takeProfits.tp1.price;
-        } else if (analysis.takeProfits.tp2 && analysis.takeProfits.tp2.price) {
-          takeProfit = analysis.takeProfits.tp2.price;
-        }
-      } else if (analysis.takeProfit && typeof analysis.takeProfit === 'number') {
-        takeProfit = analysis.takeProfit;
-      }
-      
-      // Fallback: try to extract from nested levels object
-      if (!stopLoss && analysis.levels) {
-        stopLoss = analysis.levels.stopLoss || analysis.levels.stop;
-      }
-      if (!takeProfit && analysis.levels) {
-        takeProfit = analysis.levels.takeProfit || analysis.levels.target;
-      }
-
-      // Parse numeric values if they're strings
-      if (stopLoss && typeof stopLoss === 'string') {
-        stopLoss = parseFloat(stopLoss.replace(/[^0-9.]/g, ''));
-      }
-      if (takeProfit && typeof takeProfit === 'string') {
-        takeProfit = parseFloat(takeProfit.replace(/[^0-9.]/g, ''));
-      }
-
-      console.log(`🎯 Trade levels - SL: ${stopLoss}, TP: ${takeProfit}`);
-
-      // Calculate optimal leverage using AI Leverage Calculator
-      let optimalLeverage = 1; // Default fallback
-      console.log('🔧 DEBUG: Starting leverage calculation...');
-      try {
-        const AILeverageCalculator = await importAILeverageCalculator();
-        console.log('🔧 DEBUG: AI Leverage Calculator imported:', !!AILeverageCalculator);
-        if (AILeverageCalculator && stopLoss) {
-          console.log('🔧 DEBUG: Both calculator and stopLoss available, proceeding...');
-          // Get current price from analysis
-          const currentPrice = analysis.entry?.price || analysis.currentPrice || 178; // fallback price
-          
-          // Get real account data from Drift API
-          let accountValue = 49; // fallback
-          let availableBalance = 49; // fallback
-          
-          try {
-            const baseUrl = process.env.INTERNAL_API_URL || 'http://localhost:3000';
-            console.log('🔧 DEBUG: Fetching balance from:', baseUrl);
-            const balanceResponse = await fetch(`${baseUrl}/api/drift/balance`);
-            const balanceData = await balanceResponse.json();
-            if (balanceData.success) {
-              accountValue = balanceData.accountValue;
-              availableBalance = balanceData.availableBalance;
-              console.log(`💰 Real account data: $${accountValue.toFixed(2)} total, $${availableBalance.toFixed(2)} available`);
-            } else {
-              console.log('🔧 DEBUG: Balance API returned error:', balanceData);
-            }
-          } catch (balanceError) {
-            console.warn('⚠️ Failed to get real balance, using fallback:', balanceError.message);
-          }
-          
-          console.log(`🧮 Calculating optimal leverage: Entry=$${currentPrice}, StopLoss=$${stopLoss}`);
-          
-          const leverageResult = AILeverageCalculator.calculateOptimalLeverage({
-            accountValue,
-            availableBalance,
-            entryPrice: currentPrice,
-            stopLossPrice: stopLoss,
-            side: side === 'BUY' ? 'long' : 'short',
-            maxLeverageAllowed: 10, // Drift platform max
-            safetyBuffer: 0.10 // 10% safety buffer
-          });
-          
-          optimalLeverage = leverageResult.recommendedLeverage;
-          console.log(`🎯 AI Calculated Leverage: ${optimalLeverage.toFixed(1)}x (Risk: ${leverageResult.riskAssessment})`);
-          console.log(`📊 Leverage Details: ${leverageResult.reasoning}`);
-        } else {
-          console.log('🔧 DEBUG: Skipping leverage calc - Calculator:', !!AILeverageCalculator, 'StopLoss:', !!stopLoss);
-        }
-      } catch (leverageError) {
-        console.warn('⚠️ Leverage calculation failed, using default 1x:', leverageError.message);
-      }
-      
-      console.log(`🔧 DEBUG: Final leverage to use: ${optimalLeverage}x`);
-
-      // Use the trading API with proper fields for Drift
       const tradePayload = {
         symbol: this.config.symbol,
         side: side,
-        amount: this.config.tradingAmount || 49, // Use available balance
+        amount: this.config.tradingAmount || 10, // Default to $10 if not set
-        leverage: optimalLeverage, // Use AI-calculated optimal leverage
+        type: 'market',
-        stopLoss: stopLoss,
+        tradingMode: 'SPOT',
-        takeProfit: takeProfit,
-        useRealDEX: this.config.enableTrading === true, // Use real DEX when live trading enabled
         analysis: analysis // Include analysis for reference
       };
       
@@ -548,27 +352,14 @@ class SimpleAutomation {
   }
 
   getStatus() {
-    const baseStatus = {
+    return {
       isActive: this.isRunning,
       mode: this.config?.mode || 'SIMULATION',
-      enableTrading: this.config?.enableTrading || false,
-      tradingStatus: this.config?.enableTrading ? 'REAL TRADES' : 'SIMULATED ONLY',
       symbol: this.config?.symbol || 'SOLUSD',
       timeframes: this.config?.selectedTimeframes || [],
       automationType: 'SIMPLE',
       ...this.stats
     };
-    
-    // Add more descriptive status based on running state
-    if (this.isRunning) {
-      baseStatus.detailedStatus = 'Running - Monitoring for trade opportunities';
-      baseStatus.nextAction = 'Next analysis cycle in progress';
-    } else {
-      baseStatus.detailedStatus = 'Stopped - No monitoring active';
-      baseStatus.nextAction = 'Start automation to begin monitoring';
-    }
-    
-    return baseStatus;
   }
 }
 

lib/simplified-stop-loss-learner-fixed.js

@@ -0,0 +1,530 @@
+/**
+ * Simplified Stop Loss Learning System
+ * 
+ * Simplified approach focusing on essential learning patterns
+ * without complex statistical analysis.
+ */
+
+const { PrismaClient } = require('@prisma/client');
+const getDB = require('./database-util');
+
+class SimplifiedStopLossLearner {
+  constructor() {
+    this.learningThresholds = {
+      emergency: 1.0,  // Emergency exit at 1% from SL
+      risk: 2.0,       // High risk at 2% from SL
+      mediumRisk: 5.0  // Medium risk at 5% from SL
+    };
+  }
+
+  async log(message) {
+    console.log(`[${new Date().toISOString()}] 🧠 SL Learner: ${message}`);
+  }
+
+  /**
+   * Record a stop loss related decision for learning
+   */
+  async recordDecision(decisionData) {
+    try {
+      const learningRecord = {
+        type: 'STOP_LOSS_DECISION',
+        tradeId: decisionData.tradeId,
+        symbol: decisionData.symbol,
+        decision: decisionData.decision,
+        distanceFromSL: decisionData.distanceFromSL,
+        reasoning: decisionData.reasoning,
+        marketConditions: decisionData.marketConditions,
+        expectedOutcome: decisionData.expectedOutcome,
+        timestamp: new Date().toISOString()
+      };
+
+      const prisma = await getDB();
+      const record = await prisma.ai_learning_data.create({
+        data: {
+          id: `sl_decision_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+          userId: 'default-user',
+          symbol: decisionData.symbol,
+          timeframe: 'DECISION',
+          analysisData: JSON.stringify(learningRecord),
+          marketConditions: JSON.stringify(decisionData.marketConditions || {}),
+          confidenceScore: 50 // Neutral starting confidence
+        }
+      });
+
+      await this.log(`📝 Decision recorded: ${decisionData.decision} for ${decisionData.symbol} at ${decisionData.distanceFromSL}%`);
+      
+      return record.id;
+    } catch (error) {
+      await this.log(`❌ Error recording decision: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Update the outcome of a previously recorded decision
+   */
+  async assessDecisionOutcome(outcomeData) {
+    try {
+      const prisma = await getDB();
+      
+      // Find the original decision record
+      const originalRecord = await prisma.ai_learning_data.findUnique({
+        where: { id: outcomeData.decisionId }
+      });
+
+      if (!originalRecord) {
+        await this.log(`⚠️ Original decision ${outcomeData.decisionId} not found`);
+        return false;
+      }
+
+      // Parse the original decision data
+      const originalDecision = JSON.parse(originalRecord.analysisData);
+      
+      // Create outcome record with learning data
+      const outcomeRecord = {
+        type: 'STOP_LOSS_OUTCOME',
+        originalDecisionId: outcomeData.decisionId,
+        actualOutcome: outcomeData.actualOutcome,
+        timeToOutcome: outcomeData.timeToOutcome,
+        pnlImpact: outcomeData.pnlImpact,
+        wasCorrect: this.evaluateDecisionCorrectness(originalDecision, outcomeData),
+        learningData: {
+          originalDecision: originalDecision.decision,
+          distanceFromSL: originalDecision.distanceFromSL,
+          outcome: outcomeData.actualOutcome,
+          profitability: outcomeData.pnlImpact > 0 ? 'PROFITABLE' : 'LOSS'
+        },
+        timestamp: new Date().toISOString()
+      };
+
+      await prisma.ai_learning_data.create({
+        data: {
+          id: `sl_outcome_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+          userId: 'default-user',
+          symbol: originalDecision.symbol,
+          timeframe: 'OUTCOME',
+          analysisData: JSON.stringify(outcomeRecord),
+          marketConditions: originalRecord.marketConditions,
+          confidenceScore: outcomeRecord.wasCorrect ? 75 : 25
+        }
+      });
+
+      await this.log(`✅ Outcome assessed for ${outcomeData.decisionId}: ${outcomeData.actualOutcome} (${outcomeRecord.wasCorrect ? 'CORRECT' : 'INCORRECT'})`);
+      
+      // Update learning thresholds based on outcomes
+      await this.updateThresholdsFromOutcome(originalDecision, outcomeRecord);
+      
+      return true;
+    } catch (error) {
+      await this.log(`❌ Error assessing outcome: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Evaluate if the original decision was correct based on outcome
+   */
+  evaluateDecisionCorrectness(originalDecision, outcome) {
+    const decision = originalDecision.decision;
+    const actualOutcome = outcome.actualOutcome;
+    const pnlImpact = outcome.pnlImpact;
+
+    // Define what constitutes a "correct" decision
+    if (decision === 'EMERGENCY_EXIT' && (actualOutcome === 'STOPPED_OUT' || pnlImpact < -50)) {
+      return true; // Correctly identified emergency
+    }
+    
+    if (decision === 'HOLD_POSITION' && pnlImpact > 0) {
+      return true; // Correctly held profitable position
+    }
+    
+    if (decision === 'ADJUST_STOP_LOSS' && actualOutcome === 'TAKE_PROFIT') {
+      return true; // Adjustment led to profitable exit
+    }
+
+    return false;
+  }
+
+  /**
+   * Get smart recommendation based on learned patterns
+   */
+  async getSmartRecommendation(requestData) {
+    try {
+      const { distanceFromSL, symbol, marketConditions } = requestData;
+      
+      // Get historical data for similar situations
+      const prisma = await getDB();
+      const similarDecisions = await prisma.ai_learning_data.findMany({
+        where: {
+          symbol: symbol,
+          analysisData: {
+            string_contains: '"type":"STOP_LOSS_DECISION"'
+          }
+        },
+        orderBy: { createdAt: 'desc' },
+        take: 20
+      });
+
+      // Analyze patterns from similar situations
+      let recommendation = this.getBaseRecommendation(distanceFromSL);
+      
+      if (similarDecisions.length >= 3) {
+        const learnedRecommendation = await this.analyzePatterns(similarDecisions, distanceFromSL);
+        if (learnedRecommendation) {
+          recommendation = learnedRecommendation;
+        }
+      }
+
+      await this.log(`🎯 Smart recommendation for ${symbol} at ${distanceFromSL}%: ${recommendation.action}`);
+      
+      return recommendation;
+    } catch (error) {
+      await this.log(`❌ Error getting smart recommendation: ${error.message}`);
+      return this.getBaseRecommendation(distanceFromSL);
+    }
+  }
+
+  /**
+   * Get base recommendation using current thresholds
+   */
+  getBaseRecommendation(distanceFromSL) {
+    if (distanceFromSL <= this.learningThresholds.emergency) {
+      return {
+        action: 'EMERGENCY_EXIT',
+        confidence: 0.8,
+        reasoning: `Very close to SL (${distanceFromSL}%), emergency exit recommended`
+      };
+    } else if (distanceFromSL <= this.learningThresholds.risk) {
+      return {
+        action: 'HIGH_ALERT',
+        confidence: 0.7,
+        reasoning: `Close to SL (${distanceFromSL}%), monitor closely`
+      };
+    } else if (distanceFromSL <= this.learningThresholds.mediumRisk) {
+      return {
+        action: 'MONITOR',
+        confidence: 0.6,
+        reasoning: `Moderate distance from SL (${distanceFromSL}%), continue monitoring`
+      };
+    } else {
+      return {
+        action: 'HOLD_POSITION',
+        confidence: 0.5,
+        reasoning: `Safe distance from SL (${distanceFromSL}%), maintain position`
+      };
+    }
+  }
+
+  /**
+   * Analyze historical patterns to improve recommendations
+   */
+  async analyzePatterns(decisions, currentDistance) {
+    const outcomes = await this.getOutcomesForDecisions(decisions);
+    
+    // Find decisions made at similar distances
+    const similarDistanceDecisions = decisions.filter(d => {
+      const data = JSON.parse(d.analysisData);
+      const distance = data.distanceFromSL;
+      return Math.abs(distance - currentDistance) <= 1.0; // Within 1%
+    });
+
+    if (similarDistanceDecisions.length < 2) {
+      return null; // Not enough similar data
+    }
+
+    // Analyze success rate of different actions at this distance
+    const actionSuccess = {};
+    
+    for (const decision of similarDistanceDecisions) {
+      const decisionData = JSON.parse(decision.analysisData);
+      const action = decisionData.decision;
+      const outcome = outcomes.find(o => o.originalDecisionId === decision.id);
+      
+      if (outcome) {
+        if (!actionSuccess[action]) {
+          actionSuccess[action] = { total: 0, successful: 0 };
+        }
+        actionSuccess[action].total++;
+        if (outcome.wasCorrect) {
+          actionSuccess[action].successful++;
+        }
+      }
+    }
+
+    // Find the action with highest success rate
+    let bestAction = null;
+    let bestSuccessRate = 0;
+    
+    for (const [action, stats] of Object.entries(actionSuccess)) {
+      if (stats.total >= 2) { // Need at least 2 samples
+        const successRate = stats.successful / stats.total;
+        if (successRate > bestSuccessRate) {
+          bestSuccessRate = successRate;
+          bestAction = action;
+        }
+      }
+    }
+
+    if (bestAction && bestSuccessRate > 0.6) {
+      return {
+        action: bestAction,
+        confidence: bestSuccessRate,
+        reasoning: `Learned pattern: ${bestAction} successful ${Math.round(bestSuccessRate * 100)}% of time at this distance`
+      };
+    }
+
+    return null;
+  }
+
+  /**
+   * Get outcomes for a set of decisions
+   */
+  async getOutcomesForDecisions(decisions) {
+    const prisma = await getDB();
+    const decisionIds = decisions.map(d => d.id);
+    
+    const outcomes = await prisma.ai_learning_data.findMany({
+      where: {
+        analysisData: {
+          string_contains: '"type":"STOP_LOSS_OUTCOME"'
+        }
+      }
+    });
+
+    return outcomes.map(o => JSON.parse(o.analysisData))
+      .filter(outcome => decisionIds.includes(outcome.originalDecisionId));
+  }
+
+  /**
+   * Update learning thresholds based on outcome data
+   */
+  async updateThresholdsFromOutcome(originalDecision, outcome) {
+    // Simple threshold adjustment based on outcomes
+    const distance = originalDecision.distanceFromSL;
+    const wasCorrect = outcome.wasCorrect;
+    
+    if (!wasCorrect) {
+      // If decision was wrong, adjust thresholds slightly
+      if (originalDecision.decision === 'HOLD_POSITION' && outcome.actualOutcome === 'STOPPED_OUT') {
+        // We should have exited earlier - make thresholds more conservative
+        this.learningThresholds.emergency = Math.min(2.0, this.learningThresholds.emergency + 0.1);
+        this.learningThresholds.risk = Math.min(3.0, this.learningThresholds.risk + 0.1);
+      }
+    }
+
+    await this.log(`🔧 Thresholds updated: emergency=${this.learningThresholds.emergency}, risk=${this.learningThresholds.risk}`);
+  }
+
+  /**
+   * Get current learning status and statistics
+   */
+  async analyzeDecisionPatterns() {
+    try {
+      const prisma = await getDB();
+      
+      // Get recent decisions and outcomes
+      const decisions = await prisma.ai_learning_data.findMany({
+        where: {
+          analysisData: {
+            string_contains: '"type":"STOP_LOSS_DECISION"'
+          },
+          createdAt: {
+            gte: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) // Last 7 days
+          }
+        },
+        orderBy: { createdAt: 'desc' }
+      });
+
+      const outcomes = await prisma.ai_learning_data.findMany({
+        where: {
+          analysisData: {
+            string_contains: '"type":"STOP_LOSS_OUTCOME"'
+          },
+          createdAt: {
+            gte: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) // Last 7 days
+          }
+        }
+      });
+
+      // Analyze patterns
+      const patterns = {
+        totalDecisions: decisions.length,
+        totalOutcomes: outcomes.length,
+        successfulDecisions: outcomes.filter(o => JSON.parse(o.analysisData).wasCorrect).length,
+        successRate: outcomes.length > 0 ? outcomes.filter(o => JSON.parse(o.analysisData).wasCorrect).length / outcomes.length : 0,
+        learnedThresholds: this.learningThresholds
+      };
+
+      return patterns;
+    } catch (error) {
+      await this.log(`❌ Error analyzing patterns: ${error.message}`);
+      return {
+        totalDecisions: 0,
+        totalOutcomes: 0,
+        successfulDecisions: 0,
+        successRate: 0,
+        learnedThresholds: this.learningThresholds
+      };
+    }
+  }
+
+  /**
+   * Get learning status
+   */
+  async getLearningStatus() {
+    try {
+      const prisma = await getDB();
+      const totalDecisions = await prisma.ai_learning_data.count({
+        where: {
+          analysisData: {
+            string_contains: '"type":"STOP_LOSS_DECISION"'
+          }
+        }
+      });
+
+      const recentDecisions = await prisma.ai_learning_data.count({
+        where: {
+          analysisData: {
+            string_contains: '"type":"STOP_LOSS_DECISION"'
+          },
+          createdAt: {
+            gte: new Date(Date.now() - 24 * 60 * 60 * 1000) // Last 24 hours
+          }
+        }
+      });
+
+      return {
+        totalDecisions,
+        recentDecisions,
+        thresholds: this.learningThresholds,
+        isActive: totalDecisions > 0
+      };
+
+    } catch (error) {
+      await this.log(`❌ Error getting learning status: ${error.message}`);
+      return {
+        totalDecisions: 0,
+        recentDecisions: 0,
+        thresholds: this.learningThresholds,
+        isActive: false
+      };
+    }
+  }
+
+  /**
+   * Generate comprehensive learning report
+   * Compatible implementation for enhanced-autonomous-risk-manager
+   */
+  async generateLearningReport() {
+    try {
+      const status = await this.getLearningStatus();
+      const patterns = await this.analyzeDecisionPatterns();
+      
+      // Calculate system confidence based on decisions made
+      const systemConfidence = this.calculateSystemConfidence(status.totalDecisions, status.recentDecisions, patterns.successRate);
+      
+      const report = {
+        timestamp: new Date().toISOString(),
+        summary: {
+          totalDecisions: status.totalDecisions,
+          recentDecisions: status.recentDecisions,
+          successfulPatterns: patterns.successfulDecisions,
+          learningThresholds: this.learningThresholds,
+          systemConfidence: systemConfidence,
+          isActive: status.isActive,
+          successRate: patterns.successRate
+        },
+        insights: {
+          emergencyThreshold: this.learningThresholds.emergency,
+          riskThreshold: this.learningThresholds.risk,
+          mediumRiskThreshold: this.learningThresholds.mediumRisk,
+          confidenceLevel: systemConfidence > 0.7 ? 'HIGH' : systemConfidence > 0.4 ? 'MEDIUM' : 'LOW',
+          totalOutcomes: patterns.totalOutcomes,
+          decisionAccuracy: patterns.successRate
+        },
+        recommendations: this.generateSystemRecommendations(status, patterns)
+      };
+
+      await this.log(`📊 Learning report generated: ${report.summary.totalDecisions} decisions, ${(systemConfidence * 100).toFixed(1)}% confidence, ${(patterns.successRate * 100).toFixed(1)}% success rate`);
+      
+      return report;
+    } catch (error) {
+      await this.log(`❌ Error generating learning report: ${error.message}`);
+      return {
+        timestamp: new Date().toISOString(),
+        summary: {
+          totalDecisions: 0,
+          recentDecisions: 0,
+          systemConfidence: 0.0,
+          isActive: false
+        },
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Calculate system confidence based on learning data
+   */
+  calculateSystemConfidence(totalDecisions, recentDecisions, successRate = 0) {
+    if (totalDecisions < 5) return 0.3; // Low confidence with insufficient data
+    if (totalDecisions < 20) return 0.4 + (successRate * 0.2); // Medium-low confidence boosted by success
+    if (totalDecisions < 50) return 0.6 + (successRate * 0.2); // Medium confidence boosted by success
+    
+    // High confidence with lots of data, scaled by recent activity and success rate
+    const recentActivityFactor = Math.min(1.0, recentDecisions / 10);
+    const successFactor = successRate || 0.5; // Default to neutral if no success data
+    return Math.min(0.95, 0.7 + (recentActivityFactor * 0.1) + (successFactor * 0.15)); // Cap at 95%
+  }
+
+  /**
+   * Generate system recommendations based on learning status
+   */
+  generateSystemRecommendations(status, patterns) {
+    const recommendations = [];
+    
+    if (status.totalDecisions < 10) {
+      recommendations.push({
+        type: 'DATA_COLLECTION',
+        message: 'Need more decision data for reliable learning',
+        priority: 'HIGH'
+      });
+    }
+    
+    if (status.recentDecisions < 3) {
+      recommendations.push({
+        type: 'ACTIVITY_LOW',
+        message: 'Recent trading activity is low - learning may be stale',
+        priority: 'MEDIUM'
+      });
+    }
+    
+    if (patterns && patterns.successRate < 0.4 && patterns.totalOutcomes >= 5) {
+      recommendations.push({
+        type: 'THRESHOLD_ADJUSTMENT',
+        message: 'Low success rate detected - consider adjusting decision thresholds',
+        priority: 'HIGH'
+      });
+    }
+    
+    if (status.totalDecisions >= 20 && patterns && patterns.successRate > 0.6) {
+      recommendations.push({
+        type: 'SYSTEM_PERFORMING',
+        message: 'System learning effectively with good success rate',
+        priority: 'LOW'
+      });
+    }
+    
+    if (status.totalDecisions >= 50) {
+      recommendations.push({
+        type: 'OPTIMIZATION_READY',
+        message: 'Sufficient data available for advanced threshold optimization',
+        priority: 'LOW'
+      });
+    }
+    
+    return recommendations;
+  }
+}
+
+module.exports = SimplifiedStopLossLearner;

monitor-position.js

@@ -81,25 +81,13 @@ async function monitor() {
       statusText = 'CAUTION - MONITOR';
     }
     
-    console.log('🤖 AI AUTONOMOUS RISK MANAGEMENT:');
+    console.log('🛡️ STOP LOSS PROTECTION:');
     console.log(`   Stop Loss: $${sl.stopLossPrice.toFixed(4)} (${sl.distancePercent}% away)`);
     console.log(`   Status: ${statusIcon} ${statusText}`);
-    
+    console.log(`   Risk Level: ${positionData.monitor.riskLevel}`);
-    // AI Action Display
-    const aiActions = {
-      'DANGER - VERY CLOSE': '🚨 AI: Executing emergency analysis',
-      'WARNING - APPROACHING': '⚠️ AI: Reviewing position for adjustments', 
-      'CAUTION - MONITOR': '🟡 AI: Enhanced monitoring active',
-      'SAFE': '✅ AI: Scanning for new opportunities'
-    };
-    
-    const aiAction = aiActions[statusText] || '🤖 AI: Autonomous operation';
-    console.log(`   AI Action: ${aiAction}`);
-    console.log(`   Beach Mode: ${'🏖️ ACTIVE - No manual intervention needed'}`);
     
     if (sl.isNear) {
-      console.log('\n🤖 AI AUTONOMOUS ACTION: Risk management protocols activated!');
+      console.log('\n🚨 ALERT: PRICE NEAR STOP LOSS! 🚨');
-      console.log('   🏖️ Relax - Your AI is handling this autonomously');
     }
     console.log('');