Added API

_scan_coins.py

@@ -45,18 +45,18 @@ COINS = ['TIA', 'LINK', 'NEAR', 'INJ', 'ARB', 'AVAX', 'SOL', 'BTC', 'ETH',
 
 # ── Qualification thresholds (minimum to be considered at all) ────────────────
 Q = {
-    'strategy_conservative': dict(min_ret=2.0,  min_pf=1.10, max_dd=12.0),
-    'strategy_hype':         dict(min_ret=3.0,  min_pf=1.15, max_dd=99.0),
-    'strategy_scalp':        dict(min_ret=1.0,  min_pf=1.05, max_dd=15.0),
-    'strategy_ml_auto':      dict(min_ret=-5.0, min_pf=0.90, max_dd=25.0),
+    'strategy_conservative': dict(min_ret=8.0,  min_pf=1.40, max_dd=12.0),
+    'strategy_hype':         dict(min_ret=8.0,  min_pf=1.30, max_dd=99.0),
+    'strategy_scalp':        dict(min_ret=5.0,  min_pf=1.20, max_dd=12.0),
+    'strategy_ml_auto':      dict(min_ret=8.0, min_pf=1.50, max_dd=15.0),
 }
 
 # ── Capital allocation per strategy (must sum to 1.0) ────────────────────────
 CAPITAL = {
-    'strategy_hype':         0.33,
-    'strategy_conservative': 0.33,
-    'strategy_scalp':        0.34,
-    'strategy_ml_auto':      0.50,   # 2 slots = 1.0 total
+    'strategy_hype':         0.40,
+    'strategy_conservative': 0.40,
+    'strategy_scalp':        0.00,   # Disabled (poor recent performance)
+    'strategy_ml_auto':      0.20,   # 2 slots = 0.10 each
 }
 
 
@@ -254,7 +254,7 @@ if not slots:
 #    ML slots share equally from the ML budget.
 # ─────────────────────────────────────────────────────────────────────────────
 ml_slot_count = sum(1 for s in slots if s['strategy'] == 'strategy_ml_auto')
-ml_per_slot   = round(CAPITAL['strategy_ml_auto'], 4)
+ml_per_slot   = round(CAPITAL['strategy_ml_auto'] / max(1, ml_slot_count), 4)
 
 final_slots = []
 for s in slots:

autonomous_bot.py

@@ -19,6 +19,7 @@ from collections import deque
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta, timezone
 from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 import pandas as pd
@@ -1133,10 +1134,11 @@ def main():
 
     bot = AutonomousTradingBot(bot_config, slots)
 
-    # ── Health-check server (required by Hugging Face Spaces) ─────────────
+    # ── API + Health-check server (required by Hugging Face Spaces) ─────────────
     # HF Docker Spaces expect an HTTP listener on port 7860 or the
     # workload is killed after 30 min as "unhealthy".
-    _start_health_server()
+    # Also serves API endpoints for monitoring from Telegram
+    _start_health_server(bot_instance=bot)
 
     if args.live:
         pk = os.getenv("HYPERLIQUID_PRIVATE_KEY")
@@ -1166,8 +1168,8 @@ def main():
                   f"{r.total_return_pct:>7.2f} | {r.profit_factor:>4.2f} | {r.max_drawdown_pct:>6.2f}")
 
 
-def _start_health_server(port: int = 7860):
-    """Start a minimal HTTP server so Hugging Face Spaces health checks pass."""
+def _start_health_server(port: int = 7860, bot_instance: Optional[AutonomousBot] = None):
+    """Start HTTP server with health check + API endpoints (for HuggingFace Spaces)."""
     _start_time = datetime.now(timezone.utc)
 
     def _health_body() -> bytes:
@@ -1178,10 +1180,96 @@ def _start_health_server(port: int = 7860):
             "ts": datetime.now(timezone.utc).isoformat(),
         }).encode()
 
+    def _get_api_response(path: str) -> tuple[int, bytes]:
+        """Route API requests and return (status_code, response_body)."""
+        if path == "/api/status":
+            try:
+                data = {
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "bot_active": True,
+                    "slots": []
+                }
+                if bot_instance:
+                    for slot in bot_instance.slots:
+                        data["slots"].append({
+                            "strategy": slot.strategy_name,
+                            "coin": slot.coin,
+                            "timeframe": slot.timeframe,
+                            "capital_fraction": slot.capital_frac,
+                        })
+                return 200, json.dumps(data).encode()
+            except Exception as e:
+                return 500, json.dumps({"error": str(e)}).encode()
+
+        elif path == "/api/ml/progress":
+            try:
+                from pathlib import Path
+                memory_dir = Path(__file__).parent / "reports"
+                data = {"coins": {}, "summary": {"total_trades": 0, "coins_tracked": 0}}
+
+                for path_obj in memory_dir.glob("ml_auto_memory_*.jsonl"):
+                    coin = path_obj.stem.replace("ml_auto_memory_", "")
+                    try:
+                        with open(path_obj) as f:
+                            records = [json.loads(line) for line in f if line.strip()]
+                        if not records:
+                            continue
+
+                        trades = len(records)
+                        wins = sum(1 for r in records if r.get("won"))
+                        win_rate = wins / trades if trades else 0
+
+                        recent = records[-20:] if len(records) > 20 else records
+                        recent_wins = sum(1 for r in recent if r.get("won"))
+                        recent_wr = recent_wins / len(recent) if recent else 0
+
+                        if recent_wr > win_rate + 0.05:
+                            trend = "🟢 IMPROVING"
+                        elif abs(recent_wr - win_rate) <= 0.05:
+                            trend = "🟡 STABLE"
+                        else:
+                            trend = "🔴 DEGRADING"
+
+                        data["coins"][coin] = {
+                            "total_trades": trades,
+                            "win_rate": round(win_rate * 100, 1),
+                            "recent_win_rate": round(recent_wr * 100, 1),
+                            "trend": trend,
+                        }
+                        data["summary"]["total_trades"] += trades
+                        data["summary"]["coins_tracked"] += 1
+                    except Exception as e:
+                        logger.debug(f"Error analyzing {coin}: {e}")
+
+                return 200, json.dumps(data).encode()
+            except Exception as e:
+                return 500, json.dumps({"error": str(e)}).encode()
+
+        elif path == "/api/config":
+            try:
+                config_path = Path(__file__).parent / "bot_config.json"
+                if config_path.exists():
+                    with open(config_path) as f:
+                        config = json.load(f)
+                    return 200, json.dumps(config).encode()
+                return 404, json.dumps({"error": "Config not found"}).encode()
+            except Exception as e:
+                return 500, json.dumps({"error": str(e)}).encode()
+
+        else:
+            return 404, json.dumps({"error": "Endpoint not found"}).encode()
+
     class _Handler(BaseHTTPRequestHandler):
         def do_GET(self):
-            body = _health_body()
-            self.send_response(200)
+            path = self.path.split("?")[0]  # Remove query string
+
+            if path.startswith("/api/"):
+                status, body = _get_api_response(path)
+            else:
+                # Health check for root path
+                status, body = 200, _health_body()
+
+            self.send_response(status)
             self.send_header("Content-Type", "application/json")
             self.send_header("Content-Length", str(len(body)))
             self.end_headers()
@@ -1200,12 +1288,16 @@ def _start_health_server(port: int = 7860):
     def _serve():
         try:
             server = HTTPServer(("0.0.0.0", port), _Handler)
-            logger.info(f"Health-check server listening on port {port}")
+            logger.info(f"Bot API server listening on port {port}")
+            logger.info(f"  /              - Health check")
+            logger.info(f"  /api/status    - Bot status & slots")
+            logger.info(f"  /api/ml/progress - ML learning stats")
+            logger.info(f"  /api/config    - Bot configuration")
             server.serve_forever()
         except Exception as e:
-            logger.warning(f"Health-check server failed: {e}")
+            logger.warning(f"API server failed: {e}")
 
-    t = threading.Thread(target=_serve, daemon=True, name="health-server")
+    t = threading.Thread(target=_serve, daemon=True, name="api-server")
     t.start()
 
 

bot_config.json

@@ -1,5 +1,5 @@
 {
-  "generated_at": "2026-05-27T01:44:42.822174+00:00",
+  "generated_at": "2026-05-28T02:26:19.496078+00:00",
   "scan_days": 180,
   "ml_backtest_seed_path": "/Users/daniel.a/hyperliquid-bot/reports/ml_auto_backtest_seed.json",
   "slots": [
@@ -7,31 +7,25 @@
       "strategy": "strategy_hype",
       "coin": "TIA",
       "timeframe": "1h",
-      "capital_frac": 0.33
+      "capital_frac": 0.4
     },
     {
       "strategy": "strategy_conservative",
       "coin": "WIF",
       "timeframe": "1h",
-      "capital_frac": 0.33
-    },
-    {
-      "strategy": "strategy_scalp",
-      "coin": "ARB",
-      "timeframe": "30m",
-      "capital_frac": 0.17
+      "capital_frac": 0.4
     },
     {
       "strategy": "strategy_ml_auto",
       "coin": "SUI",
       "timeframe": "1h",
-      "capital_frac": 0.085
+      "capital_frac": 0.1
     },
     {
       "strategy": "strategy_ml_auto",
       "coin": "NEAR",
       "timeframe": "1h",
-      "capital_frac": 0.085
+      "capital_frac": 0.1
     }
   ]
 }

investigate_config.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""Investigate what changed with scalp and ml_auto strategies."""
+
+import json
+import subprocess
+from pathlib import Path
+
+# Load current config
+config_path = Path("bot_config.json")
+with open(config_path) as f:
+    current_config = json.load(f)
+
+print("=" * 70)
+print("CURRENT BOT CONFIG")
+print("=" * 70)
+print(json.dumps(current_config, indent=2))
+
+print("\n" + "=" * 70)
+print("GIT HISTORY - Recent backtest runs")
+print("=" * 70)
+
+# Get recent commits that touch bot_config
+result = subprocess.run(
+    ["git", "log", "--oneline", "-10", "bot_config.json"],
+    capture_output=True, text=True
+)
+print(result.stdout)
+
+print("\n" + "=" * 70)
+print("Configuration from 2 commits ago (before recent changes)")
+print("=" * 70)
+
+result = subprocess.run(
+    ["git", "show", "HEAD~2:bot_config.json"],
+    capture_output=True, text=True
+)
+if result.returncode == 0:
+    print(result.stdout)
+else:
+    print("Could not retrieve historical config")
+
+print("\n" + "=" * 70)
+print("Analysis: Why did scalp and ml_auto appear in current config?")
+print("=" * 70)
+print("""
+Based on the conversation summary:
+- Scalp was removed in commit 0936622 ("removing scalp")
+- But now it's back in the config with ARB 30m
+
+Possible explanations:
+1. _scan_coins.py was run and re-added scalp with ARB
+2. User manually added slots back
+3. Configuration was reset
+
+Let's check _scan_coins.py to see if it adds scalp...
+""")
+

optimize_ml_coins.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""
+ML Auto Coin Optimizer - Find the best coins for ML strategy.
+
+Backtests ML Auto on many coins to find:
+  • Highest return
+  • Best risk-adjusted (Sharpe)
+  • Most consistent (lowest drawdown)
+  • Best fit for ensemble learning
+"""
+
+import sys
+import importlib
+import json
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+import pandas as pd
+from hbot import HyperliquidAPI
+from backtest import StrategyBacktester
+
+api = HyperliquidAPI(verify_ssl=False)
+
+# Test on these coins (sorted by 180d volume/liquidity)
+TEST_COINS = [
+    'BTC', 'ETH', 'SOL',          # Majors
+    'TIA', 'ARB', 'AVAX', 'OP',   # L1s/L2s
+    'DOGE', 'WIF', 'LINK',        # Alts with good volume
+    'INJ', 'SUI', 'NEAR', 'APT',  # High-beta ecosystem
+    'DOGE', 'LINK', 'AVAX',       # Diversified
+]
+
+def fetch_candles(coin: str, timeframe: str = "1h", days: int = 180) -> pd.DataFrame:
+    """Fetch historical candles."""
+    try:
+        start_ms = int((datetime.now(timezone.utc) - timedelta(days=days)).timestamp() * 1000)
+        raw = api.get_candles(coin, timeframe, start_ms)
+
+        if not raw:
+            return pd.DataFrame()
+
+        rows = [
+            {
+                "timestamp": pd.to_datetime(int(x["t"]), unit="ms", utc=True),
+                "open": float(x["o"]),
+                "high": float(x["h"]),
+                "low": float(x["l"]),
+                "close": float(x["c"]),
+                "volume": float(x["v"]),
+            }
+            for x in raw
+        ]
+        df = (
+            pd.DataFrame(rows)
+            .drop_duplicates("timestamp")
+            .sort_values("timestamp")
+            .set_index("timestamp")
+        )
+        return df
+    except Exception as e:
+        print(f"      Error fetching {coin}: {e}")
+        return pd.DataFrame()
+
+
+def backtest_ml_on_coin(coin: str, days: int = 180) -> dict:
+    """Backtest ML Auto strategy on a single coin."""
+
+    # Import fresh
+    for mod in ["strategy_ml_auto", "backtest", "strategy"]:
+        sys.modules.pop(mod, None)
+
+    import backtest as bt_mod
+    from strategy_ml_auto import StrategyEngine
+
+    # Fetch data
+    df = fetch_candles(coin, "1h", days)
+    if df.empty or len(df) < 100:
+        return None
+
+    # Backtest
+    try:
+        strategy = StrategyEngine({"use_regime_filter": False, "coin": coin})
+        tester = StrategyBacktester(
+            strategy=strategy,
+            starting_capital=1000.0,
+            fee_bps=4.32,
+            slippage_bps=1.0,
+            position_risk_fraction=0.005,
+            strategy_name="strategy_ml_auto",
+        )
+        result = tester.backtest(df, coin, "1h")
+        return {
+            "coin": coin,
+            "trades": result.trades,
+            "win_rate": result.win_rate * 100,
+            "return_pct": result.total_return_pct,
+            "profit_factor": result.profit_factor,
+            "sharpe": result.sharpe_ratio,
+            "max_dd": result.max_drawdown_pct,
+            "fees": result.total_fees_paid,
+        }
+    except Exception as e:
+        print(f"    Backtest failed for {coin}: {e}")
+        return None
+
+
+def main():
+    print("\n" + "="*90)
+    print("  ML AUTO COIN OPTIMIZER — Finding Best ML Coins")
+    print("="*90)
+    print("  Testing 180-day backtest on 1h timeframe across multiple coins...\n")
+
+    results = []
+
+    for i, coin in enumerate(sorted(set(TEST_COINS)), 1):
+        print(f"  [{i:2d}/{len(set(TEST_COINS))}] Testing {coin:6s} ... ", end="", flush=True)
+
+        result = backtest_ml_on_coin(coin, days=180)
+
+        if result is None or result["trades"] == 0:
+            print("✗ (no trades)")
+            continue
+
+        print(f"✓ {result['trades']:3d} trades | Return: {result['return_pct']:+6.2f}% | "
+              f"WR: {result['win_rate']:5.1f}% | Sharpe: {result['sharpe']:6.2f}")
+
+        results.append(result)
+
+    if not results:
+        print("\n  ⚠️  No profitable strategies found!\n")
+        return
+
+    # Sort by composite score
+    results_sorted = sorted(
+        results,
+        key=lambda x: x["return_pct"] * 0.5 + x["sharpe"] * 20 - x["max_dd"] * 0.3,
+        reverse=True
+    )
+
+    print("\n" + "="*90)
+    print("  TOP ML AUTO COINS (sorted by composite score)")
+    print("="*90)
+    print(f"{'Rank':<6} {'Coin':<6} {'Trades':<8} {'Return%':<10} {'Win%':<8} "
+          f"{'PF':<6} {'Sharpe':<8} {'DD%':<7} {'Score':<8}")
+    print("─" * 90)
+
+    for i, r in enumerate(results_sorted[:15], 1):
+        score = r["return_pct"] * 0.5 + r["sharpe"] * 20 - r["max_dd"] * 0.3
+
+        # Rating
+        if r["return_pct"] >= 15:
+            rating = "🥇"
+        elif r["return_pct"] >= 8:
+            rating = "🥈"
+        elif r["return_pct"] >= 3:
+            rating = "🥉"
+        else:
+            rating = " "
+
+        print(f"{i:<6} {r['coin']:<6} {r['trades']:<8} {r['return_pct']:>8.2f}%  "
+              f"{r['win_rate']:>6.1f}%  {r['profit_factor']:>5.2f}  {r['sharpe']:>7.2f}  "
+              f"{r['max_dd']:>6.2f}%  {score:>7.2f} {rating}")
+
+    # Analysis
+    print("\n" + "="*90)
+    print("  ANALYSIS")
+    print("="*90)
+
+    profitable = [r for r in results if r["return_pct"] > 8]
+    high_sharpe = [r for r in results if r["sharpe"] > 1.5]
+    low_dd = [r for r in results if r["max_dd"] < 8]
+
+    print(f"\n  Profitable (>8%):  {len(profitable)} coins")
+    if profitable:
+        print(f"    {', '.join(r['coin'] for r in profitable)}")
+
+    print(f"\n  High Sharpe (>1.5): {len(high_sharpe)} coins")
+    if high_sharpe:
+        print(f"    {', '.join(r['coin'] for r in high_sharpe)}")
+
+    print(f"\n  Low DD (<8%):      {len(low_dd)} coins")
+    if low_dd:
+        print(f"    {', '.join(r['coin'] for r in low_dd)}")
+
+    # Current holdings vs best
+    current = ["SUI", "NEAR"]
+    print(f"\n  Current ML coins: {', '.join(current)}")
+
+    current_results = {r["coin"]: r for r in results}
+    if any(c in current_results for c in current):
+        print(f"\n  Current performance:")
+        for coin in current:
+            if coin in current_results:
+                r = current_results[coin]
+                print(f"    {coin}: {r['return_pct']:+6.2f}% | {r['trades']:3d} trades | "
+                      f"Sharpe {r['sharpe']:6.2f}")
+
+        best = results_sorted[0]
+        print(f"\n  Best alternative:")
+        print(f"    {best['coin']}: {best['return_pct']:+6.2f}% | {best['trades']:3d} trades | "
+              f"Sharpe {best['sharpe']:6.2f}")
+
+        improvement = best["return_pct"] - current_results[current[0]]["return_pct"]
+        print(f"\n  Potential improvement: {improvement:+.2f}% by swapping to {best['coin']}")
+
+    print("\n" + "="*90 + "\n")
+
+    # Generate recommendations
+    print("  💡 RECOMMENDATIONS:\n")
+
+    if len(profitable) >= 2:
+        top_2 = results_sorted[:2]
+        print(f"  ✅ Replace SUI+NEAR with top 2 performers:")
+        print(f"     • {top_2[0]['coin']}: {top_2[0]['return_pct']:+.2f}%")
+        print(f"     • {top_2[1]['coin']}: {top_2[1]['return_pct']:+.2f}%")
+        print(f"     Expected blended return: {(top_2[0]['return_pct'] + top_2[1]['return_pct'])/2:+.2f}%\n")
+
+    print("  ⚠️  Current SUI+NEAR performance:")
+    for coin in current:
+        if coin in current_results:
+            r = current_results[coin]
+            status = "📈" if r['return_pct'] > 0 else "📉"
+            print(f"     {status} {coin}: {r['return_pct']:+6.2f}%  ({r['trades']} trades)")
+
+    print("\n")
+
+
+if __name__ == "__main__":
+    main()
+

reports/ml_auto_backtest_seed.json

@@ -1,5 +1,5 @@
 {
-  "generated_at": "2026-05-26T01:27:11.471248+00:00",
+  "generated_at": "2026-05-28T02:01:22.311732+00:00",
   "days": 180,
   "coins": {
     "INJ_1h": {
@@ -17,23 +17,23 @@
       "coin": "SUI",
       "timeframe": "1h",
       "days": 180,
-      "trades": 51,
-      "win_rate": 0.3922,
-      "total_return_pct": 16.6672,
-      "profit_factor": 1.5335,
-      "max_drawdown_pct": 7.3214,
-      "sharpe_ratio": 1.4458
+      "trades": 28,
+      "win_rate": 0.3929,
+      "total_return_pct": 18.9368,
+      "profit_factor": 2.0416,
+      "max_drawdown_pct": 5.2638,
+      "sharpe_ratio": 1.683
     },
     "WIF_1h": {
       "coin": "WIF",
       "timeframe": "1h",
       "days": 180,
-      "trades": 47,
-      "win_rate": 0.2553,
-      "total_return_pct": 2.0146,
-      "profit_factor": 1.082,
-      "max_drawdown_pct": 15.3181,
-      "sharpe_ratio": 0.3044
+      "trades": 23,
+      "win_rate": 0.2609,
+      "total_return_pct": 1.8033,
+      "profit_factor": 1.129,
+      "max_drawdown_pct": 5.9185,
+      "sharpe_ratio": 0.2863
     },
     "NEAR_1h": {
       "coin": "NEAR",
@@ -50,89 +50,89 @@
       "coin": "ARB",
       "timeframe": "1h",
       "days": 180,
-      "trades": 47,
-      "win_rate": 0.2979,
-      "total_return_pct": -0.7004,
-      "profit_factor": 1.0116,
+      "trades": 49,
+      "win_rate": 0.2857,
+      "total_return_pct": -2.7523,
+      "profit_factor": 0.9535,
       "max_drawdown_pct": 9.0079,
-      "sharpe_ratio": 0.0925
+      "sharpe_ratio": -0.0933
     },
     "TIA_1h": {
       "coin": "TIA",
       "timeframe": "1h",
       "days": 180,
-      "trades": 81,
-      "win_rate": 0.2469,
-      "total_return_pct": -14.4036,
-      "profit_factor": 0.7708,
-      "max_drawdown_pct": 18.1684,
-      "sharpe_ratio": -0.9351
+      "trades": 25,
+      "win_rate": 0.08,
+      "total_return_pct": -16.0572,
+      "profit_factor": 0.2677,
+      "max_drawdown_pct": 16.0572,
+      "sharpe_ratio": -2.8536
     },
     "ETH_1h": {
       "coin": "ETH",
       "timeframe": "1h",
       "days": 180,
-      "trades": 87,
-      "win_rate": 0.3218,
-      "total_return_pct": 3.1797,
-      "profit_factor": 1.1092,
-      "max_drawdown_pct": 13.5227,
-      "sharpe_ratio": 0.5133
+      "trades": 37,
+      "win_rate": 0.2432,
+      "total_return_pct": -2.038,
+      "profit_factor": 0.9889,
+      "max_drawdown_pct": 11.5952,
+      "sharpe_ratio": 0.0324
     },
     "AVAX_1h": {
       "coin": "AVAX",
       "timeframe": "1h",
       "days": 180,
-      "trades": 58,
-      "win_rate": 0.2241,
-      "total_return_pct": -6.1659,
-      "profit_factor": 0.9099,
-      "max_drawdown_pct": 13.961,
-      "sharpe_ratio": -0.2511
+      "trades": 83,
+      "win_rate": 0.253,
+      "total_return_pct": -14.6898,
+      "profit_factor": 0.8073,
+      "max_drawdown_pct": 18.1576,
+      "sharpe_ratio": -0.868
     },
     "LINK_1h": {
       "coin": "LINK",
       "timeframe": "1h",
       "days": 180,
-      "trades": 44,
-      "win_rate": 0.1818,
-      "total_return_pct": -12.2838,
-      "profit_factor": 0.6972,
-      "max_drawdown_pct": 13.1115,
-      "sharpe_ratio": -0.9768
+      "trades": 67,
+      "win_rate": 0.2836,
+      "total_return_pct": -5.4177,
+      "profit_factor": 0.9354,
+      "max_drawdown_pct": 13.8572,
+      "sharpe_ratio": -0.1937
     },
     "OP_1h": {
       "coin": "OP",
       "timeframe": "1h",
       "days": 180,
-      "trades": 23,
-      "win_rate": 0.2174,
-      "total_return_pct": -2.6188,
-      "profit_factor": 0.8857,
-      "max_drawdown_pct": 9.8678,
-      "sharpe_ratio": -0.2088
+      "trades": 60,
+      "win_rate": 0.2667,
+      "total_return_pct": -7.1059,
+      "profit_factor": 0.8779,
+      "max_drawdown_pct": 16.1324,
+      "sharpe_ratio": -0.438
     },
     "DOGE_1h": {
       "coin": "DOGE",
       "timeframe": "1h",
       "days": 180,
-      "trades": 59,
-      "win_rate": 0.2373,
-      "total_return_pct": -3.3419,
-      "profit_factor": 0.9756,
-      "max_drawdown_pct": 20.2514,
-      "sharpe_ratio": -0.0191
+      "trades": 79,
+      "win_rate": 0.3165,
+      "total_return_pct": 2.1745,
+      "profit_factor": 1.0875,
+      "max_drawdown_pct": 16.9499,
+      "sharpe_ratio": 0.4138
     },
     "APT_1h": {
       "coin": "APT",
       "timeframe": "1h",
       "days": 180,
-      "trades": 72,
-      "win_rate": 0.1528,
-      "total_return_pct": -24.91,
-      "profit_factor": 0.5768,
-      "max_drawdown_pct": 25.7906,
-      "sharpe_ratio": -1.96
+      "trades": 84,
+      "win_rate": 0.2024,
+      "total_return_pct": -25.4033,
+      "profit_factor": 0.618,
+      "max_drawdown_pct": 26.6465,
+      "sharpe_ratio": -2.0437
     },
     "BTC_1h": {
       "coin": "BTC",
@@ -149,12 +149,12 @@
       "coin": "SOL",
       "timeframe": "1h",
       "days": 180,
-      "trades": 9,
-      "win_rate": 0.1111,
-      "total_return_pct": -5.1493,
-      "profit_factor": 0.4041,
-      "max_drawdown_pct": 8.1601,
-      "sharpe_ratio": -1.2027
+      "trades": 50,
+      "win_rate": 0.2,
+      "total_return_pct": -10.6837,
+      "profit_factor": 0.7761,
+      "max_drawdown_pct": 17.0197,
+      "sharpe_ratio": -0.6932
     }
   }
 }

run_all_backtests.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""Comprehensive backtest runner for all active strategies in bot config."""
+
+import json
+import sys
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+import pandas as pd
+from hbot import HyperliquidAPI
+from backtest import StrategyBacktester
+from strategy_conservative import StrategyEngine as ConservativeEngine
+from strategy_hype import StrategyEngine as HypeEngine
+from strategy_ml_auto import StrategyEngine as MLAutoEngine
+from strategy_scalp import StrategyEngine as ScalpEngine
+
+
+# ── Initialize API with SSL verification disabled ────────────────────
+api = HyperliquidAPI(verify_ssl=False)
+
+
+# ── Load historical data ──────────────────────────────────────────────
+def fetch_candles(coin: str, timeframe: str, days: int = 180) -> pd.DataFrame:
+    """Fetch candles from Hyperliquid API."""
+
+    interval_map = {
+        "1m": "1m", "5m": "5m", "15m": "15m", "30m": "30m",
+        "1h": "1h", "4h": "4h", "1d": "1d"
+    }
+    interval = interval_map.get(timeframe, "1h")
+
+    try:
+        start_ms = int((datetime.now(timezone.utc) - timedelta(days=days)).timestamp() * 1000)
+        raw = api.get_candles(coin, interval, start_ms)
+
+        if not raw:
+            print(f"  ⚠️  No data for {coin} {interval}")
+            return pd.DataFrame()
+
+        rows = [
+            {
+                "timestamp": pd.to_datetime(int(x["t"]), unit="ms", utc=True),
+                "open": float(x["o"]),
+                "high": float(x["h"]),
+                "low": float(x["l"]),
+                "close": float(x["c"]),
+                "volume": float(x["v"]),
+            }
+            for x in raw
+        ]
+        df = pd.DataFrame(rows).drop_duplicates("timestamp").sort_values("timestamp").set_index("timestamp")
+        return df
+
+    except Exception as e:
+        print(f"  ✗ Error fetching {coin} {timeframe}: {e}")
+        return pd.DataFrame()
+
+
+# ── Main backtest runner ──────────────────────────────────────────────
+def main():
+    """Run backtest for all strategies in bot config."""
+
+    config_path = Path(__file__).parent / "bot_config.json"
+    with open(config_path) as f:
+        config = json.load(f)
+
+    print(f"\n{'='*70}")
+    print(f"  BACKTEST REPORT - All Active Strategies")
+    print(f"  Generated: {datetime.utcnow().isoformat()}")
+    print(f"{'='*70}\n")
+
+    all_results = []
+
+    for slot in config["slots"]:
+        strategy_name = slot["strategy"]
+        coin = slot["coin"]
+        timeframe = slot["timeframe"]
+        capital_frac = slot["capital_frac"]
+
+        print(f"\n🔄 Testing {strategy_name:25} | {coin} {timeframe} (allocation: {capital_frac:.1%})")
+        print(f"   {'─'*65}")
+
+        # Fetch data
+        df = fetch_candles(coin, timeframe, days=180)
+        if df.empty:
+            print(f"   ✗ SKIPPED (no data)")
+            continue
+
+        print(f"   ✓ Loaded {len(df)} candles")
+
+        # Instantiate strategy
+        if strategy_name == "strategy_hype":
+            strategy = HypeEngine({"use_regime_filter": False})
+        elif strategy_name == "strategy_conservative":
+            strategy = ConservativeEngine({"use_regime_filter": False})
+        elif strategy_name == "strategy_scalp":
+            strategy = ScalpEngine({"use_regime_filter": False})
+        elif strategy_name == "strategy_ml_auto":
+            strategy = MLAutoEngine({"use_regime_filter": False, "coin": coin})
+        else:
+            print(f"   ✗ Unknown strategy: {strategy_name}")
+            continue
+
+        # Run backtest
+        tester = StrategyBacktester(
+            strategy=strategy,
+            starting_capital=1000.0,
+            fee_bps=3.0,
+            slippage_bps=2.0,
+            position_risk_fraction=0.02,
+            strategy_name=strategy_name,
+        )
+
+        result = tester.backtest(df, coin, timeframe)
+        all_results.append({
+            "slot": f"{strategy_name:25}",
+            "coin": coin,
+            "tf": timeframe,
+            "alloc": f"{capital_frac:.1%}",
+            "trades": result.trades,
+            "win%": f"{result.win_rate*100:.1f}",
+            "ret%": f"{result.total_return_pct:+.2f}",
+            "pf": f"{result.profit_factor:.2f}",
+            "dd%": f"{result.max_drawdown_pct:.2f}",
+            "sharpe": f"{result.sharpe_ratio:.2f}",
+            "fees": f"${result.total_fees_paid:.2f}",
+        })
+
+        status = "✓" if result.total_return_pct >= 5.0 else "✗" if result.total_return_pct < 0 else "~"
+        print(f"   {status} Trades: {result.trades:3d} | Win: {result.win_rate*100:5.1f}% | "
+              f"Return: {result.total_return_pct:+6.2f}% | PF: {result.profit_factor:5.2f} | "
+              f"DD: {result.max_drawdown_pct:5.2f}% | Sharpe: {result.sharpe_ratio:5.2f}")
+        print(f"      Fees paid: ${result.total_fees_paid:.2f}")
+
+    # Print summary table
+    print(f"\n{'='*70}")
+    print(f"  SUMMARY TABLE (180-day backtest)")
+    print(f"{'='*70}\n")
+
+    header = f"{'Strategy':<27} {'Coin':<6} {'TF':<5} {'Alloc':<7} {'Trades':<8} {'Win%':<8} {'Return%':<10} {'PF':<6} {'DD%':<7} {'Sharpe':<8} {'Fees':<10}"
+    print(header)
+    print("─" * len(header))
+
+    total_return = 0.0
+    for r in all_results:
+        ret_pct = float(r["ret%"])
+        total_return += ret_pct * float(r["alloc"].strip("%")) / 100.0
+
+        print(f"{r['slot']:<27} {r['coin']:<6} {r['tf']:<5} {r['alloc']:<7} "
+              f"{r['trades']:<8} {r['win%']:<8} {r['ret%']:<10} {r['pf']:<6} "
+              f"{r['dd%']:<7} {r['sharpe']:<8} {r['fees']:<10}")
+
+    print("─" * len(header))
+    print(f"{'PORTFOLIO BLENDED':<27} {'':6} {'':5} {'100.0%':<7} "
+          f"{'':8} {'':8} {total_return:+10.2f}% {'':6} {'':7} {'':8}")
+    print(f"\n{'='*70}\n")
+
+
+if __name__ == "__main__":
+    main()
+
+
+
+
+

track_ml_learning.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""
+ML Auto Performance Tracker - Monitor model learning over time.
+
+Shows:
+  • Live win rate vs baseline rule-only performance
+  • Training examples collected per coin
+  • Model confidence trends
+  • Shadow mode status
+  • Recommendation on when to rotate coins
+"""
+
+import json
+import os
+from pathlib import Path
+from datetime import datetime
+from collections import defaultdict
+
+MEMORY_DIR = Path(__file__).parent / "reports"
+
+def analyze_memory_file(coin: str):
+    """Analyze a single coin's memory ledger."""
+    path = MEMORY_DIR / f"ml_auto_memory_{coin}.jsonl"
+
+    if not path.exists():
+        return None
+
+    records = []
+    try:
+        with open(path) as f:
+            for line in f:
+                line = line.strip()
+                if line:
+                    records.append(json.loads(line))
+    except Exception as e:
+        print(f"  Error reading {coin}: {e}")
+        return None
+
+    if not records:
+        return None
+
+    # Calculate stats
+    total_trades = len(records)
+    wins = sum(1 for r in records if r.get("won"))
+    win_rate = wins / total_trades if total_trades else 0
+
+    # Recent performance (last 20 trades)
+    recent = records[-20:]
+    recent_wins = sum(1 for r in recent if r.get("won"))
+    recent_wr = recent_wins / len(recent) if recent else 0
+
+    # Historical performance (before last 20)
+    historical = records[:-20] if len(records) > 20 else []
+    historical_wins = sum(1 for r in historical if r.get("won"))
+    historical_wr = historical_wins / len(historical) if historical else 0
+
+    # Side distribution
+    long_trades = sum(1 for r in records if r.get("side") == 1)
+    short_trades = sum(1 for r in records if r.get("side") == -1)
+
+    # Calculate PnL (rough estimate)
+    total_pnl = 0
+    for r in records:
+        entry = float(r.get("entry", 0))
+        exit_px = float(r.get("exit", 0))
+        side = int(r.get("side", 1))
+        if entry and exit_px:
+            pnl = (exit_px - entry) * side * abs(exit_px) / 100  # Rough estimate
+            total_pnl += pnl if r.get("won") else pnl * -0.2
+
+    # Newest and oldest trades
+    oldest_ts = records[0].get("ts", "unknown")
+    newest_ts = records[-1].get("ts", "unknown")
+
+    return {
+        "coin": coin,
+        "total_trades": total_trades,
+        "win_rate": win_rate,
+        "recent_wr": recent_wr,
+        "historical_wr": historical_wr,
+        "improvement": recent_wr - historical_wr if historical else 0,
+        "long_trades": long_trades,
+        "short_trades": short_trades,
+        "oldest_ts": oldest_ts,
+        "newest_ts": newest_ts,
+        "memory_file_size": path.stat().st_size,
+    }
+
+
+def main():
+    print("\n" + "="*80)
+    print("  ML AUTO LEARNING TRACKER — Performance Over Time")
+    print("="*80 + "\n")
+
+    # Find all memory files
+    memory_files = list(MEMORY_DIR.glob("ml_auto_memory_*.jsonl"))
+
+    if not memory_files:
+        print("  ⚠️  No ML memory files found yet. Start trading to collect data!\n")
+        return
+
+    results = []
+    for path in sorted(memory_files):
+        coin = path.stem.replace("ml_auto_memory_", "")
+        analysis = analyze_memory_file(coin)
+        if analysis:
+            results.append(analysis)
+
+    if not results:
+        print("  ⚠️  Could not analyze any memory files.\n")
+        return
+
+    # Print detailed report
+    print(f"{'Coin':<8} {'Trades':<8} {'Win%':<8} {'Recent%':<10} {'Trend':<12} {'Long:Short':<12} {'Status':<15}")
+    print("─" * 80)
+
+    for r in sorted(results, key=lambda x: x["win_rate"], reverse=True):
+        win_pct = r["win_rate"] * 100
+        recent_pct = r["recent_wr"] * 100
+        improvement = r["improvement"] * 100
+
+        # Trend indicator
+        if improvement > 5:
+            trend = f"↗️ +{improvement:.1f}pp"
+            status = "🟢 IMPROVING"
+        elif improvement > 0:
+            trend = f"→ +{improvement:.1f}pp"
+            status = "🟡 STABLE"
+        else:
+            trend = f"↘ {improvement:.1f}pp"
+            status = "🔴 DEGRADING"
+
+        side_ratio = f"{r['long_trades']}:{r['short_trades']}"
+
+        print(f"{r['coin']:<8} {r['total_trades']:<8} {win_pct:>6.1f}%  {recent_pct:>8.1f}%  "
+              f"{trend:<12} {side_ratio:<12} {status:<15}")
+
+    print("\n" + "="*80)
+    print("  INTERPRETATION GUIDE")
+    print("="*80 + """
+  🟢 IMPROVING (Recent% > Historical%)
+    → Model is learning! Confidence in predictions is rising.
+    → Keep coin active, monitor for stability.
+
+  🟡 STABLE (Recent% ≈ Historical%)
+    → Model has plateaued. Good consistent baseline.
+    → Performance is predictable and repeatable.
+
+  🔴 DEGRADING (Recent% < Historical%)
+    → Model fit to old market regime. Performance drifting.
+    → Consider retraining or rotating to new coin.
+    → If stays negative >30 trades, rotate out.
+
+  Win Rate Interpretation:
+    • >50% = Excellent (2:1 RR makes this highly profitable)
+    • >40% = Good
+    • >30% = Acceptable (2.5:1 RR needed)
+    • <30% = Poor (not sustainable with fixed RR)
+
+  Trades per Coin:
+    • <10 trades = too early to judge, keep collecting data
+    • 10-30 trades = initial verdict forming
+    • 30+ trades = reliable signal of model quality
+""" + "="*80 + "\n")
+
+    # Summary stats
+    total_all = sum(r["total_trades"] for r in results)
+    avg_wr = sum(r["win_rate"] for r in results) / len(results) if results else 0
+
+    print(f"  📊 SUMMARY")
+    print(f"     Total trades across all coins: {total_all}")
+    print(f"     Average win rate: {avg_wr*100:.1f}%")
+    print(f"     Coins tracked: {len(results)}")
+
+    # Recommendations
+    print(f"\n  💡 RECOMMENDATIONS")
+    improving = [r for r in results if r["improvement"] > 0.05]
+    degrading = [r for r in results if r["improvement"] < -0.05 and r["total_trades"] > 30]
+    early = [r for r in results if r["total_trades"] < 10]
+
+    if improving:
+        print(f"     ✅ Keep active: {', '.join(r['coin'] for r in improving)} (learning)")
+    if degrading:
+        print(f"     ⚠️  Consider rotating: {', '.join(r['coin'] for r in degrading)} (degrading)")
+    if early:
+        print(f"     ⏳ Collect more data: {', '.join(r['coin'] for r in early)} (<10 trades)")
+
+    print()
+
+
+if __name__ == "__main__":
+    main()
+