diff --git a/MT5 EA Sniper Strategy Blueprint.txt b/MT5 EA Sniper Strategy Blueprint.txt
deleted file mode 100644
index c28284c..0000000
--- a/MT5 EA Sniper Strategy Blueprint.txt	
+++ /dev/null
@@ -1,68 +0,0 @@
-MT5 Expert Advisor Blueprint – OB +
-BOS + Liquidity Sweep + FVG Strategy
-Overview
-This MT5 EA is designed to work on all forex pairs including Gold (XAUUSD). It uses
-institutional concepts across multiple timeframes, including Order Blocks (OB), Break of
-Structure (BOS), Liquidity Sweeps, and Fair Value Gaps (FVG). It identifies sniper entries on
-the 1M chart, refined by 15M and H4 bias.
-
-
-Entry Logic
-
-1. Monitor price action on the 1M chart.
-2. Detect a Liquidity Sweep (e.g., price grabs stop-losses above/below equal highs/lows).
-3. Confirm Break of Structure (BOS) in the opposite direction.
-4. Identify a valid Fair Value Gap (FVG) between BOS and OB.
-5. Validate a fresh Order Block in the direction of structure shift.
-6. Enter trade at OB zone or FVG midpoint.
-7. SL = just beyond OB or sweep wick.
-8. TP = 1:3 or better RR or next HTF structure.
-
-
-
-
-EA Configurable Parameters
-Parameter                      Description                    Example Value
-MaxTradesPerDay                Maximum trades per pair        3
-                               per day
-RiskPercent                    % of equity risked per trade   1%
-UseTimeFilter                  Enable time filter             true
-                               (London/NY sessions)
-SessionTimeStart               Start of trading window        08:00
-SessionTimeEnd                 End of trading window          21:00
-MinRR                          Minimum risk-reward ratio      1:3
-                               to enter trade
-SymbolsToTrade                 Symbols to trade (e.g.,        ["XAUUSD", "EURUSD",
-                               majors + gold)                 "GBPUSD", ...]
-
-
-Entry Pseudocode (Simplified)
-
-if (Timeframe == M1) {
-    if (LiquiditySweepDetected()) {
-       if (BreakOfStructureDetected()) {
-          if (FairValueGapExists()) {
-             if (ValidOrderBlockDetected()) {
-                ExecuteTrade(
-                   Entry = OB Zone or FVG midpoint,
-                   StopLoss = beyond OB or liquidity wick,
-                   TakeProfit = 3x Risk or next HTF zone,
-                   RiskPerTrade = 1%
-                );
-             }
-          }
-       }
-    }
-}
-
-
-
-
-Chart Visuals (Optional)
-
-- Draw OB zone (box)
-- Highlight FVG as shaded zone
-- Mark BOS with arrows/labels
-- Show sweep with icons (🔺/🔻)
-- Entry/SL/TP lines displayed
-
\ No newline at end of file
diff --git a/docs/BASELINE_TEST_SCRIPT.md b/docs/BASELINE_TEST_SCRIPT.md
new file mode 100644
index 0000000..fc65a93
--- /dev/null
+++ b/docs/BASELINE_TEST_SCRIPT.md
@@ -0,0 +1,198 @@
+# Sniper EA Baseline Performance Test Script
+
+## 🎯 Objective
+Establish baseline performance metrics for the current Sniper EA implementation to serve as reference point for future development iterations.
+
+## 📋 Test Configuration
+
+### Strategy Tester Settings
+```
+Expert Advisor: SniperEA
+Symbol: EURUSD
+Period: M1 (1 minute)
+Date Range: 2024-07-01 to 2024-09-25 (3 months)
+Model: Every tick (based on all available least timeframes)
+Optimization: Disabled
+Deposit: 10000 USD
+Leverage: 1:100
+```
+
+### EA Parameters (Baseline Configuration)
+```
+// Risk Management
+RiskPercent = 1.0
+MinRR = 2.0
+MaxPositionsPerSymbol = 3
+MaxTotalPositions = 10
+
+// Pattern Detection
+OBStrengthFilter = 1.0
+MinFVGSize = 5.0
+BOSConfirmationBars = 3
+SweepDistanceThreshold = 10.0
+
+// Session Settings
+UseTimeFilter = true
+SessionTimeStart = "08:00"
+SessionTimeEnd = "21:00"
+
+// Debug Settings
+EnableDebugMode = true
+EnableDetailedLogging = true
+```
+
+## 🔍 Test Execution Steps
+
+### Step 1: Pre-Test Verification (5 minutes)
+1. **Compilation Check**:
+   - Verify .ex5 file exists and is recent
+   - Check compilation log for warnings
+   - Confirm file size is reasonable (80-90KB expected)
+
+2. **Parameter Validation**:
+   - Verify all input parameters are within valid ranges
+   - Confirm debug mode is enabled for detailed logging
+   - Check symbol availability and data quality
+
+### Step 2: Strategy Tester Execution (15-30 minutes)
+1. **Launch Strategy Tester**: Press `Ctrl+R`
+2. **Configure Settings**: Apply baseline configuration above
+3. **Start Test**: Click "Start" and monitor progress
+4. **Monitor Logs**: Watch for initialization and pattern detection messages
+
+### Step 3: Results Analysis (10 minutes)
+1. **Performance Metrics Collection**:
+   - Total Net Profit
+   - Gross Profit / Gross Loss
+   - Profit Factor
+   - Expected Payoff
+   - Maximum Drawdown (absolute and percentage)
+   - Total Trades
+   - Winning Trades (% of total)
+   - Losing Trades (% of total)
+   - Largest Profit Trade
+   - Largest Loss Trade
+   - Average Profit Trade
+   - Average Loss Trade
+   - Maximum Consecutive Wins
+   - Maximum Consecutive Losses
+
+2. **Risk Management Validation**:
+   - Verify no trade exceeded 1% account risk
+   - Confirm position limits were respected
+   - Check stop loss and take profit placement accuracy
+
+3. **Pattern Detection Analysis**:
+   - Count of each pattern type detected
+   - Pattern detection accuracy (manual spot check)
+   - Multi-timeframe bias alignment verification
+
+## 📊 Expected Baseline Results
+
+### Target Performance Metrics
+```
+Profit Factor: > 1.2 (acceptable), > 1.5 (good)
+Win Rate: 45-65%
+Maximum Drawdown: < 15%
+Risk per Trade: Exactly 1.0%
+Average R:R Ratio: 2.0:1 minimum
+Total Trades: 50-150 (for 3-month period)
+```
+
+### Pattern Detection Expectations
+```
+Order Blocks: 200-500 detected
+Fair Value Gaps: 100-300 detected
+Break of Structure: 150-400 detected
+Liquidity Sweeps: 100-250 detected
+Valid Setups: 50-150 (pattern combinations)
+```
+
+## 🚨 Red Flags to Watch For
+
+### Critical Issues
+- **Zero Trades**: No trading activity indicates logic failure
+- **Excessive Trades**: >500 trades suggests over-trading
+- **High Drawdown**: >20% indicates poor risk management
+- **Low Win Rate**: <35% suggests pattern detection issues
+- **Poor R:R**: <1.5:1 average indicates TP/SL calculation problems
+
+### Warning Signs
+- Compilation warnings in log
+- Pattern detection errors
+- Trade execution failures
+- Position sizing inconsistencies
+- Session filtering malfunctions
+
+## 📝 Test Results Template
+
+```
+=== SNIPER EA BASELINE TEST RESULTS ===
+Date: ___________
+Test Duration: 3 months (2024-07-01 to 2024-09-25)
+Symbol: EURUSD
+Timeframe: M1
+
+PERFORMANCE METRICS:
+- Total Net Profit: $______
+- Profit Factor: ______
+- Total Trades: ______
+- Winning Trades: ______ (____%)
+- Maximum Drawdown: $______ (____%)
+- Average R:R Ratio: ______:1
+
+PATTERN DETECTION:
+- Order Blocks Detected: ______
+- Fair Value Gaps Detected: ______
+- BOS Events Detected: ______
+- Liquidity Sweeps Detected: ______
+- Valid Trading Setups: ______
+
+RISK MANAGEMENT:
+- Maximum Risk per Trade: _____%
+- Position Limits Respected: [ ] Yes [ ] No
+- SL/TP Placement Accuracy: [ ] Good [ ] Issues
+
+OVERALL ASSESSMENT:
+[ ] PASS - Ready for incremental development
+[ ] CONDITIONAL - Minor issues to address
+[ ] FAIL - Major issues require immediate attention
+
+NOTES:
+_________________________________
+_________________________________
+```
+
+## 🔄 Next Steps Based on Results
+
+### If Test PASSES:
+1. Document baseline metrics as reference
+2. Proceed with incremental development workflow
+3. Use results as regression testing benchmark
+4. Begin Phase 2 workflow implementation
+
+### If Test Shows ISSUES:
+1. Analyze specific failure points
+2. Review compilation logs for errors
+3. Validate pattern detection logic
+4. Check risk management calculations
+5. Fix issues before proceeding
+
+### If Test FAILS Completely:
+1. Review EA initialization process
+2. Check symbol data availability
+3. Validate input parameters
+4. Examine multi-timeframe data updates
+5. Consider rollback to last known working version
+
+## 📊 Performance Tracking
+
+This baseline test establishes the foundation for:
+- **Regression Testing**: Ensure new features don't break existing functionality
+- **Performance Benchmarking**: Compare future optimizations against baseline
+- **Quality Assurance**: Validate that changes improve rather than degrade performance
+- **Risk Validation**: Confirm risk management remains consistent across iterations
+
+---
+
+**Execute this test before implementing any new features or modifications to establish a reliable performance baseline.**
diff --git a/docs/COMPILATION_AUTOMATION.md b/docs/COMPILATION_AUTOMATION.md
new file mode 100644
index 0000000..3aaedbd
--- /dev/null
+++ b/docs/COMPILATION_AUTOMATION.md
@@ -0,0 +1,393 @@
+# 🔧 MT5 EA Compilation & Validation Automation
+
+## 🎯 Objective
+Establish automated compilation checkpoints and validation scripts to streamline the development process and catch issues early.
+
+## 📋 Compilation Checkpoint Strategy
+
+### Checkpoint Frequency
+```
+✅ After every 50-100 lines of code
+✅ After completing each function
+✅ Before running any tests
+✅ Before committing changes
+✅ Before deploying to demo/live
+```
+
+### Automated Compilation Script
+
+**File**: `compile_ea.ps1` (PowerShell Script)
+
+```powershell
+# MT5 EA Compilation Automation Script
+param(
+    [string]$EAName = "SniperEA",
+    [string]$SourcePath = "D:\Projects\MT5-EA-Sniper-Strategy\src",
+    [string]$MT5Path = "C:\Users\$\AppData\Roaming\MetaQuotes\Terminal\D0E8209F77C8CF37AD8BF550E51FF075",
+    [switch]$Verbose
+)
+
+Write-Host "=== MT5 EA Compilation Automation ===" -ForegroundColor Green
+Write-Host "EA Name: $EAName" -ForegroundColor Yellow
+Write-Host "Source: $SourcePath\$EAName.mq5" -ForegroundColor Yellow
+
+# Check if source file exists
+$SourceFile = "$SourcePath\$EAName.mq5"
+if (-not (Test-Path $SourceFile)) {
+    Write-Host "ERROR: Source file not found: $SourceFile" -ForegroundColor Red
+    exit 1
+}
+
+# Get file modification time
+$SourceModified = (Get-Item $SourceFile).LastWriteTime
+Write-Host "Source Modified: $SourceModified" -ForegroundColor Cyan
+
+# Check if MetaEditor is available
+$MetaEditorPath = "$MT5Path\MetaEditor64.exe"
+if (-not (Test-Path $MetaEditorPath)) {
+    Write-Host "ERROR: MetaEditor not found: $MetaEditorPath" -ForegroundColor Red
+    exit 1
+}
+
+# Compile the EA
+Write-Host "Compiling $EAName..." -ForegroundColor Yellow
+$CompileArgs = "/compile:$SourceFile"
+if ($Verbose) {
+    $CompileArgs += " /log"
+}
+
+$Process = Start-Process -FilePath $MetaEditorPath -ArgumentList $CompileArgs -Wait -PassThru -WindowStyle Hidden
+
+# Check compilation result
+$ExpertPath = "$MT5Path\MQL5\Experts\$EAName.ex5"
+if (Test-Path $ExpertPath) {
+    $CompiledModified = (Get-Item $ExpertPath).LastWriteTime
+    $FileSize = (Get-Item $ExpertPath).Length
+    
+    if ($CompiledModified -gt $SourceModified.AddSeconds(-10)) {
+        Write-Host "✅ COMPILATION SUCCESSFUL" -ForegroundColor Green
+        Write-Host "Compiled: $CompiledModified" -ForegroundColor Cyan
+        Write-Host "File Size: $([math]::Round($FileSize/1KB, 2)) KB" -ForegroundColor Cyan
+        
+        # Log successful compilation
+        $LogEntry = "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - COMPILE SUCCESS - $EAName - $([math]::Round($FileSize/1KB, 2)) KB"
+        Add-Content -Path "$SourcePath\compilation.log" -Value $LogEntry
+        
+        exit 0
+    } else {
+        Write-Host "⚠️ COMPILATION MAY HAVE FAILED - File not updated" -ForegroundColor Yellow
+        exit 2
+    }
+} else {
+    Write-Host "❌ COMPILATION FAILED - No .ex5 file generated" -ForegroundColor Red
+    
+    # Log failed compilation
+    $LogEntry = "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - COMPILE FAILED - $EAName"
+    Add-Content -Path "$SourcePath\compilation.log" -Value $LogEntry
+    
+    exit 1
+}
+```
+
+### Quick Compilation Batch File
+
+**File**: `quick_compile.bat`
+
+```batch
+@echo off
+echo === Quick EA Compilation ===
+cd /d "D:\Projects\MT5-EA-Sniper-Strategy"
+powershell -ExecutionPolicy Bypass -File "compile_ea.ps1" -EAName "SniperEA"
+if %ERRORLEVEL% EQU 0 (
+    echo.
+    echo ✅ Ready for testing!
+    echo.
+) else (
+    echo.
+    echo ❌ Fix compilation errors before proceeding
+    echo.
+)
+pause
+```
+
+## 🔍 Automated Validation Scripts
+
+### Pre-Compilation Validation
+
+**File**: `validate_code.ps1`
+
+```powershell
+# Code Validation Script
+param(
+    [string]$SourceFile = "D:\Projects\MT5-EA-Sniper-Strategy\src\SniperEA.mq5"
+)
+
+Write-Host "=== Code Validation Checks ===" -ForegroundColor Green
+
+$Issues = @()
+$Content = Get-Content $SourceFile -Raw
+
+# Check 1: Required Functions Present
+$RequiredFunctions = @(
+    "OnInit()",
+    "OnTick()",
+    "ProcessTradingLogic()",
+    "CalculatePositionSize(",
+    "ExecuteBuyTrade(",
+    "ExecuteSellTrade("
+)
+
+foreach ($Function in $RequiredFunctions) {
+    if ($Content -notmatch [regex]::Escape($Function)) {
+        $Issues += "Missing required function: $Function"
+    }
+}
+
+# Check 2: Risk Management Parameters
+$RiskParams = @(
+    "RiskPercent",
+    "MaxPositionsPerSymbol",
+    "MaxTotalPositions"
+)
+
+foreach ($Param in $RiskParams) {
+    if ($Content -notmatch "input.*$Param") {
+        $Issues += "Missing risk parameter: $Param"
+    }
+}
+
+# Check 3: Debug Mode Available
+if ($Content -notmatch "EnableDebugMode") {
+    $Issues += "Debug mode parameter not found"
+}
+
+# Check 4: Trade Object Initialization
+if ($Content -notmatch "CTrade.*trade") {
+    $Issues += "CTrade object not properly declared"
+}
+
+# Check 5: Magic Number Set
+if ($Content -notmatch "SetExpertMagicNumber") {
+    $Issues += "Magic number not set for trade identification"
+}
+
+# Report Results
+if ($Issues.Count -eq 0) {
+    Write-Host "✅ All validation checks passed!" -ForegroundColor Green
+    exit 0
+} else {
+    Write-Host "❌ Validation issues found:" -ForegroundColor Red
+    foreach ($Issue in $Issues) {
+        Write-Host "  - $Issue" -ForegroundColor Yellow
+    }
+    exit 1
+}
+```
+
+### Post-Compilation Validation
+
+**File**: `validate_compilation.ps1`
+
+```powershell
+# Post-Compilation Validation
+param(
+    [string]$EAName = "SniperEA",
+    [string]$MT5Path = "C:\Users\$\AppData\Roaming\MetaQuotes\Terminal\D0E8209F77C8CF37AD8BF550E51FF075"
+)
+
+Write-Host "=== Post-Compilation Validation ===" -ForegroundColor Green
+
+$ExpertPath = "$MT5Path\MQL5\Experts\$EAName.ex5"
+$Issues = @()
+
+# Check 1: .ex5 file exists
+if (-not (Test-Path $ExpertPath)) {
+    $Issues += ".ex5 file not found - compilation failed"
+} else {
+    $FileInfo = Get-Item $ExpertPath
+    $FileSize = $FileInfo.Length
+    $LastModified = $FileInfo.LastWriteTime
+    
+    Write-Host "File Size: $([math]::Round($FileSize/1KB, 2)) KB" -ForegroundColor Cyan
+    Write-Host "Last Modified: $LastModified" -ForegroundColor Cyan
+    
+    # Check 2: File size reasonable (should be 80-100KB for Sniper EA)
+    if ($FileSize -lt 50KB) {
+        $Issues += "File size too small ($([math]::Round($FileSize/1KB, 2)) KB) - possible compilation issues"
+    } elseif ($FileSize -gt 200KB) {
+        $Issues += "File size unusually large ($([math]::Round($FileSize/1KB, 2)) KB) - check for bloat"
+    }
+    
+    # Check 3: File recently modified (within last 5 minutes)
+    $FiveMinutesAgo = (Get-Date).AddMinutes(-5)
+    if ($LastModified -lt $FiveMinutesAgo) {
+        $Issues += "File not recently modified - may be stale compilation"
+    }
+}
+
+# Check 4: Log file for compilation errors
+$LogPath = "$MT5Path\MQL5\Logs"
+if (Test-Path $LogPath) {
+    $RecentLogs = Get-ChildItem $LogPath -Filter "*.log" | 
+                  Where-Object { $_.LastWriteTime -gt (Get-Date).AddMinutes(-10) }
+    
+    foreach ($Log in $RecentLogs) {
+        $LogContent = Get-Content $Log.FullName -Tail 50
+        $ErrorLines = $LogContent | Where-Object { $_ -match "error|warning" -and $_ -match $EAName }
+        
+        if ($ErrorLines) {
+            $Issues += "Compilation warnings/errors found in $($Log.Name)"
+        }
+    }
+}
+
+# Report Results
+if ($Issues.Count -eq 0) {
+    Write-Host "✅ Post-compilation validation passed!" -ForegroundColor Green
+    Write-Host "EA is ready for testing" -ForegroundColor Green
+    exit 0
+} else {
+    Write-Host "❌ Post-compilation issues found:" -ForegroundColor Red
+    foreach ($Issue in $Issues) {
+        Write-Host "  - $Issue" -ForegroundColor Yellow
+    }
+    exit 1
+}
+```
+
+## 🚀 VS Code Integration
+
+### VS Code Task Configuration
+
+**File**: `.vscode/tasks.json`
+
+```json
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "Compile Sniper EA",
+            "type": "shell",
+            "command": "powershell",
+            "args": [
+                "-ExecutionPolicy", "Bypass",
+                "-File", "${workspaceFolder}/compile_ea.ps1",
+                "-EAName", "SniperEA",
+                "-Verbose"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "presentation": {
+                "echo": true,
+                "reveal": "always",
+                "focus": false,
+                "panel": "shared"
+            },
+            "problemMatcher": []
+        },
+        {
+            "label": "Validate & Compile",
+            "dependsOrder": "sequence",
+            "dependsOn": [
+                "Validate Code",
+                "Compile Sniper EA",
+                "Post-Compile Validation"
+            ]
+        },
+        {
+            "label": "Validate Code",
+            "type": "shell",
+            "command": "powershell",
+            "args": [
+                "-ExecutionPolicy", "Bypass",
+                "-File", "${workspaceFolder}/validate_code.ps1"
+            ]
+        },
+        {
+            "label": "Post-Compile Validation",
+            "type": "shell",
+            "command": "powershell",
+            "args": [
+                "-ExecutionPolicy", "Bypass",
+                "-File", "${workspaceFolder}/validate_compilation.ps1"
+            ]
+        }
+    ]
+}
+```
+
+### VS Code Keyboard Shortcuts
+
+**File**: `.vscode/keybindings.json`
+
+```json
+[
+    {
+        "key": "ctrl+shift+b",
+        "command": "workbench.action.tasks.runTask",
+        "args": "Validate & Compile"
+    },
+    {
+        "key": "f5",
+        "command": "workbench.action.tasks.runTask",
+        "args": "Compile Sniper EA"
+    }
+]
+```
+
+## 📊 Compilation Monitoring
+
+### Compilation Log Analysis
+
+**File**: `analyze_compilation_log.ps1`
+
+```powershell
+# Analyze compilation patterns
+$LogFile = "D:\Projects\MT5-EA-Sniper-Strategy\src\compilation.log"
+
+if (Test-Path $LogFile) {
+    $Logs = Get-Content $LogFile
+    $SuccessCount = ($Logs | Where-Object { $_ -match "COMPILE SUCCESS" }).Count
+    $FailCount = ($Logs | Where-Object { $_ -match "COMPILE FAILED" }).Count
+    $TotalCompilations = $SuccessCount + $FailCount
+    
+    if ($TotalCompilations -gt 0) {
+        $SuccessRate = [math]::Round(($SuccessCount / $TotalCompilations) * 100, 2)
+        
+        Write-Host "=== Compilation Statistics ===" -ForegroundColor Green
+        Write-Host "Total Compilations: $TotalCompilations" -ForegroundColor Cyan
+        Write-Host "Successful: $SuccessCount" -ForegroundColor Green
+        Write-Host "Failed: $FailCount" -ForegroundColor Red
+        Write-Host "Success Rate: $SuccessRate%" -ForegroundColor Yellow
+        
+        # Recent compilation trend
+        $RecentLogs = $Logs | Select-Object -Last 10
+        $RecentSuccess = ($RecentLogs | Where-Object { $_ -match "COMPILE SUCCESS" }).Count
+        Write-Host "Recent Success Rate (last 10): $([math]::Round(($RecentSuccess/10)*100, 2))%" -ForegroundColor Cyan
+    }
+}
+```
+
+## 🎯 Usage Instructions
+
+### For Development Workflow:
+
+1. **Before Coding**: Run `validate_code.ps1` to check current state
+2. **During Coding**: Use `Ctrl+Shift+B` in VS Code for full validation & compilation
+3. **Quick Compilation**: Use `F5` in VS Code or run `quick_compile.bat`
+4. **After Major Changes**: Run full validation sequence
+
+### Integration with Your Current Setup:
+
+Since you already have the Strategy Tester open and ready:
+
+1. **Save these scripts** in your project directory
+2. **Set up VS Code tasks** for one-click compilation
+3. **Use automated validation** before each Strategy Tester run
+4. **Monitor compilation logs** to track development progress
+
+---
+
+**Next Step**: Set up these automation scripts, then proceed with your baseline testing in the Strategy Tester you have open.
diff --git a/docs/FEATURE_BRANCH_METHODOLOGY.md b/docs/FEATURE_BRANCH_METHODOLOGY.md
new file mode 100644
index 0000000..535c960
--- /dev/null
+++ b/docs/FEATURE_BRANCH_METHODOLOGY.md
@@ -0,0 +1,291 @@
+# 🌿 Feature Branch Methodology for MT5 EA Development
+
+## 🎯 Objective
+Establish a systematic approach to feature development using branching methodology that enables safe incremental development, easy rollbacks, and parallel feature work.
+
+## 📋 Branch Structure Strategy
+
+### Main Branch Structure
+```
+master (main)           ← Production-ready, stable code
+├── develop             ← Integration branch for features
+├── feature/risk-mgmt   ← Individual feature branches
+├── feature/patterns    ← Pattern detection enhancements
+├── feature/ui-panel    ← User interface improvements
+├── hotfix/bug-fix      ← Critical bug fixes
+└── release/v1.1        ← Release preparation branches
+```
+
+### Branch Naming Conventions
+```
+feature/[feature-name]     ← New features
+bugfix/[bug-description]   ← Bug fixes
+hotfix/[critical-fix]      ← Critical production fixes
+release/[version]          ← Release preparation
+experiment/[test-name]     ← Experimental features
+optimize/[component]       ← Performance optimizations
+```
+
+## 🚀 Feature Development Workflow
+
+### Phase 1: Feature Planning & Branch Creation
+```bash
+# 1. Start from latest develop branch
+git checkout develop
+git pull origin develop
+
+# 2. Create feature branch
+git checkout -b feature/enhanced-pattern-detection
+
+# 3. Document feature scope
+echo "Feature: Enhanced Pattern Detection" > FEATURE_SCOPE.md
+echo "- Improve OB detection accuracy" >> FEATURE_SCOPE.md
+echo "- Add pattern strength scoring" >> FEATURE_SCOPE.md
+echo "- Implement pattern filtering" >> FEATURE_SCOPE.md
+```
+
+### Phase 2: Incremental Development
+```bash
+# Small, focused commits with descriptive messages
+git add src/SniperEA.mq5
+git commit -m "feat: improve order block detection accuracy
+
+- Enhanced swing point identification
+- Added strength calculation algorithm
+- Improved boundary detection logic
+- Added unit tests for OB detection
+
+Tested: Unit tests pass, compiles successfully"
+
+# Continue with incremental commits
+git add src/SniperEA.mq5
+git commit -m "feat: add pattern strength scoring system
+
+- Implemented strength calculation based on price reaction
+- Added volume-based strength adjustment
+- Created strength threshold filtering
+- Updated pattern validation logic
+
+Tested: Integration tests pass, Strategy Tester validates"
+```
+
+### Phase 3: Testing & Validation
+```bash
+# Create testing checkpoint
+git tag feature/enhanced-pattern-detection-v0.1
+
+# Document test results
+echo "=== Test Results ===" > TEST_RESULTS.md
+echo "Unit Tests: PASS" >> TEST_RESULTS.md
+echo "Integration Tests: PASS" >> TEST_RESULTS.md
+echo "Strategy Tester: PASS (Profit Factor: 1.45)" >> TEST_RESULTS.md
+
+git add TEST_RESULTS.md
+git commit -m "test: document feature testing results
+
+- All unit tests passing
+- Integration tests successful
+- Strategy Tester shows improved performance
+- Ready for merge to develop"
+```
+
+### Phase 4: Integration & Merge
+```bash
+# Switch to develop and update
+git checkout develop
+git pull origin develop
+
+# Merge feature branch
+git merge --no-ff feature/enhanced-pattern-detection
+
+# Tag the integration
+git tag develop-enhanced-patterns-integrated
+
+# Push to remote
+git push origin develop
+git push origin --tags
+```
+
+## 📊 File Management Strategy
+
+### Backup Strategy Before Major Changes
+```powershell
+# Automated backup script: backup_before_feature.ps1
+param([string]$FeatureName)
+
+$BackupDir = "D:\Projects\MT5-EA-Sniper-Strategy\backups"
+$Timestamp = Get-Date -Format "yyyyMMdd-HHmmss"
+$BackupPath = "$BackupDir\$FeatureName-$Timestamp"
+
+# Create backup directory
+New-Item -ItemType Directory -Path $BackupPath -Force
+
+# Copy source files
+Copy-Item "src\*.mq5" -Destination $BackupPath
+Copy-Item "src\*.ex5" -Destination $BackupPath -ErrorAction SilentlyContinue
+
+Write-Host "Backup created: $BackupPath" -ForegroundColor Green
+```
+
+### Working Copy Management
+```
+Project Structure:
+├── src/
+│   ├── SniperEA.mq5           ← Main development file
+│   ├── SniperEA_stable.mq5    ← Last known stable version
+│   └── SniperEA_backup.mq5    ← Automatic backup
+├── backups/
+│   ├── feature-name-20240925/ ← Feature-specific backups
+│   └── daily-20240925/        ← Daily automated backups
+├── tests/
+│   ├── unit_tests/            ← Individual function tests
+│   └── integration_tests/     ← System integration tests
+└── docs/
+    ├── FEATURE_SCOPE.md       ← Current feature documentation
+    └── TEST_RESULTS.md        ← Testing results log
+```
+
+## 🔄 Development Cycle for Each Feature
+
+### Micro-Cycle (Individual Functions)
+**Duration**: 30 minutes - 2 hours
+```
+1. Plan function implementation (5-10 minutes)
+2. Implement function (15-60 minutes)
+3. Unit test function (10-20 minutes)
+4. Commit changes (2-5 minutes)
+5. Update documentation (5-10 minutes)
+```
+
+### Mini-Cycle (Feature Components)
+**Duration**: 2-8 hours
+```
+1. Complete related function group
+2. Integration testing (30-60 minutes)
+3. Strategy Tester validation (30-60 minutes)
+4. Performance regression check (15-30 minutes)
+5. Commit feature component
+6. Update feature documentation
+```
+
+### Major-Cycle (Complete Features)
+**Duration**: 1-5 days
+```
+1. Complete all feature components
+2. Comprehensive testing (2-4 hours)
+3. Multi-symbol validation (1-2 hours)
+4. Demo testing (1-3 days)
+5. Merge to develop branch
+6. Update release documentation
+```
+
+## 🛡️ Risk Management in Feature Development
+
+### Safe Development Practices
+```
+✅ Always work on feature branches
+✅ Commit working code frequently (every 1-2 hours)
+✅ Test before each commit
+✅ Keep commits small and focused
+✅ Document changes thoroughly
+✅ Maintain stable backup versions
+```
+
+### Rollback Procedures
+```
+# Quick rollback to last commit
+git reset --hard HEAD~1
+
+# Rollback to specific commit
+git reset --hard [commit-hash]
+
+# Rollback to stable version
+git checkout master
+git checkout -b hotfix/rollback-feature
+cp src/SniperEA_stable.mq5 src/SniperEA.mq5
+git add src/SniperEA.mq5
+git commit -m "hotfix: rollback to stable version"
+```
+
+### Emergency Procedures
+```
+# If feature branch is corrupted
+git checkout develop
+git checkout -b feature/[name]-recovery
+cp backups/[latest-backup]/SniperEA.mq5 src/
+# Continue development from backup
+
+# If develop branch has issues
+git checkout master
+git checkout -b hotfix/emergency-fix
+# Apply critical fixes
+# Test thoroughly
+# Merge to master and develop
+```
+
+## 📋 Feature Development Checklist
+
+### Before Starting Feature Development:
+- [ ] Create feature branch from develop
+- [ ] Document feature scope and requirements
+- [ ] Create backup of current stable version
+- [ ] Set up testing environment
+- [ ] Plan implementation approach
+
+### During Feature Development:
+- [ ] Implement in small, testable increments
+- [ ] Compile and test after each function
+- [ ] Commit working code frequently
+- [ ] Update documentation as you go
+- [ ] Run regression tests regularly
+
+### Before Merging Feature:
+- [ ] All unit tests pass
+- [ ] Integration tests successful
+- [ ] Strategy Tester validation complete
+- [ ] Performance meets baseline standards
+- [ ] Documentation updated
+- [ ] Code reviewed (self-review minimum)
+
+### After Merging Feature:
+- [ ] Update develop branch
+- [ ] Tag integration point
+- [ ] Update release notes
+- [ ] Plan next feature development
+- [ ] Archive feature branch (optional)
+
+## 🎯 Practical Implementation for Your Current Setup
+
+### Immediate Setup (Next 30 minutes):
+```bash
+# Initialize git repository (if not already done)
+cd "D:\Projects\MT5-EA-Sniper-Strategy"
+git init
+git add .
+git commit -m "initial: baseline Sniper EA implementation"
+
+# Create develop branch
+git checkout -b develop
+
+# Create your first feature branch
+git checkout -b feature/baseline-optimization
+```
+
+### Integration with Your Current Workflow:
+1. **Complete baseline testing** in your open Strategy Tester
+2. **Document baseline results** as your stable reference point
+3. **Create feature branch** for your next enhancement
+4. **Use incremental development** with the 4-tier testing protocol
+5. **Merge successful features** back to develop branch
+
+### Recommended First Features to Branch:
+```
+feature/pattern-optimization     ← Optimize existing pattern detection
+feature/risk-enhancement        ← Enhance risk management features
+feature/performance-monitoring  ← Add performance tracking
+feature/visualization          ← Add chart visualization features
+```
+
+---
+
+**Next Action**: Set up the branch structure and begin your first feature branch after completing the baseline testing you have in progress.
diff --git a/docs/MT5_EA_DEVELOPMENT_WORKFLOW.md b/docs/MT5_EA_DEVELOPMENT_WORKFLOW.md
new file mode 100644
index 0000000..e95a5b4
--- /dev/null
+++ b/docs/MT5_EA_DEVELOPMENT_WORKFLOW.md
@@ -0,0 +1,261 @@
+# 🚀 MT5 Expert Advisor Development Workflow
+
+## 📋 Overview
+
+This document establishes the **definitive development workflow** for MT5 Expert Advisor development, balancing efficiency with proper validation to minimize risk and maximize code quality.
+
+## 🎯 Core Workflow Philosophy
+
+**Answer to Your Question**: **INCREMENTAL DEVELOPMENT WITH STAGED VALIDATION**
+
+- ✅ **DO**: Implement features incrementally with testing at each stage
+- ❌ **DON'T**: Implement all features first, then test everything at the end
+
+**Rationale**: Trading systems require continuous validation because financial losses from bugs are severe and irreversible.
+
+## 🏗️ 4-Tier Testing Protocol
+
+### Tier 1: Unit Testing (Individual Functions)
+**When**: After implementing each new function
+**Duration**: 5-15 minutes per function
+**Method**: Isolated function testing
+
+```
+Scope: Single function validation
+Tools: Strategy Tester with controlled inputs
+Frequency: Every new function or major modification
+Pass Criteria: Function behaves correctly with all input variations
+```
+
+**Example Unit Tests**:
+- `CalculatePositionSize()`: Test with various account sizes, risk percentages, SL distances
+- `DetectOrderBlocks()`: Validate OB detection with known historical patterns
+- `AnalyzeEntryOpportunity()`: Test pattern combination logic with controlled scenarios
+
+### Tier 2: Integration Testing (Function Groups)
+**When**: After completing related function groups
+**Duration**: 30-60 minutes per group
+**Method**: Strategy Tester with realistic scenarios
+
+```
+Scope: Related functions working together
+Tools: Strategy Tester with 1-2 weeks of data
+Frequency: After completing each major component
+Pass Criteria: Functions integrate correctly, no conflicts
+```
+
+**Example Integration Tests**:
+- Risk Management Group: Position sizing + risk calculation + trade validation
+- Pattern Detection Group: All pattern detection functions working together
+- Trade Execution Group: Entry analysis + trade execution + position management
+
+### Tier 3: Strategy Testing (Complete System)
+**When**: After major feature additions or before releases
+**Duration**: 2-4 hours
+**Method**: Comprehensive backtesting
+
+```
+Scope: Full EA system validation
+Tools: Strategy Tester with 1-3 months of data
+Frequency: Weekly or after significant changes
+Pass Criteria: Performance meets baseline benchmarks
+```
+
+**Strategy Test Configuration**:
+- Multiple symbols (EURUSD, GBPUSD, XAUUSD minimum)
+- Extended time periods (1-3 months)
+- Various market conditions (trending, ranging, volatile)
+- Performance regression testing against baseline
+
+### Tier 4: Live Demo Testing (Real Market Validation)
+**When**: After successful strategy testing
+**Duration**: 1-2 weeks minimum
+**Method**: Demo account with real market conditions
+
+```
+Scope: Real-world performance validation
+Tools: Demo account with live data feeds
+Frequency: Before any live deployment
+Pass Criteria: Consistent performance with backtesting results
+```
+
+## 📅 Development Workflow Stages
+
+### Stage 1: Planning & Design (Before Coding)
+**Duration**: 1-2 hours
+**Activities**:
+1. **Define Feature Requirements**: Clear specification of what to implement
+2. **Impact Analysis**: Identify affected systems and potential conflicts
+3. **Test Strategy Design**: Plan how to validate the new feature
+4. **Rollback Plan**: Define how to revert if issues arise
+
+**Deliverables**:
+- Feature specification document
+- Test plan outline
+- Implementation checklist
+
+### Stage 2: Implementation (Coding)
+**Duration**: Variable based on feature complexity
+**Activities**:
+1. **Incremental Coding**: Implement in small, testable chunks
+2. **Continuous Compilation**: Compile after every 50-100 lines of code
+3. **Unit Testing**: Test each function as it's completed
+4. **Code Documentation**: Comment complex logic immediately
+
+**Best Practices**:
+- Implement one function at a time
+- Test immediately after implementation
+- Commit working code frequently (if using version control)
+- Never implement multiple complex features simultaneously
+
+### Stage 3: Integration & Validation (Testing)
+**Duration**: 30-60 minutes per feature
+**Activities**:
+1. **Integration Testing**: Verify new feature works with existing systems
+2. **Regression Testing**: Ensure existing functionality still works
+3. **Performance Testing**: Validate no performance degradation
+4. **Edge Case Testing**: Test boundary conditions and error scenarios
+
+**Validation Checklist**:
+- [ ] New feature functions correctly
+- [ ] Existing features still work (regression test)
+- [ ] Performance meets baseline standards
+- [ ] Error handling works properly
+- [ ] Risk management remains intact
+
+### Stage 4: Strategy Validation (System Testing)
+**Duration**: 2-4 hours
+**Activities**:
+1. **Comprehensive Backtesting**: Full system test with extended data
+2. **Multi-Symbol Testing**: Validate across different currency pairs
+3. **Market Condition Testing**: Test in various market environments
+4. **Performance Benchmarking**: Compare against baseline metrics
+
+**Success Criteria**:
+- Performance equal to or better than baseline
+- No critical errors or failures
+- Risk management functioning correctly
+- Pattern detection accuracy maintained
+
+### Stage 5: Demo Deployment (Pre-Live Testing)
+**Duration**: 1-2 weeks
+**Activities**:
+1. **Demo Account Setup**: Deploy to demo environment
+2. **Real-Time Monitoring**: Monitor live performance
+3. **Performance Analysis**: Compare demo results with backtesting
+4. **Issue Resolution**: Address any discrepancies
+
+**Monitoring Points**:
+- Trade execution accuracy
+- Pattern detection in real-time
+- Risk management compliance
+- Performance consistency
+
+## ⚡ Quick Decision Framework
+
+### For MINOR Changes (Single function modifications):
+```
+1. Unit Test (5-10 minutes)
+2. Quick Integration Test (15-20 minutes)
+3. Deploy if tests pass
+```
+
+### For MODERATE Changes (New features, multiple functions):
+```
+1. Unit Test each function (15-30 minutes)
+2. Integration Test (30-45 minutes)
+3. Strategy Test (1-2 hours)
+4. Demo Test (3-7 days)
+5. Deploy if all tests pass
+```
+
+### For MAJOR Changes (Core logic modifications, new strategies):
+```
+1. Full 4-Tier Testing Protocol
+2. Extended Strategy Testing (multiple market conditions)
+3. Extended Demo Testing (2+ weeks)
+4. Gradual live deployment with monitoring
+```
+
+## 🔄 Compilation & Testing Frequency
+
+### Compilation Frequency:
+- **Every 50-100 lines of code**: Catch syntax errors early
+- **After each function completion**: Ensure function compiles correctly
+- **Before each test**: Ensure latest code is being tested
+- **Before commits**: Ensure working code is saved
+
+### Testing Frequency:
+- **Unit Tests**: After each function implementation
+- **Integration Tests**: After completing related function groups
+- **Strategy Tests**: Weekly or after significant changes
+- **Demo Tests**: Before any live deployment
+
+## 📊 Quality Gates & Success Criteria
+
+### Unit Test Pass Criteria:
+- Function compiles without errors
+- Function handles all expected input variations
+- Function returns expected outputs
+- Error handling works correctly
+
+### Integration Test Pass Criteria:
+- Functions work together without conflicts
+- Data flows correctly between functions
+- No performance degradation
+- Existing functionality unaffected
+
+### Strategy Test Pass Criteria:
+- Performance meets or exceeds baseline
+- Risk management compliance maintained
+- No critical errors during extended testing
+- Pattern detection accuracy preserved
+
+### Demo Test Pass Criteria:
+- Real-time performance matches backtesting
+- No unexpected behaviors in live market
+- Risk management functions correctly
+- Trade execution accuracy maintained
+
+## 🚨 Red Flags & Stop Conditions
+
+### Immediate Stop Conditions:
+- **Compilation Errors**: Fix before proceeding
+- **Risk Management Failures**: Critical priority fix
+- **Performance Degradation >20%**: Investigate immediately
+- **Pattern Detection Accuracy <60%**: Review implementation
+
+### Warning Conditions:
+- **Performance Degradation 10-20%**: Monitor closely
+- **Increased Error Rate**: Review and optimize
+- **Demo Results Differ from Backtesting**: Investigate discrepancies
+
+## 🎯 Recommended Workflow for Your Current Situation
+
+Since your Sniper EA is **already complete and functional**, here's your optimal path:
+
+### Phase 1: Establish Baseline (CURRENT PRIORITY)
+1. **Complete Baseline Testing** (using your current Strategy Tester setup)
+2. **Document Performance Metrics** (profit factor, win rate, drawdown)
+3. **Validate Pattern Detection** (run pattern validation framework)
+4. **Stress Test Risk Management** (verify 1% risk compliance)
+
+### Phase 2: Incremental Enhancement
+1. **Identify Next Feature** (from your implementation plan)
+2. **Apply 4-Tier Testing Protocol** for each new feature
+3. **Maintain Performance Benchmarks** (regression testing)
+4. **Document Changes** (maintain change log)
+
+### Phase 3: Optimization & Refinement
+1. **Parameter Optimization** (using Strategy Tester optimization)
+2. **Performance Tuning** (based on demo testing results)
+3. **Advanced Features** (visualization, analytics, etc.)
+4. **Production Deployment** (gradual live implementation)
+
+---
+
+## 📞 Quick Reference
+
+**For Your Question**: Use **incremental development with staged validation**. Test thoroughly at each stage rather than implementing everything first. This approach minimizes risk and ensures consistent quality in trading systems.
+
+**Next Immediate Action**: Complete your baseline testing using the Strategy Tester setup you have open, then document the results as your development benchmark.
diff --git a/docs/PATTERN_VALIDATION_FRAMEWORK.md b/docs/PATTERN_VALIDATION_FRAMEWORK.md
new file mode 100644
index 0000000..a365022
--- /dev/null
+++ b/docs/PATTERN_VALIDATION_FRAMEWORK.md
@@ -0,0 +1,280 @@
+# Sniper EA Pattern Detection Validation Framework
+
+## 🎯 Objective
+Validate the accuracy and reliability of pattern detection across multiple currency pairs and market conditions to ensure robust trading logic.
+
+## 📊 Multi-Symbol Test Matrix
+
+### Primary Test Symbols
+```
+Major Pairs:
+- EURUSD (High liquidity, tight spreads)
+- GBPUSD (Volatile, good for pattern testing)
+- USDJPY (Different price structure)
+- USDCHF (Lower volatility baseline)
+
+Commodity Currencies:
+- AUDUSD (Commodity correlation)
+- NZDUSD (Lower liquidity test)
+- USDCAD (Oil correlation)
+
+Gold:
+- XAUUSD (High volatility, different pip structure)
+```
+
+### Test Timeframes
+```
+Primary: M1 (Entry signals)
+Secondary: M15 (Pattern confirmation)
+Tertiary: H4 (Bias confirmation)
+Quaternary: D1 (Trend alignment)
+```
+
+## 🔍 Pattern Detection Test Scenarios
+
+### Scenario 1: Order Block Detection Accuracy
+**Test Parameters:**
+```
+Lookback Period: 50 bars
+Strength Filter: 1.0 (baseline)
+Minimum OB Size: 5 pips
+Test Duration: 1 week of data
+```
+
+**Validation Criteria:**
+- OB zones should align with actual supply/demand areas
+- Strength calculation should reflect actual price reaction
+- Fresh OBs should be prioritized over stale ones
+- OB boundaries should be clearly defined
+
+**Expected Results:**
+```
+EURUSD: 15-25 valid OBs per day
+GBPUSD: 20-30 valid OBs per day
+XAUUSD: 10-20 valid OBs per day
+Lower volatility pairs: 8-15 valid OBs per day
+```
+
+### Scenario 2: Fair Value Gap Detection
+**Test Parameters:**
+```
+Minimum Gap Size: 5 pips
+Maximum Gap Age: 24 hours
+Gap Fill Threshold: 50%
+Test Duration: 1 week of data
+```
+
+**Validation Criteria:**
+- Gaps should represent actual price inefficiencies
+- Gap boundaries should be accurate (high of lower candle to low of higher candle)
+- Gap classification (bullish/bearish) should be correct
+- Gap mitigation tracking should be accurate
+
+**Expected Results:**
+```
+EURUSD: 5-10 valid FVGs per day
+GBPUSD: 8-15 valid FVGs per day
+XAUUSD: 10-20 valid FVGs per day
+Quiet sessions: 2-5 valid FVGs per day
+```
+
+### Scenario 3: Break of Structure Detection
+**Test Parameters:**
+```
+Swing Point Lookback: 20 bars
+Confirmation Bars: 3
+Minimum Break Distance: 10 pips
+Test Duration: 1 week of data
+```
+
+**Validation Criteria:**
+- BOS should represent actual trend changes
+- Swing high/low identification should be accurate
+- Break confirmation should be reliable
+- Direction classification should be correct
+
+**Expected Results:**
+```
+EURUSD: 3-8 valid BOS per day
+GBPUSD: 5-12 valid BOS per day
+XAUUSD: 4-10 valid BOS per day
+Trending markets: Higher BOS frequency
+```
+
+### Scenario 4: Liquidity Sweep Detection
+**Test Parameters:**
+```
+Equal High/Low Tolerance: 3 pips
+Sweep Distance Threshold: 10 pips
+Lookback Period: 100 bars
+Test Duration: 1 week of data
+```
+
+**Validation Criteria:**
+- Sweeps should target actual equal highs/lows
+- Sweep distance should be meaningful
+- Sweep direction should be correctly identified
+- False sweep filtering should be effective
+
+**Expected Results:**
+```
+EURUSD: 2-6 valid sweeps per day
+GBPUSD: 4-8 valid sweeps per day
+XAUUSD: 3-7 valid sweeps per day
+Range-bound markets: Higher sweep frequency
+```
+
+## 🧪 Pattern Combination Testing
+
+### Test 1: Complete Strategy Sequence
+**Sequence**: Liquidity Sweep → BOS → FVG → Order Block
+
+**Test Methodology:**
+1. Run EA on each symbol for 1 week
+2. Log all pattern detections with timestamps
+3. Manually verify 20% of detected sequences
+4. Calculate accuracy percentage
+
+**Success Criteria:**
+- Pattern sequence logic should be sound
+- Timing relationships should be correct
+- False positive rate should be <20%
+- Complete sequences should occur 1-3 times per day per symbol
+
+### Test 2: Multi-Timeframe Alignment
+**Test Parameters:**
+```
+M1: Entry signal patterns
+M15: Pattern confirmation
+H4: Bias alignment
+D1: Trend confirmation
+```
+
+**Validation Process:**
+1. Compare M1 signals with higher timeframe bias
+2. Verify alignment accuracy
+3. Test bias override functionality
+4. Validate neutral bias handling
+
+**Expected Alignment Rates:**
+```
+M1 with M15: 70-80% alignment
+M1 with H4: 60-70% alignment
+M1 with D1: 50-60% alignment
+```
+
+## 📋 Validation Test Execution
+
+### Phase 1: Individual Pattern Testing (Day 1-2)
+```
+For each symbol in test matrix:
+1. Enable debug mode for detailed logging
+2. Run Strategy Tester for 1 week of data
+3. Extract pattern detection logs
+4. Perform manual verification on sample set
+5. Calculate accuracy metrics
+6. Document any anomalies or issues
+```
+
+### Phase 2: Pattern Combination Testing (Day 3-4)
+```
+For each symbol:
+1. Run complete strategy sequence detection
+2. Log all pattern combinations
+3. Verify sequence timing and logic
+4. Test multi-timeframe alignment
+5. Validate trade signal generation
+6. Check for false positives/negatives
+```
+
+### Phase 3: Cross-Symbol Analysis (Day 5)
+```
+1. Compare pattern detection rates across symbols
+2. Analyze performance in different market conditions
+3. Identify symbol-specific adjustments needed
+4. Validate parameter consistency
+5. Document optimization recommendations
+```
+
+## 📊 Results Documentation Template
+
+```
+=== PATTERN VALIDATION RESULTS ===
+Test Date: ___________
+Test Duration: 1 week per symbol
+Symbols Tested: 8 major pairs + XAUUSD
+
+PATTERN DETECTION ACCURACY:
+Order Blocks:
+- EURUSD: ____% accuracy (___/__ validated)
+- GBPUSD: ____% accuracy (___/__ validated)
+- XAUUSD: ____% accuracy (___/__ validated)
+- Overall: ____% accuracy
+
+Fair Value Gaps:
+- EURUSD: ____% accuracy (___/__ validated)
+- GBPUSD: ____% accuracy (___/__ validated)
+- XAUUSD: ____% accuracy (___/__ validated)
+- Overall: ____% accuracy
+
+Break of Structure:
+- EURUSD: ____% accuracy (___/__ validated)
+- GBPUSD: ____% accuracy (___/__ validated)
+- XAUUSD: ____% accuracy (___/__ validated)
+- Overall: ____% accuracy
+
+Liquidity Sweeps:
+- EURUSD: ____% accuracy (___/__ validated)
+- GBPUSD: ____% accuracy (___/__ validated)
+- XAUUSD: ____% accuracy (___/__ validated)
+- Overall: ____% accuracy
+
+PATTERN COMBINATION TESTING:
+Complete Sequences Detected: ______
+Manual Verification Sample: ______
+Sequence Accuracy: _____%
+False Positive Rate: _____%
+
+MULTI-TIMEFRAME ALIGNMENT:
+M1-M15 Alignment: _____%
+M1-H4 Alignment: _____%
+M1-D1 Alignment: _____%
+
+ISSUES IDENTIFIED:
+_________________________________
+_________________________________
+
+OPTIMIZATION RECOMMENDATIONS:
+_________________________________
+_________________________________
+
+OVERALL ASSESSMENT:
+[ ] EXCELLENT (>85% accuracy across all patterns)
+[ ] GOOD (75-85% accuracy)
+[ ] ACCEPTABLE (65-75% accuracy)
+[ ] NEEDS IMPROVEMENT (<65% accuracy)
+```
+
+## 🔧 Troubleshooting Common Issues
+
+### Low Pattern Detection Accuracy
+- Review parameter sensitivity
+- Check symbol-specific characteristics
+- Validate historical data quality
+- Adjust detection thresholds
+
+### High False Positive Rate
+- Tighten pattern validation criteria
+- Increase confirmation requirements
+- Add additional filtering conditions
+- Review pattern definition logic
+
+### Inconsistent Cross-Symbol Performance
+- Implement symbol-specific parameters
+- Add volatility-based adjustments
+- Consider spread and liquidity factors
+- Validate pip value calculations
+
+---
+
+**Execute this validation framework after baseline testing to ensure pattern detection reliability before proceeding with development workflow implementation.**
diff --git a/docs/PERFORMANCE_REGRESSION_FRAMEWORK.md b/docs/PERFORMANCE_REGRESSION_FRAMEWORK.md
new file mode 100644
index 0000000..8bbc23c
--- /dev/null
+++ b/docs/PERFORMANCE_REGRESSION_FRAMEWORK.md
@@ -0,0 +1,350 @@
+# 📊 Performance Regression Testing Framework
+
+## 🎯 Objective
+Establish automated performance regression testing to ensure new features don't degrade EA performance and maintain consistent trading results across development iterations.
+
+## 📋 Regression Testing Strategy
+
+### Core Performance Metrics to Track
+```
+Primary Metrics:
+- Profit Factor (target: >1.2)
+- Win Rate (target: 45-65%)
+- Maximum Drawdown (target: <15%)
+- Total Net Profit
+- Risk per Trade (must be exactly 1.0%)
+
+Secondary Metrics:
+- Average R:R Ratio (target: >2.0:1)
+- Total Trades Count
+- Average Trade Duration
+- Largest Loss Trade
+- Maximum Consecutive Losses
+
+Pattern Detection Metrics:
+- Order Blocks Detected per Day
+- Fair Value Gaps Detected per Day
+- BOS Events per Day
+- Liquidity Sweeps per Day
+- Valid Setup Conversion Rate
+```
+
+### Baseline Performance Database
+
+**File**: `performance_baseline.json`
+```json
+{
+  "baseline_version": "1.0.0",
+  "test_date": "2024-09-25",
+  "test_period": "2024-07-01 to 2024-09-25",
+  "test_symbol": "EURUSD",
+  "test_timeframe": "M1",
+  "metrics": {
+    "profit_factor": 1.45,
+    "win_rate": 58.5,
+    "max_drawdown_percent": 12.3,
+    "total_net_profit": 1250.00,
+    "total_trades": 87,
+    "average_rr_ratio": 2.15,
+    "risk_per_trade": 1.0,
+    "pattern_detection": {
+      "order_blocks_per_day": 18.5,
+      "fvg_per_day": 8.2,
+      "bos_per_day": 5.7,
+      "sweeps_per_day": 3.4,
+      "setup_conversion_rate": 15.2
+    }
+  },
+  "test_configuration": {
+    "deposit": 10000,
+    "leverage": 100,
+    "risk_percent": 1.0,
+    "min_rr": 2.0,
+    "max_positions": 10
+  }
+}
+```
+
+## 🔧 Automated Regression Testing Scripts
+
+### Main Regression Test Script
+
+**File**: `run_regression_test.ps1`
+```powershell
+param(
+    [string]$EAName = "SniperEA",
+    [string]$TestSymbol = "EURUSD",
+    [string]$StartDate = "2024-07-01",
+    [string]$EndDate = "2024-09-25",
+    [string]$BaselineFile = "performance_baseline.json"
+)
+
+Write-Host "=== Performance Regression Test ===" -ForegroundColor Green
+Write-Host "EA: $EAName" -ForegroundColor Yellow
+Write-Host "Symbol: $TestSymbol" -ForegroundColor Yellow
+Write-Host "Period: $StartDate to $EndDate" -ForegroundColor Yellow
+
+# Load baseline performance
+if (Test-Path $BaselineFile) {
+    $Baseline = Get-Content $BaselineFile | ConvertFrom-Json
+    Write-Host "Baseline loaded: Version $($Baseline.baseline_version)" -ForegroundColor Cyan
+} else {
+    Write-Host "WARNING: No baseline file found. This will become the new baseline." -ForegroundColor Yellow
+    $CreateBaseline = $true
+}
+
+# Strategy Tester automation would go here
+# For now, we'll simulate the process and provide manual steps
+
+Write-Host "`n=== Manual Strategy Tester Steps ===" -ForegroundColor Magenta
+Write-Host "1. Open Strategy Tester (Ctrl+R)" -ForegroundColor White
+Write-Host "2. Configure settings:" -ForegroundColor White
+Write-Host "   - Expert: $EAName" -ForegroundColor Gray
+Write-Host "   - Symbol: $TestSymbol" -ForegroundColor Gray
+Write-Host "   - Period: M1" -ForegroundColor Gray
+Write-Host "   - Dates: $StartDate to $EndDate" -ForegroundColor Gray
+Write-Host "   - Model: Every tick" -ForegroundColor Gray
+Write-Host "3. Click Start and wait for completion" -ForegroundColor White
+Write-Host "4. Run this script again with results" -ForegroundColor White
+
+# Prompt for manual results input
+Write-Host "`n=== Enter Test Results ===" -ForegroundColor Green
+$Results = @{}
+$Results.profit_factor = Read-Host "Profit Factor"
+$Results.win_rate = Read-Host "Win Rate (%)"
+$Results.max_drawdown_percent = Read-Host "Maximum Drawdown (%)"
+$Results.total_net_profit = Read-Host "Total Net Profit"
+$Results.total_trades = Read-Host "Total Trades"
+
+# Calculate performance comparison
+if (-not $CreateBaseline) {
+    Write-Host "`n=== Performance Comparison ===" -ForegroundColor Green
+    
+    $ProfitFactorChange = [math]::Round((([double]$Results.profit_factor - $Baseline.metrics.profit_factor) / $Baseline.metrics.profit_factor) * 100, 2)
+    $WinRateChange = [math]::Round([double]$Results.win_rate - $Baseline.metrics.win_rate, 2)
+    $DrawdownChange = [math]::Round([double]$Results.max_drawdown_percent - $Baseline.metrics.max_drawdown_percent, 2)
+    
+    Write-Host "Profit Factor: $($Results.profit_factor) ($($ProfitFactorChange)%)" -ForegroundColor $(if($ProfitFactorChange -ge 0){"Green"}else{"Red"})
+    Write-Host "Win Rate: $($Results.win_rate)% ($($WinRateChange)%)" -ForegroundColor $(if($WinRateChange -ge 0){"Green"}else{"Red"})
+    Write-Host "Max Drawdown: $($Results.max_drawdown_percent)% ($($DrawdownChange)%)" -ForegroundColor $(if($DrawdownChange -le 0){"Green"}else{"Red"})
+    
+    # Regression analysis
+    $RegressionIssues = @()
+    
+    if ($ProfitFactorChange -lt -10) {
+        $RegressionIssues += "Profit Factor decreased by more than 10%"
+    }
+    if ($WinRateChange -lt -5) {
+        $RegressionIssues += "Win Rate decreased by more than 5%"
+    }
+    if ($DrawdownChange -gt 3) {
+        $RegressionIssues += "Maximum Drawdown increased by more than 3%"
+    }
+    
+    if ($RegressionIssues.Count -eq 0) {
+        Write-Host "`n✅ REGRESSION TEST PASSED" -ForegroundColor Green
+        Write-Host "Performance maintained or improved" -ForegroundColor Green
+    } else {
+        Write-Host "`n❌ REGRESSION TEST FAILED" -ForegroundColor Red
+        Write-Host "Issues detected:" -ForegroundColor Red
+        foreach ($Issue in $RegressionIssues) {
+            Write-Host "  - $Issue" -ForegroundColor Yellow
+        }
+    }
+}
+
+# Save results
+$TestResults = @{
+    test_date = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
+    ea_version = "current"
+    test_period = "$StartDate to $EndDate"
+    test_symbol = $TestSymbol
+    metrics = $Results
+    regression_status = if($RegressionIssues.Count -eq 0){"PASS"}else{"FAIL"}
+    issues = $RegressionIssues
+}
+
+$ResultsFile = "regression_test_$(Get-Date -Format 'yyyyMMdd_HHmmss').json"
+$TestResults | ConvertTo-Json -Depth 3 | Out-File $ResultsFile
+Write-Host "`nResults saved to: $ResultsFile" -ForegroundColor Cyan
+```
+
+### Performance Tracking Database
+
+**File**: `performance_tracker.ps1`
+```powershell
+# Performance History Tracker
+param(
+    [string]$Action = "add", # add, view, compare
+    [string]$Version = "",
+    [string]$ResultsFile = ""
+)
+
+$DatabaseFile = "performance_history.json"
+
+# Initialize database if it doesn't exist
+if (-not (Test-Path $DatabaseFile)) {
+    $Database = @{
+        created = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
+        tests = @()
+    }
+    $Database | ConvertTo-Json -Depth 4 | Out-File $DatabaseFile
+}
+
+$Database = Get-Content $DatabaseFile | ConvertFrom-Json
+
+switch ($Action) {
+    "add" {
+        if ($ResultsFile -and (Test-Path $ResultsFile)) {
+            $TestResult = Get-Content $ResultsFile | ConvertFrom-Json
+            $TestResult | Add-Member -NotePropertyName "version" -NotePropertyValue $Version
+            
+            $Database.tests += $TestResult
+            $Database | ConvertTo-Json -Depth 4 | Out-File $DatabaseFile
+            
+            Write-Host "Test result added to performance database" -ForegroundColor Green
+        } else {
+            Write-Host "Results file not found: $ResultsFile" -ForegroundColor Red
+        }
+    }
+    
+    "view" {
+        Write-Host "=== Performance History ===" -ForegroundColor Green
+        foreach ($Test in $Database.tests) {
+            Write-Host "`nVersion: $($Test.version) - $($Test.test_date)" -ForegroundColor Yellow
+            Write-Host "Profit Factor: $($Test.metrics.profit_factor)" -ForegroundColor Cyan
+            Write-Host "Win Rate: $($Test.metrics.win_rate)%" -ForegroundColor Cyan
+            Write-Host "Max Drawdown: $($Test.metrics.max_drawdown_percent)%" -ForegroundColor Cyan
+            Write-Host "Status: $($Test.regression_status)" -ForegroundColor $(if($Test.regression_status -eq "PASS"){"Green"}else{"Red"})
+        }
+    }
+    
+    "compare" {
+        if ($Database.tests.Count -ge 2) {
+            $Latest = $Database.tests[-1]
+            $Previous = $Database.tests[-2]
+            
+            Write-Host "=== Performance Comparison ===" -ForegroundColor Green
+            Write-Host "Latest: $($Latest.version) vs Previous: $($Previous.version)" -ForegroundColor Yellow
+            
+            $PFChange = [math]::Round((([double]$Latest.metrics.profit_factor - [double]$Previous.metrics.profit_factor) / [double]$Previous.metrics.profit_factor) * 100, 2)
+            $WRChange = [math]::Round([double]$Latest.metrics.win_rate - [double]$Previous.metrics.win_rate, 2)
+            
+            Write-Host "Profit Factor: $($Latest.metrics.profit_factor) ($($PFChange)%)" -ForegroundColor $(if($PFChange -ge 0){"Green"}else{"Red"})
+            Write-Host "Win Rate: $($Latest.metrics.win_rate)% ($($WRChange)%)" -ForegroundColor $(if($WRChange -ge 0){"Green"}else{"Red"})
+        } else {
+            Write-Host "Need at least 2 test results for comparison" -ForegroundColor Yellow
+        }
+    }
+}
+```
+
+## 📊 Regression Test Execution Workflow
+
+### Pre-Development Regression Test
+```powershell
+# Before starting new feature development
+.\run_regression_test.ps1 -EAName "SniperEA" -TestSymbol "EURUSD"
+.\performance_tracker.ps1 -Action "add" -Version "pre-feature-X" -ResultsFile "regression_test_*.json"
+```
+
+### Post-Development Regression Test
+```powershell
+# After completing feature development
+.\run_regression_test.ps1 -EAName "SniperEA" -TestSymbol "EURUSD"
+.\performance_tracker.ps1 -Action "add" -Version "post-feature-X" -ResultsFile "regression_test_*.json"
+.\performance_tracker.ps1 -Action "compare"
+```
+
+### Multi-Symbol Regression Testing
+
+**File**: `multi_symbol_regression.ps1`
+```powershell
+$TestSymbols = @("EURUSD", "GBPUSD", "XAUUSD")
+$Results = @()
+
+foreach ($Symbol in $TestSymbols) {
+    Write-Host "Testing $Symbol..." -ForegroundColor Yellow
+    
+    # Manual testing prompt for each symbol
+    Write-Host "Configure Strategy Tester for $Symbol and press Enter when complete..."
+    Read-Host
+    
+    # Collect results
+    $SymbolResults = @{}
+    $SymbolResults.symbol = $Symbol
+    $SymbolResults.profit_factor = Read-Host "Profit Factor for $Symbol"
+    $SymbolResults.win_rate = Read-Host "Win Rate for $Symbol"
+    $SymbolResults.max_drawdown = Read-Host "Max Drawdown for $Symbol"
+    
+    $Results += $SymbolResults
+}
+
+# Analyze multi-symbol performance
+Write-Host "`n=== Multi-Symbol Results ===" -ForegroundColor Green
+foreach ($Result in $Results) {
+    Write-Host "$($Result.symbol): PF=$($Result.profit_factor), WR=$($Result.win_rate)%, DD=$($Result.max_drawdown)%" -ForegroundColor Cyan
+}
+
+# Save multi-symbol results
+$MultiSymbolResults = @{
+    test_date = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
+    test_type = "multi_symbol_regression"
+    results = $Results
+}
+
+$MultiSymbolFile = "multi_symbol_regression_$(Get-Date -Format 'yyyyMMdd_HHmmss').json"
+$MultiSymbolResults | ConvertTo-Json -Depth 3 | Out-File $MultiSymbolFile
+Write-Host "Multi-symbol results saved to: $MultiSymbolFile" -ForegroundColor Green
+```
+
+## 🎯 Integration with Development Workflow
+
+### Regression Testing Schedule
+```
+Daily: Quick regression test on EURUSD (30 minutes)
+Weekly: Multi-symbol regression test (2-3 hours)
+Before Major Releases: Comprehensive regression suite (4-6 hours)
+After Bug Fixes: Targeted regression test (1 hour)
+```
+
+### Automated Alerts
+```powershell
+# Add to regression test script
+if ($RegressionIssues.Count -gt 0) {
+    # Create alert file
+    $Alert = @{
+        timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
+        severity = "HIGH"
+        message = "Performance regression detected"
+        issues = $RegressionIssues
+    }
+    
+    $Alert | ConvertTo-Json | Out-File "REGRESSION_ALERT.json"
+    Write-Host "🚨 REGRESSION ALERT CREATED" -ForegroundColor Red
+}
+```
+
+## 📋 Regression Testing Checklist
+
+### Before Each Feature Development:
+- [ ] Run baseline regression test
+- [ ] Document current performance metrics
+- [ ] Save results to performance database
+- [ ] Verify all metrics within acceptable ranges
+
+### After Each Feature Implementation:
+- [ ] Run regression test with new feature
+- [ ] Compare results with baseline
+- [ ] Identify any performance degradation
+- [ ] Document changes and improvements
+
+### Weekly Performance Review:
+- [ ] Run multi-symbol regression tests
+- [ ] Analyze performance trends
+- [ ] Identify optimization opportunities
+- [ ] Update baseline if consistently improved
+
+---
+
+**Next Action**: Set up the regression testing framework and run your first baseline test using the Strategy Tester you currently have open. This will establish your performance benchmark for all future development.
diff --git a/docs/QUICK_MONITORING.md b/docs/QUICK_MONITORING.md
new file mode 100644
index 0000000..a240a69
--- /dev/null
+++ b/docs/QUICK_MONITORING.md
@@ -0,0 +1,178 @@
+# 🚀 Quick EA Monitoring Reference
+
+## 📍 Where to Check EA Status RIGHT NOW
+
+### 1. **Experts Tab** (Most Important!)
+**Location**: `View → Toolbox → Experts` tab in MT5
+
+**Look for these SUCCESS messages:**
+```
+✅ === Sniper EA Initialization Completed Successfully ===
+✅ [PATTERN] SniperEA: Order Block detected on EURUSD
+✅ [TRADE] SniperEA: BULLISH SETUP EXECUTED on EURUSD
+✅ [DEBUG] SniperEA: Market Bias: BULLISH for EURUSD
+```
+
+**Watch out for ERROR messages:**
+```
+❌ ERROR: Failed to setup symbols array
+❌ [ERROR] SniperEA: Trade Execution failed
+❌ WARNING: Invalid input parameters
+```
+
+### 2. **Chart Information Panel**
+**Location**: Top-left corner of your chart
+
+**Should show:**
+```
+Sniper EA - ACTIVE          ← EA is running
+Session: LONDON/NY/ASIAN     ← Current session
+Balance: 10000.00            ← Account balance
+Positions: 0/10              ← Current/Max positions
+```
+
+### 3. **Strategy Tester** (For Backtesting)
+**Quick Setup:**
+- Press `Ctrl+R`
+- Select "SniperEA"
+- Symbol: EURUSD
+- Period: M1
+- Click "Start"
+
+## 🔍 5-Minute Health Check
+
+### Step 1: Check EA is Running (30 seconds)
+1. Open chart with EA attached
+2. Look for information panel (top-left)
+3. Status should show "ACTIVE"
+
+### Step 2: Check Logs (2 minutes)
+1. Open `View → Toolbox → Experts`
+2. Look for recent "SniperEA" entries
+3. Should see initialization and pattern detection messages
+
+### Step 3: Verify Settings (1 minute)
+1. Right-click EA on chart → "Expert Advisors" → "Properties"
+2. Check "Allow live trading" is enabled
+3. Verify `EnableDebugMode = true` (you already set this ✓)
+
+### Step 4: Test Pattern Detection (2 minutes)
+1. Wait for new candle formation
+2. Check Experts tab for new pattern detection logs
+3. Should see "[PATTERN]" or "[DEBUG]" messages
+
+## 📊 What Good Performance Looks Like
+
+### **Healthy Log Output (Every 5-15 minutes):**
+```
+[DEBUG] SniperEA: Updating Multi-Timeframe Analysis for EURUSD
+[PATTERN] SniperEA: Order Block detected on EURUSD - Bullish OB at 1.0850
+[DEBUG] SniperEA: Market Bias: BULLISH for EURUSD
+```
+
+### **Successful Trade Example:**
+```
+[PATTERN] SniperEA: Entry Opportunity - Bullish setup detected
+[TRADE] SniperEA: BULLISH SETUP EXECUTED on EURUSD
+Entry: 1.0865, SL: 1.0845 (20 pips), TP: 1.0905 (2:1 RR), Lot: 0.10
+```
+
+## 🚨 Red Flags (Stop and Fix These!)
+
+### **Critical Errors:**
+```
+❌ ERROR: Failed to setup symbols array
+❌ ERROR: Invalid lot size calculated
+❌ ERROR: Trade Execution failed with error 134
+```
+
+### **Warning Signs:**
+- No log messages for >30 minutes
+- Information panel shows "INACTIVE"
+- Repeated "Invalid" or "Failed" messages
+- No pattern detection for hours
+
+## ⚡ Quick Fixes
+
+### **If EA Shows INACTIVE:**
+1. Remove EA from chart
+2. Drag it back from Navigator
+3. Enable "Allow live trading"
+4. Check Experts tab for initialization
+
+### **If No Log Messages:**
+1. Ensure `EnableDebugMode = true`
+2. Check if current time is in trading session
+3. Verify symbol data is updating
+4. Restart MT5 if needed
+
+### **If Trade Execution Fails:**
+1. Check account balance
+2. Verify symbol is tradeable
+3. Check margin requirements
+4. Ensure position limits not exceeded
+
+## 📱 Daily Monitoring Routine (2 minutes)
+
+### **Morning Check:**
+- [ ] EA status: ACTIVE
+- [ ] Recent pattern detection logs
+- [ ] Account balance unchanged (no unexpected trades)
+- [ ] Current session displayed correctly
+
+### **Evening Review:**
+- [ ] Check trade history for the day
+- [ ] Review any error messages
+- [ ] Verify position management worked
+- [ ] Note any unusual behavior
+
+## 🎯 Success Indicators
+
+### **First Hour After Start:**
+- ✅ Initialization message appears
+- ✅ Multi-timeframe analysis updates
+- ✅ Pattern detection attempts logged
+- ✅ Information panel displays correctly
+
+### **First Day:**
+- ✅ Pattern detection every 15-60 minutes
+- ✅ At least 1-2 trade opportunities identified
+- ✅ Risk management calculations working
+- ✅ Session filtering functioning
+
+### **First Week:**
+- ✅ 5-15 trades executed (depending on market)
+- ✅ Win rate around 50-60%
+- ✅ Risk-reward ratio maintained at 2:1+
+- ✅ No critical errors in logs
+
+## 📞 Emergency Checklist
+
+### **If EA Stops Working:**
+1. Check Experts tab for error messages
+2. Restart MT5
+3. Re-attach EA to chart
+4. Verify account connection
+5. Check symbol specifications
+
+### **If Too Many Trades:**
+1. Reduce `MaxTradesPerDay` parameter
+2. Enable `RequireMultiTFConfirmation`
+3. Increase pattern strength filters
+4. Check for duplicate EA instances
+
+### **If No Trades for Days:**
+1. Verify trading session settings
+2. Check pattern detection sensitivity
+3. Ensure sufficient account balance
+4. Review symbol availability
+
+---
+
+## 🔗 Quick Links
+- **Full Testing Guide**: See `TESTING_GUIDE.md`
+- **EA Parameters**: Right-click EA → Properties → Inputs
+- **Trade History**: `View → Toolbox → Trade`
+- **Account Info**: `View → Toolbox → Trade → Account`
+
+**Remember**: Debug mode is ON, so you'll see detailed logs! 📝
diff --git a/docs/RISK_MANAGEMENT_STRESS_TEST.md b/docs/RISK_MANAGEMENT_STRESS_TEST.md
new file mode 100644
index 0000000..f8278c6
--- /dev/null
+++ b/docs/RISK_MANAGEMENT_STRESS_TEST.md
@@ -0,0 +1,278 @@
+# Sniper EA Risk Management Stress Testing Framework
+
+## 🎯 Objective
+Comprehensively validate risk management systems under various market conditions and stress scenarios to ensure capital protection and consistent risk application.
+
+## 🔍 Risk Management Components to Test
+
+### 1. Position Sizing Validation
+**Function**: `CalculatePositionSize()`
+**Test Parameters**:
+```
+Account Balances: $1,000, $10,000, $100,000
+Risk Percentages: 0.5%, 1.0%, 2.0%
+Stop Loss Distances: 10, 20, 50, 100 pips
+Symbols: EURUSD, GBPUSD, XAUUSD, USDJPY
+```
+
+**Validation Criteria**:
+- Exact 1% risk per trade (or specified percentage)
+- Proper lot size normalization to broker requirements
+- Minimum/maximum lot size compliance
+- Accurate pip value calculations across different symbols
+
+### 2. Risk Amount Calculation
+**Function**: `CalculateRiskAmount()`
+**Test Scenarios**:
+```
+Scenario 1: Standard Account ($10,000, 1% risk = $100)
+Scenario 2: Small Account ($1,000, 1% risk = $10)
+Scenario 3: Large Account ($100,000, 1% risk = $1,000)
+Scenario 4: Edge Case (Account < $500)
+```
+
+**Expected Results**:
+- Risk amount = Account Balance × (Risk% / 100)
+- Proper handling of edge cases
+- Validation of risk percentage limits (0.1% - 10%)
+
+### 3. Position Limits Enforcement
+**Test Parameters**:
+```
+MaxPositionsPerSymbol: 3
+MaxTotalPositions: 10
+Test Symbols: 8 major pairs
+Concurrent Signal Generation: Simulate multiple simultaneous signals
+```
+
+**Stress Test Scenarios**:
+- Generate 15+ simultaneous signals across all symbols
+- Verify only 10 total positions are opened
+- Confirm max 3 positions per symbol
+- Test position counting accuracy
+
+### 4. Margin Requirement Validation
+**Function**: `CalculateMarginRequired()`
+**Test Cases**:
+```
+High Leverage (1:500): Verify low margin requirements
+Low Leverage (1:50): Verify higher margin requirements
+Different Symbols: Test margin calculations across pairs
+Large Position Sizes: Test margin for maximum lot sizes
+```
+
+**Validation Points**:
+- Accurate margin calculations per symbol
+- Proper leverage factor application
+- Account free margin verification before trade execution
+
+## 🚨 Stress Testing Scenarios
+
+### Stress Test 1: High Volatility Market Conditions
+**Simulation**: NFP Friday, Central Bank Announcements
+**Parameters**:
+```
+Spread Widening: 2-5x normal spreads
+Price Gaps: 20-50 pip gaps at market open
+Rapid Price Movement: 100+ pip moves in minutes
+Slippage Simulation: 3-10 pip slippage
+```
+
+**Risk Management Validation**:
+- Position sizing remains accurate despite volatility
+- Stop loss placement accounts for wider spreads
+- Trade execution validation under stress
+- Margin requirements adjust appropriately
+
+### Stress Test 2: Multiple Simultaneous Signals
+**Scenario**: All 8 symbols generate signals within 1 minute
+**Test Process**:
+```
+1. Simulate 20+ simultaneous pattern detections
+2. Verify position limit enforcement
+3. Check risk calculation accuracy under load
+4. Validate trade execution prioritization
+5. Confirm proper signal rejection when limits reached
+```
+
+**Expected Behavior**:
+- Only 10 positions opened (total limit)
+- Max 3 positions per symbol
+- Proper signal prioritization (first valid signals processed)
+- Accurate risk calculation for each position
+
+### Stress Test 3: Account Drawdown Scenarios
+**Test Conditions**:
+```
+Starting Balance: $10,000
+Drawdown Levels: 5%, 10%, 15%, 20%
+Risk Percentage: Fixed at 1%
+Position Management: Test break-even and trailing stops
+```
+
+**Validation Points**:
+- Risk amount adjusts with account balance changes
+- Position sizing scales appropriately
+- No over-leveraging during drawdown periods
+- Proper account equity vs. balance calculations
+
+### Stress Test 4: Extreme Market Conditions
+**Scenarios**:
+```
+Market Crash: -500 pip moves in major pairs
+Flash Crash: Rapid price spikes and reversals
+Weekend Gaps: 50-100 pip gaps at market open
+Low Liquidity: Thin market conditions
+```
+
+**Risk Controls to Validate**:
+- Stop loss execution during gaps
+- Position sizing adjustments for volatility
+- Trade execution validation in thin markets
+- Margin call prevention mechanisms
+
+## 📊 Test Execution Framework
+
+### Phase 1: Unit Testing (Individual Functions)
+```
+Test Duration: 2-3 hours
+Method: Isolated function testing with various inputs
+
+For CalculatePositionSize():
+- Test 100+ combinations of account size, risk%, SL distance
+- Verify calculations against manual calculations
+- Test edge cases (very small/large values)
+- Validate lot size normalization
+
+For CalculateRiskAmount():
+- Test various account balances and risk percentages
+- Verify percentage calculations
+- Test boundary conditions
+- Validate error handling
+```
+
+### Phase 2: Integration Testing (Combined Functions)
+```
+Test Duration: 4-6 hours
+Method: Strategy Tester with controlled scenarios
+
+Test Process:
+1. Set up multiple test scenarios in Strategy Tester
+2. Force multiple simultaneous signals
+3. Monitor position opening behavior
+4. Verify risk calculations in real trading context
+5. Test position limit enforcement
+```
+
+### Phase 3: Stress Testing (Extreme Conditions)
+```
+Test Duration: 6-8 hours
+Method: Historical data from high-volatility periods
+
+Test Periods:
+- March 2020 (COVID crash)
+- Brexit referendum (June 2016)
+- Swiss Franc unpegging (January 2015)
+- NFP releases with high volatility
+
+Validation:
+- Risk management holds under extreme conditions
+- No position sizing errors during volatility
+- Proper handling of gaps and slippage
+- Margin requirements remain accurate
+```
+
+## 📋 Risk Management Test Results Template
+
+```
+=== RISK MANAGEMENT STRESS TEST RESULTS ===
+Test Date: ___________
+Test Duration: 3 phases over 2 days
+Account Size: $10,000 (baseline)
+
+POSITION SIZING ACCURACY:
+- 1% Risk Compliance: ____% accuracy (___/__ trades)
+- Lot Size Normalization: [ ] Pass [ ] Fail
+- Min/Max Lot Compliance: [ ] Pass [ ] Fail
+- Cross-Symbol Accuracy: ____% (___/__ symbols)
+
+POSITION LIMITS ENFORCEMENT:
+- Max Total Positions (10): [ ] Enforced [ ] Violated
+- Max Per Symbol (3): [ ] Enforced [ ] Violated
+- Simultaneous Signal Handling: [ ] Pass [ ] Fail
+- Position Counting Accuracy: ____% (___/__ tests)
+
+MARGIN CALCULATIONS:
+- Margin Requirement Accuracy: ____% (___/__ tests)
+- Free Margin Validation: [ ] Pass [ ] Fail
+- Leverage Factor Application: [ ] Pass [ ] Fail
+- Symbol-Specific Calculations: [ ] Pass [ ] Fail
+
+STRESS TEST RESULTS:
+High Volatility Performance:
+- Risk Compliance During Stress: ____% (___/__ trades)
+- Position Sizing Stability: [ ] Stable [ ] Issues
+- Margin Requirement Accuracy: [ ] Pass [ ] Fail
+
+Multiple Signal Handling:
+- 20 Simultaneous Signals: [ ] Handled Correctly [ ] Issues
+- Position Limit Enforcement: [ ] Pass [ ] Fail
+- Signal Prioritization: [ ] Logical [ ] Issues
+
+Account Drawdown Scenarios:
+- Risk Adjustment Accuracy: ____% (___/__ scenarios)
+- Position Sizing Scaling: [ ] Correct [ ] Issues
+- Equity vs Balance Handling: [ ] Pass [ ] Fail
+
+CRITICAL ISSUES IDENTIFIED:
+_________________________________
+_________________________________
+
+PERFORMANCE UNDER STRESS:
+[ ] EXCELLENT - All systems performed flawlessly
+[ ] GOOD - Minor issues, easily addressable
+[ ] ACCEPTABLE - Some issues, require attention
+[ ] POOR - Major issues, immediate fixes required
+
+RECOMMENDATIONS:
+_________________________________
+_________________________________
+```
+
+## 🔧 Common Risk Management Issues & Solutions
+
+### Issue: Inconsistent Position Sizing
+**Symptoms**: Trades risk more or less than 1%
+**Solutions**:
+- Verify pip value calculations
+- Check lot size normalization
+- Validate stop loss distance calculations
+- Review symbol specifications
+
+### Issue: Position Limits Not Enforced
+**Symptoms**: More than 10 total or 3 per symbol positions
+**Solutions**:
+- Review position counting logic
+- Check position filtering by magic number
+- Validate symbol-specific position tracking
+- Test concurrent signal handling
+
+### Issue: Margin Calculation Errors
+**Symptoms**: Insufficient margin errors or over-leveraging
+**Solutions**:
+- Verify leverage factor application
+- Check symbol-specific margin requirements
+- Validate account information retrieval
+- Review margin calculation formula
+
+### Issue: Poor Performance Under Stress
+**Symptoms**: Risk management fails during high volatility
+**Solutions**:
+- Add volatility-based adjustments
+- Implement additional safety checks
+- Review slippage and spread handling
+- Add emergency position closure logic
+
+---
+
+**Execute this stress testing framework after pattern validation to ensure robust risk management before implementing the development workflow.**
diff --git a/docs/STANDARDIZED_TEST_DATASETS.md b/docs/STANDARDIZED_TEST_DATASETS.md
new file mode 100644
index 0000000..90b8ea5
--- /dev/null
+++ b/docs/STANDARDIZED_TEST_DATASETS.md
@@ -0,0 +1,452 @@
+# 📊 Standardized Test Datasets for Consistent Backtesting
+
+## 🎯 Objective
+Establish standardized test datasets and scenarios to ensure consistent, repeatable backtesting results across all development iterations and feature implementations.
+
+## 📋 Test Dataset Categories
+
+### Primary Test Datasets
+
+#### Dataset 1: Baseline Performance (3 Months)
+```
+Name: BASELINE_3M_EURUSD
+Symbol: EURUSD
+Period: 2024-07-01 to 2024-09-25
+Timeframe: M1
+Characteristics: Mixed market conditions, normal volatility
+Purpose: Primary regression testing and performance benchmarking
+Expected Trades: 80-120
+Expected Win Rate: 50-65%
+```
+
+#### Dataset 2: High Volatility Period (1 Month)
+```
+Name: HIGH_VOL_1M_EURUSD
+Symbol: EURUSD
+Period: 2024-08-01 to 2024-08-31 (NFP releases, ECB meetings)
+Timeframe: M1
+Characteristics: High volatility, frequent news events
+Purpose: Stress testing and volatility handling validation
+Expected Trades: 40-60
+Expected Drawdown: Higher than baseline
+```
+
+#### Dataset 3: Low Volatility Period (1 Month)
+```
+Name: LOW_VOL_1M_EURUSD
+Symbol: EURUSD
+Period: 2024-07-15 to 2024-08-15 (Summer trading period)
+Timeframe: M1
+Characteristics: Low volatility, ranging markets
+Purpose: Pattern detection accuracy in quiet markets
+Expected Trades: 20-40
+Expected Win Rate: Higher precision expected
+```
+
+#### Dataset 4: Trending Market (2 Weeks)
+```
+Name: TREND_2W_EURUSD
+Symbol: EURUSD
+Period: 2024-09-01 to 2024-09-15 (Strong directional move)
+Timeframe: M1
+Characteristics: Clear trending conditions
+Purpose: Trend-following strategy validation
+Expected Trades: 25-40
+Expected R:R: Higher than baseline
+```
+
+### Multi-Symbol Test Datasets
+
+#### Dataset 5: Major Pairs Comparison (1 Month)
+```
+Symbols: EURUSD, GBPUSD, USDJPY, USDCHF
+Period: 2024-08-01 to 2024-08-31
+Purpose: Cross-pair performance validation
+Expected Behavior: Consistent pattern detection across pairs
+```
+
+#### Dataset 6: Commodity Currency Test (1 Month)
+```
+Symbols: AUDUSD, NZDUSD, USDCAD
+Period: 2024-08-01 to 2024-08-31
+Purpose: Commodity-correlated pair testing
+Expected Behavior: Different volatility patterns
+```
+
+#### Dataset 7: Gold Testing (2 Weeks)
+```
+Symbol: XAUUSD
+Period: 2024-09-01 to 2024-09-15
+Purpose: High-value, high-volatility instrument testing
+Expected Behavior: Larger pip movements, different risk calculations
+```
+
+## 🔧 Test Dataset Configuration Scripts
+
+### Dataset Configuration Generator
+
+**File**: `generate_test_configs.ps1`
+```powershell
+# Generate standardized test configurations
+$TestDatasets = @(
+    @{
+        Name = "BASELINE_3M_EURUSD"
+        Symbol = "EURUSD"
+        StartDate = "2024-07-01"
+        EndDate = "2024-09-25"
+        Description = "Primary baseline performance dataset"
+        ExpectedTrades = "80-120"
+        ExpectedWinRate = "50-65%"
+        Purpose = "Regression testing and benchmarking"
+    },
+    @{
+        Name = "HIGH_VOL_1M_EURUSD"
+        Symbol = "EURUSD"
+        StartDate = "2024-08-01"
+        EndDate = "2024-08-31"
+        Description = "High volatility stress testing"
+        ExpectedTrades = "40-60"
+        ExpectedWinRate = "45-60%"
+        Purpose = "Volatility handling validation"
+    },
+    @{
+        Name = "LOW_VOL_1M_EURUSD"
+        Symbol = "EURUSD"
+        StartDate = "2024-07-15"
+        EndDate = "2024-08-15"
+        Description = "Low volatility precision testing"
+        ExpectedTrades = "20-40"
+        ExpectedWinRate = "55-70%"
+        Purpose = "Pattern detection accuracy in quiet markets"
+    },
+    @{
+        Name = "TREND_2W_EURUSD"
+        Symbol = "EURUSD"
+        StartDate = "2024-09-01"
+        EndDate = "2024-09-15"
+        Description = "Trending market validation"
+        ExpectedTrades = "25-40"
+        ExpectedWinRate = "50-65%"
+        Purpose = "Trend-following strategy validation"
+    }
+)
+
+# Generate configuration files
+foreach ($Dataset in $TestDatasets) {
+    $ConfigContent = @"
+# Test Dataset Configuration: $($Dataset.Name)
+
+## Dataset Information
+- **Name**: $($Dataset.Name)
+- **Symbol**: $($Dataset.Symbol)
+- **Period**: $($Dataset.StartDate) to $($Dataset.EndDate)
+- **Description**: $($Dataset.Description)
+- **Purpose**: $($Dataset.Purpose)
+
+## Expected Results
+- **Expected Trades**: $($Dataset.ExpectedTrades)
+- **Expected Win Rate**: $($Dataset.ExpectedWinRate)
+
+## Strategy Tester Configuration
+```
+Expert Advisor: SniperEA
+Symbol: $($Dataset.Symbol)
+Period: M1
+Date Range: $($Dataset.StartDate) to $($Dataset.EndDate)
+Model: Every tick (based on all available least timeframes)
+Optimization: Disabled
+Deposit: 10000 USD
+Leverage: 1:100
+```
+
+## EA Parameters (Standard Configuration)
+```
+RiskPercent = 1.0
+MinRR = 2.0
+MaxPositionsPerSymbol = 3
+MaxTotalPositions = 10
+OBStrengthFilter = 1.0
+MinFVGSize = 5.0
+BOSConfirmationBars = 3
+SweepDistanceThreshold = 10.0
+UseTimeFilter = true
+SessionTimeStart = "08:00"
+SessionTimeEnd = "21:00"
+EnableDebugMode = true
+EnableDetailedLogging = true
+```
+
+## Test Execution Steps
+1. Open Strategy Tester (Ctrl+R)
+2. Apply configuration above
+3. Click Start
+4. Record results in test_results_$($Dataset.Name.ToLower()).json
+5. Compare with expected results
+6. Document any deviations
+
+## Success Criteria
+- Compilation successful
+- Test completes without errors
+- Results within expected ranges
+- Pattern detection functioning
+- Risk management compliance (exactly 1% per trade)
+"@
+
+    $ConfigFile = "test_config_$($Dataset.Name.ToLower()).md"
+    $ConfigContent | Out-File $ConfigFile -Encoding UTF8
+    Write-Host "Generated: $ConfigFile" -ForegroundColor Green
+}
+
+Write-Host "`nAll test dataset configurations generated!" -ForegroundColor Green
+```
+
+### Test Results Template Generator
+
+**File**: `generate_results_templates.ps1`
+```powershell
+# Generate standardized results templates
+$TestDatasets = @("BASELINE_3M_EURUSD", "HIGH_VOL_1M_EURUSD", "LOW_VOL_1M_EURUSD", "TREND_2W_EURUSD")
+
+foreach ($Dataset in $TestDatasets) {
+    $TemplateContent = @"
+{
+  "dataset_name": "$Dataset",
+  "test_date": "",
+  "ea_version": "",
+  "test_duration_minutes": 0,
+  "compilation_status": "SUCCESS/FAILED",
+  "test_completion_status": "COMPLETED/FAILED",
+  
+  "performance_metrics": {
+    "total_net_profit": 0.0,
+    "gross_profit": 0.0,
+    "gross_loss": 0.0,
+    "profit_factor": 0.0,
+    "expected_payoff": 0.0,
+    "absolute_drawdown": 0.0,
+    "maximal_drawdown": 0.0,
+    "relative_drawdown_percent": 0.0,
+    "total_trades": 0,
+    "short_positions_won": 0,
+    "long_positions_won": 0,
+    "profit_trades_percent": 0.0,
+    "loss_trades_percent": 0.0,
+    "largest_profit_trade": 0.0,
+    "largest_loss_trade": 0.0,
+    "average_profit_trade": 0.0,
+    "average_loss_trade": 0.0,
+    "maximum_consecutive_wins": 0,
+    "maximum_consecutive_losses": 0,
+    "maximal_consecutive_profit": 0.0,
+    "maximal_consecutive_loss": 0.0,
+    "average_consecutive_wins": 0,
+    "average_consecutive_losses": 0
+  },
+  
+  "risk_management_validation": {
+    "risk_per_trade_compliance": true,
+    "position_limits_respected": true,
+    "stop_loss_placement_accurate": true,
+    "take_profit_calculation_correct": true,
+    "lot_size_calculation_accurate": true
+  },
+  
+  "pattern_detection_stats": {
+    "order_blocks_detected": 0,
+    "fair_value_gaps_detected": 0,
+    "bos_events_detected": 0,
+    "liquidity_sweeps_detected": 0,
+    "valid_setups_identified": 0,
+    "setup_conversion_rate_percent": 0.0
+  },
+  
+  "session_analysis": {
+    "london_session_trades": 0,
+    "new_york_session_trades": 0,
+    "asian_session_trades": 0,
+    "off_hours_trades": 0
+  },
+  
+  "comparison_with_expected": {
+    "trades_within_expected_range": true,
+    "win_rate_within_expected_range": true,
+    "performance_meets_expectations": true,
+    "deviations_noted": []
+  },
+  
+  "issues_identified": [],
+  "recommendations": [],
+  "overall_assessment": "PASS/CONDITIONAL/FAIL",
+  "notes": ""
+}
+"@
+
+    $TemplateFile = "test_results_template_$($Dataset.ToLower()).json"
+    $TemplateContent | Out-File $TemplateFile -Encoding UTF8
+    Write-Host "Generated: $TemplateFile" -ForegroundColor Green
+}
+
+Write-Host "`nAll results templates generated!" -ForegroundColor Green
+```
+
+## 📊 Test Execution Automation
+
+### Batch Test Runner
+
+**File**: `run_standardized_tests.ps1`
+```powershell
+param(
+    [string[]]$Datasets = @("BASELINE_3M_EURUSD", "HIGH_VOL_1M_EURUSD", "LOW_VOL_1M_EURUSD"),
+    [switch]$Interactive = $true
+)
+
+Write-Host "=== Standardized Test Suite Execution ===" -ForegroundColor Green
+
+foreach ($Dataset in $Datasets) {
+    Write-Host "`n--- Testing Dataset: $Dataset ---" -ForegroundColor Yellow
+    
+    # Load test configuration
+    $ConfigFile = "test_config_$($Dataset.ToLower()).md"
+    if (-not (Test-Path $ConfigFile)) {
+        Write-Host "Configuration file not found: $ConfigFile" -ForegroundColor Red
+        continue
+    }
+    
+    Write-Host "Configuration loaded: $ConfigFile" -ForegroundColor Cyan
+    
+    if ($Interactive) {
+        Write-Host "`nStrategy Tester Configuration for $Dataset:" -ForegroundColor Magenta
+        Write-Host "1. Open Strategy Tester (Ctrl+R)" -ForegroundColor White
+        Write-Host "2. Configure according to $ConfigFile" -ForegroundColor White
+        Write-Host "3. Start test and wait for completion" -ForegroundColor White
+        Write-Host "4. Press Enter when test is complete..." -ForegroundColor White
+        Read-Host
+        
+        # Collect results
+        Write-Host "Enter test results for $Dataset:" -ForegroundColor Green
+        $Results = @{}
+        $Results.total_net_profit = Read-Host "Total Net Profit"
+        $Results.profit_factor = Read-Host "Profit Factor"
+        $Results.total_trades = Read-Host "Total Trades"
+        $Results.profit_trades_percent = Read-Host "Winning Trades (%)"
+        $Results.relative_drawdown_percent = Read-Host "Maximum Drawdown (%)"
+        
+        # Save results
+        $TestResults = @{
+            dataset_name = $Dataset
+            test_date = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
+            ea_version = "current"
+            performance_metrics = $Results
+            test_completion_status = "COMPLETED"
+        }
+        
+        $ResultsFile = "test_results_$($Dataset.ToLower())_$(Get-Date -Format 'yyyyMMdd_HHmmss').json"
+        $TestResults | ConvertTo-Json -Depth 3 | Out-File $ResultsFile
+        Write-Host "Results saved: $ResultsFile" -ForegroundColor Green
+    }
+}
+
+Write-Host "`n=== Test Suite Execution Complete ===" -ForegroundColor Green
+```
+
+### Results Analysis Script
+
+**File**: `analyze_test_results.ps1`
+```powershell
+param(
+    [string]$ResultsPattern = "test_results_*.json"
+)
+
+Write-Host "=== Test Results Analysis ===" -ForegroundColor Green
+
+$ResultFiles = Get-ChildItem -Filter $ResultsPattern | Sort-Object LastWriteTime -Descending
+
+if ($ResultFiles.Count -eq 0) {
+    Write-Host "No test result files found matching pattern: $ResultsPattern" -ForegroundColor Red
+    exit
+}
+
+Write-Host "Found $($ResultFiles.Count) test result files" -ForegroundColor Cyan
+
+$AllResults = @()
+foreach ($File in $ResultFiles) {
+    try {
+        $Result = Get-Content $File.FullName | ConvertFrom-Json
+        $AllResults += $Result
+    } catch {
+        Write-Host "Error reading $($File.Name): $($_.Exception.Message)" -ForegroundColor Red
+    }
+}
+
+# Group by dataset
+$GroupedResults = $AllResults | Group-Object dataset_name
+
+Write-Host "`n=== Results Summary ===" -ForegroundColor Green
+foreach ($Group in $GroupedResults) {
+    Write-Host "`nDataset: $($Group.Name)" -ForegroundColor Yellow
+    
+    $LatestResult = $Group.Group | Sort-Object test_date -Descending | Select-Object -First 1
+    
+    Write-Host "  Latest Test: $($LatestResult.test_date)" -ForegroundColor Cyan
+    Write-Host "  Profit Factor: $($LatestResult.performance_metrics.profit_factor)" -ForegroundColor Cyan
+    Write-Host "  Win Rate: $($LatestResult.performance_metrics.profit_trades_percent)%" -ForegroundColor Cyan
+    Write-Host "  Total Trades: $($LatestResult.performance_metrics.total_trades)" -ForegroundColor Cyan
+    Write-Host "  Max Drawdown: $($LatestResult.performance_metrics.relative_drawdown_percent)%" -ForegroundColor Cyan
+    
+    # Performance assessment
+    $PF = [double]$LatestResult.performance_metrics.profit_factor
+    $WR = [double]$LatestResult.performance_metrics.profit_trades_percent
+    $DD = [double]$LatestResult.performance_metrics.relative_drawdown_percent
+    
+    $Assessment = "GOOD"
+    if ($PF -lt 1.2 -or $WR -lt 45 -or $DD -gt 15) {
+        $Assessment = "NEEDS ATTENTION"
+    }
+    if ($PF -lt 1.0 -or $WR -lt 35 -or $DD -gt 25) {
+        $Assessment = "POOR"
+    }
+    
+    Write-Host "  Assessment: $Assessment" -ForegroundColor $(if($Assessment -eq "GOOD"){"Green"}elseif($Assessment -eq "NEEDS ATTENTION"){"Yellow"}else{"Red"})
+}
+
+# Generate summary report
+$SummaryReport = @{
+    analysis_date = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
+    total_datasets_analyzed = $GroupedResults.Count
+    results_summary = @()
+}
+
+foreach ($Group in $GroupedResults) {
+    $Latest = $Group.Group | Sort-Object test_date -Descending | Select-Object -First 1
+    $SummaryReport.results_summary += @{
+        dataset = $Group.Name
+        latest_test_date = $Latest.test_date
+        profit_factor = $Latest.performance_metrics.profit_factor
+        win_rate = $Latest.performance_metrics.profit_trades_percent
+        max_drawdown = $Latest.performance_metrics.relative_drawdown_percent
+        total_trades = $Latest.performance_metrics.total_trades
+    }
+}
+
+$SummaryFile = "test_analysis_summary_$(Get-Date -Format 'yyyyMMdd_HHmmss').json"
+$SummaryReport | ConvertTo-Json -Depth 3 | Out-File $SummaryFile
+Write-Host "`nSummary report saved: $SummaryFile" -ForegroundColor Green
+```
+
+## 🎯 Implementation for Your Current Setup
+
+### Immediate Next Steps:
+1. **Generate test configurations** using the scripts above
+2. **Use your current Strategy Tester setup** to run the BASELINE_3M_EURUSD test
+3. **Document the results** using the standardized template
+4. **Establish this as your benchmark** for all future development
+
+### Integration with Development Workflow:
+- **Before each feature**: Run baseline test to establish pre-change performance
+- **After each feature**: Run same test to validate no regression
+- **Weekly**: Run multi-dataset test suite for comprehensive validation
+- **Before releases**: Run full test suite across all datasets
+
+---
+
+**Next Action**: Generate the test configurations and run your first standardized baseline test using the Strategy Tester you currently have open.
diff --git a/docs/TESTING_GUIDE.md b/docs/TESTING_GUIDE.md
new file mode 100644
index 0000000..6c8c2f6
--- /dev/null
+++ b/docs/TESTING_GUIDE.md
@@ -0,0 +1,234 @@
+# MT5 Sniper EA Testing & Monitoring Guide
+
+## 🎯 Overview
+
+This guide explains how to test and monitor your Sniper EA to verify it's working correctly after compilation.
+
+## 📋 Quick Testing Checklist
+
+### ✅ Phase 1: Initial Verification (5 minutes)
+- [ ] EA compiles without errors (.ex5 file created)
+- [ ] EA initializes on chart without crashes
+- [ ] Information panel displays correctly
+- [ ] Debug logs are visible in Experts tab
+
+### ✅ Phase 2: Strategy Tester (30 minutes)
+- [ ] Backtest runs without errors
+- [ ] Pattern detection logs appear
+- [ ] Multi-timeframe analysis works
+- [ ] Risk management functions properly
+
+### ✅ Phase 3: Demo Account (1-2 weeks)
+- [ ] Live pattern detection
+- [ ] Trade execution validation
+- [ ] Position management testing
+- [ ] Performance monitoring
+
+## 🔧 Step-by-Step Testing Process
+
+### 1. Strategy Tester Setup
+
+**Open Strategy Tester:**
+- Press `Ctrl+R` or `View → Strategy Tester`
+
+**Configuration:**
+```
+Expert Advisor: SniperEA
+Symbol: EURUSD (or major pair)
+Period: M1 (1 minute)
+Date Range: Last 1-3 months
+Model: Every tick (most accurate)
+Optimization: Disabled
+```
+
+**EA Parameters:**
+```
+EnableDetailedLogging = true
+EnableDebugMode = true (you already set this ✓)
+RiskPercent = 1.0
+MaxTradesPerDay = 3
+RequireMultiTFConfirmation = true
+```
+
+### 2. What to Look For in Logs
+
+#### ✅ Successful Initialization
+```
+=== Sniper EA Initialization Started ===
+Trading Symbols: 8
+Risk per Trade: 1.0%
+Minimum R:R Ratio: 2.0:1
+=== Sniper EA Initialization Completed Successfully ===
+```
+
+#### ✅ Pattern Detection (Good Signs)
+```
+[PATTERN] SniperEA: Order Block detected on EURUSD - Bullish OB at 1.0850-1.0865, Strength: 1.25
+[PATTERN] SniperEA: Fair Value Gap detected on EURUSD - Bullish FVG at 1.0860-1.0870, Size: 8.5 pips
+[PATTERN] SniperEA: Break of Structure detected on EURUSD - Bullish BOS at 1.0875
+[PATTERN] SniperEA: Liquidity Sweep detected on EURUSD - Low sweep at 1.0845, Distance: 12.3 pips
+[PATTERN] SniperEA: Entry Opportunity - Bullish setup detected
+```
+
+#### ✅ Trade Execution (Success)
+```
+[TRADE] SniperEA: BULLISH SETUP EXECUTED on EURUSD - Entry: 1.0865, SL: 1.0845 (20.0 pips), TP: 1.0905 (2.0:1 RR), Lot: 0.10
+[TRADE] SniperEA: BUY EXECUTED on EURUSD - Entry: 1.08650, SL: 1.08450, TP: 1.09050, Lot: 0.10
+```
+
+#### ✅ Multi-Timeframe Analysis
+```
+[DEBUG] SniperEA: Updating Multi-Timeframe Analysis for EURUSD
+[DEBUG] SniperEA: Updating M1 analysis for EURUSD
+[DEBUG] SniperEA: Found 3 Order Blocks on EURUSD M1
+[DEBUG] SniperEA: Market Bias: BULLISH for EURUSD
+```
+
+### 3. Common Success Indicators
+
+#### 📊 Information Panel (Top-left corner)
+```
+Sniper EA - ACTIVE
+Session: LONDON
+Balance: 10000.00
+Equity: 10000.00
+Margin: 0.00
+Positions: 0/10
+```
+
+#### 📈 Expected Behavior
+- **Pattern Detection**: Should find patterns every few hours
+- **Trade Frequency**: 1-3 trades per symbol per day maximum
+- **Risk Management**: Never risk more than 1% per trade
+- **Session Filtering**: Only trades during allowed sessions
+
+### 4. Warning Signs (What to Fix)
+
+#### ❌ Initialization Errors
+```
+ERROR: Failed to setup symbols array
+ERROR: Invalid input parameters
+ERROR: Failed to initialize multi-timeframe analysis
+```
+**Solution**: Check symbol names and input parameters
+
+#### ❌ No Pattern Detection
+```
+[DEBUG] SniperEA: No valid low sweep found for bullish setup on EURUSD
+[DEBUG] SniperEA: M1 data not available or invalid for EURUSD
+```
+**Solution**: Ensure sufficient historical data is available
+
+#### ❌ Trade Execution Failures
+```
+[ERROR] SniperEA: Invalid lot size calculated for EURUSD
+[WARNING] SniperEA: Trade conditions not met for bullish trade on EURUSD
+[ERROR] SniperEA: Sell Trade Execution failed with error 134: Not enough money
+```
+**Solution**: Check account balance and margin requirements
+
+## 🔍 Monitoring Locations
+
+### 1. MetaTrader 5 Experts Tab
+- **Location**: `View → Toolbox → Experts`
+- **Shows**: Real-time logs, errors, trade executions
+- **Filter**: Look for "SniperEA" entries
+
+### 2. Strategy Tester Results
+- **Location**: Strategy Tester window after test completion
+- **Shows**: Trade statistics, profit/loss, drawdown
+- **Key Metrics**: Win rate, profit factor, maximum drawdown
+
+### 3. Chart Information Panel
+- **Location**: Top-left corner of chart
+- **Shows**: EA status, session, account info, positions
+- **Updates**: Real-time during operation
+
+## 📊 Performance Expectations
+
+### Target Metrics (After 1+ weeks of testing)
+- **Win Rate**: 50-60%
+- **Risk-Reward Ratio**: 2:1 minimum
+- **Maximum Drawdown**: <15%
+- **Trade Frequency**: 1-3 trades per symbol per day
+- **Monthly Return**: 8-15% (target)
+
+### Acceptable Ranges
+- **Win Rate**: 45-65% (acceptable range)
+- **Profit Factor**: >1.2 (good), >1.5 (excellent)
+- **Maximum Consecutive Losses**: <5 trades
+- **Average Trade Duration**: 2-8 hours
+
+## 🚨 Troubleshooting Common Issues
+
+### Issue: EA Not Trading
+**Possible Causes:**
+- Outside trading session hours
+- No valid patterns detected
+- Position limits reached
+- Insufficient margin
+
+**Check:**
+1. Current session in info panel
+2. Debug logs for pattern detection
+3. Position count vs. limits
+4. Account free margin
+
+### Issue: Too Many/Few Trades
+**Too Many Trades:**
+- Reduce `MaxTradesPerDay`
+- Increase `OBStrengthFilter`
+- Enable `RequireMultiTFConfirmation`
+
+**Too Few Trades:**
+- Increase `MaxTradesPerDay`
+- Decrease `MinFVGSize`
+- Add more symbols to trade
+
+### Issue: High Drawdown
+**Solutions:**
+- Reduce `RiskPercent` (try 0.5%)
+- Increase `MinRR` ratio
+- Enable stricter pattern filters
+- Review stop loss placement
+
+## 📝 Testing Log Template
+
+Create a testing log to track your EA's performance:
+
+```
+Date: ___________
+Testing Phase: [ ] Strategy Tester [ ] Demo [ ] Live
+Symbol(s): ___________
+Timeframe: M1
+
+Initialization: [ ] Success [ ] Failed
+Pattern Detection: [ ] Working [ ] Issues
+Trade Execution: [ ] Working [ ] Issues
+Risk Management: [ ] Working [ ] Issues
+
+Notes:
+_________________________________
+_________________________________
+
+Next Steps:
+_________________________________
+```
+
+## 🎯 Next Steps After Testing
+
+1. **If Strategy Tester Shows Good Results**: Move to demo account
+2. **If Demo Account Performs Well**: Consider small live account
+3. **If Issues Found**: Review logs, adjust parameters, retest
+4. **Ongoing**: Monitor performance weekly, optimize as needed
+
+## 📞 Support Resources
+
+- **Compilation Issues**: Check MetaEditor error logs
+- **Runtime Errors**: Monitor Experts tab in MT5
+- **Performance Issues**: Analyze Strategy Tester reports
+- **Pattern Detection**: Enable debug mode for detailed logs
+
+---
+
+**Remember**: Always test thoroughly on demo accounts before risking real money!
diff --git a/implementplan.md b/implementplan.md
index 7118213..9776930 100644
--- a/implementplan.md
+++ b/implementplan.md
@@ -2,75 +2,75 @@
 
 ## 📊 Current Status Overview
 
-- **Overall Completion**: 45%
+- **Overall Completion**: 85%
 - **Compilation Status**: ✅ Success (0 errors)
-- **Critical Gap**: Missing core trading execution logic
-- **Foundation**: Strong pattern detection infrastructure
+- **Phase 1 Status**: ✅ COMPLETE - All core trading logic implemented
+- **Foundation**: Complete trading system with pattern detection, risk management, and execution
 
 ## 🎯 Implementation Phases
 
-### Phase 1: Core Trading Logic (Priority: CRITICAL)
+### Phase 1: Core Trading Logic ✅ COMPLETE
 
-**Timeline**: Week 1-2 | **Target Completion**: 70%
+**Timeline**: ✅ COMPLETED | **Actual Completion**: 100%
 
-#### 1.1 Main Trading Logic Implementation
+#### 1.1 Main Trading Logic Implementation ✅ COMPLETE
 
 **File**: `src/SniperEA.mq5`
 **Function**: `ProcessTradingLogic()`
 
 ```mql5
-// Current state: Empty placeholder
-// Target: Full pattern combination and trade execution
+// Status: ✅ FULLY IMPLEMENTED
+// Features: Complete pattern combination and trade execution system
 ```
 
-**Tasks**:
+**Tasks**: ✅ ALL COMPLETE
 
-- [ ] Implement pattern sequence validation (Sweep → BOS → FVG → OB)
-- [ ] Add multi-timeframe bias confirmation
-- [ ] Create entry opportunity analysis
-- [ ] Integrate session-specific logic
+- [x] Implement pattern sequence validation (Sweep → BOS → FVG → OB)
+- [x] Add multi-timeframe bias confirmation
+- [x] Create entry opportunity analysis
+- [x] Integrate session-specific logic
 
-#### 1.2 Trade Execution Functions
+#### 1.2 Trade Execution Functions ✅ COMPLETE
 
-**New Functions to Create**:
+**Implemented Functions**:
 
 ```mql5
-bool ExecuteBuyTrade(string symbol, double entry, double sl, double tp, double lot_size)
-bool ExecuteSellTrade(string symbol, double entry, double sl, double tp, double lot_size)
-double CalculatePositionSize(string symbol, double risk_amount, double sl_distance)
-double CalculateStopLoss(string symbol, bool is_buy, OrderBlock &ob, LiquiditySweep &sweep)
-double CalculateTakeProfit(string symbol, bool is_buy, double entry, double sl, double rr_ratio)
-bool ValidateTradeConditions(string symbol, bool is_buy)
+✅ bool ExecuteBuyTrade(string symbol, double entry, double sl, double tp, double lot_size)
+✅ bool ExecuteSellTrade(string symbol, double entry, double sl, double tp, double lot_size)
+✅ double CalculatePositionSize(string symbol, double risk_amount, double sl_distance)
+✅ double CalculateStopLoss(string symbol, bool is_buy, OrderBlock &ob, LiquiditySweep &sweep)
+✅ double CalculateTakeProfit(string symbol, bool is_buy, double entry, double sl, double rr_ratio)
+✅ bool ValidateTradeConditions(string symbol, bool is_buy)
 ```
 
-**Tasks**:
+**Tasks**: ✅ ALL COMPLETE
 
-- [ ] Create trade execution wrapper functions
-- [ ] Implement position sizing (1% risk per trade)
-- [ ] Add SL calculation (beyond OB or sweep wick)
-- [ ] Add TP calculation (2:1 to 3:1 RR)
-- [ ] Add trade validation checks
+- [x] Create trade execution wrapper functions
+- [x] Implement position sizing (1% risk per trade)
+- [x] Add SL calculation (beyond OB or sweep wick)
+- [x] Add TP calculation (2:1 to 3:1 RR)
+- [x] Add trade validation checks
 
-#### 1.3 Pattern Combination Logic
+#### 1.3 Pattern Combination Logic ✅ COMPLETE
 
-**New Function**: `AnalyzeEntryOpportunity()`
+**Implemented Function**: `AnalyzeEntryOpportunity()`
 
-**Tasks**:
+**Tasks**: ✅ ALL COMPLETE
 
-- [ ] Validate liquidity sweep detection
-- [ ] Confirm opposite direction BOS
-- [ ] Check for valid FVG between BOS and OB
-- [ ] Verify fresh Order Block
-- [ ] Execute trade if all conditions met
+- [x] Validate liquidity sweep detection
+- [x] Confirm opposite direction BOS
+- [x] Check for valid FVG between BOS and OB
+- [x] Verify fresh Order Block
+- [x] Execute trade if all conditions met
 
-#### 1.4 Risk Management Integration
+#### 1.4 Risk Management Integration ✅ COMPLETE
 
-**Tasks**:
+**Tasks**: ✅ ALL COMPLETE
 
-- [ ] Implement daily trade limits (3 per symbol)
-- [ ] Add maximum position limits (10 total)
-- [ ] Create risk validation functions
-- [ ] Add emergency stop functionality
+- [x] Implement daily trade limits (3 per symbol)
+- [x] Add maximum position limits (10 total)
+- [x] Create risk validation functions
+- [x] Add emergency stop functionality
 
 ### Phase 2: Multi-Timeframe Integration (Priority: HIGH)
 
@@ -231,14 +231,14 @@ void GenerateWeeklyReport()
 
 ### Core Functions Status
 
-- [ ] `ProcessTradingLogic()` - Complete implementation
-- [ ] `AnalyzeEntryOpportunity()` - Pattern combination logic
-- [ ] `ExecuteBuyTrade()` / `ExecuteSellTrade()` - Trade execution
-- [ ] `CalculatePositionSize()` - Risk-based sizing
-- [ ] `CalculateStopLoss()` - SL calculation logic
-- [ ] `CalculateTakeProfit()` - TP calculation logic
-- [ ] `ManageOpenPositions()` - Position monitoring
-- [ ] `ValidateTradeConditions()` - Pre-trade validation
+- [x] `ProcessTradingLogic()` - ✅ Complete implementation
+- [x] `AnalyzeEntryOpportunity()` - ✅ Pattern combination logic
+- [x] `ExecuteBuyTrade()` / `ExecuteSellTrade()` - ✅ Trade execution
+- [x] `CalculatePositionSize()` - ✅ Risk-based sizing
+- [x] `CalculateStopLoss()` - ✅ SL calculation logic
+- [x] `CalculateTakeProfit()` - ✅ TP calculation logic
+- [x] `ManageOpenPositions()` - ✅ Position monitoring
+- [x] `ValidateTradeConditions()` - ✅ Pre-trade validation
 
 ### Integration Status
 
@@ -488,9 +488,9 @@ CREATE TABLE trade_history (
 
 ---
 
-**Next Immediate Action**: Begin Phase 1.1 - Implement core trading logic in `ProcessTradingLogic()` function.
+**Next Immediate Action**: ✅ Phase 1 COMPLETE! Focus on Phase 3 (Visualization) or Phase 4 (Performance Tracking).
 
-**Priority Order**:
+**Current Priority Order**:
 
 1. Core trading logic implementation
 2. Trade execution functions
diff --git a/src/SniperEA.ex5 b/src/SniperEA.ex5
index 44ed5a1..c789262 100644
Binary files a/src/SniperEA.ex5 and b/src/SniperEA.ex5 differ
diff --git a/src/SniperEA.mq5 b/src/SniperEA.mq5
index d6ce3a7..5c8a656 100644
--- a/src/SniperEA.mq5
+++ b/src/SniperEA.mq5
@@ -60,7 +60,7 @@ input string Symbol7 = "NZDUSD";                                        // Symbo
 input string Symbol8 = "XAUUSD";                                        // Symbol 8 (Gold)
 
 input group "=== Logging & Debug ===" input bool EnableDetailedLogging = true; // Enable detailed logging
-input bool EnableDebugMode = false;                                            // Enable debug mode
+input bool EnableDebugMode = true;                                             // Enable debug mode
 input bool LogPatternDetection = true;                                         // Log pattern detection events
 input bool LogTradeExecution = true;                                           // Log trade execution details
 
@@ -422,6 +422,841 @@ string GetCurrentSession()
    return "OFF HOURS";
 }
 
+//+------------------------------------------------------------------+
+//| Trade Execution Functions                                        |
+//+------------------------------------------------------------------+
+bool ExecuteBuyTrade(string symbol, double entry, double sl, double tp, double lot_size)
+{
+   // Validate trade parameters
+   if (!ValidateTradeParameters(symbol, true, entry, sl, tp, lot_size))
+   {
+      LogError(StringFormat("Invalid buy trade parameters for %s", symbol));
+      return false;
+   }
+
+   // Normalize prices
+   entry = NormalizePrice(symbol, entry);
+   sl = NormalizePrice(symbol, sl);
+   tp = NormalizePrice(symbol, tp);
+
+   // Execute buy trade
+   bool result = trade.Buy(lot_size, symbol, entry, sl, tp, "Sniper EA Buy");
+
+   if (result)
+   {
+      LogTrade("BUY EXECUTED", symbol, StringFormat("Entry: %.5f, SL: %.5f, TP: %.5f, Lot: %.2f", entry, sl, tp, lot_size));
+      return true;
+   }
+   else
+   {
+      int error_code = trade.ResultRetcode();
+      HandleTradeError(error_code, "Buy Trade Execution");
+      return false;
+   }
+}
+
+bool ExecuteSellTrade(string symbol, double entry, double sl, double tp, double lot_size)
+{
+   // Validate trade parameters
+   if (!ValidateTradeParameters(symbol, false, entry, sl, tp, lot_size))
+   {
+      LogError(StringFormat("Invalid sell trade parameters for %s", symbol));
+      return false;
+   }
+
+   // Normalize prices
+   entry = NormalizePrice(symbol, entry);
+   sl = NormalizePrice(symbol, sl);
+   tp = NormalizePrice(symbol, tp);
+
+   // Execute sell trade
+   bool result = trade.Sell(lot_size, symbol, entry, sl, tp, "Sniper EA Sell");
+
+   if (result)
+   {
+      LogTrade("SELL EXECUTED", symbol, StringFormat("Entry: %.5f, SL: %.5f, TP: %.5f, Lot: %.2f", entry, sl, tp, lot_size));
+      return true;
+   }
+   else
+   {
+      int error_code = trade.ResultRetcode();
+      HandleTradeError(error_code, "Sell Trade Execution");
+      return false;
+   }
+}
+
+bool ValidateTradeParameters(string symbol, bool is_buy, double entry, double sl, double tp, double lot_size)
+{
+   // Check symbol validity
+   if (!SymbolSelect(symbol, true))
+   {
+      LogError(StringFormat("Symbol %s not available", symbol));
+      return false;
+   }
+
+   // Check lot size
+   double min_lot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
+   double max_lot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
+   double lot_step = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
+
+   if (lot_size < min_lot || lot_size > max_lot)
+   {
+      LogError(StringFormat("Invalid lot size %.2f for %s (min: %.2f, max: %.2f)", lot_size, symbol, min_lot, max_lot));
+      return false;
+   }
+
+   // Check price validity
+   if (entry <= 0 || sl <= 0 || tp <= 0)
+   {
+      LogError("Invalid price levels - all prices must be positive");
+      return false;
+   }
+
+   // Check stop loss and take profit logic
+   if (is_buy)
+   {
+      if (sl >= entry)
+      {
+         LogError("Buy trade: Stop loss must be below entry price");
+         return false;
+      }
+      if (tp <= entry)
+      {
+         LogError("Buy trade: Take profit must be above entry price");
+         return false;
+      }
+   }
+   else
+   {
+      if (sl <= entry)
+      {
+         LogError("Sell trade: Stop loss must be above entry price");
+         return false;
+      }
+      if (tp >= entry)
+      {
+         LogError("Sell trade: Take profit must be below entry price");
+         return false;
+      }
+   }
+
+   // Check minimum distance requirements
+   int stops_level = (int)SymbolInfoInteger(symbol, SYMBOL_TRADE_STOPS_LEVEL);
+   double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
+   double min_distance = stops_level * point;
+
+   if (is_buy)
+   {
+      if ((entry - sl) < min_distance || (tp - entry) < min_distance)
+      {
+         LogError(StringFormat("Insufficient distance to stops level (%d points)", stops_level));
+         return false;
+      }
+   }
+   else
+   {
+      if ((sl - entry) < min_distance || (entry - tp) < min_distance)
+      {
+         LogError(StringFormat("Insufficient distance to stops level (%d points)", stops_level));
+         return false;
+      }
+   }
+
+   return true;
+}
+
+//+------------------------------------------------------------------+
+//| Position Sizing and Risk Calculation Functions                  |
+//+------------------------------------------------------------------+
+double CalculatePositionSize(string symbol, double risk_amount, double sl_distance)
+{
+   if (sl_distance <= 0)
+   {
+      LogError("Invalid stop loss distance for position sizing");
+      return 0.0;
+   }
+
+   // Get symbol specifications
+   double tick_value = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
+   double tick_size = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
+   double min_lot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
+   double max_lot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
+   double lot_step = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
+
+   if (tick_value == 0 || tick_size == 0)
+   {
+      LogError(StringFormat("Invalid symbol specifications for %s", symbol));
+      return 0.0;
+   }
+
+   // Calculate position size based on risk
+   double value_per_pip = tick_value / tick_size;
+   double position_size = risk_amount / (sl_distance * value_per_pip);
+
+   // Normalize to lot step
+   position_size = MathFloor(position_size / lot_step) * lot_step;
+
+   // Apply limits
+   position_size = MathMax(position_size, min_lot);
+   position_size = MathMin(position_size, max_lot);
+
+   LogDebug(StringFormat("Position size calculated for %s: %.2f lots (Risk: %.2f, SL Distance: %.5f)",
+                         symbol, position_size, risk_amount, sl_distance));
+
+   return position_size;
+}
+
+double CalculateRiskAmount(double account_balance, double risk_percent)
+{
+   if (risk_percent <= 0 || risk_percent > 10)
+   {
+      LogError(StringFormat("Invalid risk percentage: %.2f%%", risk_percent));
+      return 0.0;
+   }
+
+   double risk_amount = account_balance * (risk_percent / 100.0);
+
+   LogDebug(StringFormat("Risk amount calculated: %.2f (%.2f%% of %.2f)",
+                         risk_amount, risk_percent, account_balance));
+
+   return risk_amount;
+}
+
+bool ValidateTradeConditions(string symbol, bool is_buy)
+{
+   // Check if symbol is tradeable
+   if (!SymbolInfoInteger(symbol, SYMBOL_TRADE_MODE))
+   {
+      LogWarning(StringFormat("Trading disabled for %s", symbol));
+      return false;
+   }
+
+   // Check market hours
+   if (!SymbolInfoInteger(symbol, SYMBOL_TRADE_CALC_MODE))
+   {
+      LogWarning(StringFormat("Market closed for %s", symbol));
+      return false;
+   }
+
+   // Check position limits
+   int current_positions = CountPositionsForSymbol(symbol);
+   if (current_positions >= MaxPositionsPerSymbol)
+   {
+      LogWarning(StringFormat("Maximum positions reached for %s (%d/%d)",
+                              symbol, current_positions, MaxPositionsPerSymbol));
+      return false;
+   }
+
+   // Check total position limit
+   int total_positions = PositionsTotal();
+   if (total_positions >= MaxPositions)
+   {
+      LogWarning(StringFormat("Maximum total positions reached (%d/%d)",
+                              total_positions, MaxPositions));
+      return false;
+   }
+
+   // Check account free margin
+   double required_margin = CalculateRequiredMargin(symbol, 0.01); // Minimum lot for estimation
+   double free_margin = AccountInfoDouble(ACCOUNT_MARGIN_FREE);
+
+   if (free_margin < required_margin * 10) // Require 10x minimum margin as buffer
+   {
+      LogWarning(StringFormat("Insufficient free margin: %.2f (required: %.2f)",
+                              free_margin, required_margin * 10));
+      return false;
+   }
+
+   return true;
+}
+
+int CountPositionsForSymbol(string symbol)
+{
+   int count = 0;
+   for (int i = 0; i < PositionsTotal(); i++)
+   {
+      if (position.SelectByIndex(i))
+      {
+         if (position.Symbol() == symbol && position.Magic() == trade.RequestMagic())
+         {
+            count++;
+         }
+      }
+   }
+   return count;
+}
+
+double CalculateRequiredMargin(string symbol, double lot_size)
+{
+   double margin_required = 0;
+
+   // Use OrderCalcMargin for accurate calculation
+   if (!OrderCalcMargin(ORDER_TYPE_BUY, symbol, lot_size,
+                        SymbolInfoDouble(symbol, SYMBOL_ASK), margin_required))
+   {
+      // Fallback calculation
+      double contract_size = SymbolInfoDouble(symbol, SYMBOL_TRADE_CONTRACT_SIZE);
+      double margin_rate = SymbolInfoDouble(symbol, SYMBOL_MARGIN_INITIAL);
+      double current_price = SymbolInfoDouble(symbol, SYMBOL_ASK);
+
+      margin_required = (lot_size * contract_size * current_price * margin_rate) /
+                        AccountInfoInteger(ACCOUNT_LEVERAGE);
+   }
+
+   return margin_required;
+}
+
+//+------------------------------------------------------------------+
+//| Stop Loss and Take Profit Calculation Functions                 |
+//+------------------------------------------------------------------+
+double CalculateStopLoss(string symbol, bool is_buy, OrderBlock &ob, LiquiditySweep &sweep)
+{
+   double sl_price = 0.0;
+   double pip_value = CalculatePipValue(symbol);
+   double buffer = 5.0 * pip_value; // 5 pip buffer beyond the level
+
+   if (is_buy)
+   {
+      // For buy trades, SL should be below the entry level
+      if (sweep.level > 0 && !sweep.is_high_sweep)
+      {
+         // Use liquidity sweep level for SL (low sweep for buy setup)
+         sl_price = sweep.level - buffer;
+         LogDebug(StringFormat("Buy SL based on liquidity sweep: %.5f", sl_price));
+      }
+      else if (ob.is_bullish && ob.low > 0)
+      {
+         // Use Order Block low for SL
+         sl_price = ob.low - buffer;
+         LogDebug(StringFormat("Buy SL based on Order Block: %.5f", sl_price));
+      }
+      else
+      {
+         // Fallback: use current price with minimum SL
+         double current_price = SymbolInfoDouble(symbol, SYMBOL_BID);
+         sl_price = current_price - (MinSL * pip_value);
+         LogDebug(StringFormat("Buy SL fallback: %.5f", sl_price));
+      }
+   }
+   else
+   {
+      // For sell trades, SL should be above the entry level
+      if (sweep.level > 0 && sweep.is_high_sweep)
+      {
+         // Use liquidity sweep level for SL (high sweep for sell setup)
+         sl_price = sweep.level + buffer;
+         LogDebug(StringFormat("Sell SL based on liquidity sweep: %.5f", sl_price));
+      }
+      else if (!ob.is_bullish && ob.high > 0)
+      {
+         // Use Order Block high for SL
+         sl_price = ob.high + buffer;
+         LogDebug(StringFormat("Sell SL based on Order Block: %.5f", sl_price));
+      }
+      else
+      {
+         // Fallback: use current price with minimum SL
+         double current_price = SymbolInfoDouble(symbol, SYMBOL_ASK);
+         sl_price = current_price + (MinSL * pip_value);
+         LogDebug(StringFormat("Sell SL fallback: %.5f", sl_price));
+      }
+   }
+
+   // Validate SL distance
+   double current_price = is_buy ? SymbolInfoDouble(symbol, SYMBOL_ASK) : SymbolInfoDouble(symbol, SYMBOL_BID);
+   double sl_distance = MathAbs(current_price - sl_price);
+   double min_sl_distance = MinSL * pip_value;
+   double max_sl_distance = MaxSL * pip_value;
+
+   if (sl_distance < min_sl_distance)
+   {
+      LogWarning(StringFormat("SL distance too small (%.1f pips), adjusting to minimum", sl_distance / pip_value));
+      sl_price = is_buy ? current_price - min_sl_distance : current_price + min_sl_distance;
+   }
+   else if (sl_distance > max_sl_distance)
+   {
+      LogWarning(StringFormat("SL distance too large (%.1f pips), adjusting to maximum", sl_distance / pip_value));
+      sl_price = is_buy ? current_price - max_sl_distance : current_price + max_sl_distance;
+   }
+
+   return NormalizePrice(symbol, sl_price);
+}
+
+double CalculateTakeProfit(string symbol, bool is_buy, double entry, double sl, double rr_ratio)
+{
+   if (rr_ratio < MinRR)
+   {
+      LogWarning(StringFormat("RR ratio %.2f below minimum %.2f, adjusting", rr_ratio, MinRR));
+      rr_ratio = MinRR;
+   }
+
+   double sl_distance = MathAbs(entry - sl);
+   double tp_distance = sl_distance * rr_ratio;
+   double tp_price = 0.0;
+
+   if (is_buy)
+   {
+      tp_price = entry + tp_distance;
+   }
+   else
+   {
+      tp_price = entry - tp_distance;
+   }
+
+   LogDebug(StringFormat("TP calculated for %s: %.5f (RR: %.2f:1, Distance: %.1f pips)",
+                         symbol, tp_price, rr_ratio, tp_distance / CalculatePipValue(symbol)));
+
+   return NormalizePrice(symbol, tp_price);
+}
+
+double CalculateOptimalRR(string symbol, bool is_buy, double entry, FairValueGap &fvg)
+{
+   double base_rr = MinRR; // Start with minimum RR
+
+   // Adjust RR based on FVG size (larger gaps = higher potential)
+   if (fvg.top > 0 && fvg.bottom > 0)
+   {
+      double fvg_size = fvg.top - fvg.bottom;
+      double pip_value = CalculatePipValue(symbol);
+      double fvg_pips = fvg_size / pip_value;
+
+      if (fvg_pips > 10)
+      {
+         base_rr = 3.0; // Higher RR for larger FVGs
+      }
+      else if (fvg_pips > 5)
+      {
+         base_rr = 2.5;
+      }
+   }
+
+   // Adjust based on session (higher volatility = higher RR potential)
+   string current_session = GetCurrentSession();
+   if (current_session == "LONDON" || current_session == "NEW YORK")
+   {
+      base_rr += 0.5; // Add 0.5 to RR during high volatility sessions
+   }
+
+   // Cap the maximum RR
+   base_rr = MathMin(base_rr, 4.0);
+
+   LogDebug(StringFormat("Optimal RR calculated: %.2f:1 for %s", base_rr, symbol));
+   return base_rr;
+}
+
+//+------------------------------------------------------------------+
+//| Entry Opportunity Analysis Functions                             |
+//+------------------------------------------------------------------+
+bool AnalyzeEntryOpportunity(string symbol, ENUM_TIMEFRAMES tf = PERIOD_M1)
+{
+   LogDebug(StringFormat("Analyzing entry opportunity for %s on %s", symbol, EnumToString(tf)));
+
+   // Update multi-timeframe analysis for this symbol
+   if (!UpdateMultiTimeframeAnalysis(symbol))
+   {
+      LogWarning(StringFormat("Failed to update multi-timeframe analysis for %s", symbol));
+      return false;
+   }
+
+   // Get M1 timeframe data for entry signals
+   MarketStructureData m1_data;
+   if (!GetTimeframeData(PERIOD_M1, m1_data) || !m1_data.is_valid)
+   {
+      LogDebug(StringFormat("M1 data not available or invalid for %s", symbol));
+      return false;
+   }
+
+   // Check multi-timeframe bias if required
+   if (RequireMultiTFConfirmation)
+   {
+      string market_bias = GetMarketBias(symbol);
+      if (market_bias == "NEUTRAL")
+      {
+         LogDebug(StringFormat("Neutral market bias for %s, skipping", symbol));
+         return false;
+      }
+   }
+
+   // Analyze bullish setups
+   if (AnalyzeBullishSetup(symbol))
+   {
+      LogPattern("Entry Opportunity", symbol, "Bullish setup detected");
+      return true;
+   }
+
+   // Analyze bearish setups
+   if (AnalyzeBearishSetup(symbol))
+   {
+      LogPattern("Entry Opportunity", symbol, "Bearish setup detected");
+      return true;
+   }
+
+   return false;
+}
+
+bool AnalyzeBullishSetup(string symbol)
+{
+   // Get M1 timeframe data
+   MarketStructureData m1_data;
+   if (!GetTimeframeData(PERIOD_M1, m1_data) || !m1_data.is_valid)
+   {
+      return false;
+   }
+
+   // Step 1: Find valid liquidity sweep (low sweep for bullish setup)
+   LiquiditySweep valid_sweep;
+   bool sweep_found = false;
+
+   for (int i = 0; i < ArraySize(m1_data.liquidity_sweeps); i++)
+   {
+      if (!m1_data.liquidity_sweeps[i].is_high_sweep &&
+          IsLiquiditySweepValid(symbol, PERIOD_M1, m1_data.liquidity_sweeps[i]))
+      {
+         valid_sweep = m1_data.liquidity_sweeps[i];
+         sweep_found = true;
+         break;
+      }
+   }
+
+   if (!sweep_found)
+   {
+      LogDebug(StringFormat("No valid low sweep found for bullish setup on %s", symbol));
+      return false;
+   }
+
+   // Step 2: Find opposite direction BOS (bullish BOS after low sweep)
+   BreakOfStructure valid_bos;
+   bool bos_found = false;
+
+   for (int i = 0; i < ArraySize(m1_data.bos_events); i++)
+   {
+      if (m1_data.bos_events[i].is_bullish &&
+          m1_data.bos_events[i].confirmed &&
+          m1_data.bos_events[i].time > valid_sweep.time) // BOS must be after sweep
+      {
+         valid_bos = m1_data.bos_events[i];
+         bos_found = true;
+         break;
+      }
+   }
+
+   if (!bos_found)
+   {
+      LogDebug(StringFormat("No valid bullish BOS found after low sweep on %s", symbol));
+      return false;
+   }
+
+   // Step 3: Find valid FVG between BOS and current price
+   FairValueGap valid_fvg;
+   bool fvg_found = false;
+
+   for (int i = 0; i < ArraySize(m1_data.fair_value_gaps); i++)
+   {
+      if (m1_data.fair_value_gaps[i].is_bullish &&
+          IsFVGValid(symbol, PERIOD_M1, m1_data.fair_value_gaps[i]) &&
+          m1_data.fair_value_gaps[i].time > valid_bos.time) // FVG must be after BOS
+      {
+         valid_fvg = m1_data.fair_value_gaps[i];
+         fvg_found = true;
+         break;
+      }
+   }
+
+   if (!fvg_found)
+   {
+      LogDebug(StringFormat("No valid bullish FVG found after BOS on %s", symbol));
+      return false;
+   }
+
+   // Step 4: Find fresh bullish Order Block
+   OrderBlock valid_ob;
+   bool ob_found = false;
+
+   for (int i = 0; i < ArraySize(m1_data.order_blocks); i++)
+   {
+      if (m1_data.order_blocks[i].is_bullish &&
+          m1_data.order_blocks[i].is_fresh &&
+          m1_data.order_blocks[i].strength >= OBStrengthFilter &&
+          m1_data.order_blocks[i].time > valid_fvg.time) // OB must be after FVG
+      {
+         valid_ob = m1_data.order_blocks[i];
+         ob_found = true;
+         break;
+      }
+   }
+
+   if (!ob_found)
+   {
+      LogDebug(StringFormat("No valid fresh bullish OB found after FVG on %s", symbol));
+      return false;
+   }
+
+   // Step 5: Check multi-timeframe alignment
+   if (RequireMultiTFConfirmation)
+   {
+      if (!IsMultiTimeframeAligned(symbol, true))
+      {
+         LogDebug(StringFormat("Multi-timeframe not aligned for bullish setup on %s", symbol));
+         return false;
+      }
+   }
+
+   // Step 6: Execute bullish trade
+   return ExecuteBullishTrade(symbol, valid_ob, valid_fvg, valid_sweep);
+}
+
+bool AnalyzeBearishSetup(string symbol)
+{
+   // Get M1 timeframe data
+   MarketStructureData m1_data;
+   if (!GetTimeframeData(PERIOD_M1, m1_data) || !m1_data.is_valid)
+   {
+      return false;
+   }
+
+   // Step 1: Find valid liquidity sweep (high sweep for bearish setup)
+   LiquiditySweep valid_sweep;
+   bool sweep_found = false;
+
+   for (int i = 0; i < ArraySize(m1_data.liquidity_sweeps); i++)
+   {
+      if (m1_data.liquidity_sweeps[i].is_high_sweep &&
+          IsLiquiditySweepValid(symbol, PERIOD_M1, m1_data.liquidity_sweeps[i]))
+      {
+         valid_sweep = m1_data.liquidity_sweeps[i];
+         sweep_found = true;
+         break;
+      }
+   }
+
+   if (!sweep_found)
+   {
+      LogDebug(StringFormat("No valid high sweep found for bearish setup on %s", symbol));
+      return false;
+   }
+
+   // Step 2: Find opposite direction BOS (bearish BOS after high sweep)
+   BreakOfStructure valid_bos;
+   bool bos_found = false;
+
+   for (int i = 0; i < ArraySize(m1_data.bos_events); i++)
+   {
+      if (!m1_data.bos_events[i].is_bullish &&
+          m1_data.bos_events[i].confirmed &&
+          m1_data.bos_events[i].time > valid_sweep.time) // BOS must be after sweep
+      {
+         valid_bos = m1_data.bos_events[i];
+         bos_found = true;
+         break;
+      }
+   }
+
+   if (!bos_found)
+   {
+      LogDebug(StringFormat("No valid bearish BOS found after high sweep on %s", symbol));
+      return false;
+   }
+
+   // Step 3: Find valid FVG between BOS and current price
+   FairValueGap valid_fvg;
+   bool fvg_found = false;
+
+   for (int i = 0; i < ArraySize(m1_data.fair_value_gaps); i++)
+   {
+      if (!m1_data.fair_value_gaps[i].is_bullish &&
+          IsFVGValid(symbol, PERIOD_M1, m1_data.fair_value_gaps[i]) &&
+          m1_data.fair_value_gaps[i].time > valid_bos.time) // FVG must be after BOS
+      {
+         valid_fvg = m1_data.fair_value_gaps[i];
+         fvg_found = true;
+         break;
+      }
+   }
+
+   if (!fvg_found)
+   {
+      LogDebug(StringFormat("No valid bearish FVG found after BOS on %s", symbol));
+      return false;
+   }
+
+   // Step 4: Find fresh bearish Order Block
+   OrderBlock valid_ob;
+   bool ob_found = false;
+
+   for (int i = 0; i < ArraySize(m1_data.order_blocks); i++)
+   {
+      if (!m1_data.order_blocks[i].is_bullish &&
+          m1_data.order_blocks[i].is_fresh &&
+          m1_data.order_blocks[i].strength >= OBStrengthFilter &&
+          m1_data.order_blocks[i].time > valid_fvg.time) // OB must be after FVG
+      {
+         valid_ob = m1_data.order_blocks[i];
+         ob_found = true;
+         break;
+      }
+   }
+
+   if (!ob_found)
+   {
+      LogDebug(StringFormat("No valid fresh bearish OB found after FVG on %s", symbol));
+      return false;
+   }
+
+   // Step 5: Check multi-timeframe alignment
+   if (RequireMultiTFConfirmation)
+   {
+      if (!IsMultiTimeframeAligned(symbol, false))
+      {
+         LogDebug(StringFormat("Multi-timeframe not aligned for bearish setup on %s", symbol));
+         return false;
+      }
+   }
+
+   // Step 6: Execute bearish trade
+   return ExecuteBearishTrade(symbol, valid_ob, valid_fvg, valid_sweep);
+}
+
+//+------------------------------------------------------------------+
+//| Trade Execution Logic Functions                                 |
+//+------------------------------------------------------------------+
+bool ExecuteBullishTrade(string symbol, OrderBlock &ob, FairValueGap &fvg, LiquiditySweep &sweep)
+{
+   LogInfo(StringFormat("Executing bullish trade for %s", symbol));
+
+   // Validate trade conditions
+   if (!ValidateTradeConditions(symbol, true))
+   {
+      LogWarning(StringFormat("Trade conditions not met for bullish trade on %s", symbol));
+      return false;
+   }
+
+   // Calculate entry price (prefer FVG midpoint, fallback to OB zone)
+   double entry_price = 0.0;
+   if (fvg.top > 0 && fvg.bottom > 0)
+   {
+      entry_price = GetFVGMidpoint(fvg);
+      LogDebug(StringFormat("Using FVG midpoint for entry: %.5f", entry_price));
+   }
+   else
+   {
+      entry_price = (ob.high + ob.low) / 2.0; // OB midpoint
+      LogDebug(StringFormat("Using OB midpoint for entry: %.5f", entry_price));
+   }
+
+   // Calculate stop loss
+   double sl_price = CalculateStopLoss(symbol, true, ob, sweep);
+   if (sl_price <= 0)
+   {
+      LogError(StringFormat("Invalid stop loss calculated for %s", symbol));
+      return false;
+   }
+
+   // Calculate optimal risk-reward ratio
+   double rr_ratio = CalculateOptimalRR(symbol, true, entry_price, fvg);
+
+   // Calculate take profit
+   double tp_price = CalculateTakeProfit(symbol, true, entry_price, sl_price, rr_ratio);
+   if (tp_price <= entry_price)
+   {
+      LogError(StringFormat("Invalid take profit calculated for %s", symbol));
+      return false;
+   }
+
+   // Calculate position size
+   double account_balance = AccountInfoDouble(ACCOUNT_BALANCE);
+   double risk_amount = CalculateRiskAmount(account_balance, RiskPercent);
+   double sl_distance = MathAbs(entry_price - sl_price);
+   double lot_size = CalculatePositionSize(symbol, risk_amount, sl_distance);
+
+   if (lot_size <= 0)
+   {
+      LogError(StringFormat("Invalid lot size calculated for %s", symbol));
+      return false;
+   }
+
+   // Execute the trade
+   bool trade_result = ExecuteBuyTrade(symbol, entry_price, sl_price, tp_price, lot_size);
+
+   if (trade_result)
+   {
+      LogTrade("BULLISH SETUP EXECUTED", symbol,
+               StringFormat("Entry: %.5f, SL: %.5f (%.1f pips), TP: %.5f (%.2f:1 RR), Lot: %.2f",
+                            entry_price, sl_price, sl_distance / CalculatePipValue(symbol),
+                            tp_price, rr_ratio, lot_size));
+   }
+
+   return trade_result;
+}
+
+bool ExecuteBearishTrade(string symbol, OrderBlock &ob, FairValueGap &fvg, LiquiditySweep &sweep)
+{
+   LogInfo(StringFormat("Executing bearish trade for %s", symbol));
+
+   // Validate trade conditions
+   if (!ValidateTradeConditions(symbol, false))
+   {
+      LogWarning(StringFormat("Trade conditions not met for bearish trade on %s", symbol));
+      return false;
+   }
+
+   // Calculate entry price (prefer FVG midpoint, fallback to OB zone)
+   double entry_price = 0.0;
+   if (fvg.top > 0 && fvg.bottom > 0)
+   {
+      entry_price = GetFVGMidpoint(fvg);
+      LogDebug(StringFormat("Using FVG midpoint for entry: %.5f", entry_price));
+   }
+   else
+   {
+      entry_price = (ob.high + ob.low) / 2.0; // OB midpoint
+      LogDebug(StringFormat("Using OB midpoint for entry: %.5f", entry_price));
+   }
+
+   // Calculate stop loss
+   double sl_price = CalculateStopLoss(symbol, false, ob, sweep);
+   if (sl_price <= 0)
+   {
+      LogError(StringFormat("Invalid stop loss calculated for %s", symbol));
+      return false;
+   }
+
+   // Calculate optimal risk-reward ratio
+   double rr_ratio = CalculateOptimalRR(symbol, false, entry_price, fvg);
+
+   // Calculate take profit
+   double tp_price = CalculateTakeProfit(symbol, false, entry_price, sl_price, rr_ratio);
+   if (tp_price >= entry_price)
+   {
+      LogError(StringFormat("Invalid take profit calculated for %s", symbol));
+      return false;
+   }
+
+   // Calculate position size
+   double account_balance = AccountInfoDouble(ACCOUNT_BALANCE);
+   double risk_amount = CalculateRiskAmount(account_balance, RiskPercent);
+   double sl_distance = MathAbs(entry_price - sl_price);
+   double lot_size = CalculatePositionSize(symbol, risk_amount, sl_distance);
+
+   if (lot_size <= 0)
+   {
+      LogError(StringFormat("Invalid lot size calculated for %s", symbol));
+      return false;
+   }
+
+   // Execute the trade
+   bool trade_result = ExecuteSellTrade(symbol, entry_price, sl_price, tp_price, lot_size);
+
+   if (trade_result)
+   {
+      LogTrade("BEARISH SETUP EXECUTED", symbol,
+               StringFormat("Entry: %.5f, SL: %.5f (%.1f pips), TP: %.5f (%.2f:1 RR), Lot: %.2f",
+                            entry_price, sl_price, sl_distance / CalculatePipValue(symbol),
+                            tp_price, rr_ratio, lot_size));
+   }
+
+   return trade_result;
+}
+
 //+------------------------------------------------------------------+
 //| Main trading logic processor                                     |
 //+------------------------------------------------------------------+
@@ -432,10 +1267,178 @@ void ProcessTradingLogic()
 
    // Check if trading is allowed in current session
    if (UseTimeFilter && GetCurrentSession() == "OFF HOURS")
+   {
+      LogDebug("Trading outside allowed session hours");
+      return;
+   }
+
+   // Check account status
+   if (!IsAccountTradingAllowed())
+   {
+      LogWarning("Account trading not allowed");
+      return;
+   }
+
+   // Manage existing positions first
+   ManageOpenPositions();
+
+   // Check if we can open new positions
+   if (PositionsTotal() >= MaxPositions)
+   {
+      LogDebug(StringFormat("Maximum positions reached (%d/%d)", PositionsTotal(), MaxPositions));
+      return;
+   }
+
+   // Process each symbol for trading opportunities
+   for (int i = 0; i < TotalSymbols; i++)
+   {
+      string symbol = SymbolsToTrade[i];
+
+      // Skip if symbol has reached maximum positions
+      if (CountPositionsForSymbol(symbol) >= MaxPositionsPerSymbol)
+      {
+         LogDebug(StringFormat("Maximum positions reached for %s (%d/%d)",
+                               symbol, CountPositionsForSymbol(symbol), MaxPositionsPerSymbol));
+         continue;
+      }
+
+      // Analyze entry opportunities for this symbol
+      if (AnalyzeEntryOpportunity(symbol, PERIOD_M1))
+      {
+         LogInfo(StringFormat("Entry opportunity processed for %s", symbol));
+      }
+   }
+
+   // Update multi-timeframe status for debugging
+   if (EnableDebugMode)
+   {
+      for (int i = 0; i < TotalSymbols; i++)
+      {
+         PrintMultiTimeframeStatus(SymbolsToTrade[i]);
+      }
+   }
+}
+
+bool IsAccountTradingAllowed()
+{
+   // Check if trading is allowed on the account
+   if (!AccountInfoInteger(ACCOUNT_TRADE_ALLOWED))
+   {
+      LogError("Trading not allowed on this account");
+      return false;
+   }
+
+   // Check if Expert Advisors are allowed
+   if (!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
+   {
+      LogError("Expert Advisor trading not allowed in terminal");
+      return false;
+   }
+
+   // Check account balance
+   double account_balance = AccountInfoDouble(ACCOUNT_BALANCE);
+   if (account_balance <= 0)
+   {
+      LogError("Invalid account balance");
+      return false;
+   }
+
+   // Check free margin
+   double free_margin = AccountInfoDouble(ACCOUNT_MARGIN_FREE);
+   if (free_margin <= 0)
+   {
+      LogError("No free margin available");
+      return false;
+   }
+
+   return true;
+}
+
+//+------------------------------------------------------------------+
+//| Position Management Functions                                    |
+//+------------------------------------------------------------------+
+void ManageOpenPositions()
+{
+   for (int i = PositionsTotal() - 1; i >= 0; i--)
+   {
+      if (position.SelectByIndex(i))
+      {
+         // Only manage positions opened by this EA
+         if (position.Magic() != trade.RequestMagic())
+            continue;
+
+         string symbol = position.Symbol();
+         ulong ticket = position.Ticket();
+
+         // Check for position management opportunities
+         if (ShouldUpdatePosition(ticket))
+         {
+            UpdatePositionManagement(ticket);
+         }
+      }
+   }
+}
+
+bool ShouldUpdatePosition(ulong ticket)
+{
+   if (!position.SelectByTicket(ticket))
+      return false;
+
+   // Check if position is in profit for trailing stop
+   double current_profit = position.Profit();
+   double position_open_price = position.PriceOpen();
+   double current_price = position.Type() == POSITION_TYPE_BUY ? SymbolInfoDouble(position.Symbol(), SYMBOL_BID) : SymbolInfoDouble(position.Symbol(), SYMBOL_ASK);
+
+   // Simple break-even logic
+   double pip_value = CalculatePipValue(position.Symbol());
+   double profit_pips = MathAbs(current_price - position_open_price) / pip_value;
+
+   // Move to break-even when in 20+ pips profit
+   if (profit_pips >= 20.0)
+   {
+      double current_sl = position.StopLoss();
+      double break_even_price = position_open_price;
+
+      if (position.Type() == POSITION_TYPE_BUY)
+      {
+         if (current_sl < break_even_price)
+         {
+            LogInfo(StringFormat("Moving position %llu to break-even", ticket));
+            return true;
+         }
+      }
+      else
+      {
+         if (current_sl > break_even_price)
+         {
+            LogInfo(StringFormat("Moving position %llu to break-even", ticket));
+            return true;
+         }
+      }
+   }
+
+   return false;
+}
+
+void UpdatePositionManagement(ulong ticket)
+{
+   if (!position.SelectByTicket(ticket))
       return;
 
-   // Main trading logic will be implemented here
-   // This is where we'll call all the market structure analysis functions
+   double new_sl = position.PriceOpen(); // Break-even
+   double current_tp = position.TakeProfit();
+
+   // Modify position to break-even
+   if (trade.PositionModify(ticket, new_sl, current_tp))
+   {
+      LogTrade("POSITION MODIFIED", position.Symbol(),
+               StringFormat("Ticket: %llu moved to break-even at %.5f", ticket, new_sl));
+   }
+   else
+   {
+      int error_code = trade.ResultRetcode();
+      HandleTradeError(error_code, "Position Modification");
+   }
 }
 
 //+------------------------------------------------------------------+