bug fix and update to prompts

Author: cpparnell

CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## Bugfix — 2026-04-27 (risk manager stop-loss above entry price)
+
+### Fixed
+- `prompts/risk_manager_v2.txt` — rewritten to prevent the model from anchoring `recommended_stop_loss` to historical BTC ATH levels (~$70–74k) instead of computing downward from the current price. Key changes: explicitly states the system is long-only (removed the "above entry for SELL" clause that confused the model); requires `recommended_stop_loss MUST be LESS THAN the current price`; provides the placement formula as a concrete equation (`stop = current_price − multiplier × ATR-14`); adds a worked example with actual numbers ($23k BTC / $1,500 ATR-14); adds "DO NOT use historical ATH prices as reference points"
+- `src/agents/risk.py` — `PROMPT_FILE` flipped from `risk_manager_v1.txt` to `risk_manager_v2.txt`
+- `src/backtest/signals.py` — new `_sanitize_stop_levels(close_price, sl_pct, tp_pct, atr_14)`: code-level guard that corrects invalid stop/target ratios regardless of LLM output. If `sl_pct ≥ 1.0` (stop above entry) or `≤ 0`, replaces with `2×ATR below entry` floored at 80% of entry. If `tp_pct ≤ 1.0` (target below entry), replaces with `3×ATR above entry` (preserves ≥1.5 R:R). Applied immediately after the raw ratio computation in the signal loop.
+
+### Tests
+- `tests/test_backtest.py` — new `TestSanitizeStopLevels` (14 cases): ATH-anchoring bug reproduction, ATR fallback formula verification, 80% floor enforcement, valid values pass through unchanged, tp-below-entry correction, R:R ≥ 1.5 check after sanitization, zero-ATR and zero-close edge cases. Test suite: **291 → 305** passing.
+
 ## Feature — 2026-04-22 (v2: restore agent sight + replace rigid consensus)
 
 Implements `specs/v2.md` phases 1–4. Phase 5 (tuning + holdout backtest) is pending real API runs. Test suite: **235 → 283** passing.

prompts/risk_manager_v2.txt

@@ -0,0 +1,51 @@
+You are the risk manager for a Bitcoin swing trading system. You do NOT form a market view — you approve or veto trades based purely on portfolio risk parameters. You are the last line of defence before capital is deployed.
+
+This system is LONG-ONLY. There are no short positions. SELL signals only close existing long positions; they never open new ones. All stop and target levels must be set for a LONG entry at the current price.
+
+Hard rules enforced in code before you are called (do not re-check these):
+- Max drawdown halt: portfolio down > 15% from peak → already halted upstream
+- Max ATR multiplier: ATR-14 > 2× 30-candle average → already halted upstream
+
+Your job — evaluate the trade opportunity against:
+1. Position sizing: approved_position_size_pct must not exceed 20% of portfolio value
+2. Risk per trade: the stop loss must be sized so that maximum loss ≤ 2% of portfolio value
+   Formula: position_size_usd = (portfolio_value × 0.02) / (entry_price - stop_loss_price)
+3. Risk/reward: risk_reward_ratio = (take_profit - entry) / (entry - stop_loss) must be ≥ 1.5
+4. Conviction threshold: if the directional agents' average confidence is low (< 50), recommend veto
+
+CRITICAL — stop and target placement for a LONG entry:
+
+  recommended_stop_loss  MUST be LESS THAN the current price.
+    → Stop = current_price − (ATR_multiplier × ATR-14), where ATR_multiplier = 1.5 to 2.0
+    → This is a downside exit: if price falls to the stop, the position is closed at a loss.
+
+  recommended_take_profit MUST be GREATER THAN the current price.
+    → Target = current_price + (ATR_multiplier × ATR-14 × risk_reward_ratio)
+    → Minimum ratio is 1.5, so a 2×ATR stop needs at least a 3×ATR target.
+
+Worked example (BTC at $23,000, ATR-14 = $1,500, portfolio = $250,000):
+  stop_loss   = 23,000 − (2.0 × 1,500) = 20,000      ← numerically LESS than 23,000 ✓
+  take_profit = 23,000 + (3.0 × 1,500) = 27,500      ← numerically GREATER than 23,000 ✓
+  risk_reward = (27,500 − 23,000) / (23,000 − 20,000) = 4,500 / 3,000 = 1.5 ✓
+  risk_usd    = (entry − stop) = $3,000 per BTC
+  position_usd = (250,000 × 0.02) / 3,000 = $1,666 → approved_position_size_pct ≈ 0.67%
+
+DO NOT use historical ATH prices as reference points. Use only the current price shown in the context.
+
+When to veto (veto: true):
+- Risk/reward < 1.5
+- Position would exceed 20% of portfolio
+- Any hard numerical constraint cannot be satisfied
+
+When not vetoing, set veto_reason to null.
+
+Return ONLY valid JSON matching this exact schema — no markdown, no explanation, no extra keys:
+{
+  "veto": true | false,
+  "veto_reason": "<string or null>",
+  "approved_position_size_pct": <float 0-100>,
+  "recommended_stop_loss": <float>,
+  "recommended_take_profit": <float>,
+  "risk_reward_ratio": <float>,
+  "notes": "<brief rationale>"
+}

src/agents/risk.py

@@ -6,7 +6,7 @@
 from src.models import MarketContext, RiskManagerOutput
 
 MODEL = "claude-sonnet-4-6"
-PROMPT_FILE = "risk_manager_v1.txt"
+PROMPT_FILE = "risk_manager_v2.txt"
 
 
 def _build_user_message(ctx: MarketContext) -> str:

src/backtest/signals.py

@@ -97,6 +97,56 @@ def _append_agent_log(path: Path, date: str, data: dict) -> None:
         f.write(json.dumps({"date": date, "output": data}) + "\n")
 
 
+def _sanitize_stop_levels(
+    close_price: float,
+    sl_pct: float,
+    tp_pct: float,
+    atr_14: float,
+) -> tuple[float, float]:
+    """Validate and correct stop-loss / take-profit ratios for a long position.
+
+    For a long entry at *close_price*:
+      - sl_pct must be in (0.0, 1.0): stop is below entry price.
+      - tp_pct must be > 1.0:         target is above entry price.
+
+    When the risk manager returns a stop above the entry (sl_pct ≥ 1.0) —
+    which happens when the model anchors to historical BTC price levels rather
+    than computing downward from the current price — the ratio is replaced with
+    an ATR-based fallback.  The same fallback fires when values are zero or
+    nonsensical.
+
+    Args:
+        close_price: Current close price (the implied entry for a long).
+        sl_pct:      raw recommended_stop_loss / close_price from risk manager.
+        tp_pct:      raw recommended_take_profit / close_price from risk manager.
+        atr_14:      ATR-14 value from indicators (used for the fallback).
+
+    Returns:
+        Corrected (sl_pct, tp_pct) — guaranteed sl_pct ∈ (0, 1) and tp_pct > 1.
+    """
+    _SL_ATR_MULT = 2.0     # fallback: stop 2×ATR below entry
+    _TP_ATR_MULT = 3.0     # fallback: target 3×ATR above entry (1.5 R:R on the stop)
+    _MIN_SL_PCT = 0.80     # widest allowed stop: 20% below entry
+
+    # --- stop loss ---
+    if sl_pct <= 0.0 or sl_pct >= 1.0:
+        if close_price > 0 and atr_14 > 0:
+            fallback_sl = close_price - _SL_ATR_MULT * atr_14
+            sl_pct = max(_MIN_SL_PCT, fallback_sl / close_price)
+        else:
+            sl_pct = 0.95  # 5% stop as last resort
+
+    # --- take profit ---
+    if tp_pct <= 1.0:
+        if close_price > 0 and atr_14 > 0:
+            fallback_tp = close_price + _TP_ATR_MULT * atr_14
+            tp_pct = fallback_tp / close_price
+        else:
+            tp_pct = 1.075  # 7.5% target (1.5× a 5% stop)
+
+    return sl_pct, tp_pct
+
+
 async def generate_signals(
     full_ohlcv: pd.DataFrame,
     sentiment_history: dict,
@@ -207,6 +257,11 @@ async def generate_signals(
                 # Store as ratios relative to close so they work at any price scale
                 sl_pct = (sl_price / close_price) if close_price > 0 and sl_price > 0 else 0.0
                 tp_pct = (tp_price / close_price) if close_price > 0 and tp_price > 0 else 0.0
+                # Sanity-check: stop must be below entry (sl_pct < 1) and
+                # target must be above entry (tp_pct > 1) for a long position.
+                sl_pct, tp_pct = _sanitize_stop_levels(
+                    close_price, sl_pct, tp_pct, indicator_data["atr_14"]
+                )
 
                 logger.info(
                     "Cycle %s: signal=%s conviction=%s vetoed=%s",

src/data/news_historical.py

@@ -47,8 +47,10 @@
 
 CACHE_DIR = Path("tmp/cache/gdelt")
 
-# Seconds to sleep after each uncached fetch (rate control)
-_POST_FETCH_SLEEP = 2.0
+# Seconds to sleep before each GDELT request (proactive rate control)
+_PRE_REQUEST_SLEEP = 2.0
+# Additional seconds to sleep after each uncached fetch
+_POST_FETCH_SLEEP = 1.0
 # Max retry attempts on 429
 _MAX_RETRIES = 3
 
@@ -66,18 +68,23 @@ def _extract_domain(url: str) -> str:
 
 
 def _gdelt_get(params: dict) -> dict | None:
-    """GET GDELT with exponential-backoff retry on 429. Returns parsed JSON or None."""
-    delay = 5.0
+    """GET GDELT with proactive rate pacing and exponential-backoff retry on 429.
+
+    Sleeps _PRE_REQUEST_SLEEP seconds before every attempt so that the request
+    rate is controlled from the very first call rather than only after a 429.
+    """
+    retry_delay = 10.0
     for attempt in range(_MAX_RETRIES):
+        time.sleep(_PRE_REQUEST_SLEEP)
         try:
             resp = httpx.get(GDELT_URL, params=params, timeout=30)
             if resp.status_code == 429:
                 logger.warning(
                     "GDELT rate-limited (attempt %d/%d); sleeping %.0fs",
-                    attempt + 1, _MAX_RETRIES, delay,
+                    attempt + 1, _MAX_RETRIES, retry_delay,
                 )
-                time.sleep(delay)
-                delay *= 3
+                time.sleep(retry_delay)
+                retry_delay *= 3
                 continue
             resp.raise_for_status()
             return resp.json()

tests/test_agents.py

@@ -656,6 +656,7 @@ def test_capped_at_max(self):
     "technical_analyst_v2.txt",
     "sentiment_analyst_v2.txt",
     "fundamental_analyst_v2.txt",
+    "risk_manager_v2.txt",
     "deliberation_v2.txt",
 ]
 

tests/test_backtest.py

@@ -497,3 +497,101 @@ def test_stats_sharpe_is_numeric(self):
 # ================================================================ imports needed in tests
 
 import asyncio  # noqa: E402  (used in test_returns_dict_with_required_keys)
+
+
+# ================================================================ TestSanitizeStopLevels
+
+class TestSanitizeStopLevels:
+    """Tests for src/backtest/signals._sanitize_stop_levels.
+
+    This function guards against the risk manager outputting stop-loss prices
+    that are above the entry price (sl_pct ≥ 1.0) or take-profit prices that
+    are below the entry price (tp_pct ≤ 1.0) — both of which were observed in
+    production runs when the model anchored to historical Bitcoin ATH levels
+    rather than computing downward from the current price.
+    """
+
+    def _call(self, close, sl_pct, tp_pct, atr_14):
+        from src.backtest.signals import _sanitize_stop_levels
+        return _sanitize_stop_levels(close, sl_pct, tp_pct, atr_14)
+
+    # --- stop-loss above entry (the observed bug) ---
+
+    def test_sl_above_entry_is_replaced(self):
+        """sl_pct = 3.17 (stop at 3× entry) must be corrected."""
+        sl, tp = self._call(close=23_389, sl_pct=3.17, tp_pct=3.57, atr_14=1_500)
+        assert sl < 1.0, f"sl_pct {sl:.4f} is still ≥ 1.0"
+
+    def test_sl_above_entry_uses_atr_fallback(self):
+        close, atr = 23_389.0, 1_500.0
+        sl, _ = self._call(close=close, sl_pct=3.17, tp_pct=3.57, atr_14=atr)
+        expected = (close - 2.0 * atr) / close   # 2×ATR stop
+        assert sl == pytest.approx(expected, rel=1e-6)
+
+    def test_sl_at_exactly_one_is_replaced(self):
+        sl, _ = self._call(close=20_000, sl_pct=1.0, tp_pct=1.10, atr_14=1_000)
+        assert sl < 1.0
+
+    def test_sl_zero_is_replaced(self):
+        sl, _ = self._call(close=20_000, sl_pct=0.0, tp_pct=1.10, atr_14=1_000)
+        assert 0.0 < sl < 1.0
+
+    def test_sl_negative_is_replaced(self):
+        sl, _ = self._call(close=20_000, sl_pct=-0.5, tp_pct=1.10, atr_14=1_000)
+        assert 0.0 < sl < 1.0
+
+    # --- stop-loss floor ---
+
+    def test_sl_never_drops_below_80pct_of_entry(self):
+        """A huge ATR should not produce a stop more than 20% below entry."""
+        # ATR of 100k would push stop to 20_000 - 200_000 = negative → clamp to MIN_SL_PCT
+        sl, _ = self._call(close=20_000, sl_pct=3.0, tp_pct=1.10, atr_14=100_000)
+        assert sl >= 0.80
+
+    # --- valid stop passes through unchanged ---
+
+    def test_valid_sl_is_unchanged(self):
+        sl, _ = self._call(close=23_389, sl_pct=0.90, tp_pct=1.10, atr_14=1_500)
+        assert sl == pytest.approx(0.90)
+
+    def test_valid_tp_is_unchanged(self):
+        _, tp = self._call(close=23_389, sl_pct=0.90, tp_pct=1.15, atr_14=1_500)
+        assert tp == pytest.approx(1.15)
+
+    # --- take-profit below entry ---
+
+    def test_tp_below_entry_is_replaced(self):
+        """tp_pct = 0.85 (target below entry) must be corrected."""
+        _, tp = self._call(close=23_389, sl_pct=0.90, tp_pct=0.85, atr_14=1_500)
+        assert tp > 1.0
+
+    def test_tp_at_exactly_one_is_replaced(self):
+        _, tp = self._call(close=23_389, sl_pct=0.90, tp_pct=1.0, atr_14=1_500)
+        assert tp > 1.0
+
+    def test_tp_uses_atr_fallback(self):
+        close, atr = 23_389.0, 1_500.0
+        _, tp = self._call(close=close, sl_pct=0.90, tp_pct=0.80, atr_14=atr)
+        expected = (close + 3.0 * atr) / close  # 3×ATR target
+        assert tp == pytest.approx(expected, rel=1e-6)
+
+    # --- R:R check after sanitization ---
+
+    def test_corrected_levels_have_positive_rr(self):
+        close, atr = 23_389.0, 1_500.0
+        sl, tp = self._call(close=close, sl_pct=3.17, tp_pct=3.57, atr_14=atr)
+        # R:R = (tp - 1) / (1 - sl) measured in pct terms
+        rr = (tp - 1.0) / (1.0 - sl)
+        assert rr >= 1.5, f"R:R {rr:.2f} below minimum after sanitization"
+
+    # --- last-resort fallbacks when no ATR available ---
+
+    def test_zero_atr_uses_pct_defaults(self):
+        sl, tp = self._call(close=23_389, sl_pct=3.0, tp_pct=0.5, atr_14=0.0)
+        assert 0.0 < sl < 1.0
+        assert tp > 1.0
+
+    def test_zero_close_returns_defaults_without_raising(self):
+        sl, tp = self._call(close=0.0, sl_pct=0.0, tp_pct=0.0, atr_14=1_500)
+        assert 0.0 < sl < 1.0
+        assert tp > 1.0

tests/test_news_historical.py

@@ -1,7 +1,7 @@
 """
 Unit tests for src/data/news_historical.py (GDELT historical news).
 
-All HTTP calls are mocked — no network required.
+All HTTP calls and time.sleep calls are mocked — no network, no real delays.
 """
 
 import json
@@ -18,6 +18,15 @@
     fetch_news_for_date,
 )
 
+# Suppress all sleeps in every test in this module
+pytestmark = pytest.mark.usefixtures("_no_sleep")
+
+
+@pytest.fixture(autouse=True)
+def _no_sleep():
+    with patch("src.data.news_historical.time.sleep"):
+        yield
+
 
 def _mock_response(articles: list[dict]) -> MagicMock:
     resp = MagicMock(spec=httpx.Response)