feat: rewrite strategy to 10m vol-lead with undying signal + watch alert

- core/strategy.py: full rewrite to Volume Lead strategy
  - 10m candle direct detection (no 40m resampling)
  - F&G 3-tier vol threshold: <=40->6x, 41-50->5x, >50->blocked
  - Undying signal: price drop does not cancel signal (sig_p fixed)
  - Vol refresh: stronger vol_r updates signal price and timer
  - Watch alert: 4x-6x approaching threshold notifies via Telegram
  - WATCH_VOL_THRESH=4.0, WATCH_COOLDOWN_MIN=30, WATCH_VOL_JUMP=0.5
- daemon/runner.py: remove FNG_MIN_ENTRY block and Bear regime block
  - Only FNG_MAX_ENTRY(>50) blocks scan (greed/extreme greed)
  - Fast-poll loop cleaned of regime check
- core/notify.py: add notify_watch() for near-signal Telegram alerts
  - Shows vol_r, distance to threshold, price, quiet pct
- tests/: add 1y data collection and simulation scripts
  - collect_1y_data.py, refresh_cache.py
  - sim_10m_vol.py, sim_current.py, sim_regime_1y.py
  - sim_regime_sweep.py, sim_vol_override.py

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

core/strategy.py

@@ -1,18 +1,20 @@
-"""Volume Lead 전략: 거래량 축적(급증+횡보) 감지 후 +TREND_AFTER_VOL% 상승 시 선진입.
+"""Volume Lead 전략: 10분봉 거래량 급증 + 횡보 감지 후 +THRESH% 상승 시 진입.
 
 흐름:
-  1. 직전 40분봉 거래량 > 로컬 5h(7봉) 평균 × VOL_MULT  AND
-     2h 가격 변동 < PRICE_QUIET_PCT%  (횡보 중 축적)
+  1. 직전 완성 10분봉 거래량 > 로컬 LV봉(280분) 평균 × VOL_THRESH  AND
+     QN봉(120분) 이전 종가 대비 가격 변동 < PRICE_QUIET_PCT%  (횡보 중 축적)
      → 신호가(signal_price) + 거래량비율(vol_ratio) 기록
-  2. signal_price 대비 +임계값% 이상 상승 시 진입
-     임계값은 vol_ratio 강도에 따라 자동 조정 (강한 신호 → 낮은 임계값 → 조기 진입)
-     - vol_ratio ≥ 5.0x → +1.0%
-     - vol_ratio ≥ 3.5x → +2.0%
-     - vol_ratio ≥ 2.5x → +3.0%
-     - 기본           → +TREND_AFTER_VOL%
-  3. SIGNAL_TIMEOUT_H 내 임계값 미달 또는 신호가 이하 하락 시 신호 초기화
+     * 더 강한 vol(> 기존 sig vol_ratio)이 오면 sig_p 갱신
+  2. signal_price 대비 +TREND_AFTER_VOL%(4.8%) 이상 상승 시 진입
+  3. 신호불사: 가격이 신호가 아래로 내려가도 신호 유지 (sig_p 고정, 만료까지 대기)
+  4. SIGNAL_TIMEOUT_MIN(480분=8h) 초과 시 신호 초기화
 
-캔들: minute10 데이터를 40분봉으로 리샘플링하여 사용
+거래량 임계값 + 진입 차단 (F&G 기반 3구간):
+  - F&G ≤ FNG_FEAR_THRESHOLD(40):   VOL_THRESH_FEAR(6.0x)   ← 공포/극공포
+  - F&G 41 ~ FNG_MAX_ENTRY(50):     VOL_THRESH_NORMAL(5.0x) ← 중립
+  - F&G > FNG_MAX_ENTRY(50):        진입 차단               ← 탐욕/극탐욕
+
+캔들: minute10 데이터 직접 사용 (40분봉 리샘플링 없음)
 """
 
 from __future__ import annotations
@@ -23,61 +25,37 @@ import time
 
 import pyupbit
 
-from .fng import FNG_MIN_ENTRY, is_entry_allowed
+from .fng import get_fng
 from .market import get_current_price
-from .market_regime import get_regime
-from .notify import notify_signal
-from .price_db import get_price_n_hours_ago
+from .notify import notify_signal, notify_watch
 
 logger = logging.getLogger(__name__)
 
-# 축적 감지 파라미터
-PRICE_QUIET_PCT  = float(os.getenv("PRICE_QUIET_PCT",  "2.0"))  # 2h 횡보 기준 (%)
-TREND_AFTER_VOL  = float(os.getenv("TREND_AFTER_VOL",  "5.0"))  # 진입 임계값 (신호가 대비 %)
-SIGNAL_TIMEOUT_H = float(os.getenv("SIGNAL_TIMEOUT_H", "8.0"))  # 신호 유효 시간 (h)
+# 10분봉 직접 사용 파라미터
+LOCAL_VOL_CANDLES  = int(os.getenv("LOCAL_VOL_CANDLES",   "28"))   # 로컬 vol 평균 구간 (280분)
+QUIET_CANDLES      = int(os.getenv("QUIET_CANDLES",       "12"))   # 횡보 체크 구간 (120분)
+PRICE_QUIET_PCT    = float(os.getenv("PRICE_QUIET_PCT",   "2.0"))  # 횡보 기준 (%)
+TREND_AFTER_VOL    = float(os.getenv("TREND_AFTER_VOL",   "4.8"))  # 진입 임계값 (신호가 대비 %)
+SIGNAL_TIMEOUT_MIN = int(os.getenv("SIGNAL_TIMEOUT_MIN", "480"))   # 신호 유효 시간 (분=8h)
 
-# 거래량 파라미터
-LOCAL_VOL_CANDLES = 7   # 5h를 40분봉으로 환산 (int(5 * 60/40) = 7)
-VOLUME_MULTIPLIER = float(os.getenv("VOLUME_MULTIPLIER", "2.0"))
+# F&G 기반 거래량 임계값 + 진입 차단
+VOL_THRESH_NORMAL  = float(os.getenv("VOL_THRESH_NORMAL", "5.0"))  # 중립 구간 (F&G 41~FNG_MAX_ENTRY)
+VOL_THRESH_FEAR    = float(os.getenv("VOL_THRESH_FEAR",   "6.0"))  # 공포/극공포 (F&G ≤ FNG_FEAR_THRESHOLD)
+FNG_FEAR_THRESHOLD = int(os.getenv("FNG_FEAR_THRESHOLD",  "40"))   # 공포 기준 (이하 → FEAR 임계값)
+FNG_MAX_ENTRY      = int(os.getenv("FNG_MAX_ENTRY",       "50"))   # 진입 허용 최대 F&G (초과 → 차단)
 
-# 40분봉 리샘플링 파라미터
-_CANDLE_MIN = 40
-_FETCH_10M  = (LOCAL_VOL_CANDLES + 3) * (_CANDLE_MIN // 10)  # 40 개의 10분봉
+# 관찰 알림 (신호 임계값에 근접했지만 미달인 종목)
+WATCH_VOL_THRESH    = float(os.getenv("WATCH_VOL_THRESH",    "4.0"))  # 관찰 시작 임계값
+WATCH_COOLDOWN_MIN  = int(os.getenv("WATCH_COOLDOWN_MIN",    "30"))   # 같은 종목 재알림 최소 간격 (분)
+WATCH_VOL_JUMP      = float(os.getenv("WATCH_VOL_JUMP",      "0.5"))  # 쿨다운 무시 vol 상승폭
 
-# 신호 강도별 진입 임계값 단계 (vol_ratio 최소값, 진입 임계값%)
-# 강한 신호일수록 낮은 임계값으로 조기 진입
-_ENTRY_TIERS: list[tuple[float, float]] = [
-    (5.0, 1.0),   # 매우 강한 신호 (≥5x) → +1.0% 즉시 진입
-    (3.5, 2.0),   # 강한 신호      (≥3.5x) → +2.0% 조기 진입
-    (2.5, 3.0),   # 중간 신호      (≥2.5x) → +3.0% 반조기 진입
-]
-# 위 조건 미충족 시 TREND_AFTER_VOL 사용
-
-# 속도(velocity) 기반 조기 진입 파라미터
-# 신호 후 가격이 빠르게 상승 중이면 거리 임계값 도달 전에 선진입
-VELOCITY_THRESHOLD = float(os.getenv("VELOCITY_THRESHOLD", "0.10"))  # %/분 (0.10 = 6%/h)
-VELOCITY_MIN_MOVE  = float(os.getenv("VELOCITY_MIN_MOVE",  "0.5"))   # 최소 이동 % (잡음 제거)
-VELOCITY_MIN_AGE_M = float(os.getenv("VELOCITY_MIN_AGE_M", "5.0"))   # 최소 경과 시간(분)
-
-
-def _calc_entry_threshold(vol_ratio: float) -> float:
-    """거래량 비율에 따른 진입 임계값 반환. 강한 신호일수록 낮은 값."""
-    for min_ratio, threshold in _ENTRY_TIERS:
-        if vol_ratio >= min_ratio:
-            return threshold
-    return TREND_AFTER_VOL
-
-
-def _resample_40m(df):
-    """minute10 DataFrame → 40분봉으로 리샘플링."""
-    return (
-        df.resample("40min")
-        .agg({"open": "first", "high": "max", "low": "min", "close": "last", "volume": "sum"})
-        .dropna(subset=["close"])
-    )
+# 10분봉 조회 수
+_FETCH_10M = LOCAL_VOL_CANDLES + QUIET_CANDLES + 5  # 45봉
 
 # 축적 신호 상태: ticker → {"price": float, "time": float(unix), "vol_ratio": float}
 _accum_signals: dict[str, dict] = {}
+# 관찰 알림 상태: ticker → {"time": float, "vol_ratio": float}
+_watch_notified: dict[str, dict] = {}
 
 
 def get_active_signals() -> dict[str, dict]:
@@ -89,50 +67,23 @@ def get_active_signals() -> dict[str, dict]:
     return dict(_accum_signals)
 
 
-def _check_vol_spike(ticker: str, vol_mult: float) -> bool:
-    """직전 완성 40분봉 거래량이 로컬 5h(7봉) 평균의 vol_mult 배 이상인지 확인."""
-    try:
-        df10 = pyupbit.get_ohlcv(ticker, interval="minute10", count=_FETCH_10M)
-    except Exception:
-        return False
-    if df10 is None or len(df10) < _CANDLE_MIN // 10 * 2:
-        return False
-
-    df = _resample_40m(df10)
-    if len(df) < LOCAL_VOL_CANDLES + 1:
-        return False
-
-    recent_vol = df["volume"].iloc[-2]                                  # 직전 완성된 40분봉
-    local_avg  = df["volume"].iloc[-(LOCAL_VOL_CANDLES + 1):-2].mean()  # 이전 7봉(≈5h) 평균
-    if local_avg <= 0:
-        return False
-
-    ratio  = recent_vol / local_avg
-    result = ratio >= vol_mult
-    if result:
-        logger.debug(
-            f"[거래량↑] {ticker} 40m={recent_vol:.0f} / 5h평균={local_avg:.0f} ({ratio:.2f}x ≥ {vol_mult}x)"
-        )
-    else:
-        logger.debug(
-            f"[거래량✗] {ticker} {ratio:.2f}x < {vol_mult}x"
-        )
-    return result
-
-
 def should_buy(ticker: str) -> bool:
-    """Volume Lead 전략.
+    """Volume Lead 전략 (10분봉 직접 감지).
 
-    1단계: F&G 필터 — 공포탐욕지수 < FNG_MIN_ENTRY(41)이면 즉시 차단
-    2단계: 거래량 급증 + 2h 횡보 → 신호가 기록
+    1단계: F&G 값으로 vol 임계값 동적 설정 (≤40→6x, >40→5x)
+    2단계: 10분봉 거래량 급증 + QN봉 횡보 → 신호가 기록 (더 강한 vol이면 갱신)
     3단계: 신호가 대비 +TREND_AFTER_VOL% 상승 확인 시 진입
+    신호불사: 가격이 신호가 아래로 내려가도 신호 유지 (sig_p 고정)
     """
-    # ── F&G 진입 필터 ─────────────────────────────────────
-    if not is_entry_allowed():
+    fng = get_fng()
+
+    # F&G 탐욕/극탐욕 구간 진입 차단
+    if fng > FNG_MAX_ENTRY:
+        logger.debug(f"[F&G차단] {ticker} F&G={fng} > {FNG_MAX_ENTRY} (탐욕) → 진입 금지")
         return False
 
-    regime   = get_regime()
-    vol_mult = regime["vol_mult"]
+    # F&G 구간별 vol 임계값
+    vth = VOL_THRESH_FEAR if fng <= FNG_FEAR_THRESHOLD else VOL_THRESH_NORMAL
 
     current = get_current_price(ticker)
     if not current:
@@ -140,101 +91,81 @@ def should_buy(ticker: str) -> bool:
 
     now = time.time()
 
-    # ── 기존 신호 유효성 확인 ────────────────────────────────
+    # ── 신호 만료 체크 ────────────────────────────────────
     sig = _accum_signals.get(ticker)
     if sig is not None:
-        age_h = (now - sig["time"]) / 3600
-        if age_h > SIGNAL_TIMEOUT_H:
+        age_min = (now - sig["time"]) / 60
+        if age_min > SIGNAL_TIMEOUT_MIN:
             del _accum_signals[ticker]
             sig = None
-            logger.debug(f"[축적타임아웃] {ticker} {age_h:.1f}h 경과 → 신호 초기화")
+            logger.debug(f"[축적타임아웃] {ticker} {age_min:.0f}분 경과 → 신호 초기화")
 
-    # ── 신호 없음: 축적 조건 체크 ────────────────────────────
-    if sig is None:
-        # 2h 가격 횡보 확인 (DB 가격 활용)
-        price_2h = get_price_n_hours_ago(ticker, 2)
-        if price_2h is None:
-            return False
+    # ── 10분봉 데이터 조회 ────────────────────────────────
+    try:
+        df10 = pyupbit.get_ohlcv(ticker, interval="minute10", count=_FETCH_10M)
+    except Exception:
+        return False
+    if df10 is None or len(df10) < LOCAL_VOL_CANDLES + QUIET_CANDLES:
+        return False
 
-        quiet = abs(current - price_2h) / price_2h * 100 < PRICE_QUIET_PCT
+    # ── 거래량 비율 계산 (직전 완성봉 기준) ───────────────
+    vol_prev = float(df10["volume"].iloc[-2])
+    vol_avg  = float(df10["volume"].iloc[-(LOCAL_VOL_CANDLES + 2):-2].mean())
+    vol_r    = vol_prev / vol_avg if vol_avg > 0 else 0.0
 
-        if not quiet:
-            logger.debug(
-                f"[횡보✗] {ticker} 2h변동={(current - price_2h) / price_2h * 100:+.1f}% "
-                f"(기준={PRICE_QUIET_PCT}%)"
+    # ── 횡보 체크 (QN봉 이전 종가 기준) ──────────────────
+    close_qn = float(df10["close"].iloc[-(QUIET_CANDLES + 1)])
+    chg      = abs(current - close_qn) / close_qn * 100 if close_qn > 0 else 999.0
+
+    # ── 관찰 알림: WATCH_VOL_THRESH ≤ vol_r < vth + 횡보 ──
+    if WATCH_VOL_THRESH <= vol_r < vth and chg < PRICE_QUIET_PCT:
+        prev = _watch_notified.get(ticker)
+        age_min  = (now - prev["time"]) / 60 if prev else 999.0
+        vol_jump = vol_r - prev["vol_ratio"] if prev else vol_r
+        if prev is None or age_min >= WATCH_COOLDOWN_MIN or vol_jump >= WATCH_VOL_JUMP:
+            _watch_notified[ticker] = {"time": now, "vol_ratio": vol_r}
+            logger.info(
+                f"[관찰] {ticker} vol={vol_r:.2f}x (신호기준={vth:.1f}x) + 횡보({chg:.1f}%) | F&G={fng}"
             )
-            return False
+            notify_watch(ticker, current, vol_r, vth, chg, fng=fng)
+    elif vol_r < WATCH_VOL_THRESH:
+        _watch_notified.pop(ticker, None)
 
-        # 거래량 급증 확인
-        if not _check_vol_spike(ticker, vol_mult):
-            return False
+    # ── vol 스파이크 + 횡보 → 신호 설정/갱신 ────────────
+    if vol_r >= vth and chg < PRICE_QUIET_PCT:
+        if sig is None or vol_r > sig.get("vol_ratio", 0.0):
+            _accum_signals[ticker] = {"price": current, "time": now, "vol_ratio": vol_r}
+            sig = _accum_signals[ticker]
+            logger.info(
+                f"[축적감지] {ticker} 10m vol={vol_r:.2f}x ≥ {vth:.1f}x + 횡보({chg:.1f}%) "
+                f"→ 신호가={current:,.2f}원 (F&G={fng})"
+            )
+            notify_signal(ticker, current, vol_r, fng=fng)
 
-        # 거래량 비율 계산 후 신호 기록
-        ratio = 0.0
-        try:
-            df10 = pyupbit.get_ohlcv(ticker, interval="minute10", count=_FETCH_10M)
-            df_h = _resample_40m(df10) if df10 is not None else None
-            if df_h is not None and len(df_h) >= LOCAL_VOL_CANDLES + 1:
-                recent_vol = df_h["volume"].iloc[-2]
-                local_avg  = df_h["volume"].iloc[-(LOCAL_VOL_CANDLES + 1):-2].mean()
-                ratio = recent_vol / local_avg if local_avg > 0 else 0.0
-        except Exception:
-            pass
-
-        entry_thr = _calc_entry_threshold(ratio)
-        _accum_signals[ticker] = {"price": current, "time": now, "vol_ratio": ratio}
-        from .fng import get_fng
-        fng_now = get_fng()
-        logger.info(
-            f"[축적감지] {ticker} 거래량 급증 + 2h 횡보 → 신호가={current:,.2f}원 "
-            f"(거래량 {ratio:.2f}x → 진입임계={entry_thr:.1f}% | F&G={fng_now})"
-        )
-        notify_signal(ticker, current, ratio, fng=fng_now)
-        return False  # 신호 첫 발생 시는 진입 안 함
-
-    # ── 신호 있음: 상승 확인 → 진입 ─────────────────────────
-    signal_price = sig["price"]
-    vol_ratio    = sig.get("vol_ratio", 0.0)
-    entry_thr    = _calc_entry_threshold(vol_ratio)
-    move_pct     = (current - signal_price) / signal_price * 100
-    age_min      = (now - sig["time"]) / 60
-
-    if current < signal_price:
-        # 신호가 이하 하락 → 축적 실패
-        del _accum_signals[ticker]
+    if sig is None:
         logger.debug(
-            f"[축적실패] {ticker} 신호가={signal_price:,.2f} → 현재={current:,.2f} (하락) → 초기화"
+            f"[축적✗] {ticker} vol={vol_r:.2f}x (기준={vth:.1f}x) / 횡보={chg:.1f}%"
         )
         return False
 
-    # ── 거리 기반 진입 ─────────────────────────────────────
-    if move_pct >= entry_thr:
+    # ── 진입 확인: 신호가 대비 +TREND_AFTER_VOL% 이상 ──
+    signal_price = sig["price"]
+    vol_ratio    = sig["vol_ratio"]
+    move_pct     = (current - signal_price) / signal_price * 100
+    age_min      = (now - sig["time"]) / 60
+
+    if move_pct >= TREND_AFTER_VOL:
         del _accum_signals[ticker]
         logger.info(
             f"[축적진입] {ticker} 신호가={signal_price:,.2f}원 → 현재={current:,.2f}원 "
-            f"(+{move_pct:.1f}% ≥ {entry_thr:.1f}% | 거래량={vol_ratio:.2f}x)"
+            f"(+{move_pct:.1f}% ≥ {TREND_AFTER_VOL}% | 거래량={vol_ratio:.2f}x | F&G={fng})"
         )
         return True
 
-    # ── 속도 기반 조기 진입 ────────────────────────────────
-    # 신호 후 N분 이상 경과 + 최소 이동 + 분당 상승률 기준 충족 시 선진입
-    if age_min >= VELOCITY_MIN_AGE_M and move_pct >= VELOCITY_MIN_MOVE:
-        velocity = move_pct / age_min  # %/분
-        if velocity >= VELOCITY_THRESHOLD:
-            del _accum_signals[ticker]
-            logger.info(
-                f"[속도진입] {ticker} 신호가={signal_price:,.2f}원 → 현재={current:,.2f}원 "
-                f"(+{move_pct:.1f}% | {velocity:.3f}%/분 ≥ {VELOCITY_THRESHOLD}%/분 | "
-                f"경과={age_min:.1f}분 | 거래량={vol_ratio:.2f}x)"
-            )
-            return True
-
+    # 신호불사: 가격 하락해도 신호 유지 (sig_p 고정, 만료까지 대기)
     logger.debug(
         f"[축적대기] {ticker} 신호가={signal_price:,.2f} 현재={current:,.2f} "
-        f"(+{move_pct:.1f}% / 목표={entry_thr:.1f}% | "
-        f"속도={move_pct/age_min:.3f}%/분 | 경과={age_min:.1f}분)"
-        if age_min > 0 else
-        f"[축적대기] {ticker} 신호가={signal_price:,.2f} 현재={current:,.2f} "
-        f"(+{move_pct:.1f}% / 목표={entry_thr:.1f}%)"
+        f"({move_pct:+.1f}% / 목표={TREND_AFTER_VOL}% | "
+        f"거래량={vol_ratio:.2f}x | 경과={age_min:.0f}분)"
     )
     return False