fix: realistic AI ranges, Ollama cold-start warmup, price-target prompt

Backtest & prompt:
- Decouple tight_test from _fast_mode so backtest tests AI's own ranges
- Prompt now asks for target_price_lo/hi as ₹ absolute prices instead of
percentages — eliminates float/%-string ambiguity across all model sizes
- Remove hardcoded % range hints; LLM derives targets from ATR + indicators
- Add _extract_price_targets() helper: tries ₹ prices first, falls back to
predicted_return_lo/hi; handles bare float, '+2.0%', '₹485.50', etc.
- Fix bare float() calls → _safe_float() in debate synthesis parse path
- Relax _JSON_REQUIRED: accept target_price_lo/hi OR predicted_return_lo/hi
- Add research/backtest_watchlist.py: backtest + live spot-check on watchlist

Ollama reliability:
- Add warmup_ollama() in ollama_client.py: 1-token ping (30s) forces model
load before real inference, catching cold-starts before they hang
- On fresh health check (Space just woke), run warmup first; if warmup times
out → set 5-min backoff immediately instead of burning a 45s real call
- Reduce chat timeout 90s → 45s (_OLLAMA_CHAT_TIMEOUT)
- Add _OLLAMA_INFER_BACKOFF_UNTIL: 5-min backoff after any inference failure,
preventing cascading 45s hangs (was 3 × 90s = 270s worst case)
- Fix UnboundLocalError: _OLLAMA_HEALTH_LAST_CHECK missing global declaration
in fast_fail_on_rate_limit block
- Add _start_ollama_keepalive() in app.py: daemon thread pings Ollama every
10 min to keep HF Space warm during active trading hours

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

ai_forecast.py

@@ -321,9 +321,11 @@ def _cache_ttl_for_tf(tf_label: str) -> int:
 
 
 
-_JSON_REQUIRED = {"direction", "confidence", "predicted_return_lo", "predicted_return_hi"}
-# "reasoning" is intentionally omitted — small Ollama models (1B params) frequently
-# truncate JSON before closing the reasoning string; rejecting those wastes usable data.
+_JSON_REQUIRED = {"direction", "confidence"}
+_JSON_PRICE_FIELDS = frozenset({"target_price_lo", "target_price_hi", "predicted_return_lo", "predicted_return_hi"})
+# Prompt now asks for target_price_lo/hi (₹); older/smaller models may still return
+# predicted_return_lo/hi (%). We require at least one pair — validated in _extract_price_targets.
+# "reasoning" intentionally omitted — small Ollama models frequently truncate before closing it.
 
 # ============================================================================
 # CALIBRATED RANGE TABLE (data-verified on NSE 2018-2025, N=828)
@@ -542,28 +544,68 @@ def _parse_json_from_llm(text: str) -> Dict | None:
                         pass
     if parsed is None:
         return None
-    # Reject if any required forecast field is missing — prevents 0.0 default corruption
+    # Reject if direction/confidence missing — prevents 0.0 default corruption
     missing = _JSON_REQUIRED - parsed.keys()
     if missing:
         logger.warning("LLM JSON missing required fields %s — rejecting partial parse", missing)
         return None
+    # Must have at least one price pair (target_price or predicted_return)
+    if not (_JSON_PRICE_FIELDS & parsed.keys()):
+        logger.warning("LLM JSON missing all price/return fields — rejecting")
+        return None
     return parsed
 
 
 def _safe_float(val, default: float = 0.0) -> float:
-    """Convert val to float, stripping trailing non-numeric chars from small-model output.
-    Examples: '3.5-' → 3.5, '+2.0%' → 2.0, None → default."""
+    """Convert val to float. Handles bare numbers, '+2.0', '-0.6%', '3.5-', None → default."""
     if val is None:
         return default
     if isinstance(val, (int, float)):
         return float(val)
-    s = str(val).strip().rstrip("-%+").lstrip("+")
+    s = str(val).strip().lstrip("₹$").replace(",", "").rstrip("-%+").lstrip("+")
     try:
         return float(s)
     except (ValueError, TypeError):
         return default
 
 
+def _extract_price_targets(
+    parsed: dict, current_price: float
+) -> tuple:
+    """
+    Return (ret_lo, ret_hi) as plain percentage returns from LLM parsed dict.
+
+    Priority:
+    1. target_price_lo/hi (₹ absolute) — models reason better in prices, no % ambiguity
+    2. predicted_return_lo/hi (%, possibly with % sign or bare float)
+    Returns (0.0, 0.0) when nothing valid is found; caller falls back to heuristic.
+    """
+    def _to_price(v):
+        if v is None:
+            return None
+        if isinstance(v, (int, float)):
+            return float(v) if float(v) > 0 else None
+        s = str(v).strip().lstrip("₹$").replace(",", "")
+        try:
+            f = float(s)
+            return f if f > 0 else None
+        except (ValueError, TypeError):
+            return None
+
+    tp_lo = _to_price(parsed.get("target_price_lo"))
+    tp_hi = _to_price(parsed.get("target_price_hi"))
+    if tp_lo is not None and tp_hi is not None and current_price > 0:
+        return (
+            round((tp_lo / current_price - 1) * 100, 3),
+            round((tp_hi / current_price - 1) * 100, 3),
+        )
+
+    return (
+        _safe_float(parsed.get("predicted_return_lo"), 0.0),
+        _safe_float(parsed.get("predicted_return_hi"), 0.0),
+    )
+
+
 # ============================================================================
 # INDICATOR NORMALIZATION
 # ============================================================================
@@ -1027,29 +1069,26 @@ def _build_synthesis_prompt(
         f"{signal_rules}\n"
         f"ATR(14): ₹{atr14:.2f}  Current price: ₹{current_price:.2f}  "
         f"Hard cap: ±{_cap_pct}% for {holding} horizon.\n\n"
-        f"PRICE TARGET GUIDANCE — your range is used DIRECTLY in production, not overridden:\n"
-        f"Set predicted_return_hi to the REALISTIC MAXIMUM the stock can reach in this timeframe.\n"
-        f"Base it on: ATR(14)=₹{atr14:.2f}, momentum, volume, news, and nearby resistance levels.\n"
-        f"{'INTRADAY: typical NSE intraday swing is 0.5–2.0%. BULLISH hi=0.5–2.0%, lo=0.2–0.8%. BEARISH hi=−0.3%, lo=−1.5%.' if tf_label == 'INTRADAY' else ''}"
-        f"{'1D: typical NSE 1-day move is 1–4%. BULLISH hi=1.5–4.0%, lo=0.5–1.5%. BEARISH hi=−0.5%, lo=−3.0%.' if tf_label == '1D' else ''}"
-        f"{'3D: typical NSE 3-day move is 2–8%. BULLISH hi=2.0–7.0%, lo=0.8–2.5%. BEARISH hi=−0.8%, lo=−5.0%.' if tf_label == '3D' else ''}"
-        f"{'5D: typical NSE 5-day move is 3–12%. BULLISH hi=3.0–10.0%, lo=1.0–3.5%. BEARISH hi=−1.0%, lo=−8.0%.' if tf_label == '5D' else ''}"
-        f" Scale within these bands by conviction: HIGH confidence → upper half, LOW → lower half.\n\n"
+        f"PRICE TARGET GUIDANCE:\n"
+        f"Set target_price_lo/hi based on the indicators above — ATR(14)=₹{atr14:.2f} is your primary"
+        f" volatility anchor. Use resistance/support levels, Bollinger Bands, and momentum to set realistic"
+        f" bounds. Do NOT use generic %-range assumptions; derive targets from THIS stock's actual data.\n\n"
         f"should_buy = true if: direction is BULLISH or BEARISH AND risk/reward ≥ 1.5× AND no major red flags.\n"
         f"entry_price = recommended ₹ entry (current price for market order; slightly below if a pullback entry is better).\n\n"
         f"START YOUR RESPONSE WITH `{{` — output ONLY a valid JSON object, zero preamble:\n"
         f'{{"direction": "BULLISH"|"BEARISH"|"NEUTRAL", '
         f'"should_buy": true|false, '
         f'"confidence": "HIGH"|"MEDIUM"|"LOW", '
-        f'"entry_price": <₹ recommended entry>, '
-        f'"predicted_return_lo": <conservative % — positive for bull, negative for bear>, '
-        f'"predicted_return_hi": <realistic max % for this timeframe — positive for bull, negative for bear>, '
+        f'"entry_price": <₹ recommended entry — plain number, e.g. {current_price:.2f}>, '
+        f'"target_price_lo": <conservative ₹ price target — plain number, e.g. {current_price * 1.01:.2f}>, '
+        f'"target_price_hi": <optimistic ₹ price target — plain number, e.g. {current_price * 1.03:.2f}>, '
         f'"reasoning": "<2-3 sentences: cite the 3 key signals + what price target means>"}}\n\n'
         f"JSON rules:\n"
-        f"- BULLISH: lo > 0, hi > lo\n"
-        f"- BEARISH: lo < hi < 0\n"
-        f"- NEUTRAL: lo < 0 < hi, should_buy = false\n"
-        f"- Absolute values must not exceed {_cap_pct}%\n"
+        f"- BULLISH: target_price_lo > entry_price, target_price_hi > target_price_lo\n"
+        f"- BEARISH: target_price_hi < entry_price, target_price_lo < target_price_hi\n"
+        f"- NEUTRAL: target_price_lo < entry_price < target_price_hi\n"
+        f"- All prices must be bare numbers (no ₹ symbol, no commas)\n"
+        f"- Price range must not exceed ±{_cap_pct}% from current price ₹{current_price:.2f}\n"
     )
 
 
@@ -1169,7 +1208,7 @@ def get_ai_forecast(
             logger.debug("AI forecast cache hit for %s %s", ticker, tf_label)
             return _cached["result"]
 
-    tight_test    = bool(_fast_mode or kwargs.get("_tight_test_ranges", False))
+    tight_test    = bool(kwargs.get("_tight_test_ranges", False))
     vol_pctile    = _volatility_percentile(ohlcv_df, tf_label)
     move_anchor   = _realized_move_anchor(ohlcv_df, tf_label, vol_pctile)
     atr14         = float(indicators.get("atr14") or move_anchor * (current_price / 100) or 10.0)
@@ -1258,8 +1297,7 @@ def get_ai_forecast(
             reasoning      = str(parsed.get("reasoning", ""))
             should_buy     = bool(parsed.get("should_buy", direction in ("BULLISH", "BEARISH")))
             ai_entry_price = _safe_float(parsed.get("entry_price"), None)
-            ret_lo         = _safe_float(parsed.get("predicted_return_lo"), 0.0)
-            ret_hi         = _safe_float(parsed.get("predicted_return_hi"), 0.0)
+            ret_lo, ret_hi = _extract_price_targets(parsed, current_price)
 
             # Guard: normalize invalid direction/confidence enum values
             if direction not in ("BULLISH", "BEARISH", "NEUTRAL"):
@@ -1374,8 +1412,7 @@ def get_ai_forecast(
             direction   = str(parsed.get("direction", "NEUTRAL")).upper()
             confidence  = str(parsed.get("confidence", "MEDIUM")).upper()
             reasoning   = str(parsed.get("reasoning", ""))
-            ret_lo      = _safe_float(parsed.get("predicted_return_lo"), 0.0)
-            ret_hi      = _safe_float(parsed.get("predicted_return_hi"), 0.0)
+            ret_lo, ret_hi = _extract_price_targets(parsed, current_price)
             if direction not in ("BULLISH", "BEARISH", "NEUTRAL"):
                 direction = "NEUTRAL"
             if confidence not in ("HIGH", "MEDIUM", "LOW"):
@@ -1495,8 +1532,7 @@ def get_ai_forecast(
         reasoning   = str(parsed.get("reasoning", ""))
         should_buy  = bool(parsed.get("should_buy", direction in ("BULLISH", "BEARISH")))
         ai_entry_price = _safe_float(parsed.get("entry_price"), None)
-        ret_lo      = float(parsed.get("predicted_return_lo", 0.0))
-        ret_hi      = float(parsed.get("predicted_return_hi", 0.0))
+        ret_lo, ret_hi = _extract_price_targets(parsed, current_price)
 
         # Guard: normalize invalid direction/confidence enum values
         if direction not in ("BULLISH", "BEARISH", "NEUTRAL"):

app.py

@@ -3649,12 +3649,41 @@ def _start_intraday_refresh_scheduler():
     threading.Thread(target=_run, daemon=True, name="intraday-refresh").start()
 
 
+def _start_ollama_keepalive():
+    """Ping Ollama every 10 min to prevent HF Space cold-start hangs during inference."""
+    _ep = os.environ.get("OLLAMA_ENDPOINT", "").strip()
+    if not _ep:
+        return
+
+    import threading, time as _time
+    _INTERVAL = 600  # 10 minutes — HF free tier sleeps after ~15 min
+
+    def _run():
+        _time.sleep(30)  # give app startup a moment first
+        while True:
+            try:
+                from ollama_client import warmup_ollama, get_ollama_model
+                _m = get_ollama_model(_ep)
+                _ok = warmup_ollama(_ep, model=_m, timeout=30)
+                if _ok:
+                    app.logger.debug("Ollama keepalive ping succeeded (%s)", _m)
+                else:
+                    app.logger.info("Ollama keepalive: Space not responding (cold/busy) — will retry in %ds", _INTERVAL)
+            except Exception as _e:
+                app.logger.debug("Ollama keepalive error: %s", _e)
+            _time.sleep(_INTERVAL)
+
+    threading.Thread(target=_run, daemon=True, name="ollama-keepalive").start()
+    app.logger.info("Ollama keepalive started (interval=%ds, endpoint=%s)", _INTERVAL, _ep)
+
+
 # Start background services at import time so both `python app.py` and
 # WSGI servers (gunicorn) warm the top5 cache and run the trade monitor.
 _prewarm_top5()
 _start_trade_monitor()
 _start_validation_scheduler()
 _start_intraday_refresh_scheduler()
+_start_ollama_keepalive()
 
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))

llm_client.py

@@ -82,6 +82,12 @@ _OLLAMA_HEALTH_LAST_CHECK: float = 0.0
 _OLLAMA_HEALTH_RESULT: bool = False
 _OLLAMA_HEALTH_TTL: int = 60
 
+# After a chat timeout or inference failure, back off for this many seconds before retrying.
+# Prevents cascading 45s timeouts when the HF Space is unresponsive.
+_OLLAMA_INFER_BACKOFF_UNTIL: float = 0.0
+_OLLAMA_INFER_BACKOFF_SECS: int = 300  # 5 minutes
+_OLLAMA_CHAT_TIMEOUT: int = 45          # was 90s; Ollama either responds in <10s or hangs
+
 # Monotonically increasing debate counter — kept for backward compat with racing calls.
 _AI_TASK_COUNTER: int = 0
 
@@ -437,11 +443,16 @@ def make_chat_call(
             _ep = os.environ.get("OLLAMA_ENDPOINT", "").strip()
             if not _ep:
                 return None
-            global _OLLAMA_HEALTH_LAST_CHECK, _OLLAMA_HEALTH_RESULT
+            global _OLLAMA_HEALTH_LAST_CHECK, _OLLAMA_HEALTH_RESULT, _OLLAMA_INFER_BACKOFF_UNTIL
             _now_h = time.time()
+            # Skip entirely if a recent inference timed out — don't burn another 45s
             with _LLM_LOCK:
+                if _now_h < _OLLAMA_INFER_BACKOFF_UNTIL:
+                    logger.debug("Ollama skipped — inference backoff active for %.0fs", _OLLAMA_INFER_BACKOFF_UNTIL - _now_h)
+                    return None
                 _cv = (_now_h - _OLLAMA_HEALTH_LAST_CHECK) < _OLLAMA_HEALTH_TTL
                 _ch = _OLLAMA_HEALTH_RESULT if _cv else None
+            _fresh_check = _ch is None
             if _ch is None:
                 _ch = check_ollama_health(_ep, timeout=8)
                 with _LLM_LOCK:
@@ -450,11 +461,28 @@ def make_chat_call(
             if not _ch:
                 return None
             _m = get_ollama_model(_ep)
+            # Fresh health check means Space just woke from sleep — warmup before real call
+            # so the model is loaded and the real inference doesn't hang.
+            if _fresh_check:
+                from ollama_client import warmup_ollama
+                _warm = warmup_ollama(_ep, model=_m, timeout=30)
+                if not _warm:
+                    with _LLM_LOCK:
+                        _OLLAMA_INFER_BACKOFF_UNTIL = time.time() + _OLLAMA_INFER_BACKOFF_SECS
+                        _OLLAMA_HEALTH_RESULT = False
+                    logger.warning("Ollama warmup failed — model still loading, backing off %ds", _OLLAMA_INFER_BACKOFF_SECS)
+                    return None
+                logger.info("Ollama warmup succeeded — model warm, proceeding with inference")
             with _OLLAMA_SEMAPHORE:
-                _r = ollama_chat(messages, endpoint=_ep, model=_m, timeout=90)
+                _r = ollama_chat(messages, endpoint=_ep, model=_m, timeout=_OLLAMA_CHAT_TIMEOUT)
             if _r:
                 logger.info("LLM: Ollama succeeded")
                 return _r, "ollama", _m
+            # Inference returned None (timeout or empty) — set backoff so we don't retry immediately
+            with _LLM_LOCK:
+                _OLLAMA_INFER_BACKOFF_UNTIL = time.time() + _OLLAMA_INFER_BACKOFF_SECS
+                _OLLAMA_HEALTH_RESULT = False  # also invalidate health so fast path re-checks later
+            logger.warning("Ollama inference failed — backing off for %ds", _OLLAMA_INFER_BACKOFF_SECS)
         except Exception as _e:
             logger.debug("Ollama call failed: %s", _e)
         return None
@@ -514,30 +542,52 @@ def make_chat_call(
 
     if fast_fail_on_rate_limit:
         # Cloud providers all failed. Ollama has no rate limits — always try it last.
-        # Use the shared health cache so a 150-stock scan doesn't burn 25s per stock.
+        # Use the shared health cache so a 150-stock scan doesn't burn _OLLAMA_CHAT_TIMEOUT per stock.
+        global _OLLAMA_HEALTH_LAST_CHECK, _OLLAMA_HEALTH_RESULT, _OLLAMA_INFER_BACKOFF_UNTIL
         _ep_check = os.environ.get("OLLAMA_ENDPOINT", "").strip()
         if _ep_check:
             from ollama_client import ollama_chat, get_ollama_model, check_ollama_health
-            # Check cached health result before doing a fresh 25s probe
             with _LLM_LOCK:
                 _now_lr = time.time()
-                _cached_valid = (_now_lr - _OLLAMA_HEALTH_LAST_CHECK) < _OLLAMA_HEALTH_TTL
-                _ch = _OLLAMA_HEALTH_RESULT if _cached_valid else None
-            if _ch is None:
-                # No recent result — do the longer probe (HF Space may be cold-starting)
-                _ch = check_ollama_health(_ep_check, timeout=25)
-                with _LLM_LOCK:
-                    _OLLAMA_HEALTH_LAST_CHECK = time.time()
-                    _OLLAMA_HEALTH_RESULT = _ch  # cache both True and False
-            if _ch:
-                _m = get_ollama_model(_ep_check)
-                with _OLLAMA_SEMAPHORE:
-                    _r = ollama_chat(messages, endpoint=_ep_check, model=_m, timeout=90)
-                if _r:
-                    logger.info("LLM: Ollama (last-resort fast_fail path) succeeded")
-                    return _r, "ollama", _m
-            else:
-                logger.debug("LLM: Ollama last-resort skipped (cached unhealthy)")
+                # Skip if a recent inference timed out
+                if _now_lr < _OLLAMA_INFER_BACKOFF_UNTIL:
+                    logger.debug("Ollama last-resort skipped — backoff active for %.0fs", _OLLAMA_INFER_BACKOFF_UNTIL - _now_lr)
+                else:
+                    _cached_valid = (_now_lr - _OLLAMA_HEALTH_LAST_CHECK) < _OLLAMA_HEALTH_TTL
+                    _ch = _OLLAMA_HEALTH_RESULT if _cached_valid else None
+                    _now_lr = None  # signal: proceed
+            if _now_lr is None:  # not in backoff
+                _fresh_lr = _ch is None
+                if _ch is None:
+                    # No recent result — do the longer probe (HF Space may be cold-starting)
+                    _ch = check_ollama_health(_ep_check, timeout=25)
+                    with _LLM_LOCK:
+                        _OLLAMA_HEALTH_LAST_CHECK = time.time()
+                        _OLLAMA_HEALTH_RESULT = _ch
+                if _ch:
+                    _m = get_ollama_model(_ep_check)
+                    # Warmup on fresh health check — prevents 45s hang on cold-start model loading
+                    if _fresh_lr:
+                        from ollama_client import warmup_ollama
+                        if not warmup_ollama(_ep_check, model=_m, timeout=30):
+                            with _LLM_LOCK:
+                                _OLLAMA_INFER_BACKOFF_UNTIL = time.time() + _OLLAMA_INFER_BACKOFF_SECS
+                                _OLLAMA_HEALTH_RESULT = False
+                            logger.warning("Ollama last-resort warmup failed — backing off %ds", _OLLAMA_INFER_BACKOFF_SECS)
+                            raise RuntimeError("All LLM providers unavailable — Ollama cold-start backoff")
+                        logger.info("Ollama last-resort warmup succeeded")
+                    with _OLLAMA_SEMAPHORE:
+                        _r = ollama_chat(messages, endpoint=_ep_check, model=_m, timeout=_OLLAMA_CHAT_TIMEOUT)
+                    if _r:
+                        logger.info("LLM: Ollama (last-resort fast_fail path) succeeded")
+                        return _r, "ollama", _m
+                    # Inference failed — backoff so next call doesn't wait again
+                    with _LLM_LOCK:
+                        _OLLAMA_INFER_BACKOFF_UNTIL = time.time() + _OLLAMA_INFER_BACKOFF_SECS
+                        _OLLAMA_HEALTH_RESULT = False
+                    logger.warning("Ollama last-resort inference failed — backing off %ds", _OLLAMA_INFER_BACKOFF_SECS)
+                else:
+                    logger.debug("LLM: Ollama last-resort skipped (cached unhealthy)")
         raise RuntimeError("All LLM providers unavailable — all rate-limited or unconfigured")
 
     # ── Retry loop ────────────────────────────────────────────────────────────

ollama_client.py

@@ -80,6 +80,33 @@ def ollama_chat(
     return None
 
 
+def warmup_ollama(endpoint: str, model: Optional[str] = None, timeout: int = 30) -> bool:
+    """Send a 1-token inference call to force model loading before a real call.
+    Returns True if model responded (warm), False if cold-start timed out.
+    Use after a fresh health check to avoid hanging 45s on the real inference."""
+    if model is None:
+        model = get_ollama_model(endpoint)
+    try:
+        payload = {
+            "model": model,
+            "messages": [{"role": "user", "content": "Hi"}],
+            "stream": False,
+            "options": {"num_predict": 1},
+        }
+        resp = requests.post(f"{endpoint}/api/chat", json=payload, timeout=timeout)
+        if resp.status_code == 200:
+            logger.debug("Ollama warmup (%s) succeeded", model)
+            return True
+        logger.debug("Ollama warmup (%s) status %d", model, resp.status_code)
+        return False
+    except requests.exceptions.Timeout:
+        logger.warning("Ollama warmup (%s) timed out after %ds — model still cold", model, timeout)
+        return False
+    except Exception as e:
+        logger.debug("Ollama warmup failed: %s", e)
+        return False
+
+
 def ollama_generate(
     prompt: str,
     endpoint: str,

research/backtest.py

@@ -684,7 +684,7 @@ def run_backtest(work_items: list[dict], csv_path: str | None = None, limit_work
                 current_price=w["price"], indicators=w["inds"], ohlcv_df=w["ohlcv"],
                 vix_declining=w["vix_decl"],
                 _fast_mode=True,               # single call — no 3-call debate
-                _tight_test_ranges=True,       # keep target ranges as tight as possible during validation
+                _tight_test_ranges=False,      # use AI's own predicted ranges (realistic)
                 _fast_fail_on_rate_limit=True, # skip to next model immediately on 429
                 _enable_backtest_openrouter=True,
             )

research/backtest_watchlist.py

@@ -0,0 +1,279 @@
+#!/usr/bin/env python3
+"""
+research/backtest_watchlist.py — Backtest AI prompts on current watchlist stocks.
+
+Uses realistic AI-owned ranges (tight_test=False) so results match what the UI shows.
+Also runs a live spot-check prediction for each stock to verify UI output.
+
+Run:
+    python research/backtest_watchlist.py           # historical backtest + live spot-check
+    python research/backtest_watchlist.py --live-only  # live spot-check only (fast)
+"""
+from __future__ import annotations
+import sys, os, argparse
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+sys.path.insert(0, os.path.dirname(__file__))
+
+import warnings
+import threading
+import time
+import pandas as pd
+import yfinance as yf
+
+warnings.filterwarnings("ignore")
+
+from backtest import (
+    fetch_data, _compute_indicators, _fwd_intraday_moves, _fwd_returns,
+    _vix_nifty_series, _simple_ml_prob, run_backtest, print_results,
+    TIMEFRAMES, NIFTY, VIX_TK,
+)
+
+# ── CONFIG ──────────────────────────────────────────────────────────────────
+# Test last ~3 months with a step of 20 trading days → ~5 dates
+DATA_START  = "2025-01-01"
+DATA_END    = "2026-07-17"
+TEST_START  = "2026-04-01"   # only run from this date forward
+STEP        = 20             # every 20 trading days (~4 weeks)
+
+_PACE_SECS  = int(os.environ.get("BACKTEST_LLM_PACE_SECS", 12))
+
+
+def _get_watchlist_tickers():
+    try:
+        import database as db
+        wl = db.get_watchlist()
+        tickers = [w["ticker"] for w in wl]
+        if not tickers:
+            print("WARNING: Watchlist is empty — using fallback set")
+            return ["TATASTEEL.NS", "AXISCADES.NS", "HINDZINC.NS"]
+        return tickers
+    except Exception as e:
+        print(f"WARNING: Could not read watchlist ({e}) — using fallback set")
+        return ["TATASTEEL.NS", "AXISCADES.NS", "HINDZINC.NS"]
+
+
+def _snap_to_trading_day(idx, ts):
+    prior = idx[idx <= ts]
+    return prior[-1] if not prior.empty else None
+
+
+def _build_work_items(tickers, dates, sc, sh, sl, sv, nc, vc, nifty_ema200, vix_slope):
+    company_names = {t: t.replace(".NS", "") for t in tickers}
+    work_items = []
+    skipped = 0
+
+    for date in dates:
+        for ticker in tickers:
+            if ticker not in sc.columns:
+                continue
+            snapped = _snap_to_trading_day(sc[ticker].dropna().index, date)
+            if snapped is None or snapped != date:
+                continue
+            try:
+                vix_level = float(vc.loc[:date].dropna().iloc[-1])
+                nifty_v   = float(nc.loc[:date].dropna().iloc[-1])
+                nifty_ema = float(nifty_ema200.loc[:date].dropna().iloc[-1])
+                nifty_ok  = nifty_v > nifty_ema
+                vix_decl  = float(vix_slope.loc[:date].dropna().iloc[-1]) < 0
+                macro_ok  = nifty_ok and vix_level < 20
+            except Exception:
+                skipped += 1
+                continue
+
+            r1, r3, r5 = _fwd_returns(sc, date, ticker)
+            up0, dn0, up1, dn1, up3, dn3, up5, dn5 = _fwd_intraday_moves(sc, sh, sl, date, ticker)
+
+            price   = float(sc[ticker].dropna().loc[:date].iloc[-1])
+            inds    = _compute_indicators(sc[ticker], sh[ticker], sl[ticker], sv[ticker], date)
+            ml_prob = _simple_ml_prob(sc[ticker], sv[ticker], date)
+
+            idx2 = sc[ticker].dropna().index.searchsorted(date, side="right")
+            try:
+                ohlcv = pd.DataFrame({
+                    "High":   sh[ticker].iloc[max(0, idx2 - 20):idx2].values,
+                    "Low":    sl[ticker].iloc[max(0, idx2 - 20):idx2].values,
+                    "Close":  sc[ticker].iloc[max(0, idx2 - 20):idx2].values,
+                    "Volume": sv[ticker].iloc[max(0, idx2 - 20):idx2].values,
+                }).dropna()
+            except Exception:
+                ohlcv = None
+
+            for tf in ["INTRADAY", "1D", "3D"]:  # 5D retired from UI
+                ret_for_tf = {"INTRADAY": 0.0, "1D": r1, "3D": r3}[tf]
+                if pd.isna(ret_for_tf) and tf != "INTRADAY":
+                    continue
+                work_items.append(dict(
+                    date=date, ticker=ticker, tf=tf,
+                    price=price, ml_prob=ml_prob, inds=inds,
+                    company=company_names[ticker], ohlcv=ohlcv,
+                    nifty_ok=nifty_ok, macro_ok=macro_ok,
+                    vix_level=vix_level, vix_decl=vix_decl,
+                    r1=r1, r3=r3, r5=r5,
+                    up0=up0, dn0=dn0,
+                    up1=up1, dn1=dn1, up3=up3, dn3=dn3, up5=up5, dn5=dn5,
+                ))
+
+    if skipped:
+        print(f"  ({skipped} (ticker,date) pairs skipped — missing macro data)")
+    return work_items
+
+
+def _print_summary(df, tickers):
+    print("\n" + "=" * 70)
+    print("Accuracy by Timeframe  (tight_test=False → AI's own ranges)")
+    print("=" * 70)
+    for tf in ["INTRADAY", "1D", "3D"]:
+        sub = df[df["timeframe"] == tf]
+        if sub.empty:
+            continue
+        n        = len(sub)
+        tgt_hits = int(sub["target_hit_for_tf"].sum())
+        dir_hits = int(sub["intraday_hit_for_tf"].sum())
+        bullish  = int((sub["direction"] == "BULLISH").sum())
+        bearish  = int((sub["direction"] == "BEARISH").sum())
+        neutral  = int((sub["direction"] == "NEUTRAL").sum())
+        avg_lo   = sub["target_price_lo"].mean() if "target_price_lo" in sub.columns else float("nan")
+        avg_hi   = sub["target_price_hi"].mean() if "target_price_hi" in sub.columns else float("nan")
+        avg_range_pct = sub.apply(
+            lambda r: abs(r.get("target_price_hi", 0) - r.get("target_price_lo", 0)) /
+                      r.get("entry_price", 1) * 100 if r.get("entry_price", 0) > 0 else 0,
+            axis=1
+        ).mean() if "target_price_hi" in sub.columns else float("nan")
+        print(f"  {tf:>10}:  target_hit={tgt_hits}/{n} ({tgt_hits/n*100:.0f}%)  "
+              f"dir={dir_hits/n*100:.0f}%  "
+              f"[B:{bullish} Bear:{bearish} N:{neutral}]  "
+              f"avg_range={avg_range_pct:.1f}%")
+
+    total     = len(df)
+    tgt_total = int(df["target_hit_for_tf"].sum())
+    dir_total = int(df["intraday_hit_for_tf"].sum())
+    print(f"\n  Overall: {tgt_total}/{total} = {tgt_total/total*100:.0f}% target_hit  "
+          f"|  {dir_total}/{total} = {dir_total/total*100:.0f}% direction")
+
+    print("\n" + "=" * 70)
+    print("Accuracy by Ticker")
+    print("=" * 70)
+    print(f"  {'Ticker':<18} {'N':>4} {'Target%':>8} {'Dir%':>6} {'AvgRange%':>10}")
+    print("  " + "-" * 52)
+    for t in tickers:
+        sub = df[df["ticker"] == t]
+        if sub.empty:
+            continue
+        n        = len(sub)
+        tgt_hits = int(sub["target_hit_for_tf"].sum())
+        dir_hits = int(sub["intraday_hit_for_tf"].sum())
+        avg_range_pct = sub.apply(
+            lambda r: abs(r.get("target_price_hi", 0) - r.get("target_price_lo", 0)) /
+                      r.get("entry_price", 1) * 100 if r.get("entry_price", 0) > 0 else 0,
+            axis=1
+        ).mean() if "target_price_hi" in sub.columns else float("nan")
+        print(f"  {t:<18} {n:>4} {tgt_hits/n*100:>7.0f}% {dir_hits/n*100:>6.0f}% {avg_range_pct:>9.1f}%")
+
+
+def _live_spot_check(tickers):
+    """Predict each watchlist stock right now and show what the UI would display."""
+    print("\n" + "=" * 70)
+    print("LIVE SPOT-CHECK — what the UI shows right now")
+    print("=" * 70)
+    print(f"  {'Ticker':<18} {'TF':>10} {'Dir':>10} {'Conf':>7} {'Lo%':>7} {'Hi%':>7} "
+          f"{'Range%':>8} {'BUY?':>6} {'Source'}")
+    print("  " + "-" * 85)
+
+    from predictor_core import predict_stock_v2, timeframe_to_dates
+
+    results = []
+    for ticker in tickers:
+        for tf in ["INTRADAY", "1D", "3D"]:
+            try:
+                start, end = timeframe_to_dates(tf)
+                pred = predict_stock_v2(
+                    ticker=ticker, start_date=start, end_date=end,
+                    _run_ai_forecast=True,
+                )
+                af = pred.get("ai_forecast") or {}
+                direction  = af.get("direction", pred.get("direction", "—"))
+                confidence = af.get("confidence", pred.get("confidence", "—"))
+                ret_lo     = af.get("predicted_return_lo") or pred.get("predicted_return_lo", 0)
+                ret_hi     = af.get("predicted_return_hi") or pred.get("predicted_return_hi", 0)
+                should_buy = af.get("should_buy")
+                source     = af.get("source", "—")
+                entry_px   = af.get("entry_price", 0)
+                range_pct  = abs((ret_hi or 0) - (ret_lo or 0))
+                buy_str    = "BUY" if should_buy is True else ("SKIP" if should_buy is False else "—")
+                print(f"  {ticker:<18} {tf:>10} {direction:>10} {confidence:>7} "
+                      f"{(ret_lo or 0):>+7.2f} {(ret_hi or 0):>+7.2f} {range_pct:>7.2f}% "
+                      f"{buy_str:>6}  {source}")
+                results.append({
+                    "ticker": ticker, "tf": tf,
+                    "direction": direction, "confidence": confidence,
+                    "ret_lo": ret_lo, "ret_hi": ret_hi, "range_pct": range_pct,
+                    "should_buy": should_buy, "source": source, "entry_px": entry_px,
+                })
+            except Exception as e:
+                print(f"  {ticker:<18} {tf:>10} ERROR: {e}")
+            time.sleep(2)  # light throttle between live calls
+
+    # Range realism summary
+    if results:
+        import statistics
+        all_ranges = [r["range_pct"] for r in results if r.get("range_pct")]
+        print(f"\n  Range stats: min={min(all_ranges):.2f}%  "
+              f"avg={statistics.mean(all_ranges):.2f}%  "
+              f"max={max(all_ranges):.2f}%")
+        print(f"  Expected realistic ranges: INTRADAY ~0.5-2%, 1D ~1-4%, 3D ~2-7%")
+        tiny = [r for r in results if r.get("range_pct", 99) < 0.5]
+        if tiny:
+            print(f"  WARNING: {len(tiny)} predictions have suspiciously tiny ranges (<0.5%):")
+            for r in tiny:
+                print(f"    {r['ticker']} {r['tf']} lo={r['ret_lo']:+.3f}% hi={r['ret_hi']:+.3f}%")
+        else:
+            print(f"  OK: All ranges are ≥0.5% — looks realistic.")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--live-only", action="store_true",
+                        help="Skip historical backtest; only run live spot-check")
+    args = parser.parse_args()
+
+    tickers = _get_watchlist_tickers()
+
+    print("=" * 70)
+    print("Watchlist Backtest — realistic AI ranges (tight_test=False)")
+    print("=" * 70)
+    print(f"Tickers : {', '.join(tickers)}")
+
+    if not args.live_only:
+        print(f"Period  : {TEST_START} → {DATA_END}  step={STEP} trading days")
+
+        # Download data
+        sc, sh, sl, sv, nc, vc = fetch_data(tickers, DATA_START, DATA_END)
+        nifty_ema200, vix_slope = _vix_nifty_series(nc, vc)
+
+        # Build date list
+        all_nifty_days = nc.dropna().index
+        dates = all_nifty_days[all_nifty_days >= pd.Timestamp(TEST_START)][::STEP]
+        print(f"Dates   : {len(dates)}  ({[str(d.date()) for d in dates]})")
+        work_items = _build_work_items(tickers, dates, sc, sh, sl, sv, nc, vc, nifty_ema200, vix_slope)
+        n_tfs = 3
+        print(f"Items   : {len(work_items)} LLM calls (~{len(work_items) * _PACE_SECS // 60} min at {_PACE_SECS}s/call)\n")
+
+        if not work_items:
+            print("ERROR: No valid work items.")
+        else:
+            csv_out = os.path.join(os.path.dirname(__file__), "ai_prompt_accuracy_watchlist.csv")
+            df = run_backtest(work_items, csv_path=csv_out)
+            if df is not None and not df.empty:
+                _print_summary(df, tickers)
+                print(f"\nSaved → {csv_out}")
+                print("\n" + "=" * 70)
+                print("FULL BREAKDOWN")
+                print_results(df)
+            else:
+                print("ERROR: run_backtest returned no results.")
+
+    _live_spot_check(tickers)
+
+
+if __name__ == "__main__":
+    main()