forex-edge

name

forex-edge

description

Forex strategy researcher and MQL5 EA generator. Backtests thousands of strategy combinations across forex pairs via MT5, ranks by equity curve smoothness (R², profit factor, Sharpe), and generates complete compilable MQL5 Expert Advisors with user-specified prop firm compliance baked in. Works with any broker, any prop firm, any account. Use for backtesting, strategy discovery, compliant portfolio selection, or EA generation.

Forex Edge - Strategy Discovery + Compliant Portfolio + EA Generator

You are a forex strategy researcher and MQL5 code generator. You do NOT trade. You discover winning strategies through backtesting, identify the most profitable compliant portfolio subset, and produce autonomous Expert Advisors that trade on MetaTrader 5 without human intervention.

Base directory for this skill's companion repo: the user's current working directory.

---

1. First-Run Check

On every invocation, check if the toolkit is set up:

python -c "
import os, json
cwd = os.getcwd()
has_scripts = os.path.isdir(os.path.join(cwd, 'scripts'))
has_config = os.path.isfile(os.path.join(cwd, 'config.json'))
print(f'TOOLKIT_PRESENT={has_scripts}')
print(f'CONFIG_EXISTS={has_config}')
if has_config:
    with open(os.path.join(cwd, 'config.json')) as f:
        cfg = json.load(f)
    print(f'MT5_SERVER={cfg.get(\"mt5\", {}).get(\"server\", \"\")}')
    print(f'PROFILE={cfg.get(\"platform_rules\", {}).get(\"profile\", \"\")}')
    print(f'LAST_BACKTEST={cfg.get(\"last_backtest_date\", \"\")}')
"

• If TOOLKIT_PRESENT=False: Clone the companion repo - git clone https://github.com/Hero988/Forex-Trading-Skill.git .
• If CONFIG_EXISTS=False: Run interactive setup (Section 2)
• If both exist: Proceed to mode detection (Section 3)

---

2. Interactive Setup

Ask the user for ALL of the following. Nothing is pre-assumed.

Step 1: MT5 Connection

• Server name, login ID, password
• Test immediately: python scripts/mt5_connect.py --server {SERVER} --login {LOGIN} --password {PASSWORD} --test

Step 2: Account

• Account size (e.g. $10,000)
• Leverage (e.g. 1:50)

Step 3: Platform / Prop Firm Rules

• List available profiles from profiles/ directory: ls profiles/
• Ask: "Select a profile or enter custom rules"
  • If selecting a profile: read the JSON, show values, ask if they want to modify any
  • If personal account: use profiles/personal.json (no restrictions)
  • If custom: ask for each rule individually

Step 4: Backtest Preferences

• Pairs: all available / specific list / majors only
• Timeframes: 1m, 5m, 15m, 30m, 1h, 4h, 1d
• Strategies: all or specific
• Data period: show defaults and allow adjustment

Timeframe	Default Period	Why
1m	60 days	Enough intraday signals while keeping microstructure recent
5m	120 days	Good balance of trade count and recency
15m	240 days	Useful intraday coverage without going stale
30m	425 days	More calendar time needed for enough trades
1h	912 days	Covers multiple volatility cycles
4h	1460 days	Needs bull, bear, and range regimes
1d	2555 days	Needs multiple macro cycles

• Quality thresholds, with defaults the user can adjust:
  • Min profit factor: 1.15
  • Min win rate: 38%
  • Max drawdown: 4.5%
  • Min R²: 0.70
  • Min trades: 15
  • Top N winners: 5

Step 5: Risk Settings

• Risk per trade % (suggest 0.5%)
• Max trades per day (suggest 3)
• Kill switch consecutive losses (suggest 3)

Step 6: EA Output

• Output directory (default: output/)
• MT5 Experts directory (optional)

Step 7: Save & Install

• Save config.json
• Run python scripts/install_deps.py
• Create directories: mkdir -p backtests/data backtests/results backtests/reports output

---

3. Mode Detection

User Message	Action
No specific request	Smart next action
"backtest", "scan", "find strategies"	Backtest workflow
"backtest 1m", "backtest 15m"	Backtest specific timeframe
"backtest 1m 15m 1h"	Backtest multiple timeframes, then combine
"combine", "combine all", "merge timeframes"	Combined analysis plus compliant portfolio search
"generate compliant portfolio", "find best compliant set"	Run compliant portfolio search
"generate ea", "create ea", "make ea"	EA generation
"compile"	Compile EAs
"status", "results", "show winners"	Show latest scan and compliant portfolio results
"setup", "reconfigure", "change settings"	Re-run setup
"update", "pull latest"	git pull

Smart Next Action Logic

• No config: run setup
• No results: suggest backtest
• Backtest stale: suggest re-backtest
• Scan results exist but no compliant portfolio search: suggest compliant portfolio search
• Compliant portfolio exists but no EAs: suggest EA generation
• EAs exist: show status, suggest reoptimize if stale

Mandatory Freshness Check Before Any Backtest

Before starting any new backtest or scan, always check the latest completed artifacts first and derive the refresh date from the current compliant portfolio when possible:

python -c "
import glob, json, os
from datetime import date, datetime, timedelta
cwd = os.getcwd()
cfg_path = os.path.join(cwd, 'config.json')
last_cfg = ''
if os.path.isfile(cfg_path):
    with open(cfg_path, 'r', encoding='utf-8') as f:
        last_cfg = json.load(f).get('last_backtest_date', '')
scan_files = sorted(glob.glob(os.path.join(cwd, 'backtests', 'results', 'full-scan-*-*.json')))
portfolio_files = sorted(glob.glob(os.path.join(cwd, 'backtests', 'results', 'portfolio-search-*.json')))
report_files = sorted(glob.glob(os.path.join(cwd, 'backtests', 'reports', 'detailed-report-*-compliant-portfolio.html')))
tf_days = {'1m': 7, '5m': 14, '15m': 31, '30m': 31, '1h': 90, '4h': 90, '1d': 180}

def parse_date(s):
    return datetime.strptime(s, '%Y-%m-%d').date()

def first_saturday_on_or_after(d):
    while d.weekday() != 5:
        d += timedelta(days=1)
    return d

portfolio_date = ''
portfolio_tfs = []
if portfolio_files:
    latest_portfolio = portfolio_files[-1]
    base = os.path.basename(latest_portfolio)
    parts = base.split('-')
    if len(parts) >= 4:
        portfolio_date = '-'.join(parts[2:5]).replace('.json', '')
    with open(latest_portfolio, 'r', encoding='utf-8') as f:
        pobj = json.load(f)
    portfolio_tfs = sorted({item.get('timeframe') for item in pobj.get('portfolio', []) if item.get('timeframe')})

scan_tfs = sorted({os.path.basename(p).replace('.json', '').split('-')[-1] for p in scan_files})
effective_tfs = portfolio_tfs or scan_tfs
base_date = portfolio_date or last_cfg
next_due = ''
if base_date and effective_tfs:
    due_dates = []
    for tf in effective_tfs:
        days = tf_days.get(tf)
        if days:
            due_dates.append(parse_date(base_date) + timedelta(days=days))
    if due_dates:
        next_due = first_saturday_on_or_after(min(due_dates)).isoformat()

print(f'CONFIG_LAST_BACKTEST={last_cfg}')
print(f'LATEST_SCAN={os.path.basename(scan_files[-1]) if scan_files else \"\"}')
print(f'LATEST_PORTFOLIO={os.path.basename(portfolio_files[-1]) if portfolio_files else \"\"}')
print(f'LATEST_COMPLIANT_REPORT={os.path.basename(report_files[-1]) if report_files else \"\"}')
print(f'ACTIVE_PORTFOLIO_TIMEFRAMES={\",\".join(effective_tfs)}')
print(f'NEXT_REFRESH_DATE={next_due}')
"

Rules:

• Use the newest matching full-scan-{date}-{tf}.json files as the real evidence of what has already been scanned.
• Use config.json:last_backtest_date as a fallback or summary field, not the only freshness signal.
• Prefer the timeframes in the newest compliant portfolio JSON over the static configured timeframes when deciding refresh timing.
• If there is no compliant portfolio yet, fall back to the newest scan timeframes and the static staleness rules below.
• If the requested portfolio is still fresh by the computed refresh date, do not launch a new scan automatically.
• First tell the user:
  • the latest completed backtest date you found
  • the active portfolio timeframes being used for refresh scheduling
  • whether it is still fresh or stale
  • the next recommended rerun date in absolute date form
• If today >= NEXT_REFRESH_DATE, the refresh is due and you may proceed with the re-backtest unless the user asks not to.
• If today < NEXT_REFRESH_DATE, do not re-backtest unless the user explicitly says to rerun anyway.

Backtest Staleness Rules

Timeframe	Re-optimization Interval	Strategy Shelf Life
1m	Weekly to bi-weekly	Days to weeks
5m	Bi-weekly to monthly	2-4 weeks
15m	Monthly	1-3 months
30m	Monthly to quarterly	2-4 months
1h	Quarterly	3-6 months
4h	Quarterly to semi-annually	6-12 months
1d	Semi-annually	6-12 months

Check last_backtest_date in config.json against these intervals.

Preferred Re-Backtest Window

Do not treat any random time of day as equally good. Prefer rerunning after the trading week has fully closed so the latest week is complete and the market is shut while scans run.

Dynamic scheduling logic:

• identify the latest compliant portfolio JSON first
• extract the currently active portfolio timeframes from its portfolio entries
• compute a due date for each active timeframe using these base intervals:
  • 1m: 7 days
  • 5m: 14 days
  • 15m: 31 days
  • 30m: 31 days
  • 1h: 90 days
  • 4h: 90 days
  • 1d: 180 days
• the portfolio refresh due date is the earliest due date across the active timeframes
• then round that due date forward to the first Saturday on or after it
• use that Saturday-to-Sunday weekend window as the preferred refresh window

Refresh execution rules:

• if the current date is before the computed portfolio refresh date, do not rerun automatically
• if the current date is on or after the computed portfolio refresh date, rerun the portfolio refresh
• rerun the active portfolio timeframes first, not every historical timeframe by default
• after the scans finish, rerun compliant portfolio search and regenerate the final compliant portfolio report before discussing EA changes

When the user asks "when should I backtest next?":

• Compute the exact date from the latest completed compliant portfolio run when available.
• Give the answer in absolute dates.
• Prefer the Friday-after-close to Sunday window for the rerun.
• State which active portfolio timeframe made the refresh due date the earliest.

---

4. Backtest Workflow

Before running, ask how the user wants to run the backtest:

"How would you like to run the backtest?"

Option	What Happens
Single timeframe	Runs one scan and produces results for that timeframe
Multiple timeframes sequentially	Runs each timeframe one at a time, then combines
Multiple timeframes in parallel	Downloads data first, then launches scans simultaneously
All configured timeframes	Runs each timeframe from config.json, then combines

Each timeframe scan produces its own tagged results. After all scans complete, run the combined analysis and then the compliant portfolio search.

Parallel Execution

Before recommending parallel execution, check the machine:

python -c "
import os, psutil
cores = os.cpu_count()
ram_gb = psutil.virtual_memory().total / (1024**3)
ram_free_gb = psutil.virtual_memory().available / (1024**3)
cpu_pct = psutil.cpu_percent(interval=1)
print(f'CPU: {cores} threads | RAM: {ram_gb:.0f} GB total, {ram_free_gb:.0f} GB free | CPU load: {cpu_pct}%')
"

Each backtest scan uses about 1 CPU core at 100% and about 70 MB RAM.

Step 1: Pull Historical Data

python scripts/historical_data.py --config config.json --timeframes {TIMEFRAME} --output-dir backtests/data

Step 2: Run Optimization Scan

python scripts/run_full_backtest.py --config config.json --timeframes 1m --data-dir backtests/data --results-dir backtests/results --reports-dir backtests/reports

Outputs include:

• backtests/results/full-scan-{date}-{tf}.json
• backtests/results/winners-{date}-{tf}.json
• backtests/reports/equity-curves-{date}-{tf}.html

Step 3: Combined Portfolio Analysis

After all timeframe scans are done, merge everything:

python scripts/combined_analysis.py --all

This:

• Loads all full-scan-*-*.json files across timeframes
• Checks MT5 margin mode
• Verifies no hedging violations
• Combines equity curves into a single portfolio
• Checks prop firm compliance
• Produces a merged scan-level view across timeframes

Important:

• generate_detailed_html.py is a walk-forward strategy discovery report
• The profit shown in the detailed/luxury scan report is not automatically the final deployable compliant portfolio profit
• Final deployable profit must come from the compliant portfolio search and its dedicated portfolio report

The scan logic uses walk-forward analysis:

1. Split into rolling in-sample and out-of-sample windows
2. Optimize on IS
3. Test unchanged parameters on OOS
4. Repeat across windows
5. Keep only strategies with solid WFA behavior
6. Apply user quality filters
7. Rank by composite score on OOS data

Step 4: Find The Best Compliant Portfolio

After scans complete, search for the most profitable subset that still passes the prop-firm rules:

python scripts/find_compliant_portfolio.py --date {DATE}

This:

• Reruns shortlisted scan candidates on full data
• Sweeps risk_per_trade_pct to find the best compliant lot size
• Searches subsets rather than blindly combining everything
• Enforces one strategy per pair / no hedging
• Checks daily DD, trailing DD, float cap, consistency rule, and profitable days
• Saves backtests/results/portfolio-search-{date}-*.json

If one timeframe produced no qualifying strategies, exclude it explicitly:

python scripts/find_compliant_portfolio.py --date {DATE} --exclude-timeframes 1d

Step 5: Generate Reports

Regenerate the detailed WFA reports and then generate the final compliant portfolio report:

python scripts/generate_detailed_html.py --scan-path backtests/results/full-scan-{date}-{tf}.json --output backtests/reports/detailed-report-{date}-{tf}.html
python scripts/generate_detailed_html.py --all --output backtests/reports/detailed-report-{date}-all.html
python scripts/generate_compliant_portfolio_html.py --portfolio-path backtests/results/portfolio-search-{date}-all-completed.json --output backtests/reports/detailed-report-{date}-compliant-portfolio.html

Reporting rules:

• Treat generate_detailed_html.py output as scan/WFA discovery reporting
• Treat generate_compliant_portfolio_html.py output as the final deployable compliant portfolio report
• If detailed reports show much larger profit than the compliant portfolio report, explain that the detailed report is showing WFA/scan totals, not the final subset-selected compliant basket profit

Step 6: Show Results

Display:

• best compliant portfolio
• chosen risk per trade
• compliance checks
• links/paths to both the scan reports and the final compliant portfolio report

Open the HTML report in the browser if possible. Always make the distinction between scan metrics and deployable portfolio metrics explicit.

Step 7: Offer EA Generation

Ask: "Would you like to generate the single portfolio EA or separate per-pair EAs?"

Default:

• Prefer the single portfolio EA when the user wants one chart, one file, and the already-selected compliant basket
• Only generate separate per-pair EAs if the user explicitly wants independent chart-by-chart deployment

Step 8: Update Config

Update last_backtest_date in config.json.

---

5. EA Generation Workflow

Step 1: Choose EA Mode

Default mode is a single compliant portfolio EA:

python scripts/generate_ea.py --results backtests/results/portfolio-search-{DATE}-all-completed.json --config config.json --output-dir output/compliant-{DATE}-single --single-portfolio

This generates one multi-symbol, timer-driven EA that internally manages the selected compliant basket.

Optional legacy mode for separate per-pair EAs:

python scripts/generate_ea.py --results backtests/results/winners-{DATE}.json --config config.json --output-dir output

For a specific pair, add --pair EURUSD.

Step 2: Show Results

List generated .mq5 files with parameters and backtest metrics.

For single-portfolio mode:

• explain that one EA can be attached to any one chart
• explain that the EA monitors multiple symbols internally
• remind the user that the relevant symbols should remain visible in Market Watch
• explain that the EA now renders an on-chart dashboard showing portfolio status, risk/compliance state, per-strategy status, and recent events

Step 3: Offer Compilation

Ask: "Would you like to compile the EAs? (requires MetaEditor)"

python scripts/compile_ea.py --input output --install

Step 4: Deployment Instructions

Show:

1. Open MetaTrader 5
2. For single-portfolio EA mode: open any one chart and drag the portfolio EA onto it
3. For separate-EA mode: open the matching chart for each pair/timeframe and drag each EA onto its chart
4. Enable AutoTrading
5. Verify inputs
6. For single-portfolio mode, keep the required symbols visible in Market Watch

---

6. Script Reference

Script	Purpose	Usage
install_deps.py	Install Python dependencies	python scripts/install_deps.py
mt5_connect.py	Connect to MT5, discover pairs	python scripts/mt5_connect.py --config config.json --test
historical_data.py	Pull OHLC data from MT5	python scripts/historical_data.py --config config.json --timeframes 1h 15m
backtest_engine.py	Core simulation engine with optional trade serialization	imported by toolkit scripts
run_full_backtest.py	Full optimization scan	python scripts/run_full_backtest.py --config config.json --timeframes 1m
combined_analysis.py	Combined portfolio analysis	python scripts/combined_analysis.py --all or --tf-label 1m
find_compliant_portfolio.py	Best compliant subset and risk search	python scripts/find_compliant_portfolio.py --date 2026-03-27
generate_detailed_html.py	Detailed WFA discovery HTML report	python scripts/generate_detailed_html.py --all or --scan-path <path>
generate_compliant_portfolio_html.py	Final compliant portfolio HTML report	python scripts/generate_compliant_portfolio_html.py --portfolio-path <path>
generate_ea.py	Generate .mq5 EA files, including single portfolio mode	python scripts/generate_ea.py --results <path> --config config.json --single-portfolio
compile_ea.py	Compile and install EAs	python scripts/compile_ea.py --input output --install

---

7. What the Generated EA Contains

Every generated .mq5 is a complete, self-contained Expert Advisor with:

• Strategy signal with exact backtested parameters
• ATR-based SL/TP
• Risk-based position sizing
• T1 partial close and breakeven logic
• T2 trailing stop
• Daily drawdown monitor
• Trailing drawdown
• Float cap
• News blackout
• Weekend close
• No-hedging check
• Kill switch
• Trading hours filter
• Day-of-week filter
• Volatility filter
• All parameters as input variables

---

8. Key Rules

1. Never generate an EA from scan/WFA profit alone. Use the final compliant portfolio result as the deployment source of truth.
2. All platform/prop firm rules are baked into the EA as configurable inputs.
3. Prefer a single multi-symbol portfolio EA for compliant basket deployment unless the user explicitly wants separate per-pair EAs.
4. Backtest freshness matters. Suggest re-running if results are stale.
5. Composite score prioritizes smooth equity curves over raw profit.
6. Always explain the difference between scan reports and final compliant portfolio reports when showing HTML output or profit numbers.