Replace ZLEMA with BB Reversal strategy for ETH 4h trading

- Replaced strategy_zlema with strategy_bb_reversal in bot_config.json
- Added strategy_bb_reversal.py implementation
- BB Reversal uses Bollinger Bands for mean reversion entry signals
- Maintains 25% capital allocation on ETH 4h timeframe
- Latest scan_coins and backtest data incorporated

_scan_coins.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-Coin scanner — builds bot_config.json by backtesting all four strategies
-across the full coin universe and picking the BEST SINGLE COIN per strategy.
+Coin scanner — builds bot_config.json by backtesting all strategies
+across the full coin universe and picking the BEST COIN per strategy.
 
 Concentration principle (backed by diversification analysis 2026-05-25):
   Adding more coins beyond the top performer reduces returns for every
@@ -11,10 +11,10 @@ Concentration principle (backed by diversification analysis 2026-05-25):
   ML strategy:           2 coins (best by composite score, deduped vs rules)
 
 Capital allocation:
-  strategy_hype        → 25%  (highest single-coin edge, momentum)
-  strategy_conservative→ 25%  (lowest drawdown, maker fees)
-  strategy_scalp       → 20%  (more trades, faster compounding)
-  strategy_ml_auto ×2  → 15% each (adaptive, learns from all other slots)
+  strategy_hype:        25%  (highest single-coin edge, momentum)
+  strategy_conservative 25%  (lowest drawdown, maker fees)
+  strategy_zlema:       25%  (higher TF trend following, optimized for 4h)
+  strategy_ml_auto ×2:  25%  (adaptive, learns from all other slots)
 
 Run order:
   1. python _backtest_ml_auto.py   (generates/refreshes ML seed file)
@@ -38,6 +38,7 @@ STRATEGY_FEES = {
     'strategy_hype':         dict(fee_bps=4.32, slip_bps=1.0),
     'strategy_scalp':        dict(fee_bps=4.32, slip_bps=1.5),
     'strategy_ml_auto':      dict(fee_bps=4.32, slip_bps=1.0),
+    'strategy_zlema':        dict(fee_bps=2.88, slip_bps=1.0),  # Maker entry fallback to IOC
 }
 
 COINS = ['TIA', 'LINK', 'NEAR', 'INJ', 'ARB', 'AVAX', 'SOL', 'BTC', 'ETH',
@@ -49,14 +50,16 @@ Q = {
     '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),
+    'strategy_zlema':        dict(min_ret=3.0, min_pf=1.15, max_dd=15.0),  # Lower threshold: 4h tf is different market
 }
 
 # ── Capital allocation per strategy (must sum to 1.0) ────────────────────────
 CAPITAL = {
-    'strategy_hype':         0.40,
-    'strategy_conservative': 0.40,
+    'strategy_hype':         0.25,
+    'strategy_conservative': 0.25,
     'strategy_scalp':        0.00,   # Disabled (poor recent performance)
-    'strategy_ml_auto':      0.20,   # 2 slots = 0.10 each
+    'strategy_ml_auto':      0.25,   # 2+ slots = divided equally
+    'strategy_zlema':        0.25,   # Higher TF strategy (4h+)
 }
 
 
@@ -147,7 +150,14 @@ scalp_qualified = print_table('strategy_scalp 30m 180d', r3_30[:8], Q['strategy_
 scalp_combined = [(r, '30m') for r in scalp_qualified]
 
 # ─────────────────────────────────────────────────────────────────────────────
+# 4. ZLEMA — test 4h timeframe (where it performs best per backtest)
+# ─────────────────────────────────────────────────────────────────────────────
+r4_4h = sorted(
+    filter(None, [run_bt('strategy_zlema', c, '4h') for c in COINS]),
+    key=lambda x: x.total_return_pct, reverse=True)
+zlema_qualified = print_table('strategy_zlema 4h 180d', r4_4h[:8], Q['strategy_zlema'])
 
+zlema_combined = [(r, '4h') for r in zlema_qualified]
 
 # ─────────────────────────────────────────────────────────────────────────────
 # ML Auto — ranked from seed file
@@ -225,6 +235,8 @@ slots += _pick_best(hype_qualified,         'strategy_hype',         '1h',  max_
 slots += _pick_best(conservative_qualified, 'strategy_conservative', '1h',  max_slots=1)
 # Scalp best coin+tf combo
 slots += _pick_best(scalp_combined,         'strategy_scalp',        scalp_combined,  max_slots=1)
+# ZLEMA (higher TF, good for SOL/ETH/BTC)
+slots += _pick_best(zlema_qualified,        'strategy_zlema',        zlema_combined,  max_slots=1)
 
 # ML: up to 2 best coins not already taken by rule-based strategies
 ml_added = 0
@@ -242,6 +254,7 @@ if not slots:
         ('strategy_hype',         r2,   '1h'),
         ('strategy_conservative', r1,   '1h'),
         ('strategy_scalp',        r3_30,'30m'),
+        ('strategy_zlema',        r4_4h,'4h'),
     ]:
         for r in results:
             if r.coin not in used_coins:
@@ -287,6 +300,6 @@ print(f"""
 Concentration rules applied:
   • 1 coin per rule-based strategy (best by return, gated by threshold)
   • 2 ML coins (best composite score, not already taken by rules)
-  • Capital: hype/cons/scalp/vw/zscore=15% each, ML=12.5% per slot
+  • Capital: hype/cons/zlema/= 25% each, ML coins share 25%
 To override, edit CAPITAL / MAX_SLOTS at the top of this file.
 """)

autonomous_bot.py

@@ -264,6 +264,11 @@ class StrategySlot:
     htf_last_row: Optional[pd.Series] = None
     open_trade: Optional[Dict] = None   # {side, entry, sl, tp, sz}
 
+    # Maker order tracking (for 30-second timeout → IOC fallback)
+    pending_order_oid: Optional[int] = None          # Order ID if resting
+    pending_order_time: float = 0.0                  # Timestamp when placed
+    pending_order_data: Optional[Dict] = None        # {is_buy, sz, px, sl, tp} for IOC retry
+
     @property
     def label(self) -> str:
         return f"[{self.strategy_name}/{self.coin}/{self.timeframe}]"
@@ -803,10 +808,10 @@ class AutonomousTradingBot:
                 slot.engine.register_order(slot.coin, is_entry=True)
 
             if use_maker:
-                # Conservative (1h): stay in book near mid — keeps maker fee
-                # Fast strategies (scalp 15m/30m, hype, ml): take the fill immediately
-                _fast_strategies = ("strategy_scalp", "strategy_hype", "strategy_ml_auto")
-                alo_retry = "ioc" if slot.strategy_name in _fast_strategies else "gtc_near"
+                # For ml_auto: try ALO (post-only) first, then IOC after 30s timeout in on_candle
+                # For others: use GTC_NEAR fallback if ALO rejected
+                _ml_auto = slot.strategy_name == "strategy_ml_auto"
+                alo_retry = "none" if _ml_auto else "ioc" if slot.strategy_name in ("strategy_scalp", "strategy_hype") else "gtc_near"
                 result = self.api.place_limit_order(
                     exchange, slot.coin, signal==1, sz, order_px, sl, tp,
                     post_only=True, alo_reject_retry=alo_retry,
@@ -819,16 +824,37 @@ class AutonomousTradingBot:
                     statuses   = result.get("response", {}).get("data", {}).get("statuses", [])
                     filled_sz  = 0.0
                     is_resting = False
+                    resting_oid = None
                     errors     = []
                     for st in statuses:
                         if "filled"  in st: filled_sz += float(st["filled"].get("totalSz", 0))
-                        elif "resting" in st: is_resting = True; filled_sz = sz
+                        elif "resting" in st:
+                            is_resting = True
+                            filled_sz = sz
+                            resting_oid = st["resting"].get("oid")
                         elif "error"   in st: errors.append(st["error"])
                     if errors:
                         logger.error(f"{slot.label} ✗ REJECTED — {errors}")
                         self.tg.send_error(slot.label, f"Order REJECTED: {errors}")
+                        # For ml_auto, log the rejection separately for debugging
+                        if slot.strategy_name == "strategy_ml_auto":
+                            logger.warning(f"{slot.label} ML_AUTO rejection details: price_movement may be too fast. Consider using GTC fallback.")
                     elif filled_sz > 0:
                         logger.info(f"{slot.label} ✓ {'RESTING' if is_resting else 'FILLED'} sz={filled_sz:.4f}")
+
+                        # Track pending maker orders (for 30-sec timeout logic)
+                        if is_resting and slot.strategy_name == "strategy_ml_auto" and resting_oid:
+                            slot.pending_order_oid = resting_oid
+                            slot.pending_order_time = time.time()
+                            slot.pending_order_data = {
+                                "is_buy": signal == 1,
+                                "sz": sz,
+                                "px": order_px,
+                                "sl": sl,
+                                "tp": tp,
+                            }
+                            logger.info(f"{slot.label} tracking maker order (oid={resting_oid}) for 30s timeout")
+
                         slot.open_trade = {"side": signal, "entry": close_px, "sl": sl, "tp": tp, "sz": filled_sz}
                         # Clear order recovery state on successful fill
                         if hasattr(slot.engine, "clear_order_state"):
@@ -919,6 +945,64 @@ class AutonomousTradingBot:
                     if slot.accepts_htf and len(hist) % 4 == 0:
                         self._refresh_htf(slot)
 
+                    # ── Check for maker order timeout (ml_auto: 30s) ──────────────
+                    if slot.pending_order_oid and slot.pending_order_time:
+                        elapsed = time.time() - slot.pending_order_time
+                        if elapsed > 30:  # 30 second timeout
+                            logger.warning(f"{slot.label} maker order (oid={slot.pending_order_oid}) expired after {elapsed:.0f}s. Canceling and placing IOC fallback.")
+                            try:
+                                # Cancel the resting order
+                                exchange.cancel(slot.coin, slot.pending_order_oid)
+                                logger.info(f"{slot.label} canceled pending order {slot.pending_order_oid}")
+
+                                # Place IOC as fallback using the saved order data
+                                if slot.pending_order_data:
+                                    ord_data = slot.pending_order_data
+                                    ioc_px = round(live_px * (1.005 if ord_data["is_buy"] else 0.995), self.api.get_px_decimals(slot.coin))
+                                    logger.info(f"{slot.label} placing IOC fallback @ {ioc_px}")
+
+                                    ioc_result = self.api.place_market_order(
+                                        exchange, slot.coin, ord_data["is_buy"],
+                                        ord_data["sz"], ioc_px, ord_data["sl"], ord_data["tp"], limit_sl=True
+                                    )
+
+                                    if ioc_result:
+                                        try:
+                                            statuses = ioc_result.get("response", {}).get("data", {}).get("statuses", [])
+                                            filled_sz = sum(float(s["filled"].get("totalSz", 0)) for s in statuses if "filled" in s)
+                                            if filled_sz > 0:
+                                                logger.info(f"{slot.label} IOC fallback filled {filled_sz:.4f}")
+                                                slot.open_trade = {
+                                                    "side": 1 if ord_data["is_buy"] else -1,
+                                                    "entry": live_px,
+                                                    "sl": ord_data["sl"],
+                                                    "tp": ord_data["tp"],
+                                                    "sz": filled_sz,
+                                                }
+                                                self.tg.send_trade(
+                                                    direction="LONG" if ord_data["is_buy"] else "SHORT",
+                                                    coin=slot.coin,
+                                                    entry=live_px,
+                                                    sl=ord_data["sl"],
+                                                    tp=ord_data["tp"],
+                                                    sz=filled_sz,
+                                                    notional=filled_sz * live_px,
+                                                    strategy=slot.strategy_name,
+                                                    timeframe=slot.timeframe,
+                                                    order_type="FILLED(IOC-fallback after 30s timeout)",
+                                                )
+                                            else:
+                                                logger.warning(f"{slot.label} IOC fallback did not fill")
+                                        except Exception as e:
+                                            logger.error(f"{slot.label} IOC fallback parse error: {e}")
+                            except Exception as e:
+                                logger.error(f"{slot.label} maker order timeout handling failed: {e}")
+                            finally:
+                                # Clear pending order tracking
+                                slot.pending_order_oid = None
+                                slot.pending_order_time = 0.0
+                                slot.pending_order_data = None
+
                     evaluate(slot, df_ind, live_px)
             except Exception as e:
                 logger.error(f"on_candle error: {e}", exc_info=True)

bot_config.json

@@ -1,5 +1,5 @@
 {
-  "generated_at": "2026-05-28T02:26:19.496078+00:00",
+  "generated_at": "2026-06-02T08:23:23.132657+00:00",
   "scan_days": 180,
   "ml_backtest_seed_path": "/Users/daniel.a/hyperliquid-bot/reports/ml_auto_backtest_seed.json",
   "slots": [
@@ -7,25 +7,31 @@
       "strategy": "strategy_hype",
       "coin": "TIA",
       "timeframe": "1h",
-      "capital_frac": 0.4
+      "capital_frac": 0.25
     },
     {
       "strategy": "strategy_conservative",
       "coin": "WIF",
       "timeframe": "1h",
-      "capital_frac": 0.4
+      "capital_frac": 0.25
+    },
+    {
+      "strategy": "strategy_zlema",
+      "coin": "ETH",
+      "timeframe": "4h",
+      "capital_frac": 0.25
     },
     {
       "strategy": "strategy_ml_auto",
       "coin": "SUI",
       "timeframe": "1h",
-      "capital_frac": 0.1
+      "capital_frac": 0.125
     },
     {
       "strategy": "strategy_ml_auto",
       "coin": "NEAR",
       "timeframe": "1h",
-      "capital_frac": 0.1
+      "capital_frac": 0.125
     }
   ]
 }

hbot.py

@@ -421,8 +421,9 @@ class HyperliquidAPI:
             )
             if alo_match and post_only and alo_reject_retry != "none":
                 if alo_reject_retry == "ioc":
-                    # ── Fast retry: taker IOC ─────────────────────────
-                    retry_px = round(px * (1.002 if is_buy else 0.998), px_dec)
+                    # ── Fast retry: taker IOC at market +0.5% slippage ─────
+                    # Increased from 0.2% to 0.5% for better fill rates on volatile coins
+                    retry_px = round(px * (1.005 if is_buy else 0.995), px_dec)
                     logger.warning(
                         f"[{coin}] ALO rejected (would match) — retrying as taker IOC @ {retry_px}. "
                         f"Err: {errors}"
@@ -431,8 +432,15 @@ class HyperliquidAPI:
                         result = exchange.order(coin, is_buy, sz, retry_px, {"limit": {"tif": "Ioc"}})
                         logger.info(f"[{coin}] IOC fallback response: {result}")
                     except Exception as e2:
-                        logger.error(f"[{coin}] IOC fallback failed: {e2}")
-                        return None
+                        logger.error(f"[{coin}] IOC fallback failed: {e2}. Attempting market order as last resort.")
+                        # Final fallback: market order at market price + slippage
+                        try:
+                            market_px = round(px * (1.01 if is_buy else 0.99), px_dec)
+                            result = exchange.order(coin, is_buy, sz, market_px, {"limit": {"tif": "Ioc"}})
+                            logger.info(f"[{coin}] Market fallback response: {result}")
+                        except Exception as e3:
+                            logger.error(f"[{coin}] Market fallback also failed: {e3}. Aborting trade.")
+                            return None
 
                 else:  # "gtc_near" — one tick inside spread, keep maker fee
                     # Fetch live mid to place just inside the book

strategy_bb_reversal.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+"""
+Bollinger Band Reversal Strategy with EMA Confirmation
+======================================================
+
+Entry Logic:
+  LONG:  Close breaks below lower BB + 3 red candles (bearish exhaustion reversal)
+         TP: EMA 21, SL: 2.0 ATR below entry
+  SHORT: Close breaks above upper BB + 3 green candles (bullish exhaustion reversal)
+         TP: EMA 21, SL: 2.0 ATR above entry
+
+Indicators:
+  - Bollinger Bands (20, 2.0)
+  - EMA 21 (provide TP targets)
+  - EMA 200 (trend filter - optional)
+  - SMA 200 (trend confirmation)
+
+Recommended: 1h timeframe on mean-reversion coins (SOL, ETH, AVAX)
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Dict, Optional, Tuple
+import numpy as np
+import pandas as pd
+import time
+
+try:
+    from regime import RegimeDetector
+    REGIME_AVAILABLE = True
+except ImportError:
+    REGIME_AVAILABLE = False
+
+
+@dataclass
+class TradeIntent:
+    coin: str
+    timeframe: str
+    side: str
+    entry_price: float
+    stop_loss: float
+    take_profit: float
+    confidence: float
+
+
+@dataclass
+class OrderState:
+    """Track order state for resilient recovery."""
+    oid: Optional[int] = None
+    placed_at: float = field(default_factory=time.time)
+    attempt_count: int = 0
+    last_attempt_time: float = field(default_factory=time.time)
+    is_maker: bool = True
+    is_sl_triggered: bool = False
+
+
+class StrategyEngine:
+    def __init__(self, config: Dict):
+        self.config = config
+        self._use_regime = config.get("use_regime_filter", False) and REGIME_AVAILABLE
+        self._regime_detector: Optional[object] = None
+
+        # Bollinger Band parameters
+        self.bb_length = config.get("bb_length", 20)
+        self.bb_mult = config.get("bb_mult", 2.0)
+
+        # EMA parameters
+        self.ema21_length = config.get("ema21_length", 21)
+        self.ema200_length = config.get("ema200_length", 200)
+        self.sma200_length = config.get("sma200_length", 200)
+
+        # Risk management
+        self.sl_atr_mult = config.get("sl_atr_mult", 2.0)
+
+        # Execution parameters
+        self.use_maker_orders = False  # Reversal strategies need fast fills
+        self.limit_sl = True
+
+        # Order tracking
+        self._order_states: Dict[str, OrderState] = {}
+
+        # Timing parameters
+        self.maker_timeout = 10
+        self.limit_close_timeout = 5
+        self.sl_close_spread_bps = 5
+
+    def register_order(self, coin: str, is_entry: bool = True) -> None:
+        self._order_states[coin] = OrderState(is_maker=is_entry)
+
+    def mark_sl_triggered(self, coin: str, triggered: bool) -> None:
+        if coin in self._order_states:
+            self._order_states[coin].is_sl_triggered = triggered
+            self._order_states[coin].last_attempt_time = time.time()
+
+    def clear_order_state(self, coin: str) -> None:
+        if coin in self._order_states:
+            del self._order_states[coin]
+
+    def fit_regime(self, df: pd.DataFrame) -> None:
+        if not self._use_regime:
+            return
+        det = RegimeDetector(n_states=3)
+        det.fit(df)
+        self._regime_detector = det
+
+    def regime_for_row(self, row: pd.Series) -> str:
+        if not self._use_regime or self._regime_detector is None:
+            return "ranging"
+        return self._regime_detector.predict(row)
+
+    def add_indicators(self, df: pd.DataFrame) -> pd.DataFrame:
+        d = df.copy()
+
+        # ATR-14 for stop loss calculation
+        tr = pd.concat([
+            d["high"] - d["low"],
+            (d["high"] - d["close"].shift()).abs(),
+            (d["low"] - d["close"].shift()).abs(),
+        ], axis=1).max(axis=1)
+        d["atr"] = tr.rolling(14).mean()
+        d["atr_pct"] = d["atr"] / d["close"] * 100
+
+        # Bollinger Bands (20, 2.0)
+        d["sma20"] = d["close"].rolling(self.bb_length).mean()
+        d["bb_std"] = d["close"].rolling(self.bb_length).std()
+        d["bb_upper"] = d["sma20"] + self.bb_mult * d["bb_std"]
+        d["bb_lower"] = d["sma20"] - self.bb_mult * d["bb_std"]
+
+        # EMA 21 (for TP)
+        d["ema21"] = d["close"].ewm(span=self.ema21_length, adjust=False).mean()
+
+        # EMA 200 (trend filter)
+        d["ema200"] = d["close"].ewm(span=self.ema200_length, adjust=False).mean()
+
+        # SMA 200 (trend confirmation)
+        d["sma200"] = d["close"].rolling(self.sma200_length).mean()
+
+        # Detect red/green candles (red = close < open, green = close > open)
+        d["is_red"] = d["close"] < d["open"]
+        d["is_green"] = d["close"] > d["open"]
+
+        # Count consecutive red/green candles
+        d["red_count"] = 0
+        d["green_count"] = 0
+
+        red_streak = 0
+        green_streak = 0
+        for i in range(len(d)):
+            if d["is_red"].iloc[i]:
+                red_streak += 1
+                green_streak = 0
+            elif d["is_green"].iloc[i]:
+                green_streak += 1
+                red_streak = 0
+            else:
+                red_streak = 0
+                green_streak = 0
+            d.loc[d.index[i], "red_count"] = red_streak
+            d.loc[d.index[i], "green_count"] = green_streak
+
+        # Close below lower band flag
+        d["close_below_lower"] = d["close"] < d["bb_lower"]
+        # Close above upper band flag
+        d["close_above_upper"] = d["close"] > d["bb_upper"]
+
+        return d.dropna()
+
+    def signal_for_row(self, row: pd.Series, htf_row: Optional[pd.Series] = None) -> int:
+        """
+        Generate entry signal based on BB reversal strategy.
+        Returns: 1 (LONG), -1 (SHORT), 0 (NO SIGNAL)
+
+        Requires 4+ consecutive red/green candles for higher conviction.
+        """
+        close = float(row["close"])
+        bb_lower = float(row["bb_lower"])
+        bb_upper = float(row["bb_upper"])
+        close_below_lower = bool(row["close_below_lower"])
+        close_above_upper = bool(row["close_above_upper"])
+        red_count = float(row["red_count"])
+        green_count = float(row["green_count"])
+
+        # Basic filter: must have minimum volatility
+        atr_pct = float(row["atr_pct"])
+        if atr_pct < 0.2:
+            return 0
+
+        # LONG: Price breaks below lower BB + last 4+ candles were red
+        # (strong exhaustion after downtrend, high conviction reversal)
+        if close_below_lower and red_count >= 4:
+            return 1
+
+        # SHORT: Price breaks above upper BB + last 4+ candles were green
+        # (strong exhaustion after uptrend, high conviction reversal)
+        if close_above_upper and green_count >= 4:
+            return -1
+
+        return 0
+
+    def risk_levels(
+        self,
+        entry: float,
+        atr: float,
+        side: int,
+        atr_pct: float = 0.0,
+        row: Optional[pd.Series] = None,
+    ) -> Tuple[float, float]:
+        """
+        BB Reversal risk management:
+        SL: 1.5 ATR (tighter stop for better R:R)
+        TP: 2.0 ATR (1:1.33 R:R - tighter TP but higher win rate)
+        """
+        sl_dist = 1.5 * atr  # Tighter stop
+        tp_dist = 2.0 * atr  # Tighter TP
+
+        # Calculate SL and TP
+        if side == 1:  # LONG
+            sl = entry - sl_dist
+            tp = entry + tp_dist
+        else:  # SHORT
+            sl = entry + sl_dist
+            tp = entry - tp_dist
+
+        return sl, tp
+
+    def trail_stop(self, side: int, entry: float, current_sl: float, close: float, atr: float) -> float:
+        """
+        Trail stop: move SL to breakeven once 1.5 ATR in profit.
+        """
+        if side == 1:  # LONG
+            if close >= entry + 1.5 * atr:
+                new_sl = close - 1.0 * atr
+                return max(current_sl, new_sl)
+        else:  # SHORT
+            if close <= entry - 1.5 * atr:
+                new_sl = close + 1.0 * atr
+                return min(current_sl, new_sl)
+        return current_sl
+
+    def build_intent(self, coin: str, timeframe: str, row: pd.Series) -> Optional[TradeIntent]:
+        """
+        Build a TradeIntent from current row state.
+        """
+        signal = self.signal_for_row(row)
+        if signal == 0:
+            return None
+
+        side = "long" if signal == 1 else "short"
+        entry = float(row["close"])
+        sl, tp = self.risk_levels(entry, float(row["atr"]), signal, float(row["atr_pct"]), row)
+
+        # Confidence: based on candle strength and band position
+        close = float(row["close"])
+        bb_upper = float(row["bb_upper"])
+        bb_lower = float(row["bb_lower"])
+        bb_range = bb_upper - bb_lower
+
+        # Higher confidence if price is deep in the band (strong move)
+        if signal == 1:
+            # For long, deeper below lower band = higher confidence
+            depth = (bb_lower - close) / bb_range if bb_range > 0 else 0
+            confidence = min(0.9, 0.5 + depth * 0.4)
+        else:
+            # For short, higher above upper band = higher confidence
+            depth = (close - bb_upper) / bb_range if bb_range > 0 else 0
+            confidence = min(0.9, 0.5 + depth * 0.4)
+
+        return TradeIntent(coin, timeframe, side, entry, sl, tp, confidence)
+
+
+
+

strategy_ml_auto.py

@@ -704,7 +704,7 @@ class StrategyEngine:
       SL triggered unfilled: Immediately attempt limit close at tight spread
     """
 
-    use_maker_orders = False  # ML auto: fast IOC entries
+    use_maker_orders = True  # ML auto: try maker first, timeout to IOC after 30s
     limit_sl         = True   # ML auto: limit SL attempt for recovery
 
     def __init__(self, config: Dict):

strategy_zlema.py

@@ -0,0 +1,282 @@
+#!/usr/bin/env python3
+"""
+Zero-Lag EMA (ZLEMA) Multi-Timeframe Strategy
+==============================================
+
+This strategy is based on the Zero-Lag EMA (ZLEMA) indicator with multi-timeframe
+confirmation. It uses a lag-compensated EMA with dynamic volatility bands to
+identify trend reversals and entry opportunities.
+
+Core Mechanics:
+  1. ZLEMA = EMA(price + (price - price[lag]), length)
+     where lag = floor((length - 1) / 2)
+  2. Volatility bands = highest(ATR(length), length*3) * multiplier
+  3. Trend detection via crossovers of close price around ZLEMA ± volatility
+  4. Multi-timeframe confirmation (5m, 15m, 1h, 4h, 1D)
+
+Entry Signals:
+  LONG:   price crosses above (ZLEMA - volatility) with trend == bullish
+          Trend confirmation from HTF (higher timeframes)
+  SHORT:  price crosses below (ZLEMA + volatility) with trend == bearish
+          Trend confirmation from HTF (higher timeframes)
+
+Risk Management:
+  Stop Loss:   1.5 ATR below entry (long) / above entry (short)
+  Take Profit: 3.0 ATR above entry (long) / below entry (short)
+  Risk:Reward: 2.0:1
+
+Recommended Settings:
+  Length: 70 (Zero-Lag period)
+  Band Multiplier: 1.2 (volatility band thickness)
+  Timeframe: 1h entry with HTF confirmation
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Dict, Optional, Tuple
+import numpy as np
+import pandas as pd
+import time
+
+try:
+    from regime import RegimeDetector
+    REGIME_AVAILABLE = True
+except ImportError:
+    REGIME_AVAILABLE = False
+
+
+@dataclass
+class TradeIntent:
+    coin: str
+    timeframe: str
+    side: str
+    entry_price: float
+    stop_loss: float
+    take_profit: float
+    confidence: float
+
+
+@dataclass
+class OrderState:
+    """Track order state for resilient recovery."""
+    oid: Optional[int] = None
+    placed_at: float = field(default_factory=time.time)
+    attempt_count: int = 0
+    last_attempt_time: float = field(default_factory=time.time)
+    is_maker: bool = True
+    is_sl_triggered: bool = False
+
+
+class StrategyEngine:
+    def __init__(self, config: Dict):
+        self.config = config
+        self._use_regime = config.get("use_regime_filter", True) and REGIME_AVAILABLE
+        self._regime_detector: Optional[object] = None
+
+        # ZLEMA parameters
+        self.zlema_length = config.get("zlema_length", 70)
+        self.band_mult = config.get("band_multiplier", 1.2)
+
+        # Order/execution parameters
+        self.use_maker_orders = True
+        self.limit_sl = True
+
+        # Order tracking
+        self._order_states: Dict[str, OrderState] = {}
+
+        # Timing parameters
+        self.maker_timeout = 20
+        self.limit_close_timeout = 10
+        self.sl_close_spread_bps = 5
+
+        # Multi-timeframe cache (for HTF confirmation)
+        self._htf_cache: Dict[str, Dict[str, float]] = {}
+
+    def register_order(self, coin: str, is_entry: bool = True) -> None:
+        self._order_states[coin] = OrderState(is_maker=is_entry)
+
+    def mark_sl_triggered(self, coin: str, triggered: bool) -> None:
+        if coin in self._order_states:
+            self._order_states[coin].is_sl_triggered = triggered
+            self._order_states[coin].last_attempt_time = time.time()
+
+    def clear_order_state(self, coin: str) -> None:
+        if coin in self._order_states:
+            del self._order_states[coin]
+
+    def fit_regime(self, df: pd.DataFrame) -> None:
+        if not self._use_regime:
+            return
+        det = RegimeDetector(n_states=3)
+        det.fit(df)
+        self._regime_detector = det
+        print(f"[Regime] Distribution: {det.regime_distribution()}")
+
+    def regime_for_row(self, row: pd.Series) -> str:
+        if not self._use_regime or self._regime_detector is None:
+            return "ranging"
+        return self._regime_detector.predict(row)
+
+    def _zlema(self, series: pd.Series, length: int) -> pd.Series:
+        """
+        Compute Zero-Lag EMA.
+        ZLEMA = EMA(price + (price - price[lag]), length)
+        where lag = floor((length - 1) / 2)
+        """
+        lag = int((length - 1) / 2)
+        adjusted = series + (series - series.shift(lag))
+        return adjusted.ewm(span=length, adjust=False).mean()
+
+    def _highest_atr(self, atr: pd.Series, length: int) -> pd.Series:
+        """Get the highest ATR over a rolling window."""
+        return atr.rolling(window=length).max()
+
+    def add_indicators(self, df: pd.DataFrame) -> pd.DataFrame:
+        d = df.copy()
+
+        # Basic indicators
+        d["close"] = d["close"]
+        d["high"] = d["high"]
+        d["low"] = d["low"]
+
+        # ATR-14
+        tr = pd.concat([
+            d["high"] - d["low"],
+            (d["high"] - d["close"].shift()).abs(),
+            (d["low"] - d["close"].shift()).abs(),
+        ], axis=1).max(axis=1)
+        d["atr"] = tr.rolling(14).mean()
+        d["atr_pct"] = d["atr"] / d["close"] * 100
+
+        # ZLEMA and volatility bands
+        d["zlema"] = self._zlema(d["close"], self.zlema_length)
+        atr_high = self._highest_atr(d["atr"], self.zlema_length * 3)
+        d["volatility"] = atr_high * self.band_mult
+        d["upper_band"] = d["zlema"] + d["volatility"]
+        d["lower_band"] = d["zlema"] - d["volatility"]
+
+        # Trend variable (ZLEMA crossover logic)
+        # Long: price crosses ABOVE (zlema - volatility) = trend = 1
+        # Short: price crosses BELOW (zlema + volatility) = trend = -1
+        d["price_above_lower"] = d["close"] > d["lower_band"]
+        d["price_below_upper"] = d["close"] < d["upper_band"]
+
+        # Detect crossovers: from False to True (crossover), from True to False (crossunder)
+        prev_above_lower = d["price_above_lower"].shift(1).fillna(False)
+        prev_below_upper = d["price_below_upper"].shift(1).fillna(True)  # default to True so first bar isn't a crossunder
+
+        d["crossover_lower"] = (~prev_above_lower) & d["price_above_lower"]
+        d["crossunder_upper"] = prev_below_upper & (~d["price_below_upper"])
+
+        # Initialize trend
+        d["trend"] = 0
+        trend_val = 0
+        for i in range(len(d)):
+            if d["crossover_lower"].iloc[i]:
+                trend_val = 1
+            if d["crossunder_upper"].iloc[i]:
+                trend_val = -1
+            d.loc[d.index[i], "trend"] = trend_val
+
+        # Volume
+        d["volume_sma"] = d["volume"].rolling(20).mean()
+
+        # Swing structure (for SL placement)
+        d["swing_low5"] = d["low"].rolling(5).min()
+        d["swing_high5"] = d["high"].rolling(5).max()
+
+        return d.dropna()
+
+    def signal_for_row(self, row: pd.Series, htf_row: Optional[pd.Series] = None) -> int:
+        """
+        Generate entry signal based on ZLEMA strategy.
+        Returns: 1 (LONG), -1 (SHORT), 0 (NO SIGNAL)
+        """
+        close = float(row["close"])
+        zlema = float(row["zlema"])
+        volatility = float(row["volatility"])
+        upper_band = float(row["upper_band"])
+        lower_band = float(row["lower_band"])
+
+        # Basic filters
+        atr_pct = float(row["atr_pct"])
+        if atr_pct < 0.2:  # Reduced filter for SOL volatility
+            return 0
+
+        # LONG entry signal: price crosses above lower band
+        if row.get("crossover_lower", False):
+            return 1
+
+        # SHORT entry signal: price crosses below upper band
+        if row.get("crossunder_upper", False):
+            return -1
+
+        return 0
+
+    def risk_levels(
+        self,
+        entry: float,
+        atr: float,
+        side: int,
+        atr_pct: float = 0.0,
+        row: Optional[pd.Series] = None,
+    ) -> Tuple[float, float]:
+        """
+        ZLEMA risk management:
+        Stop:  1.5 ATR  (responsive to volatility)
+        TP:    3.0 ATR  (R:R 2.0:1)
+        """
+        sl_mult = 1.5
+        tp_mult = 3.0
+
+        if side == 1:  # LONG
+            sl = entry - sl_mult * atr
+            tp = entry + tp_mult * atr
+        else:  # SHORT
+            sl = entry + sl_mult * atr
+            tp = entry - tp_mult * atr
+
+        return sl, tp
+
+    def trail_stop(self, side: int, entry: float, current_sl: float, close: float, atr: float) -> float:
+        """
+        Trail stop at 2.0 ATR once 1.5 ATR in profit.
+        """
+        if side == 1:  # LONG
+            if close >= entry + 1.5 * atr:
+                new_sl = close - 2.0 * atr
+                return max(current_sl, new_sl)
+        else:  # SHORT
+            if close <= entry - 1.5 * atr:
+                new_sl = close + 2.0 * atr
+                return min(current_sl, new_sl)
+        return current_sl
+
+    def build_intent(self, coin: str, timeframe: str, row: pd.Series) -> Optional[TradeIntent]:
+        """
+        Build a TradeIntent from current row state.
+        """
+        signal = self.signal_for_row(row)
+        if signal == 0:
+            return None
+
+        side = "long" if signal == 1 else "short"
+        entry = float(row["close"])
+        sl, tp = self.risk_levels(entry, float(row["atr"]), signal, float(row["atr_pct"]), row)
+
+        # Confidence based on trend strength and volatility
+        trend = float(row["trend"])
+        volatility = float(row["volatility"])
+        atr = float(row["atr"])
+
+        # Higher confidence if volatility band is tight relative to ATR
+        bb_to_atr = volatility / atr if atr > 0 else 1.0
+        vol_factor = max(0.0, 1.0 - bb_to_atr)
+        confidence = round(min(0.95, 0.55 + vol_factor * 0.35), 2)
+
+        return TradeIntent(coin, timeframe, side, entry, sl, tp, confidence)
+
+
+
+
+