Replace RSI divergence with a 70/30 crossing

The divergence rule needed a pivot pair, a three-bar confirmation lag
and separate 60/40 bounds on the weekly leg, so it fired weeks after the
move and almost never on a real series. It is replaced, not supplemented:
RSI(14) closing at or beyond 70 / 30 on a bar whose predecessor was
outside that zone, the same thresholds daily and weekly.

The crossing is the signal, so a name parked beyond the threshold fires
once rather than on every bar it stays there. `reversal.py` is deleted
and `meanrev.py` takes its place in the school list.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

docs/analytics.md

@@ -186,7 +186,7 @@ Modules are split by methodology so a new pattern lands in an obvious file.
 | `breakout` | Bollinger / Donchian (50, weekly 52) breakout, BB squeeze release, swing-pivot break, Darvas box, NR7 / Inside Bar, Keltner channel, 52-week high proximity, Wyckoff Spring / Upthrust |
 | `meanrev` | RSI overbought / oversold, Connors RSI(2) dip in uptrend |
 | `momentum` | MACD signal-line cross, Coppock curve (monthly) |
-| `reversal` | Bull / bear engulfing at extreme, RSI ↔ price divergence |
+| `meanrev` | RSI(14) crossing into overbought / oversold, daily and weekly |
 | `volume` | Capitulation bottom (Wyckoff selling climax), OBV divergence, Chaikin Money Flow, Money Flow Index |
 
 ### Public API

skills/terrafin/SKILL.md

@@ -479,15 +479,14 @@ Parameters:
 Patterns evaluated per symbol:
 
 - close-vs-MA cross grid — `MA20/60/120/200_{GOLDEN,DEATH}_CROSS` (daily) and `MA20/60/120W_{GOLDEN,DEATH}_CROSS` (weekly)
-- `52W_NEW_HIGH`, `52W_NEW_LOW`, `WEEKLY_NEW_HIGH`, `WEEKLY_NEW_LOW`, `MINERVINI_TEMPLATE`, `RSI_BULL_DIVERGENCE`, `RSI_BEAR_DIVERGENCE`, their `WEEKLY_` counterparts, `WEEKLY_VOLUME_DRYUP`
+- `52W_NEW_HIGH`, `52W_NEW_LOW`, `WEEKLY_NEW_HIGH`, `WEEKLY_NEW_LOW`, `MINERVINI_TEMPLATE`, `RSI_OVERBOUGHT` and `RSI_OVERSOLD` with their `WEEKLY_` counterparts, `WEEKLY_VOLUME_DRYUP`
 
 Severity, as the catalogue actually emits it:
 
 - no pattern emits `low`, so `severity_min="low"` and `"medium"` return the same set
-- `"high"` narrows to exactly `52W_NEW_HIGH`, `52W_NEW_LOW`, `WEEKLY_NEW_HIGH`, `WEEKLY_NEW_LOW`, `MINERVINI_TEMPLATE`, `WEEKLY_RSI_BULL_DIVERGENCE`, `WEEKLY_RSI_BEAR_DIVERGENCE`
-- a weekly divergence re-fires for about three consecutive weekly bars, so `"high"` is not a one-shot bucket
+- `"high"` narrows to exactly `52W_NEW_HIGH`, `52W_NEW_LOW`, `WEEKLY_NEW_HIGH`, `WEEKLY_NEW_LOW`, `MINERVINI_TEMPLATE`, `WEEKLY_RSI_OVERBOUGHT`, `WEEKLY_RSI_OVERSOLD`
 
-A cross fires only on the bar where the close flips sides, so expect roughly 1–2 signals per symbol — not a flood.
+Expect roughly 1–2 signals per symbol per scan — not a flood.
 
 Coverage fields — check these before concluding "nothing is triggering":
 

src/TerraFin/agent/runtime/capability.py

@@ -300,16 +300,18 @@ def build_default_capability_registry(
                     "\n"
                     "Patterns evaluated per symbol: the close-vs-MA cross grid "
                     "(MA20/60/120/200 daily and MA20/60/120 weekly, golden and "
-                    "death), 52W_NEW_HIGH, 52W_NEW_LOW, MINERVINI_TEMPLATE, "
-                    "RSI_BULL_DIVERGENCE, RSI_BEAR_DIVERGENCE, and "
+                    "death), 52W_NEW_HIGH, 52W_NEW_LOW, WEEKLY_NEW_HIGH, "
+                    "WEEKLY_NEW_LOW, MINERVINI_TEMPLATE, RSI_OVERBOUGHT, "
+                    "RSI_OVERSOLD and their WEEKLY_ counterparts, and "
                     "WEEKLY_VOLUME_DRYUP.\n"
                     "\n"
                     "SEVERITY: no pattern currently emits 'low', so "
                     "`severity_min='low'` and `'medium'` return the same set. "
                     "`'high'` narrows to exactly {52W_NEW_HIGH, 52W_NEW_LOW, "
-                    "MINERVINI_TEMPLATE}. A cross fires only on the bar where "
-                    "the close flips sides, so expect roughly 1-2 signals per "
-                    "symbol, not a flood.\n"
+                    "WEEKLY_NEW_HIGH, WEEKLY_NEW_LOW, MINERVINI_TEMPLATE, "
+                    "WEEKLY_RSI_OVERBOUGHT, WEEKLY_RSI_OVERSOLD}. "
+                    "Expect roughly 1-2 signals per symbol per scan, "
+                    "not a flood.\n"
                     "\n"
                     "COVERAGE: `requested` is the symbol count asked for, "
                     "`scanned` how many were actually fetched and evaluated, and "

src/TerraFin/analytics/analysis/patterns/__init__.py

@@ -24,7 +24,7 @@ Split by methodology so a new pattern lands in an obvious file:
 
 - ``trend``     — MA crosses, Minervini template
 - ``breakout``  — 52-week high/low, weekly volume dry-up
-- ``reversal``  — RSI/price divergence
+- ``meanrev``   — RSI crossing into overbought / oversold
 
 Each school module exposes ``evaluate(ticker, ohlc) -> list[Signal]``;
 the package-level ``evaluate`` aggregates them.
@@ -32,12 +32,12 @@ the package-level ``evaluate`` aggregates them.
 
 from TerraFin.data.contracts.dataframes import TimeSeriesDataFrame
 
-from . import breakout, reversal, trend
+from . import breakout, meanrev, trend
 from ._base import _OHLCV_CACHE_KEY, Severity, Signal
 from .catalog import PATTERN_TIMEFRAMES, signal_key
 
 
-_ACTIVE_SCHOOLS = (trend, breakout, reversal)
+_ACTIVE_SCHOOLS = (trend, breakout, meanrev)
 
 
 def _preload_ohlcv(ohlc) -> None:

src/TerraFin/analytics/analysis/patterns/catalog.py

@@ -33,11 +33,11 @@ PATTERN_TIMEFRAMES: dict[str, str] = {
     "WEEKLY_VOLUME_DRYUP": "weekly",
     "WEEKLY_NEW_HIGH": "weekly",
     "WEEKLY_NEW_LOW": "weekly",
-    "WEEKLY_RSI_BULL_DIVERGENCE": "weekly",
-    "WEEKLY_RSI_BEAR_DIVERGENCE": "weekly",
-    # Reversal
-    "RSI_BULL_DIVERGENCE": "daily",
-    "RSI_BEAR_DIVERGENCE": "daily",
+    # Mean reversion — RSI crossing into an extreme
+    "RSI_OVERBOUGHT": "daily",
+    "RSI_OVERSOLD": "daily",
+    "WEEKLY_RSI_OVERBOUGHT": "weekly",
+    "WEEKLY_RSI_OVERSOLD": "weekly",
 }
 
 
@@ -45,8 +45,8 @@ def signal_key(signal: Signal) -> str | None:
     """What identifies one finding across every bar it re-fires on.
 
     The trigger bar wins: it names the exact bar the finding is about, so a
-    divergence that re-confirms on three consecutive weekly bars off one pivot
-    stays a single finding. `week_ending` is next, naming the data week the fire
+    detector that re-confirms the same event on several later bars stays a
+    single finding. `week_ending` is next, naming the data week the fire
     belongs to. Both are facts the detector put in the snapshot.
 
     The week only keys a pattern this map calls weekly. A daily pattern that

src/TerraFin/analytics/analysis/patterns/meanrev.py

@@ -0,0 +1,92 @@
+"""Mean-reversion conditions — RSI crossing into an extreme.
+
+One rule: RSI(14) closing at or beyond 70 / 30 on a bar that was not there the
+bar before. No pivots and no confirmation lag, so the signal lands on the bar
+it describes rather than weeks later.
+"""
+
+from ._base import (
+    Signal,
+    bar_date,
+    entered_extreme,
+    week_ending,
+    weekly_bars,
+    wilder_rsi,
+)
+from ._base import (
+    closes as _closes,
+)
+
+
+RSI_PERIOD = 14
+OVERBOUGHT = 70.0
+OVERSOLD = 30.0
+
+
+def evaluate(ticker: str, ohlc) -> list[Signal]:
+    out: list[Signal] = []
+    out.extend(_rsi_extreme(ticker, ohlc))
+    out.extend(_weekly_rsi_extreme(ticker, ohlc))
+    return out
+
+
+def _rsi_extreme(
+    ticker: str,
+    ohlc,
+    *,
+    name_prefix: str = "",
+    severity: str = "medium",
+    snapshot_extra: dict | None = None,
+) -> list[Signal]:
+    cs = _closes(ohlc)
+    if len(cs) < RSI_PERIOD + 2:
+        return []
+    rsi = wilder_rsi(cs, n=RSI_PERIOD)
+    if len(rsi) < 2:
+        return []
+    # lookback=1: the previous bar must have been outside the zone, so a name
+    # parked above 70 for weeks fires once, on the crossing.
+    if entered_extreme(rsi, threshold=OVERBOUGHT, low=False, lookback=1):
+        name, direction, word = "RSI_OVERBOUGHT", "overbought", "above"
+    elif entered_extreme(rsi, threshold=OVERSOLD, low=True, lookback=1):
+        name, direction, word = "RSI_OVERSOLD", "oversold", "below"
+    else:
+        return []
+    return [
+        Signal(
+            name=f"{name_prefix}{name}",
+            ticker=ticker,
+            severity=severity,
+            message=(
+                f"RSI({RSI_PERIOD}) crossed {word} "
+                f"{OVERBOUGHT if direction == 'overbought' else OVERSOLD:.0f} "
+                f"to {rsi[-1]:.1f} (close {cs[-1]:.2f})."
+            ),
+            snapshot={
+                "rsi": rsi[-1],
+                "rsi_prev": rsi[-2],
+                "close": cs[-1],
+                "trigger_bar": bar_date(ohlc, len(ohlc) - 1),
+                **(snapshot_extra or {}),
+            },
+        )
+    ]
+
+
+def _weekly_rsi_extreme(ticker: str, ohlc) -> list[Signal]:
+    """The same rule on weekly bars, at the same 70 / 30.
+
+    Severity is `high`, as for every other weekly signal: a weekly RSI(14)
+    reaches an extreme rarely enough to be worth pushing uncurated.
+    """
+    try:
+        weekly = weekly_bars(ohlc, ticker)
+    except Exception:
+        return []
+    return _rsi_extreme(
+        ticker,
+        weekly,
+        name_prefix="WEEKLY_",
+        severity="high",
+        snapshot_extra={"week_ending": week_ending(weekly)},
+    )

src/TerraFin/analytics/analysis/patterns/reversal.py

@@ -1,127 +0,0 @@
-"""Reversal conditions — RSI/price divergence."""
-
-from ._base import (
-    Signal,
-    bar_date,
-    swing_pivots,
-    week_ending,
-    weekly_bars,
-    wilder_rsi,
-)
-from ._base import (
-    closes as _closes,
-)
-
-
-def evaluate(ticker: str, ohlc) -> list[Signal]:
-    out: list[Signal] = []
-    out.extend(_rsi_divergence(ticker, ohlc))
-    out.extend(_weekly_rsi_divergence(ticker, ohlc))
-    return out
-
-
-# ─── RSI / price divergence (fractal pivot based) ────────────────────────────
-
-
-def _rsi_divergence(
-    ticker: str,
-    ohlc,
-    *,
-    rsi_period: int = 14,
-    half_window: int = 3,
-    rsi_high: float = 70.0,
-    rsi_low: float = 30.0,
-    name_prefix: str = "",
-    severity: str = "medium",
-    snapshot_extra: dict | None = None,
-) -> list[Signal]:
-    cs = _closes(ohlc)
-    if len(cs) < rsi_period + half_window * 4 + 5:
-        return []
-    rsi_series = wilder_rsi(cs, n=rsi_period)
-    if len(rsi_series) < half_window * 4:
-        return []
-    # Align: RSI starts at index `rsi_period` in cs.
-    rsi_offset = len(cs) - len(rsi_series)
-    cs_aligned = cs[rsi_offset:]
-    pp = swing_pivots(cs_aligned, half=half_window)
-    rp = swing_pivots(rsi_series, half=half_window)
-    p_highs = [p for p in pp if p.side == +1]
-    p_lows = [p for p in pp if p.side == -1]
-    r_highs = [p for p in rp if p.side == +1]
-    r_lows = [p for p in rp if p.side == -1]
-
-    last_idx = len(cs_aligned) - 1
-    # Fire only if the most recent confirmed pivot is recent (within 2*half).
-    fire_window = half_window + 2
-
-    if len(p_highs) >= 2 and len(r_highs) >= 2 and last_idx - p_highs[-1].bar_index <= fire_window:
-        if p_highs[-1].price > p_highs[-2].price and r_highs[-1].price < r_highs[-2].price:
-            if r_highs[-2].price >= rsi_high:
-                return [
-                    Signal(
-                        name=f"{name_prefix}RSI_BEAR_DIVERGENCE",
-                        ticker=ticker,
-                        severity=severity,
-                        message=(
-                            f"RSI bearish divergence "
-                            f"(price HH {p_highs[-1].price:.2f}, RSI lower-high "
-                            f"{r_highs[-1].price:.1f})."
-                        ),
-                        snapshot={
-                            "price_high": p_highs[-1].price,
-                            "rsi_high": r_highs[-1].price,
-                            "trigger_bar": bar_date(ohlc, rsi_offset + p_highs[-1].bar_index),
-                            **(snapshot_extra or {}),
-                        },
-                    )
-                ]
-    if len(p_lows) >= 2 and len(r_lows) >= 2 and last_idx - p_lows[-1].bar_index <= fire_window:
-        if p_lows[-1].price < p_lows[-2].price and r_lows[-1].price > r_lows[-2].price:
-            if r_lows[-2].price <= rsi_low:
-                return [
-                    Signal(
-                        name=f"{name_prefix}RSI_BULL_DIVERGENCE",
-                        ticker=ticker,
-                        severity=severity,
-                        message=(
-                            f"RSI bullish divergence "
-                            f"(price LL {p_lows[-1].price:.2f}, RSI higher-low "
-                            f"{r_lows[-1].price:.1f})."
-                        ),
-                        snapshot={
-                            "price_low": p_lows[-1].price,
-                            "rsi_low": r_lows[-1].price,
-                            "trigger_bar": bar_date(ohlc, rsi_offset + p_lows[-1].bar_index),
-                            **(snapshot_extra or {}),
-                        },
-                    )
-                ]
-    return []
-
-
-def _weekly_rsi_divergence(ticker: str, ohlc) -> list[Signal]:
-    """Same divergence rule on weekly bars.
-
-    Severity is `high`, not the daily `medium`: a divergence that takes months
-    of weekly pivots to form is rare and is the class of signal worth pushing
-    for a name the user has not curated.
-    """
-    try:
-        weekly = weekly_bars(ohlc, ticker)
-    except Exception:
-        return []
-    # Looser bounds than the daily 70/30: weekly RSI(14) rarely reaches either
-    # extreme, and at 30 the bull side never fired on any name tested.
-    # `week_ending` is what keys the weekly dedup. Without it these fall back to
-    # the run date's ISO week, which double-ships on the KRX schedule and then
-    # swallows the following week.
-    return _rsi_divergence(
-        ticker,
-        weekly,
-        rsi_high=60.0,
-        rsi_low=40.0,
-        name_prefix="WEEKLY_",
-        severity="high",
-        snapshot_extra={"week_ending": week_ending(weekly)},
-    )

tests/agent/test_pattern_scan.py

@@ -23,7 +23,7 @@ def _stub_scan_inputs(monkeypatch):
         # emits "low", so a stub must not invent one.
         return [
             Signal(name="MA20_GOLDEN_CROSS", ticker=ticker, severity="medium", message="stub medium"),
-            Signal(name="RSI_BEAR_DIVERGENCE", ticker=ticker, severity="medium", message="stub medium 2"),
+            Signal(name="RSI_OVERSOLD", ticker=ticker, severity="medium", message="stub medium 2"),
             Signal(name="52W_NEW_HIGH", ticker=ticker, severity="high", message="stub high"),
         ]
 

tests/analytics/test_pattern_catalog.py

@@ -23,15 +23,13 @@ def _sig(name="WEEKLY_NEW_HIGH", ticker="NVDA", **snapshot):
 
 
 def test_trigger_bar_outranks_the_data_week():
-    """A divergence re-confirms on three consecutive weekly bars off one pivot.
-
-    Keyed on `week_ending` that is three findings; keyed on the pivot bar it is
-    one, which is what it is.
+    """A weekly signal carries both fields. The trigger bar names the exact bar
+    the finding is about, so re-reports across later weeks stay one finding.
     """
     keys = {
         signal_key(
             _sig(
-                name="WEEKLY_RSI_BULL_DIVERGENCE",
+                name="WEEKLY_RSI_OVERSOLD",
                 trigger_bar="2026-08-21",
                 week_ending=week,
             )
@@ -67,7 +65,7 @@ def _emittable_pattern_names() -> set[str]:
         if f.name in ("__init__.py", "_base.py", "catalog.py"):
             continue
         names |= set(re.findall(r'name="([A-Z0-9_]+)"', f.read_text()))
-    # The MA-cross grid and the divergence pair build their names by f-string,
+    # The MA-cross grid and the RSI extreme pair build their names by f-string,
     # so expand them from the lists that drive those loops.
     from TerraFin.analytics.analysis.patterns import trend
 
@@ -76,7 +74,7 @@ def _emittable_pattern_names() -> set[str]:
     for p in trend._WEEKLY_MA_PERIODS:
         names |= {f"MA{p}W_GOLDEN_CROSS", f"MA{p}W_DEATH_CROSS"}
     for prefix in ("", "WEEKLY_"):
-        names |= {f"{prefix}RSI_BULL_DIVERGENCE", f"{prefix}RSI_BEAR_DIVERGENCE"}
+        names |= {f"{prefix}RSI_OVERBOUGHT", f"{prefix}RSI_OVERSOLD"}
     return names
 
 
@@ -102,8 +100,8 @@ def test_declared_timeframes_are_pinned():
         "WEEKLY_VOLUME_DRYUP",
         "WEEKLY_NEW_HIGH",
         "WEEKLY_NEW_LOW",
-        "WEEKLY_RSI_BULL_DIVERGENCE",
-        "WEEKLY_RSI_BEAR_DIVERGENCE",
+        "WEEKLY_RSI_OVERBOUGHT",
+        "WEEKLY_RSI_OVERSOLD",
     }
     assert set(PATTERN_TIMEFRAMES.values()) == {"daily", "weekly"}
 
@@ -137,19 +135,20 @@ def test_a_real_detector_emits_a_trigger_bar_on_a_production_frame():
     import numpy as np
     import pandas as pd
 
-    from TerraFin.analytics.analysis.patterns import reversal
+    from TerraFin.analytics.analysis.patterns import meanrev
 
-    def seg(a, b, n):
-        # Exclusive of the start: a duplicated joint is never strictly extreme,
-        # so `swing_pivots` would confirm no pivot at the turn.
-        return list(np.linspace(a, b, n + 1))[1:]
+    # A zigzag that leaves RSI(14) mid-range, then four down bars: RSI crosses
+    # below 30 on the last one. Too short for a weekly RSI, so only daily fires.
+    closes, price = [], 100.0
+    for i in range(20):
+        price *= 1.01 if i % 2 == 0 else 0.99
+        closes.append(price)
+    tail = closes[-1]
+    closes.extend(tail * 0.98**k for k in range(1, 5))
 
-    # Crash, bounce, then a lower price low on weaker momentum — a bull
-    # divergence whose pivot lands inside the fire window.
-    closes = [100.0] + seg(100, 100.5, 39) + seg(100.5, 55, 25) + seg(55, 80, 15) + seg(80, 52, 30) + seg(52, 62, 5)
     frame = pd.DataFrame(
         {
-            "time": pd.date_range("2020-01-01", periods=len(closes), freq="B"),
+            "time": pd.date_range("2020-01-06", periods=len(closes), freq="B"),
             "open": closes,
             "high": np.array(closes) * 1.01,
             "low": np.array(closes) * 0.99,
@@ -162,7 +161,7 @@ def test_a_real_detector_emits_a_trigger_bar_on_a_production_frame():
     # Pinned to the pair, not to "some ISO string": the weekly branch keys off
     # `week_ending`, which never touches `bar_date`, so a substituted weekly
     # emission would satisfy a looser assertion with the bug reinstated.
-    keyed = [(s.name, signal_key(s)) for s in reversal.evaluate("AAA", frame)]
-    assert keyed == [("RSI_BULL_DIVERGENCE", "2020-06-02")], (
-        "if the series stopped producing this pivot, adjust the fixture, not the assertion"
+    keyed = [(s.name, signal_key(s)) for s in meanrev.evaluate("AAA", frame)]
+    assert keyed == [("RSI_OVERSOLD", "2020-02-06")], (
+        "if the series stopped crossing here, adjust the fixture, not the assertion"
     )

tests/analytics/test_weekly_patterns.py

@@ -1,4 +1,4 @@
-"""Weekly-timeframe patterns: `WEEKLY_NEW_HIGH/LOW` and weekly RSI divergence.
+"""Weekly-timeframe patterns: `WEEKLY_NEW_HIGH/LOW` and the weekly RSI extreme.
 
 The first version of `_weekly_new_extreme` compared `cs[-2]` to its OWN trailing
 window, which is true throughout any steady advance — so the detector never
@@ -10,7 +10,7 @@ import numpy as np
 import pandas as pd
 import pytest
 
-from TerraFin.analytics.analysis.patterns import breakout, reversal
+from TerraFin.analytics.analysis.patterns import breakout, meanrev
 from TerraFin.analytics.analysis.patterns._base import is_krx_ticker, weekly_bars
 
 
@@ -28,6 +28,25 @@ def _frame(closes, *, start="2020-01-01", volume=1e6):
     ).set_index("time")
 
 
+def _prod_frame(closes, *, start="2020-01-06", volume=1e6):
+    """The shape the monitor passes: `time` is a COLUMN under a `RangeIndex`.
+
+    A frame indexed by time makes `bar_date` succeed for the wrong reason, so
+    anything asserting `trigger_bar` has to use this one.
+    """
+    closes = list(closes)
+    return pd.DataFrame(
+        {
+            "time": pd.date_range(start, periods=len(closes), freq="B"),
+            "open": closes,
+            "high": np.array(closes) * 1.01,
+            "low": np.array(closes) * 0.99,
+            "close": closes,
+            "volume": [volume] * len(closes),
+        }
+    )
+
+
 def _ramp(a, b, n):
     return list(np.linspace(a, b, n))
 
@@ -215,16 +234,39 @@ def test_is_krx_ticker():
     assert not is_krx_ticker("")
 
 
-# ── weekly RSI divergence ────────────────────────────────────────────────────
+# ── weekly RSI extreme ───────────────────────────────────────────────────────
 
 
-def test_weekly_rsi_delegates_with_weekly_bars_and_looser_bounds(monkeypatch):
-    """The weekly pass must reuse the daily rule, on weekly bars, at 60/40.
+def _rsi_series(step, n):
+    """A zigzag that leaves RSI(14) mid-range, then `n` bars of `step` drift.
 
-    Weekly RSI(14) rarely reaches 30/70 — at 30 the bull side never fired on
-    any real series tested — so the weekly call loosens the bounds while daily
-    keeps the 70/30 that was asked for.
+    `n` picks how far past the threshold the last bar lands, so the same
+    builder gives both the crossing bar and the bar after it.
     """
+    out, price = [], 100.0
+    for i in range(20):
+        price *= 1.01 if i % 2 == 0 else 0.99
+        out.append(price)
+    tail = out[-1]
+    out.extend(tail * step**k for k in range(1, n + 1))
+    return out
+
+
+def _weekly_prod_frame(weekly_closes, *, start="2020-01-06"):
+    """Five identical daily bars per week, so each weekly close is the input."""
+    return _prod_frame([c for c in weekly_closes for _ in range(5)], start=start)
+
+
+# RSI(14) on `_rsi_series`: 68.75 → 72.36 at 5 up bars, 31.40 → 28.01 at 4 down
+# bars. One bar further and the previous bar is already in the zone.
+_CROSS_UP = 1.02, 5
+_PARKED_UP = 1.02, 6
+_CROSS_DOWN = 0.98, 4
+_PARKED_DOWN = 0.98, 5
+
+
+def test_weekly_rsi_delegates_with_weekly_bars(monkeypatch):
+    """The weekly pass reuses the daily rule, on weekly bars, at high severity."""
     captured = {}
 
     def spy(ticker, ohlc, **kwargs):
@@ -233,12 +275,10 @@ def test_weekly_rsi_delegates_with_weekly_bars_and_looser_bounds(monkeypatch):
         captured.update(kwargs)
         return []
 
-    monkeypatch.setattr(reversal, "_rsi_divergence", spy)
+    monkeypatch.setattr(meanrev, "_rsi_extreme", spy)
     daily = _frame(_ramp(100, 300, 600))
-    reversal._weekly_rsi_divergence("AAA", daily)
+    meanrev._weekly_rsi_extreme("AAA", daily)
 
-    assert captured["rsi_high"] == 60.0
-    assert captured["rsi_low"] == 40.0
     assert captured["name_prefix"] == "WEEKLY_"
     assert captured["severity"] == "high"
     # It was handed weekly bars, not the daily frame.
@@ -246,16 +286,6 @@ def test_weekly_rsi_delegates_with_weekly_bars_and_looser_bounds(monkeypatch):
     assert captured["rows"] < len(daily)
 
 
-def test_daily_rsi_keeps_its_own_thresholds():
-    import inspect
-
-    params = inspect.signature(reversal._rsi_divergence).parameters
-    assert params["rsi_high"].default == 70.0
-    assert params["rsi_low"].default == 30.0
-    assert params["name_prefix"].default == ""
-    assert params["severity"].default == "medium"
-
-
 def test_weekly_signals_carry_the_data_week_for_dedup():
     """`week_ending` is what makes a weekly fire unique per week rather than
     per run day; without it the EOD scan falls back to the run date's ISO week,
@@ -278,7 +308,7 @@ def test_weekly_signals_carry_the_data_week_for_dedup():
 def test_flat_series_fires_nothing():
     flat = [100.0] * 700
     assert breakout._weekly_new_extreme("AAA", _frame(flat)) == []
-    assert reversal._weekly_rsi_divergence("AAA", _frame(flat)) == []
+    assert meanrev._weekly_rsi_extreme("AAA", _frame(flat)) == []
 
 
 def test_every_weekly_pattern_emits_week_ending():
@@ -297,61 +327,71 @@ def test_every_weekly_pattern_emits_week_ending():
             assert signal.snapshot.get("week_ending"), signal.name
 
 
-def test_weekly_rsi_snapshot_extra_reaches_the_signal(monkeypatch):
-    """`_weekly_rsi_divergence` must inject `week_ending` into the snapshot.
-
-    Asserted through the delegation contract because the divergence fire
-    conditions are not reachable from a synthetic series.
-    """
-    captured = {}
-
-    def spy(ticker, ohlc, **kwargs):
-        captured.update(kwargs)
-        return []
-
-    monkeypatch.setattr(reversal, "_rsi_divergence", spy)
-    daily = _frame(_ramp(100, 300, 600))
-    reversal._weekly_rsi_divergence("AAA", daily)
-
-    extra = captured.get("snapshot_extra") or {}
-    assert extra.get("week_ending") == weekly_bars(daily).index[-1].date().isoformat()
-
-
-def _divergence_fixture(n: int = 49):
-    """A damped sine on a rising drift, which produces the pivot pair the
-    divergence rule needs. Fires at n=49; the fire window is narrow, so the
-    length matters."""
-    import math
+def test_weekly_rsi_snapshot_extra_reaches_the_signal():
+    """A real fire: `_weekly_rsi_extreme` injects the data week into the
+    snapshot, and the prefix and severity survive to the emitted Signal."""
+    frame = _weekly_prod_frame(_rsi_series(*_CROSS_UP))
+    fired = meanrev._weekly_rsi_extreme("AAA", frame)
 
-    return [100 + 0.6 * i + 25 * (0.995**i) * math.sin(2 * math.pi * i / 20) for i in range(n)]
+    assert [x.name for x in fired] == ["WEEKLY_RSI_OVERBOUGHT"]
+    assert fired[0].severity == "high"
+    assert fired[0].snapshot["week_ending"] == weekly_bars(frame, "AAA").index[-1].date().isoformat()
 
 
-def test_rsi_divergence_emits_the_prefix_severity_and_snapshot_extra():
-    """A real fire, not a spy: the prefix, severity and merged snapshot all
-    have to survive to the emitted Signal."""
-    fired = reversal._rsi_divergence(
+def test_rsi_extreme_emits_the_prefix_severity_and_snapshot_extra():
+    """The caller-supplied prefix, severity and extra all reach the Signal, and
+    the rule's own snapshot fields survive the merge."""
+    fired = meanrev._rsi_extreme(
         "AAA",
-        _frame(_divergence_fixture()),
-        rsi_high=60.0,
-        rsi_low=40.0,
+        _prod_frame(_rsi_series(*_CROSS_UP)),
         name_prefix="WEEKLY_",
         severity="high",
         snapshot_extra={"week_ending": "2026-09-04"},
     )
-    assert [x.name for x in fired] == ["WEEKLY_RSI_BEAR_DIVERGENCE"]
+    assert [x.name for x in fired] == ["WEEKLY_RSI_OVERBOUGHT"]
     assert fired[0].severity == "high"
     assert fired[0].snapshot["week_ending"] == "2026-09-04"
-    # The rule's own fields survive the merge.
-    assert "rsi_high" in fired[0].snapshot
+    assert "rsi" in fired[0].snapshot
 
 
-def test_rsi_divergence_defaults_emit_no_prefix_and_medium():
-    fired = reversal._rsi_divergence("AAA", _frame(_divergence_fixture()), rsi_high=60.0, rsi_low=40.0)
-    assert [x.name for x in fired] == ["RSI_BEAR_DIVERGENCE"]
+def test_rsi_extreme_defaults_emit_no_prefix_and_medium():
+    fired = meanrev._rsi_extreme("AAA", _prod_frame(_rsi_series(*_CROSS_UP)))
+    assert [x.name for x in fired] == ["RSI_OVERBOUGHT"]
     assert fired[0].severity == "medium"
     assert "week_ending" not in fired[0].snapshot
 
 
+def test_rsi_extreme_fires_on_the_bar_it_crosses_each_threshold():
+    up = _prod_frame(_rsi_series(*_CROSS_UP))
+    down = _prod_frame(_rsi_series(*_CROSS_DOWN))
+
+    fired_up = meanrev._rsi_extreme("AAA", up)
+    assert [x.name for x in fired_up] == ["RSI_OVERBOUGHT"]
+    assert fired_up[0].snapshot["rsi"] >= meanrev.OVERBOUGHT
+    assert fired_up[0].snapshot["rsi_prev"] < meanrev.OVERBOUGHT
+
+    fired_down = meanrev._rsi_extreme("AAA", down)
+    assert [x.name for x in fired_down] == ["RSI_OVERSOLD"]
+    assert fired_down[0].snapshot["rsi"] <= meanrev.OVERSOLD
+    assert fired_down[0].snapshot["rsi_prev"] > meanrev.OVERSOLD
+
+
+def test_rsi_already_in_the_zone_on_the_previous_bar_does_not_refire():
+    """`lookback=1`: a name parked past the threshold fires once, on the
+    crossing, not on every bar it stays there."""
+    for step, n in (_PARKED_UP, _PARKED_DOWN):
+        frame = _prod_frame(_rsi_series(step, n))
+        assert meanrev._rsi_extreme("AAA", frame) == [], (step, n)
+
+
+def test_the_trigger_bar_is_the_crossing_bar():
+    """Read off `frame.index` instead of the `time` column and this is None on
+    every production frame, which silently unkeys the dedup."""
+    frame = _prod_frame(_rsi_series(*_CROSS_UP))
+    fired = meanrev._rsi_extreme("AAA", frame)
+    assert fired[0].snapshot["trigger_bar"] == frame["time"].iloc[-1].date().isoformat()
+
+
 def test_weekly_volume_dryup_carries_the_data_week():
     import numpy as np
 
@@ -534,15 +574,15 @@ def test_holiday_week_survives_end_to_end_through_a_detector():
         ("breakout", lambda m: m._weekly_new_extreme("005930.KS", _krx_frame())),
         ("breakout", lambda m: m._weekly_volume_dryup_signal("005930.KS", _krx_frame())),
         ("breakout", lambda m: m.detect_weekly_volume_dryup(_krx_frame(), ticker="005930.KS")),
-        ("reversal", lambda m: m._weekly_rsi_divergence("005930.KS", _krx_frame())),
+        ("meanrev", lambda m: m._weekly_rsi_extreme("005930.KS", _krx_frame())),
         ("trend", lambda m: m._ma_cross_grid("005930.KS", _krx_frame())),
     ],
 )
 def test_every_weekly_entry_point_forwards_the_ticker(monkeypatch, module_name, call):
     """`weekly_bars` needs the ticker to pick the right session calendar."""
-    from TerraFin.analytics.analysis.patterns import breakout, reversal, trend
+    from TerraFin.analytics.analysis.patterns import breakout, meanrev, trend
 
-    module = {"breakout": breakout, "reversal": reversal, "trend": trend}[module_name]
+    module = {"breakout": breakout, "meanrev": meanrev, "trend": trend}[module_name]
     seen = []
     real = weekly_bars
 
@@ -557,31 +597,20 @@ def test_every_weekly_entry_point_forwards_the_ticker(monkeypatch, module_name,
     assert all(t == "005930.KS" for t in seen), seen
 
 
-def _bull_divergence_fixture(n: int = 48):
-    """Mirror of `_divergence_fixture` tuned to fire the BULL branch.
-
-    The two branches build their snapshots independently, so the bear fixture
-    does not exercise the bull one.
-    """
-    import math
-
-    return [max(1.0, 200 - 0.5 * i + 20 * (0.995**i) * math.sin(2 * math.pi * i / 16)) for i in range(n)]
-
-
-def test_bull_branch_also_merges_snapshot_extra():
-    fired = reversal._rsi_divergence(
+def test_the_oversold_branch_also_merges_snapshot_extra():
+    """The two branches emit independently, so the overbought fixture does not
+    exercise this one."""
+    fired = meanrev._rsi_extreme(
         "AAA",
-        _frame(_bull_divergence_fixture()),
-        rsi_high=60.0,
-        rsi_low=40.0,
+        _prod_frame(_rsi_series(*_CROSS_DOWN)),
         name_prefix="WEEKLY_",
         severity="high",
         snapshot_extra={"week_ending": "2026-09-04"},
     )
-    assert [x.name for x in fired] == ["WEEKLY_RSI_BULL_DIVERGENCE"]
+    assert [x.name for x in fired] == ["WEEKLY_RSI_OVERSOLD"]
     assert fired[0].severity == "high"
     assert fired[0].snapshot["week_ending"] == "2026-09-04"
-    assert "rsi_low" in fired[0].snapshot
+    assert "rsi" in fired[0].snapshot
 
 
 def test_weekly_new_high_does_not_refire_while_the_close_ties_the_max():
@@ -625,15 +654,15 @@ def test_evaluate_emits_the_weekly_breakout_and_rsi_families():
     names = {s.name for s in evaluate("AAA", advance)}
     assert "WEEKLY_NEW_HIGH" in names
 
-    # The reversal school is asserted separately, via the delegation tests
-    # below — a natural weekly-RSI fire is not reachable from a ramp.
+    # A steady ramp never crosses into an RSI extreme, so the meanrev school is
+    # asserted separately by the wiring test below.
 
 
 def test_evaluate_reaches_the_weekly_rsi_leg(monkeypatch):
-    from TerraFin.analytics.analysis.patterns import evaluate, reversal
+    from TerraFin.analytics.analysis.patterns import evaluate, meanrev
 
     called = []
-    monkeypatch.setattr(reversal, "_weekly_rsi_divergence", lambda t, o: called.append(t) or [])
+    monkeypatch.setattr(meanrev, "_weekly_rsi_extreme", lambda t, o: called.append(t) or [])
     evaluate("AAA", _frame(_ramp(100, 200, 400)))
     assert called == ["AAA"]