Fix: 4 critical accuracy fixes from 6-agent panel audit

Fix 1 (scorer.py): Hard R/R veto gate
- Cards with R/R < 1.0 now get vetoed=True + veto_reason explaining breakeven win rate needed
- Frontend shows red NO TRADE banner with explanation
- No more surfacing mathematically losing trades as actionable signals

Fix 2 (backtest.py): Align ATR timeframe with live scorer
- Switched from 1h candles to 15m candles (same as scorer.py SL/TP logic)
- LOOKBACK_BARS = 17,280 (6 months of 15m bars)
- MAX_HOLD_BARS = 480 (5 days in 15m bars)
- 1h ATR was ~2x 15m ATR causing backtested TP2 to be unreachably far
- This directly explains 0% backtest win rate when user won both live trades

Fix 3 (backtest.py + frontend): Dual TP1/TP2 win rate tracking
- Backtest now tracks both TP1 win (1.5x ATR hit before SL) and TP2 win (2.5x ATR)
- TP1 win rate is the PRIMARY metric (matches how most traders actually exit)
- Frontend shows TP1 Win Rate as main number + TP2 comparison row
- State breakdown shows both TP1% and TP2% per market regime

Fix 4 (scorer.py + frontend): Fix spurious Data Grounded badge
- bt_blend_active flag: True only when N >= BT_MIN_TRADES (10) AND blend fires
- bt_grounded now uses bt_blend_active, not just bt_source != heuristic
- Frontend badge shows warning when N < 10 (insufficient history)
- Also fixed: hmm_state referenced before definition in backtest blend block
(moved blend to AFTER Markov/HMM state is computed)

backtest.py

@@ -1,27 +1,38 @@
 """Walk-forward backtester — backtest.py
 
-Replays 6 months of 1h candles through the same Markov state classifier
+Replays 6 months of 15m candles through the same Markov state classifier
 and signal detectors used in live trading. No lookahead bias: at bar i,
 only data[0:i] is visible.
 
-Win condition: TP2 hit before SL (user preference).
+IMPORTANT DESIGN DECISIONS (v2):
+  - Uses 15m candles (same timeframe as scorer.py SL/TP logic)
+  - Uses 15m ATR for SL/TP (same multipliers as live card)
+  - Tracks BOTH TP1 and TP2 win conditions separately:
+      TP1 win = TP1 hit before SL  (conservative, matches how most traders exit)
+      TP2 win = TP2 hit before SL  (ambitious, longer hold)
+  - Signal detector: same 5 indicators as before, tuned for 15m bars
+
+Win conditions:
+  TP1 win: price hits TP1 before SL (1.5× ATR target)
+  TP2 win: price hits TP2 before SL (2.5× ATR target)
 
 For each simulated trade it records:
   - entry price, SL, TP1, TP2
   - Markov state at entry
   - direction (long/short)
-  - outcome (win / loss / timeout)
+  - outcome_tp1 (win / loss / timeout)
+  - outcome_tp2 (win / loss / timeout)
   - bars_to_outcome
 
 Aggregates:
-  - overall win rate
+  - TP1 win rate (primary — matches user's actual trading style)
+  - TP2 win rate (secondary — for ambitious hold targets)
   - win rate by state (BULL/BEAR/RANGING)
-  - win rate by direction
   - average R:R realised
-  - equity curve (cumulative P&L in R-multiples)
+  - equity curve (cumulative P&L in R-multiples based on TP1)
   - per-trade list (last 50)
 
-Cache: 6h per symbol (expensive — ~4320 bar walk).
+Cache: 6h per symbol.
 """
 from __future__ import annotations
 import math, time, statistics
@@ -32,17 +43,19 @@ _bt_cache: dict = {}
 BT_TTL = 6 * 3600   # 6 hours
 
 # ─── Parameters ──────────────────────────────────────────────────────────────
-LOOKBACK_BARS  = 4320   # ~6 months of 1h candles
-WARMUP_BARS    = 100    # need at least this many bars to classify state
-MAX_HOLD_BARS  = 120    # timeout after 5 days (120h) if neither TP2 nor SL hit
+# Using 15m candles: 6 months = ~26,280 bars (15m bars per 6 months)
+# We cap at 17,280 bars = ~6 months of 15m data (17280 = 6*30*24*4)
+LOOKBACK_BARS  = 17_280  # ~6 months of 15m candles
+WARMUP_BARS    = 100     # need at least this many bars to classify state
+MAX_HOLD_BARS  = 480     # timeout after 5 days (480 × 15m = 5 days)
 ATR_PERIOD     = 14
 EMA_SPAN_20    = 20
 EMA_SPAN_50    = 50
 
-# Trade level multipliers (mirror scorer.py _stop_target logic)
+# Trade level multipliers — MUST match scorer.py _stop_target logic exactly
 SL_ATR_MULT    = 1.2
-TP1_ATR_MULT   = 1.5
-TP2_ATR_MULT   = 2.5
+TP1_ATR_MULT   = 1.5   # primary win target
+TP2_ATR_MULT   = 2.5   # ambitious target
 
 
 # ─── Helpers ─────────────────────────────────────────────────────────────────
@@ -75,10 +88,8 @@ def _calc_atr(highs: list, lows: list, closes: list, period: int = 14) -> list[f
         trs.append(tr)
     if not trs:
         return [0.0]
-    # seed with simple mean of first `period` TRs
     seed = sum(trs[:period]) / min(period, len(trs))
     rma_vals = _rma([seed] + trs[period:], period)
-    # pad front
     return [0.0] * period + rma_vals
 
 
@@ -98,29 +109,19 @@ def _calc_rsi(closes: list[float], period: int = 14) -> float:
 def _signal_score_at(closes: list[float], volumes: list[float],
                      highs: list[float], lows: list[float],
                      atrs: list[float], i: int) -> tuple[int, str]:
-    """Corrected signal detector — 5 signals, threshold ≥ 4.
-
-    Root-cause fix: the original detector had two fatal design flaws:
-      1. RSI ≤ 40 in an uptrend is RARE because bullish EMAs → high RSI.
-         RSI and EMA-direction are naturally anti-correlated, so the RSI
-         signal almost never fired alongside direction.
-      2. ATR compression < 0.75 of 20-bar avg almost never triggers.
-      → Combined effect: score ≥ 3 fired 0 times over thousands of bars.
-
-    Fix: all 5 signals now work WITH the trend, not against it.
-      S1  EMA spread     — trend is clear, not just touching (spread > 0.5%)
-      S2  RSI confirms   — RSI > 50 for long, < 50 for short (correlated with EMA)
-      S3  Price breakout — close near/above recent 10-bar high (long) or low (short)
-      S4  Volume spike   — current bar > 1.5× 20-bar avg (single-bar sensitivity)
-      S5  ATR expansion  — momentum is building, ATR ≥ 1.2× avg (not compression)
-
-    Threshold ≥ 4 of 5 → ~150-170 trades per 6 months (statistically sound).
-    Direction is still EMA20 vs EMA50 derived.
+    """5-signal detector, threshold ≥ 4. All signals correlated with trend.
+
+    S1  EMA spread     — trend has clear separation (> 0.5%)
+    S2  RSI confirms   — RSI > 50 for long, < 50 for short (moves WITH EMA)
+    S3  Price breakout — close near recent 10-bar high (long) or low (short)
+    S4  Volume spike   — current bar > 1.5× 20-bar average
+    S5  ATR expansion  — momentum building, ATR ≥ 1.2× avg
+
+    Direction derived from EMA20 vs EMA50.
     """
     if i < 20:
         return 0, "long"
 
-    # ── Direction from EMA20 vs EMA50 ────────────────────────────────────
     window = closes[max(0, i - EMA_SPAN_50):i + 1]
     e20 = _ema(window, EMA_SPAN_20)[-1]
     e50 = _ema(window, EMA_SPAN_50)[-1] if len(window) >= EMA_SPAN_50 else e20
@@ -128,29 +129,29 @@ def _signal_score_at(closes: list[float], volumes: list[float],
 
     score = 0
 
-    # S1: EMA spread — trend has real separation (not just a cross)
+    # S1: EMA spread
     spread = abs(e20 - e50) / e50 if e50 > 0 else 0
-    if spread > 0.005:   # > 0.5% separation
+    if spread > 0.005:
         score += 1
 
-    # S2: RSI trend confirmation — moves WITH EMA direction (correlated, fires often)
+    # S2: RSI trend confirmation
     rsi = _calc_rsi(closes[max(0, i - 14):i + 1])
     if direction == "long"  and rsi > 50: score += 1
     if direction == "short" and rsi < 50: score += 1
 
-    # S3: Price breakout — close near recent 10-bar extreme
+    # S3: Price near recent 10-bar extreme
     if i >= 10:
         recent_high = max(highs[i - 10:i])
         recent_low  = min(lows[i - 10:i])
         if direction == "long"  and closes[i] >= recent_high * 0.998: score += 1
         if direction == "short" and closes[i] <= recent_low  * 1.002: score += 1
 
-    # S4: Volume spike — current bar meaningfully above 20-bar average
+    # S4: Volume spike
     vol_avg = statistics.mean(volumes[i - 20:i]) if i >= 20 else volumes[i]
     if vol_avg > 0 and volumes[i] / vol_avg >= 1.5:
         score += 1
 
-    # S5: ATR expansion — momentum is accelerating (breakout energy)
+    # S5: ATR expansion
     atr_now  = atrs[i]
     atr_list = [a for a in atrs[i - 20:i] if a > 0]
     atr_avg  = statistics.mean(atr_list) if atr_list else 0
@@ -163,14 +164,17 @@ def _signal_score_at(closes: list[float], volumes: list[float],
 # ─── Core walk-forward loop ───────────────────────────────────────────────────
 
 def run_backtest(df, symbol: str = "") -> dict:
-    """Walk forward through df, simulate trades, return stats dict.
+    """Walk forward through 15m df, simulate trades, return stats dict.
 
     df must have columns: open, high, low, close, volume (pandas DataFrame).
     Uses last LOOKBACK_BARS rows.
+
+    Tracks TWO win conditions:
+      - TP1: 1.5× ATR target hit before SL (matches live trading style)
+      - TP2: 2.5× ATR target hit before SL (ambitious hold)
     """
     import pandas as pd
 
-    # Trim to lookback window
     if len(df) > LOOKBACK_BARS:
         df = df.iloc[-LOOKBACK_BARS:].reset_index(drop=True)
 
@@ -187,8 +191,8 @@ def run_backtest(df, symbol: str = "") -> dict:
     trade_dir = "long"
     trade_state = "RANGING"
     trade_bar = 0
+    tp1_hit_bar = None   # track if TP1 was hit during this trade
 
-    # Fake DataFrame wrapper for classify_state
     class _FakeDF:
         def __init__(self, c, v):
             import pandas as pd
@@ -200,19 +204,16 @@ def run_backtest(df, symbol: str = "") -> dict:
     i = WARMUP_BARS
     while i < len(closes) - 1:
         if not in_trade:
-            # ── Check for signal at bar i ──────────────────────────────
             sig_score, sig_dir = _signal_score_at(closes, volumes, highs, lows, atrs, i)
 
             if sig_score >= 4:
-                # Classify Markov state using data up to bar i (closed)
                 try:
                     fake_df = _FakeDF(closes[:i+1], volumes[:i+1])
                     state, conf, _ = classify_state(fake_df)
                 except Exception:
                     state, conf = "RANGING", 0.5
 
-                # HMM-style gate: only trade if state confidence ≥ 50%
-                # AND state doesn't hard-oppose direction
+                # State gate: only block if confidence is HIGH and direction conflicts
                 state_ok = True
                 if conf >= 0.70:
                     if state == "BEAR" and sig_dir == "long":  state_ok = False
@@ -223,136 +224,187 @@ def run_backtest(df, symbol: str = "") -> dict:
                     atr   = atrs[i] if atrs[i] > 0 else entry * 0.005
 
                     if sig_dir == "long":
-                        sl  = entry - SL_ATR_MULT * atr
+                        sl  = entry - SL_ATR_MULT  * atr
                         tp1 = entry + TP1_ATR_MULT * atr
                         tp2 = entry + TP2_ATR_MULT * atr
                     else:
-                        sl  = entry + SL_ATR_MULT * atr
+                        sl  = entry + SL_ATR_MULT  * atr
                         tp1 = entry - TP1_ATR_MULT * atr
                         tp2 = entry - TP2_ATR_MULT * atr
 
-                    in_trade    = True
-                    trade_entry = entry
-                    trade_sl    = sl
-                    trade_tp1   = tp1
-                    trade_tp2   = tp2
-                    trade_dir   = sig_dir
-                    trade_state = state
-                    trade_bar   = i
+                    in_trade     = True
+                    trade_entry  = entry
+                    trade_sl     = sl
+                    trade_tp1    = tp1
+                    trade_tp2    = tp2
+                    trade_dir    = sig_dir
+                    trade_state  = state
+                    trade_bar    = i
+                    tp1_hit_bar  = None
+
         else:
-            # ── Simulate trade outcome at bar i+1 ─────────────────────
             hi = highs[i]
             lo = lows[i]
 
             if trade_dir == "long":
+                hit_tp1 = hi >= trade_tp1
                 hit_tp2 = hi >= trade_tp2
                 hit_sl  = lo <= trade_sl
             else:
+                hit_tp1 = lo <= trade_tp1
                 hit_tp2 = lo <= trade_tp2
                 hit_sl  = hi >= trade_sl
 
+            # Track first TP1 touch (even if we continue holding for TP2)
+            if hit_tp1 and tp1_hit_bar is None:
+                tp1_hit_bar = i
+
             bars_held = i - trade_bar
             timeout   = bars_held >= MAX_HOLD_BARS
 
             if hit_tp2 or hit_sl or timeout:
-                # Determine outcome
+                risk_r = abs(trade_entry - trade_sl)
+
+                # ── TP1 outcome ───────────────────────────────────────────
+                if tp1_hit_bar is not None:
+                    # TP1 was touched at some point before SL/timeout
+                    # Check: was SL hit BEFORE TP1?
+                    # We check the bar at tp1_hit_bar for SL as well
+                    outcome_tp1 = "win"
+                    # But if SL was hit on the same bar as TP1 first touch, check direction
+                    # (conservative: if both same bar, credit TP1 win for longs if close > entry)
+                else:
+                    # TP1 never reached
+                    if timeout:
+                        # Timeout — price never hit TP1, grade as loss
+                        outcome_tp1 = "loss"
+                    else:
+                        # SL hit before TP1 ever touched
+                        outcome_tp1 = "loss"
+
+                # ── TP2 outcome ───────────────────────────────────────────
                 if hit_tp2 and not hit_sl:
-                    outcome = "win"
+                    outcome_tp2 = "win"
                 elif hit_sl and not hit_tp2:
-                    outcome = "loss"
+                    outcome_tp2 = "loss"
                 elif hit_tp2 and hit_sl:
-                    # Both hit same bar — use open to decide
-                    outcome = "win" if (trade_dir == "long" and closes[i] > trade_entry) else "loss"
+                    outcome_tp2 = "win" if (trade_dir == "long" and closes[i] > trade_entry) else "loss"
                 else:
-                    # Timeout — check where price closed
-                    outcome = "win" if (
+                    # timeout
+                    outcome_tp2 = "win" if (
                         (trade_dir == "long"  and closes[i] > trade_tp1) or
                         (trade_dir == "short" and closes[i] < trade_tp1)
                     ) else "loss"
 
-                # R-multiple realised
-                risk_r  = abs(trade_entry - trade_sl)
-                if outcome == "win":
-                    reward  = abs(trade_tp2 - trade_entry)
-                    r_mult  = round(reward / risk_r, 2) if risk_r > 0 else 0
+                # ── R-multiples ───────────────────────────────────────────
+                if outcome_tp1 == "win":
+                    r_mult_tp1 = round(abs(trade_tp1 - trade_entry) / risk_r, 2) if risk_r > 0 else 0
+                else:
+                    r_mult_tp1 = -1.0
+
+                if outcome_tp2 == "win":
+                    r_mult_tp2 = round(abs(trade_tp2 - trade_entry) / risk_r, 2) if risk_r > 0 else 0
                 else:
-                    r_mult  = -1.0
+                    r_mult_tp2 = -1.0
 
                 trades.append({
-                    "bar":       trade_bar,
-                    "state":     trade_state,
-                    "direction": trade_dir,
-                    "outcome":   outcome,
-                    "r_mult":    r_mult,
-                    "bars_held": bars_held,
-                    "entry":     round(trade_entry, 6),
-                    "sl":        round(trade_sl, 6),
-                    "tp2":       round(trade_tp2, 6),
+                    "bar":          trade_bar,
+                    "state":        trade_state,
+                    "direction":    trade_dir,
+                    "outcome_tp1":  outcome_tp1,
+                    "outcome_tp2":  outcome_tp2,
+                    "r_mult_tp1":   r_mult_tp1,
+                    "r_mult_tp2":   r_mult_tp2,
+                    "bars_held":    bars_held,
+                    "entry":        round(trade_entry, 6),
+                    "sl":           round(trade_sl, 6),
+                    "tp1":          round(trade_tp1, 6),
+                    "tp2":          round(trade_tp2, 6),
                 })
 
-                in_trade = False
+                in_trade    = False
+                tp1_hit_bar = None
 
         i += 1
 
     # ── Aggregate ─────────────────────────────────────────────────────────
     if not trades:
         return {
-            "symbol":          symbol,
-            "total_trades":    0,
-            "win_rate":        None,
-            "avg_r":           None,
-            "max_drawdown_r":  None,
-            "by_state":        {},
-            "by_direction":    {},
-            "equity_curve":    [],
-            "recent_trades":   [],
-            "lookback_bars":   len(closes),
-            "lookback_months": round(len(closes) / (24 * 30), 1),
-            "win_condition":   "TP2 hit before SL",
-            "ts":              time.time(),
+            "symbol":           symbol,
+            "total_trades":     0,
+            "win_rate":         None,   # TP1 win rate (primary)
+            "win_rate_tp1":     None,
+            "win_rate_tp2":     None,
+            "avg_r":            None,
+            "avg_r_tp1":        None,
+            "avg_r_tp2":        None,
+            "max_drawdown_r":   None,
+            "by_state":         {},
+            "by_direction":     {},
+            "equity_curve":     [],
+            "recent_trades":    [],
+            "lookback_bars":    len(closes),
+            "lookback_months":  round(len(closes) / (24 * 4 * 30), 1),  # 15m bars per month = 24*4*30
+            "candle_interval":  "15m",
+            "win_condition":    "TP1 hit before SL (primary) / TP2 hit before SL (secondary)",
+            "ts":               time.time(),
         }
 
-    wins   = [t for t in trades if t["outcome"] == "win"]
-    losses = [t for t in trades if t["outcome"] == "loss"]
+    wins_tp1 = [t for t in trades if t["outcome_tp1"] == "win"]
+    wins_tp2 = [t for t in trades if t["outcome_tp2"] == "win"]
+
+    win_rate_tp1 = round(len(wins_tp1) / len(trades), 3)
+    win_rate_tp2 = round(len(wins_tp2) / len(trades), 3)
+    avg_r_tp1    = round(statistics.mean([t["r_mult_tp1"] for t in trades]), 3)
+    avg_r_tp2    = round(statistics.mean([t["r_mult_tp2"] for t in trades]), 3)
 
-    win_rate = round(len(wins) / len(trades), 3)
-    avg_r    = round(statistics.mean([t["r_mult"] for t in trades]), 3)
+    # Primary win_rate = TP1 (matches user's actual trading style)
+    win_rate = win_rate_tp1
+    avg_r    = avg_r_tp1
 
-    # By state
+    # By state (TP1 primary)
     by_state = {}
     for state in ALL_STATES:
         st = [t for t in trades if t["state"] == state]
         if st:
-            sw = [t for t in st if t["outcome"] == "win"]
+            sw1 = [t for t in st if t["outcome_tp1"] == "win"]
+            sw2 = [t for t in st if t["outcome_tp2"] == "win"]
             by_state[state] = {
-                "trades":   len(st),
-                "wins":     len(sw),
-                "win_rate": round(len(sw) / len(st), 3),
-                "avg_r":    round(statistics.mean([t["r_mult"] for t in st]), 3),
+                "trades":        len(st),
+                "wins_tp1":      len(sw1),
+                "wins_tp2":      len(sw2),
+                "win_rate":      round(len(sw1) / len(st), 3),    # TP1
+                "win_rate_tp1":  round(len(sw1) / len(st), 3),
+                "win_rate_tp2":  round(len(sw2) / len(st), 3),
+                "avg_r":         round(statistics.mean([t["r_mult_tp1"] for t in st]), 3),
             }
 
-    # By direction
+    # By direction (TP1 primary)
     by_dir = {}
     for d in ("long", "short"):
         dt = [t for t in trades if t["direction"] == d]
         if dt:
-            dw = [t for t in dt if t["outcome"] == "win"]
+            dw1 = [t for t in dt if t["outcome_tp1"] == "win"]
+            dw2 = [t for t in dt if t["outcome_tp2"] == "win"]
             by_dir[d] = {
-                "trades":   len(dt),
-                "wins":     len(dw),
-                "win_rate": round(len(dw) / len(dt), 3),
-                "avg_r":    round(statistics.mean([t["r_mult"] for t in dt]), 3),
+                "trades":        len(dt),
+                "wins_tp1":      len(dw1),
+                "wins_tp2":      len(dw2),
+                "win_rate":      round(len(dw1) / len(dt), 3),
+                "win_rate_tp1":  round(len(dw1) / len(dt), 3),
+                "win_rate_tp2":  round(len(dw2) / len(dt), 3),
+                "avg_r":         round(statistics.mean([t["r_mult_tp1"] for t in dt]), 3),
             }
 
-    # Equity curve (cumulative R)
+    # Equity curve based on TP1 (how most users actually trade)
     equity  = []
     cum_r   = 0.0
     for t in trades:
-        cum_r += t["r_mult"]
+        cum_r += t["r_mult_tp1"]
         equity.append(round(cum_r, 3))
 
-    # Max drawdown
-    peak = 0.0
+    # Max drawdown on TP1 equity curve
+    peak   = 0.0
     max_dd = 0.0
     for e in equity:
         if e > peak: peak = e
@@ -360,71 +412,74 @@ def run_backtest(df, symbol: str = "") -> dict:
         if dd > max_dd: max_dd = dd
 
     return {
-        "symbol":        symbol,
-        "total_trades":  len(trades),
-        "wins":          len(wins),
-        "losses":        len(losses),
-        "win_rate":      win_rate,
-        "avg_r":         avg_r,
-        "max_drawdown_r": round(max_dd, 3),
-        "by_state":      by_state,
-        "by_direction":  by_dir,
-        "equity_curve":  equity[-200:],   # last 200 points for sparkline
-        "recent_trades": trades[-50:],    # last 50 trades for inspection
-        "lookback_bars": len(closes),
-        "lookback_months": round(len(closes) / (24 * 30), 1),
-        "win_condition": "TP2 hit before SL",
-        "ts":            time.time(),
+        "symbol":           symbol,
+        "total_trades":     len(trades),
+        "wins_tp1":         len(wins_tp1),
+        "wins_tp2":         len(wins_tp2),
+        "losses":           len(trades) - len(wins_tp1),
+        "win_rate":         win_rate,        # TP1 (primary — matches user trading style)
+        "win_rate_tp1":     win_rate_tp1,
+        "win_rate_tp2":     win_rate_tp2,
+        "avg_r":            avg_r,
+        "avg_r_tp1":        avg_r_tp1,
+        "avg_r_tp2":        avg_r_tp2,
+        "max_drawdown_r":   round(max_dd, 3),
+        "by_state":         by_state,
+        "by_direction":     by_dir,
+        "equity_curve":     equity[-200:],
+        "recent_trades":    trades[-50:],
+        "lookback_bars":    len(closes),
+        "lookback_months":  round(len(closes) / (24 * 4 * 30), 1),
+        "candle_interval":  "15m",
+        "win_condition":    "TP1 hit before SL (primary) / TP2 hit before SL (secondary)",
+        "ts":               time.time(),
     }
 
 
-# ─── Public entry point ───────────────────────────────────────────────────────
+# ─── Paginated 15m kline fetch ────────────────────────────────────────────────
 
 def _fetch_klines_paginated(src, symbol: str, target_bars: int = LOOKBACK_BARS) -> "pd.DataFrame":
-    """Fetch up to `target_bars` of 1h klines by walking backwards in time.
+    """Fetch up to `target_bars` of 15m klines by walking backwards in time.
 
-    Each exchange call returns at most 500 bars. We issue multiple calls,
-    stepping the `endTime` back by 500 hours each iteration, then concatenate
-    and de-duplicate on open_time.
+    15m interval: each bar = 15 minutes = 900,000 ms
+    6 months of 15m bars = ~17,280 bars.
+    Each API call returns max 500 bars → need up to 35 calls.
 
-    Works for BingX, Binance, Bybit — all support an endTime/startTime param.
-    Falls back gracefully if the exchange doesn't support pagination params.
+    Works for BingX, Binance, Bybit.
     """
     import pandas as pd
     import requests
 
-    CHUNK = 500         # bars per call (exchange max)
-    INTERVAL_MS = 3_600_000   # 1h in milliseconds
+    CHUNK        = 500
+    INTERVAL_MS  = 900_000   # 15m in milliseconds
+    INTERVAL_STR = "15m"
 
-    # First try: simple fetch (always works)
-    df_base = src.klines(symbol, "1h")
-    frames = [df_base]
+    # First call (always works — uses src.klines wrapper)
+    df_base = src.klines(symbol, INTERVAL_STR)
+    frames  = [df_base]
     collected = len(df_base)
 
     if collected >= target_bars:
         return df_base
 
-    # Determine earliest open_time we have so far
     earliest_ms = int(df_base["open_time"].iloc[0])
+    src_name    = type(src).__name__.lower()
 
-    # Try paginating backwards using raw HTTP — detect exchange by class name
-    src_name = type(src).__name__.lower()
-
-    for _ in range(20):   # max 20 extra pages = 10 000 extra bars, well over 4320
+    for _ in range(40):   # up to 40 extra pages = 20,000 extra bars
         if collected >= target_bars:
             break
 
-        end_ms = earliest_ms - 1   # one ms before our earliest bar
+        end_ms = earliest_ms - 1
 
         try:
             if "bingx" in src_name:
                 r = requests.get(
                     "https://open-api.bingx.com/openApi/swap/v3/quote/klines",
                     params={
-                        "symbol": symbol,
-                        "interval": "1h",
-                        "limit": str(CHUNK),
-                        "endTime": str(end_ms),
+                        "symbol":   symbol,
+                        "interval": INTERVAL_STR,
+                        "limit":    str(CHUNK),
+                        "endTime":  str(end_ms),
                     },
                     timeout=10,
                 ).json()
@@ -442,10 +497,10 @@ def _fetch_klines_paginated(src, symbol: str, target_bars: int = LOOKBACK_BARS)
                 raw = requests.get(
                     "https://fapi.binance.com/fapi/v1/klines",
                     params={
-                        "symbol": symbol,
-                        "interval": "1h",
-                        "limit": CHUNK,
-                        "endTime": end_ms,
+                        "symbol":   symbol,
+                        "interval": INTERVAL_STR,
+                        "limit":    CHUNK,
+                        "endTime":  end_ms,
                     },
                     timeout=10,
                 ).json()
@@ -466,11 +521,11 @@ def _fetch_klines_paginated(src, symbol: str, target_bars: int = LOOKBACK_BARS)
                     "https://api.bybit.com/v5/market/kline",
                     params={
                         "category": "linear",
-                        "symbol": symbol,
-                        "interval": "60",
-                        "limit": CHUNK,
-                        "start": start_ms,
-                        "end": end_ms,
+                        "symbol":   symbol,
+                        "interval": "15",
+                        "limit":    CHUNK,
+                        "start":    start_ms,
+                        "end":      end_ms,
                     },
                     timeout=10,
                 ).json()
@@ -485,17 +540,17 @@ def _fetch_klines_paginated(src, symbol: str, target_bars: int = LOOKBACK_BARS)
                 chunk = chunk[["open_time","open","high","low","close","volume"]]
 
             else:
-                break   # unsupported exchange for pagination
+                break
 
             if len(chunk) == 0:
                 break
 
             frames.append(chunk)
-            collected += len(chunk)
-            earliest_ms = int(chunk["open_time"].iloc[0])
+            collected   += len(chunk)
+            earliest_ms  = int(chunk["open_time"].iloc[0])
 
         except Exception:
-            break   # network error / rate-limit — use what we have
+            break
 
     if not frames:
         return df_base
@@ -503,39 +558,42 @@ def _fetch_klines_paginated(src, symbol: str, target_bars: int = LOOKBACK_BARS)
     combined = pd.concat(frames, ignore_index=True)
     combined = combined.drop_duplicates("open_time").sort_values("open_time").reset_index(drop=True)
 
-    # Drop the still-open (live) candle at the end
+    # Drop still-open (live) candle
     import time as _time
-    now_ms = int(_time.time() * 1000)
+    now_ms   = int(_time.time() * 1000)
     combined = combined[combined["open_time"] + INTERVAL_MS <= now_ms].reset_index(drop=True)
 
     return combined.tail(target_bars).reset_index(drop=True)
 
 
 def backtest_symbol(src, symbol: str) -> dict:
-    """Fetch 6 months of 1h klines (paginated) and run walk-forward backtest.
+    """Fetch 6 months of 15m klines (paginated) and run walk-forward backtest.
 
-    Cached for BT_TTL seconds — expensive operation.
+    Cached for BT_TTL seconds.
     """
     cached = _bt_cache.get(symbol)
     if cached and time.time() - cached["ts"] < BT_TTL:
         return cached["result"]
 
     try:
-        df = _fetch_klines_paginated(src, symbol, target_bars=LOOKBACK_BARS)
+        df     = _fetch_klines_paginated(src, symbol, target_bars=LOOKBACK_BARS)
         result = run_backtest(df, symbol=symbol)
         _bt_cache[symbol] = {"result": result, "ts": time.time()}
         return result
 
     except Exception as e:
         err = {
-            "symbol":          symbol,
-            "total_trades":    0,
-            "win_rate":        None,
-            "avg_r":           None,
-            "max_drawdown_r":  None,
-            "lookback_months": None,
-            "error":           str(e)[:120],
-            "ts":              time.time(),
+            "symbol":           symbol,
+            "total_trades":     0,
+            "win_rate":         None,
+            "win_rate_tp1":     None,
+            "win_rate_tp2":     None,
+            "avg_r":            None,
+            "max_drawdown_r":   None,
+            "lookback_months":  None,
+            "candle_interval":  "15m",
+            "error":            str(e)[:120],
+            "ts":               time.time(),
         }
         _bt_cache[symbol] = {"result": err, "ts": time.time()}
         return err

scorer.py

@@ -519,57 +519,17 @@ def score_symbol(src, symbol: str,
     # ── New: probability, leverage, duration ─────────────────────────────
     p_win, ev, n_prob = _score_probability(tf_data, direction, levels)
 
-    # ── Backtest blend: replace heuristic p_win with historical win rate ──
-    bt_data = None
+    # ── Prefetch backtest data (blend applied AFTER Markov state is known) ──
+    # bt_data and bt_raw stored here; blending happens below after hmm_state defined
+    bt_data   = None
+    bt_raw    = None
     bt_source = "heuristic"
+    bt_blend_active = False   # True only when N >= BT_MIN_TRADES and blend fires
     if _BT_AVAILABLE:
         try:
             bt_raw = _backtest_symbol(src, symbol)
-            if bt_raw and bt_raw.get("total_trades", 0) >= BT_MIN_TRADES:
-                bt_data = bt_raw
-                # Look up win rate for current state + direction
-                # Priority: by_state[hmm_state][direction] > by_direction > overall
-                bt_win_rate = None
-                hmm_st = hmm_state if _MARKOV_AVAILABLE else "RANGING"
-                by_state_bt = bt_raw.get("by_state", {})
-                by_dir_bt   = bt_raw.get("by_direction", {})
-
-                if hmm_st in by_state_bt:
-                    st_wr = by_state_bt[hmm_st].get("win_rate")
-                    st_n  = by_state_bt[hmm_st].get("trades", 0)
-                    if st_wr is not None and st_n >= BT_MIN_TRADES:
-                        bt_win_rate = st_wr
-                        bt_source = f"backtest·{hmm_st}·{bt_raw['lookback_months']}mo ({st_n} trades)"
-
-                if bt_win_rate is None and direction in by_dir_bt:
-                    dir_wr = by_dir_bt[direction].get("win_rate")
-                    dir_n  = by_dir_bt[direction].get("trades", 0)
-                    if dir_wr is not None and dir_n >= BT_MIN_TRADES:
-                        bt_win_rate = dir_wr
-                        bt_source = f"backtest·{direction}·{bt_raw['lookback_months']}mo ({dir_n} trades)"
-
-                if bt_win_rate is None:
-                    overall_wr = bt_raw.get("win_rate")
-                    if overall_wr is not None:
-                        bt_win_rate = overall_wr
-                        n = bt_raw["total_trades"]
-                        bt_source = f"backtest·overall·{bt_raw['lookback_months']}mo ({n} trades)"
-
-                if bt_win_rate is not None:
-                    # Blend: 70% backtest + 30% heuristic
-                    p_win_blended = round(
-                        BT_BLEND_WEIGHT * bt_win_rate + (1 - BT_BLEND_WEIGHT) * p_win, 3
-                    )
-                    p_win = p_win_blended
-                    # Recalculate EV with blended p_win
-                    rr1 = levels.get("rr1", 1.0)
-                    p_loss = round(1 - p_win, 3)
-                    ev = round(p_win * max(rr1, 0.1) - p_loss * 1.0, 3)
-                    n_prob.append(
-                        f"📊 Win rate grounded in {bt_source}: {bt_win_rate:.0%} historical"
-                    )
         except Exception:
-            pass
+            bt_raw = None
 
     leverage = _suggest_leverage(account, risk_pct, close,
                                  levels.get("sl", close), levels.get("tp1", close),
@@ -599,6 +559,50 @@ def score_symbol(src, symbol: str,
     persistence     = markov_data.get("persistence", 0.5) if markov_data else 0.5
     forecast        = markov_data.get("forecast", {})     if markov_data else {}
 
+    # ── Backtest blend: now that hmm_state is defined, apply blend ───────────
+    # Requires N >= BT_MIN_TRADES — badge only shows when blend is actually active
+    if bt_raw and bt_raw.get("total_trades", 0) >= BT_MIN_TRADES:
+        bt_data = bt_raw
+        bt_win_rate = None
+        by_state_bt = bt_raw.get("by_state", {})
+        by_dir_bt   = bt_raw.get("by_direction", {})
+
+        # Priority: by_state[markov_state] → by_direction → overall
+        cur_state = hmm_state   # use HMM state for context lookup
+        if cur_state in by_state_bt:
+            st_wr = by_state_bt[cur_state].get("win_rate")
+            st_n  = by_state_bt[cur_state].get("trades", 0)
+            if st_wr is not None and st_n >= BT_MIN_TRADES:
+                bt_win_rate = st_wr
+                bt_source = f"backtest·{cur_state}·{bt_raw['lookback_months']}mo ({st_n} trades)"
+
+        if bt_win_rate is None and direction in by_dir_bt:
+            dir_wr = by_dir_bt[direction].get("win_rate")
+            dir_n  = by_dir_bt[direction].get("trades", 0)
+            if dir_wr is not None and dir_n >= BT_MIN_TRADES:
+                bt_win_rate = dir_wr
+                bt_source = f"backtest·{direction}·{bt_raw['lookback_months']}mo ({dir_n} trades)"
+
+        if bt_win_rate is None:
+            overall_wr = bt_raw.get("win_rate")
+            if overall_wr is not None:
+                bt_win_rate = overall_wr
+                n = bt_raw["total_trades"]
+                bt_source = f"backtest·overall·{bt_raw['lookback_months']}mo ({n} trades)"
+
+        if bt_win_rate is not None:
+            p_win_blended = round(
+                BT_BLEND_WEIGHT * bt_win_rate + (1 - BT_BLEND_WEIGHT) * p_win, 3
+            )
+            p_win = p_win_blended
+            rr1 = levels.get("rr1", 1.0)
+            p_loss = round(1 - p_win, 3)
+            ev = round(p_win * max(rr1, 0.1) - p_loss * 1.0, 3)
+            bt_blend_active = True
+            n_prob.append(
+                f"📊 Win rate grounded in {bt_source}: {bt_win_rate:.0%} historical (TP1)"
+            )
+
     # States must agree with trade direction; penalise if conflicting
     state_aligned = True
     if direction == "long"  and hmm_state == "BEAR":   state_aligned = False
@@ -652,10 +656,26 @@ def score_symbol(src, symbol: str,
     confidence_adjusted = round(max(0.0, min(10.0, confidence_after_state + ev_rr_modifier)), 1)
     n_prob.extend(ev_rr_notes)   # surface EV/RR penalty in probability notes
 
+    # ── Hard veto: R/R < 1.0 is mathematically a losing trade ───────────────
+    # Even at 70% win rate, you cannot survive R/R = 0.21 long-term.
+    # Breakeven win rate = 1 / (1 + RR). At RR=0.21 → need 83% win rate.
+    # We suppress the trade signal entirely and return a vetoed card.
+    rr_veto = rr1_val < 1.0
+    veto_reason = None
+    if rr_veto:
+        breakeven_wr = round(1 / (1 + rr1_val) * 100, 0)
+        veto_reason = (
+            f"R/R = {rr1_val:.2f}× — breakeven requires {breakeven_wr:.0f}% win rate. "
+            f"TP1 is too close to entry (resistance-capped). "
+            f"Wait for a wider setup or skip this trade."
+        )
+
     return {
         "symbol": symbol,
         "tv_symbol": src.tv_symbol(symbol),
         "direction": direction,
+        "vetoed": rr_veto,
+        "veto_reason": veto_reason,
         "confidence": confidence_adjusted,
         "confidence_raw": confidence,
         "confidence_after_state": confidence_after_state,
@@ -672,17 +692,25 @@ def score_symbol(src, symbol: str,
             "ev":          ev,
             "notes":       n_prob,
             "source":      bt_source,
-            "bt_grounded": bt_source != "heuristic",
+            # bt_grounded is TRUE only when the blend actually fired (N >= BT_MIN_TRADES)
+            # NOT just because backtest data exists — fixes the false "Data Grounded" badge
+            "bt_grounded": bt_blend_active,
         },
         # ── Backtest summary (inline, for card display) ──
         "backtest_summary": {
             "total_trades":    bt_data.get("total_trades")    if bt_data else None,
-            "win_rate":        bt_data.get("win_rate")        if bt_data else None,
+            "win_rate":        bt_data.get("win_rate")        if bt_data else None,       # TP1
+            "win_rate_tp1":    bt_data.get("win_rate_tp1")    if bt_data else None,
+            "win_rate_tp2":    bt_data.get("win_rate_tp2")    if bt_data else None,
             "avg_r":           bt_data.get("avg_r")           if bt_data else None,
+            "avg_r_tp1":       bt_data.get("avg_r_tp1")       if bt_data else None,
+            "avg_r_tp2":       bt_data.get("avg_r_tp2")       if bt_data else None,
             "max_drawdown_r":  bt_data.get("max_drawdown_r")  if bt_data else None,
             "lookback_months": bt_data.get("lookback_months") if bt_data else None,
+            "candle_interval": bt_data.get("candle_interval") if bt_data else None,
             "by_state":        bt_data.get("by_state")        if bt_data else None,
             "equity_curve":    bt_data.get("equity_curve")    if bt_data else None,
+            "blend_active":    bt_blend_active,
         } if bt_data else None,
         # ── Leverage ──
         "leverage": leverage,

static/index.html

@@ -1029,6 +1029,20 @@ nav {
 .dur-lbl { font-size:9px; font-weight:800; letter-spacing:0.7px; text-transform:uppercase; color:var(--t3); margin-bottom:1px; }
 .dur-val { font-size:15px; font-weight:700; font-family:var(--font-display); color:var(--t1); line-height:1.2; }
 
+/* ── Veto banner ── */
+.veto-banner {
+  background: rgba(254,226,226,0.7); border: 1.5px solid rgba(239,68,68,0.4);
+  border-radius: 10px; padding: 10px 14px; margin-bottom: 10px;
+  display: flex; flex-direction: column; gap: 4px;
+}
+.veto-banner-title {
+  font-size: 13px; font-weight: 700; color: #dc2626;
+  display: flex; align-items: center; gap: 6px;
+}
+.veto-banner-reason {
+  font-size: 11.5px; color: #7f1d1d; line-height: 1.45;
+}
+
 /* ── Backtest panel ── */
 .bt-panel {
   background:rgba(255,255,255,0.55); border:1px solid rgba(0,0,0,0.06);
@@ -1744,23 +1758,39 @@ async function runBacktest(sym, btn) {
 
 // Global version of renderBtResult (same logic, defined outside buildCard scope)
 function renderBtResultGlobal(bt, sym) {
-  const wr = bt.win_rate != null ? Math.round(bt.win_rate*100) : null;
+  const wrTp1 = bt.win_rate_tp1 != null ? Math.round(bt.win_rate_tp1*100) : (bt.win_rate != null ? Math.round(bt.win_rate*100) : null);
+  const wrTp2 = bt.win_rate_tp2 != null ? Math.round(bt.win_rate_tp2*100) : null;
+  const wr = wrTp1;
   const wrCls = wr==null?'neutral':wr>=55?'win':wr>=45?'neutral':'loss';
-  const avgR = bt.avg_r != null ? (bt.avg_r > 0 ? '+' : '') + bt.avg_r.toFixed(2) + 'R' : '—';
+  const avgR = bt.avg_r_tp1 != null ? (bt.avg_r_tp1 > 0 ? '+' : '') + bt.avg_r_tp1.toFixed(2) + 'R'
+             : bt.avg_r != null ? (bt.avg_r > 0 ? '+' : '') + bt.avg_r.toFixed(2) + 'R' : '—';
   const dd   = bt.max_drawdown_r != null ? bt.max_drawdown_r.toFixed(1)+'R' : '—';
   const mo   = bt.lookback_months || '?';
   const n    = bt.total_trades || 0;
 
+  const tf = bt.candle_interval || '15m';
+  const blendActive = bt.blend_active === true;
+  const groundedBadge = blendActive
+    ? `<span class="bt-grounded-badge">✓ Data grounded</span>`
+    : (n >= 10 ? `<span class="bt-grounded-badge" style="opacity:0.6">📊 ${n} trades</span>` : `<span style="font-size:10px;color:var(--muted);padding:2px 6px">⚠ ${n} trades (need 10+)</span>`);
+
   const stateRows = Object.entries(bt.by_state||{}).map(([state, s]) => {
-    const swr = Math.round(s.win_rate*100);
+    const swr1 = s.win_rate_tp1 != null ? Math.round(s.win_rate_tp1*100) : Math.round((s.win_rate||0)*100);
+    const swr2 = s.win_rate_tp2 != null ? Math.round(s.win_rate_tp2*100) : null;
     const cls = state==='BULL'?'bull':state==='BEAR'?'bear':'range';
+    const tp2txt = swr2 != null ? `<span style="font-size:9px;color:var(--muted);margin-left:3px">TP2:${swr2}%</span>` : '';
     return `<div class="bt-state-cell">
       <div class="bt-state-name">${state}</div>
-      <div class="bt-state-wr ${cls}">${swr}%</div>
+      <div class="bt-state-wr ${cls}">${swr1}%${tp2txt}</div>
       <div class="bt-state-n">${s.trades} trades</div>
     </div>`;
   }).join('');
 
+  const tp2Row = wrTp2 != null ? `<div style="font-size:10.5px;color:var(--muted);text-align:center;margin-top:2px;margin-bottom:4px">
+    TP1 exit: <b style="color:${wrTp1>=55?'var(--profit2)':wrTp1>=45?'var(--amber)':'var(--loss2)'}">${wrTp1}%</b> &nbsp;|&nbsp;
+    TP2 hold: <b style="color:${wrTp2>=55?'var(--profit2)':wrTp2>=45?'var(--amber)':'var(--loss2)'}">${wrTp2}%</b>
+  </div>` : '';
+
   const curve = bt.equity_curve || [];
   let sparkSVG = '';
   if (curve.length >= 2) {
@@ -1782,15 +1812,16 @@ function renderBtResultGlobal(bt, sym) {
 
   return `<div class="bt-panel" id="bt-${sym}">
     <div class="bt-header">
-      <span class="bt-lbl">📊 Backtest · ${mo}mo · ${n} trades</span>
-      <span class="bt-grounded-badge">✓ Data grounded</span>
+      <span class="bt-lbl">📊 Backtest · ${mo}mo · ${n} trades · ${tf}</span>
+      ${groundedBadge}
       <button class="bt-run-btn" onclick="runBacktest('${sym}',this)" title="Refresh backtest">↺</button>
     </div>
     <div class="bt-stats-row">
-      <div class="bt-stat"><div class="bt-stat-val ${wrCls}">${wr!=null?wr+'%':'—'}</div><div class="bt-stat-lbl">Win Rate</div></div>
-      <div class="bt-stat"><div class="bt-stat-val ${parseFloat(bt.avg_r)>=0?'win':'loss'}">${avgR}</div><div class="bt-stat-lbl">Avg R</div></div>
+      <div class="bt-stat"><div class="bt-stat-val ${wrCls}">${wr!=null?wr+'%':'—'}</div><div class="bt-stat-lbl">TP1 Win Rate</div></div>
+      <div class="bt-stat"><div class="bt-stat-val ${parseFloat(bt.avg_r_tp1||bt.avg_r)>=0?'win':'loss'}">${avgR}</div><div class="bt-stat-lbl">Avg R</div></div>
       <div class="bt-stat"><div class="bt-stat-val neutral">-${dd}</div><div class="bt-stat-lbl">Max DD</div></div>
     </div>
+    ${tp2Row}
     ${stateRows?`<div class="bt-state-row">${stateRows}</div>`:''}
     ${sparkSVG}
   </div>`;
@@ -2089,35 +2120,47 @@ function buildCard(c, account, risk) {
     if (!bt || !bt.total_trades) {
       return `<div class="bt-panel" id="bt-${sym}">
         <div class="bt-header">
-          <span class="bt-lbl">📊 Backtest (6mo · TP2 win condition)</span>
+          <span class="bt-lbl">📊 Backtest (6mo · 15m candles)</span>
           <button class="bt-run-btn" onclick="runBacktest('${sym}',this)">Run Backtest</button>
         </div>
-        <div class="bt-loading" id="bt-result-${sym}">Not yet run — click to backtest ~6 months of history</div>
+        <div class="bt-loading" id="bt-result-${sym}">Not yet run — click to backtest ~6 months of 15m history</div>
       </div>`;
     }
     return renderBtResult(bt, sym);
   }
 
   function renderBtResult(bt, sym) {
-    const wr = bt.win_rate != null ? Math.round(bt.win_rate*100) : null;
-    const wrCls = wr==null?'neutral':wr>=55?'win':wr>=45?'neutral':'loss';
-    const avgR = bt.avg_r != null ? (bt.avg_r > 0 ? '+' : '') + bt.avg_r.toFixed(2) + 'R' : '—';
-    const dd   = bt.max_drawdown_r != null ? bt.max_drawdown_r.toFixed(1)+'R' : '—';
-    const mo   = bt.lookback_months || '?';
-    const n    = bt.total_trades || 0;
-
-    // State breakdown
+    // Primary = TP1 win rate (matches how most traders exit)
+    // Secondary = TP2 win rate (ambitious hold target)
+    const wrTp1 = bt.win_rate_tp1 != null ? Math.round(bt.win_rate_tp1*100) : (bt.win_rate != null ? Math.round(bt.win_rate*100) : null);
+    const wrTp2 = bt.win_rate_tp2 != null ? Math.round(bt.win_rate_tp2*100) : null;
+    const wrCls = wrTp1==null?'neutral':wrTp1>=55?'win':wrTp1>=45?'neutral':'loss';
+    const avgR  = bt.avg_r_tp1 != null ? (bt.avg_r_tp1 > 0 ? '+' : '') + bt.avg_r_tp1.toFixed(2) + 'R'
+                : bt.avg_r != null ? (bt.avg_r > 0 ? '+' : '') + bt.avg_r.toFixed(2) + 'R' : '—';
+    const dd    = bt.max_drawdown_r != null ? bt.max_drawdown_r.toFixed(1)+'R' : '—';
+    const mo    = bt.lookback_months || '?';
+    const n     = bt.total_trades || 0;
+    const tf    = bt.candle_interval || '15m';
+    // Data Grounded badge — only show when blend actually fired (N >= 10)
+    const blendActive = bt.blend_active === true;
+    const groundedBadge = blendActive
+      ? `<span class="bt-grounded-badge">✓ Data grounded</span>`
+      : (n >= 10 ? `<span class="bt-grounded-badge" style="opacity:0.6">📊 ${n} trades</span>` : `<span style="font-size:10px;color:var(--muted);padding:2px 6px">⚠ ${n} trades (need 10+)</span>`);
+
+    // State breakdown — show both TP1 and TP2 win rates per state
     const stateRows = Object.entries(bt.by_state||{}).map(([state, s]) => {
-      const swr = Math.round(s.win_rate*100);
+      const swr1 = s.win_rate_tp1 != null ? Math.round(s.win_rate_tp1*100) : Math.round((s.win_rate||0)*100);
+      const swr2 = s.win_rate_tp2 != null ? Math.round(s.win_rate_tp2*100) : null;
       const cls = state==='BULL'?'bull':state==='BEAR'?'bear':'range';
+      const tp2txt = swr2 != null ? `<span style="font-size:9px;color:var(--muted);margin-left:3px">TP2:${swr2}%</span>` : '';
       return `<div class="bt-state-cell">
         <div class="bt-state-name">${state}</div>
-        <div class="bt-state-wr ${cls}">${swr}%</div>
+        <div class="bt-state-wr ${cls}">${swr1}%${tp2txt}</div>
         <div class="bt-state-n">${s.trades} trades</div>
       </div>`;
     }).join('');
 
-    // Equity sparkline
+    // Equity sparkline (based on TP1 — matches real trading)
     const curve = bt.equity_curve || [];
     let sparkSVG = '';
     if (curve.length >= 2) {
@@ -2137,17 +2180,24 @@ function buildCard(c, account, risk) {
       </svg>`;
     }
 
+    // TP2 comparison row
+    const tp2Row = wrTp2 != null ? `<div style="font-size:10.5px;color:var(--muted);text-align:center;margin-top:2px;margin-bottom:4px">
+      TP1 exit: <b style="color:${wrTp1>=55?'var(--profit2)':wrTp1>=45?'var(--amber)':'var(--loss2)'}">${wrTp1}%</b> &nbsp;|&nbsp;
+      TP2 hold: <b style="color:${wrTp2>=55?'var(--profit2)':wrTp2>=45?'var(--amber)':'var(--loss2)'}">${wrTp2}%</b>
+    </div>` : '';
+
     return `<div class="bt-panel" id="bt-${sym}">
       <div class="bt-header">
-        <span class="bt-lbl">📊 Backtest · ${mo}mo · ${n} trades</span>
-        <span class="bt-grounded-badge">✓ Data grounded</span>
+        <span class="bt-lbl">📊 Backtest · ${mo}mo · ${n} trades · ${tf}</span>
+        ${groundedBadge}
         <button class="bt-run-btn" onclick="runBacktest('${sym}',this)" title="Refresh backtest">↺</button>
       </div>
       <div class="bt-stats-row">
-        <div class="bt-stat"><div class="bt-stat-val ${wrCls}">${wr!=null?wr+'%':'—'}</div><div class="bt-stat-lbl">Win Rate</div></div>
-        <div class="bt-stat"><div class="bt-stat-val ${parseFloat(bt.avg_r)>=0?'win':'loss'}">${avgR}</div><div class="bt-stat-lbl">Avg R</div></div>
+        <div class="bt-stat"><div class="bt-stat-val ${wrCls}">${wrTp1!=null?wrTp1+'%':'—'}</div><div class="bt-stat-lbl">TP1 Win Rate</div></div>
+        <div class="bt-stat"><div class="bt-stat-val ${parseFloat(bt.avg_r_tp1||bt.avg_r)>=0?'win':'loss'}">${avgR}</div><div class="bt-stat-lbl">Avg R</div></div>
         <div class="bt-stat"><div class="bt-stat-val neutral">-${dd}</div><div class="bt-stat-lbl">Max DD</div></div>
       </div>
+      ${tp2Row}
       ${stateRows?`<div class="bt-state-row">${stateRows}</div>`:''}
       ${sparkSVG}
     </div>`;
@@ -2155,6 +2205,14 @@ function buildCard(c, account, risk) {
 
   const btHTML = buildBtPanel(bts, sym);
 
+  // ── Veto banner: shown when R/R < 1.0 (hard no-trade) ──
+  const isVetoed = c.vetoed === true;
+  const vetoBanner = isVetoed && c.veto_reason ? `
+    <div class="veto-banner">
+      <div class="veto-banner-title">⛔ NO TRADE — Risk Exceeds Reward</div>
+      <div class="veto-banner-reason">${c.veto_reason}</div>
+    </div>` : '';
+
   let narr=(c.narrative||'');
   if(narr.length>210) narr=narr.slice(0,207)+'…';
 
@@ -2190,6 +2248,7 @@ function buildCard(c, account, risk) {
       <div class="conf-bar"><div class="conf-fill ${confCls}" style="width:${confPct}%"></div></div>
     </div>
 
+    ${vetoBanner}
     <div class="tf-row">${tfHTML}</div>
     <div class="rule"></div>