back to stage

confirm_sell_backtest.py

@@ -4,7 +4,8 @@
 
 규칙:
   - 이벤트 = 종목 자기고점 기준 이격이 -10% 위에서 -10% 이하로 '새로 진입'한 구간 1개 (깊이 무관)
-  - 1차 후 다음 이벤트 -> 2차,3차... 연쇄 (일수 제한 없음)
+  - 1차 후 '직전 이벤트로부터 22거래일 이내'에 다음 이벤트 -> 2차,3차... 연쇄
+    (22일 넘기면 끊기고 그게 새 1차)
   - 2차가 성립하면 그 날 '전량매도' (깊이 비교 없음)
   - 신고가 갱신 시 리셋
 
@@ -18,9 +19,7 @@ import sys, ssl
 import pandas as pd
 import numpy as np
 import FinanceDataReader as fdr
-from datetime import datetime, timedelta, timezone
-
-_KST = timezone(timedelta(hours=9))
+from datetime import datetime, timedelta
 
 ssl._create_default_https_context = ssl._create_unverified_context
 if sys.platform == 'win32':
@@ -31,142 +30,58 @@ if sys.platform == 'win32':
 # =============================================
 TICKERS = {
     'KOSPI': [
-        # '005930', '000660', '373220', '207940', 
-        # '005380',
+        # '005930', '000660', '373220', '207940', '005380',
         # '000270', '068270', '035420', '035720', '005490',
-        # '105560', '055550', '012330', 
-        # '051910', 
-        # '012450',
-        # '006400',
+        # '105560', '055550', '012330', '051910', '006400',
         # '028260', '066570', '096770', '034730', '015760',
-        # '178920',
         # '204320',
-        # '005250',
+        # '012450',
     ],
     'KOSDAQ': [
         # '247540', '086520', '196170', '028300', '348370',
-        # '058470', '068760', '263750', '035900', '277810',
+        # '058470', '068760', '263750', '035900', 
+        # '277810',
+        '234690',
         # '041510', '035760', '112040', '293490', '145020',
         # '039030', '240810', '357780', 
         # '403870', 
         # '121600',
         # '399720',
-        # '277810',        
-        # '257720',
-        # '017510',
-        # '389020',
-        # '195940',
-        '251370',
+        # '234340',
     ],
 }
 
 # =============================================
 # 설정
 # =============================================
-DIV_THRESHOLD  = -0.10   # 이격 기준(고정). 이격이 이보다 깊어지면 flag ON 시작.
-MIN_DEEPEN     = 0.020   # 다음 단계로 가려면 직전 단계보다 최소 이만큼(%p) 더 깊어야 (노이즈 방지)
-DAILY_JUMP     = 0.10    # 하루만에 이격이 전일比 이만큼(%p)+ 급락하면 '대기' 건너뛰고 점프
-
-# --- 단계 수 손잡이: flag ON 후 '몇 번 더 깊어져야' 전량매도가 발동하나 ---
-#   3 = 기존(flag→1차→2차flag→2차매도, 깊어짐 3번). 줄이면 더 일찍 울리지만 더 자주 울림.
-#   2 = flag→1차→매도 (깊어짐 2번) / 1 = flag→매도 (깊어짐 1번, 가장 일찍/가장 자주)
-CONFIRM_STAGES = 0
-
-# =============================================
-# 매도 엔진 선택
-#   'STAGE'  = 기존: 이격 flag→1차→2차flag→2차 (단계누적). 헛알람 적지만 후행(느림).
-#   'RS_A4'  = 새거: RS선이 시장보다 약해지면(데드크로스) '무장' -> A-4(추세죽음) 확인되는
-#              즉시 매도. 단계 안 거침 -> 더 일찍. RS는 선행지표라 240 깨지기 전에 경고.
-# =============================================
-ENGINE         = 'RS_A4'   # 'STAGE' / 'RS_A4'
-RS_MA_PERIOD   = 20        # RS선(종목/지수)의 이동평균 기간. RS < 이 평균이면 데드크로스(약화)
-RS_SMOOTH      = 5         # RS선 자체를 이 일수 EMA로 부드럽게(톱니 제거). 1이면 smoothing 안함.
-RS_BUFFER      = 0.02      # 데드크로스 버퍼: RS가 MA보다 '이만큼(2%) 확실히 아래'여야 약화 인정
-                           #   (RS·MA 딱 붙어서 0.0001 차이로 톡톡 교차하는 잦은 알람 방지)
-RS_PERSIST     = 3         # RS가 이만큼(거래일) 연속 약해야 '무장' (하루 노이즈 방지)
-RS_CONFIRM     = 'MA60'      # 무장 후 '매도 확인' 신호:
-                           #   'A4'    = 이평선 평평(느림/안전, 천천히 죽는 추세용)
-                           #   'MA60'  = 종가가 60선 깨면(빠름! 급락에 강함) ← 늦게 우는 거 해결
-                           #   'MA120' = 종가가 120선 깨면(중간)
-                           #   'NONE'  = RS 데드크로스만으로(제일 빠름/제일 시끄러움)
-CONFIRM_NEEDS_FLAT = 'MARGIN'  # MA60/MA120 확인에 추가 게이트 (오르는 중엔 매도 금지):
-                           #   'OFF'        = 종가만 (빠르지만 오를 때도 찍힘)
-                           #   'SELF'       = 확인선 기울기 우상향이면 금지 (기울기 후행→느림)
-                           #   'MARGIN'     = 종가가 확인선보다 CONFIRM_MARGIN 아래여야 (빠름+눌림무시)
-                           #   'MARGIN+240' = MARGIN + 240선 가파른상승(>FLAT_MAX_240)이면 금지 ← 추천
-                           #   '240'        = 240선이 평평/꺾임이어야 (더 엄격)
-                           #   (RS_CONFIRM='A4'/'NONE'일 땐 이 설정 무시)
-CONFIRM_MARGIN   = 0.035   # 'MARGIN' 모드에서: 종가가 확인선보다 이만큼(3%) 아래여야 '붕괴'로 인정.
-                           #   잠깐 눌림(선 살짝 스침)은 무시, 진짜 급락만. 기울기 안 기다려서 빠름.
-SELL_ONCE      = True      # 첫 매도 후엔 '진짜 추세복귀'까지 재무장 금지.
-                           #   떨어지는 종목이 -30/-40/-50/-80%서 계속 또 우는 톱니 제거.
-RELOCK_LINE    = 240       # 잠금해제 기준선: 240=확실(폭락주 내내 잠김) / 120=느슨(빨리 풀림)
-                           #   폭락 중엔 120선이 주가에 바짝 붙어 잠깐 반등에도 풀려버림 -> 240 권장
-RELOCK_MIN_DAYS = 60       # + 첫 매도 후 최소 이 일수는 무조건 잠금(둘 다 충족해야 해제)
-NO_ARM_BELOW_240 = -0.10   # 종가가 240선보다 이만큼(-10%) 더 아래면 '무장 금지'.
-                           #   이미 추세 무너진(240 한참 아래) 종목은 최후보루 대상 아님.
-                           #   None 이면 이 필터 끔(240 아래여도 무장 허용).
-NO_ARM_DIV_BELOW = -0.30   # 이격(고점 대비 낙폭)이 이미 이만큼(-25%) 넘게 깊으면 '무장 금지'.
-                           #   240선은 폭락주 따라 바닥까지 내려와서 못 거름 -> '고점 대비'로 막음.
-                           #   이미 -50/-80% 빠진 시체에 '팔아라' 안 함. None=필터 끔.
+DIV_THRESHOLD  = -0.10   # 이격 기준
+MIN_DEEPEN     = 0.025   # 다음 단계로 가려면 직전 단계보다 최소 이만큼(%p) 더 깊어야 (노이즈 방지)
+DAILY_JUMP     = 0.10    # 하루만에 이격이 전일 대비 이만큼(%p)+ 급락하면 '대기' 건너뛰고 바로 확정 점프
 PEAK_WINDOW    = 252     # 고점 기준 = 최근 N거래일(252=1년) 내 최고점 (오래된 고점에 안 묶임)
-# CONFIRM_WINDOW 제거됨: 1차->2차 사이 일수 제한 없음 (며칠이 걸리든 연쇄 허용)
-
-# =============================================
-# 추세 필터: A-4(기울기 평평/하락)만 사용
-#   [공통 전제 AND] 60선이 240선 돌파 후 RUN_MIN_DAYS 경과
-#   [그 위 A-4] 60/120/240선 기울기가 각 밴드 안이면 매도 허용. 240선 없으면 매도 끔.
-# =============================================
-USE_TREND      = True    # 추세필터 전체 on/off (꺼지면 필터 없음)
-
-# 공통 전제: 60선이 240선 돌파 후 이만큼(거래일) 지나야 매도 허용
-RUN_MIN_DAYS   = 40     # 60선이 240선 돌파 후 경과일 (막 돌파 직후=240선 너무 근처라 의미없음)
-
-# 240선 추정: 240일치 데이터가 없으면(상장초기 등) 있는 만큼 최장 평균으로 대체
-ESTIMATE_MA240   = True    # True면 240일 미만이어도 추정해서 판정 (매도 라인에 [240추정] 표시)
-MA240_MIN        = 120     # 최소 이만큼(거래일) 있어야 추정. 이 미만이면 추정 안함(매도 끔)
-
-# A-4) 기울기가 '낮으면'(평평/하락) 매도 허용 — 60/120/240선 각각 밴드(하한<기울기≤상한)
-#   상승 동력이 죽었다고 보고 던짐. AND/OR로 결합.
-#   하한이 -1 이하(예 -9)면 '하한 없음'. 240은 하한 0% (마이너스되면 이미 늦음).
-USE_TREND_FLAT   = True    # A-4 사용?
-FLAT_SLOPE_DAYS  = 10      # 기울기 측정 간격(거래일)
-FLAT_SMOOTH      = 5       # 기울기 스무딩 일수
-FLAT_MIN_60      = -9.0    # 60선 기울기 하한 (-9=하한없음)
-FLAT_MAX_60      = 0.00    # 60선 기울기 상한 (≤0%=꺾여 내려가거나 완전 평평)
-FLAT_MIN_120     = -9.0    # 120선 기울기 하한 (-9=하한없음)
-FLAT_MAX_120     = 0.05    # 120선 기울기 상한
-FLAT_MIN_240     = 0.00    # 240선 기울기 하한 (0%=마이너스면 너무 늦음 -> 제외)
-FLAT_MAX_240     = 0.04    # 240선 기울기 상한 (이보다 가파르게 오르면=상승추세 한복판 눌림 -> 매도X)
-FLAT_COMBINE     = 'AND'   # 'AND'(세 선 다 만족) / 'OR'(하나라도 만족)
-
-SHOW_STEPS     = True    # True면 매도마다 [단계 상세](flag/1차/2차 언제 어떻게) 출력
-
+CONFIRM_WINDOW = 9999      # 1차 이벤트로부터 2차(매도)까지 N일 이내
 LOOK_AHEAD     = 200     # 매도 후 관찰기간(거래일)
 PROTECT_DROP   = -0.10   # 매도가 대비 이만큼 더 빠지면 '잘 판 것'
 
-TREND_MIN_DAYS = 60      # '240올'(강한 상승추세): 최근 N거래일 연속 240선 위
-TREND_MIN_GAP  = 0.05    # '240올': 종가가 240선 +5% 이상
+TREND_MIN_DAYS = 60      # '240올': 최근 N거래일 연속 240선 위
+TREND_MIN_GAP  = 0.05    # '240올': 매도일 종가가 240선 +5% 이상
 
-# 강한 상승추세(240올) 중이면 매도 금지 — 급등주가 상승 한복판에서 60선 잠깐 깨는
-#  '눌림'을 붕괴로 오인하는 false alarm 방지. (240 기울기보다 튼튼: 60일연속 240위+5%갭)
-NO_SELL_STRONG_UPTREND = False   # True면 in_240_run(강한상승) 시 매도 보류
+# --- 매도 알람 억제 필터 (요청사항) ---
+SKIP_IF_BELOW_240  = True   # 매도 시점 종가가 240선 아래면 알람 끔 (이미 늦음)
+SKIP_IF_NO_240     = True   # 240선이 없으면(데이터 부족) 알람 끔
+MAX_EARLY_DAYS     = 129    # 매도 후 이 일수까지만 유효. 이보다 늦게(130일+) 240이탈하면
+                            #   = 너무 일찍 판 것 -> 알람 끔. (None이면 이 필터 끔)
+SKIP_IF_STILL_UP   = True   # 매도 후 관찰기간 내내 240 안 깨고 추세유지=헛매도(false alarm) -> 알람 끔
 
 ANALYZE_FROM = '2020-01-01'   # 채점(매도집계) 시작일 — 이건 '언제부터 결과를 볼지'일 뿐
-ANALYZE_TO   = None      # None=오늘(매번 호출시점 KST 기준). 특정일 고정하려면 'YYYY-MM-DD'.
+ANALYZE_TO   = None      # None=오늘
 
 # ★ 데이터 로딩은 ANALYZE_FROM 과 무관하게 '항상 충분히 과거부터' 불러온다.
 #   (고점/이격은 전체 가격이력으로 계산돼야 하므로. ANALYZE_FROM 만 늦추면 고점을
 #    잘못 잡아 매도시점이 달라지는 버그가 생김 -> 그래서 DATA_START 는 고정.)
 DATA_START   = '2018-01-01'   # 고정. 더 과거를 보려면 이 날짜만 앞당기면 됨.
 
-
-def _end_date():
-    """데이터 끝날짜. ANALYZE_TO 가 None 이면 '지금 KST 오늘'을 매번 새로 계산
-       (앱이 며칠째 켜져 있어도 항상 최신 데이터를 가져오도록)."""
-    if ANALYZE_TO:
-        return ANALYZE_TO
-    return datetime.now(_KST).strftime('%Y-%m-%d')
+_to_dt = datetime.strptime(ANALYZE_TO, '%Y-%m-%d') if ANALYZE_TO else datetime.today()
+ANALYZE_TO = _to_dt.strftime('%Y-%m-%d')
 
 
 # =============================================
@@ -188,113 +103,21 @@ def _trailing_peaks(stock, index, win):
     return pk, ipk
 
 
-def _days_since_cross(t, ma60, ma240):
-    """t 시점 기준, 60선이 240선을 위로 돌파한 뒤 며칠(거래일) 지났나.
-       현재 60>240가 아니면 -1. 돌파 시점을 못 찾으면 t(처음부터 위로 간주)."""
-    if ma60 is None or np.isnan(ma60[t]) or np.isnan(ma240[t]) or ma60[t] <= ma240[t]:
-        return -1
-    k = t
-    while k > 0:
-        if np.isnan(ma60[k - 1]) or np.isnan(ma240[k - 1]):
-            break
-        if ma60[k - 1] <= ma240[k - 1]:        # 직전날 60<=240 -> 여기가 돌파 직후
-            break
-        k -= 1
-    return t - k
-
-
-def _smoothed_slope(line, days, smooth):
-    """선의 days간격 기울기((line[t]/line[t-days])-1)를 구하고 smooth일 이동평균."""
-    n = len(line)
-    raw = np.full(n, np.nan)
-    for t in range(days, n):
-        a = line[t]; b = line[t - days]
-        if not np.isnan(a) and not np.isnan(b) and b > 0:
-            raw[t] = a / b - 1
-    if smooth <= 1:
-        return raw
-    out = np.full(n, np.nan)
-    for t in range(n):
-        lo = max(0, t - smooth + 1)
-        seg = raw[lo:t + 1]
-        seg = seg[~np.isnan(seg)]
-        if len(seg) > 0:
-            out[t] = seg.mean()
-    return out
-
-
-def trend_ok(t, stock, ma240, ma60=None, ma120=None, flat_slopes=None):
-    """추세 필터(USE_TREND).
-       [공통 전제 AND] 60선이 240선 돌파 후 RUN_MIN_DAYS 경과
-       [그 위 A-4] 60/120/240선 기울기가 각 밴드 안이면 매도 허용.
-       240선 없으면 매도 끔. 사유에 실제 값/기울기 포함(디버깅)."""
-    if not USE_TREND:
-        return True, ''
-    m = ma240[t]
-    m60v = ma60[t] if (ma60 is not None) else float('nan')
-    vals = f'[ma60={m60v:,.0f} ma240={m:,.0f} 종가={stock[t]:,.0f}]' if not np.isnan(m) else ''
-    if np.isnan(m) or m <= 0:
-        return False, '240없음'
-    since = _days_since_cross(t, ma60, ma240)
-    if since < 0:
-        return False, f'60<240(우상향아님){vals}'
-    if since < RUN_MIN_DAYS:
-        return False, f'돌파후{since}일(<{RUN_MIN_DAYS}){vals}'
-    a4 = False; a4msg = ''
-    if USE_TREND_FLAT and flat_slopes is not None:
-        checks = []   # (선, 기울기값, 하한, 상한, 통과?)
-        for ln, lo, hi in ((60, FLAT_MIN_60, FLAT_MAX_60),
-                           (120, FLAT_MIN_120, FLAT_MAX_120),
-                           (240, FLAT_MIN_240, FLAT_MAX_240)):
-            arr = flat_slopes.get(ln)
-            if arr is not None and not np.isnan(arr[t]):
-                v = float(arr[t])
-                checks.append((ln, v, lo, hi, (lo < v <= hi)))
-        if checks:
-            a4 = all(c[4] for c in checks) if FLAT_COMBINE == 'AND' else any(c[4] for c in checks)
-            def _fm(ln, v, lo, hi, ok):
-                mk = 'O' if ok else 'X'
-                if lo <= -1:
-                    return f'{ln}:{v*100:.1f}≤{hi*100:.1f}%{mk}'
-                return f'{ln}:{v*100:.1f}∈({lo*100:.0f},{hi*100:.1f}]{mk}'
-            a4msg = ' '.join(_fm(*c) for c in checks)
-    if a4:
-        return True, f'A4(평평·{a4msg})'
-    ex = (' ' + a4msg) if a4msg else ''
-    return False, f'추세미달{vals}{ex}(돌파후{since}일)'
-
-
-def find_confirmed_sells(stock, index, dates, start_pos, ma60=None, ma240=None,
-                         low=None, bbl=None, ma240_est=None, ma120=None):
-    """확정매도 찾기 — 단계누적(CONFIRM_STAGES단계)+급변점프 + 추세필터(A-4)."""
+def find_confirmed_sells(stock, index, dates, start_pos):
+    """확정매도(2차) 찾기 — 단계별 누적 하락 + 하루 이격 급변 점프.
+       고점 = '최근 PEAK_WINDOW(252) 거래일 내 최고점' (트레일링).
+       단계: flagON(대기) -> 1차(확정) -> 2차flagON(대기) -> 2차매도(확정)
+       - 평소: 직전 단계보다 이격 MIN_DEEPEN(2.5%p)+ 더 깊으면 다음 단계
+       - 하루 급변: 전일 이격 대비 오늘 이격이 DAILY_JUMP(10%p)+ 급락하면
+                    '대기(flagON)' 건너뛰고 바로 확정으로 점프
+       - 1차 -> 2차(매도)는 22일 이내
+       - 이격 -10% 위로 회복하면 에피소드 리셋(매도했던 것도 풀림)."""
     n = len(stock)
     twpk, twip = _trailing_peaks(stock, index, PEAK_WINDOW)
-
-    flat_slopes = None
-    if USE_TREND_FLAT:
-        flat_slopes = {}
-        for ln, arr in ((60, ma60), (120, ma120), (240, ma240)):
-            if arr is not None:
-                flat_slopes[ln] = _smoothed_slope(arr, FLAT_SLOPE_DAYS, FLAT_SMOOTH)
-
-    SELL_STAGE = max(1, int(CONFIRM_STAGES)) + 1   # 이 단계에 도달하면 전량매도
-
-    def _sname(stg):
-        """단계 이름. 기본(CONFIRM_STAGES=3)이면 친숙한 1차/2차 이름, 아니면 N단계."""
-        if CONFIRM_STAGES == 3:
-            return {1: 'flag ON', 2: '1차', 3: '2차 flag ON'}.get(stg, f'{stg}단계')
-        return 'flag ON' if stg == 1 else f'{stg}단계'
-
-    def _gate(t):
-        ok, why = (True, '')
-        if ma240 is not None:
-            ok, why = trend_ok(t, stock, ma240, ma60, ma120, flat_slopes)
-        return ok, why
-
     stage = 0; ref_div = None; first_i = None; sold = False
     prev_div = None
     sells = []
-    jumps = []
+    jumps = []          # 하루급변 점프 발동 내역
     _SNAME = {0: '없음', 1: 'flagON', 2: '1차', 3: '2차flagON', 4: '2차매도'}
 
     def _log_jump(t, frm, to, div, pdv, st):
@@ -304,325 +127,60 @@ def find_confirmed_sells(stock, index, dates, start_pos, ma60=None, ma240=None,
                           'from': _SNAME[frm], 'to': _SNAME[to],
                           'skip': (frm == 0 and to == 2) or (frm == 2 and to == 4)})
 
-    def _sell(t, st, div, via=''):
-        if t < start_pos:
-            return False, '관찰기간밖'
-        ok, why = _gate(t)
-        if ok:
-            est = bool(ma240_est[t]) if ma240_est is not None else False
-            sells.append({'i': t, 'price': st, 'div': div, 'date': dates[t],
-                          'trend': why, 'via': via, 'est': est})
-            return True, why
-        return False, why                        # 추세필터에 막힘 (why=차단사유)
-
-    steps = []      # 단계 전이 상세 로그
-    def _step(t, name, div, note=''):
-        if t >= start_pos:
-            steps.append({'date': dates[t], 'name': name, 'div': div, 'note': note})
-
     for t in range(n):
         st = float(stock[t]); it = float(index[t])
         peak = float(twpk[t]); iap = float(twip[t])
-        s_term = (st / peak - 1)                       # 종목: 자기고점 대비
-        i_term = ((it / iap - 1) if iap else 0.0)      # 지수: 고점일 대비
-        div = s_term - i_term
-        _bd = f'[종목 {s_term*100:+.0f}% − 지수 {i_term*100:+.0f}%]'   # 이격 분해(디버깅)
+        div = (st / peak - 1) - ((it / iap - 1) if iap else 0.0)
 
+        # 이격 -10% 위로(=최근 고점 근처로 회복/신고가) -> 에피소드 리셋
         if div > DIV_THRESHOLD:
-            if stage != 0 and t >= start_pos:
-                _step(t, f'리셋(이격 {DIV_THRESHOLD*100:.0f}%위 회복)', div)
             stage = 0; ref_div = None; first_i = None; sold = False
             prev_div = div
             continue
-        if sold:
+
+        if sold:                                # 매도 후, 아직 회복 못함 -> 정지 유지
             prev_div = div
             continue
 
+        # 하루 급변: 전일 이격 대비 DAILY_JUMP 이상 급락
         crash = (prev_div is not None) and ((div - prev_div) <= -DAILY_JUMP)
-        cnote = f'하루급변 {(div-prev_div)*100:.1f}%p (점프기준 {DAILY_JUMP*100:.0f}%p)' if crash else ''
-
-        def _try_sell(note, via):
-            """매도 시도. 발동하면 True(+발동로그), 차단되면 False(+차단로그). 대기 안함."""
-            fired, why = _sell(t, st, div, via)
-            if fired:
-                _step(t, '전량매도 ★발동', div, note + ' ' + _bd)
-                return True
-            _step(t, f'매도조건 충족했으나 차단({why}) — 이번 신호 무시', div, note)
-            return False
+        within = (first_i is None) or ((t - first_i) <= CONFIRM_WINDOW)
 
-        # --- 일반화된 단계 머신 ---
-        # 무장(stage>=1) 후 깊어질 때마다 stage+1 (급변이면 +2로 한 단계 건너뜀).
-        # stage 가 SELL_STAGE 에 도달하면 전량매도.
-        if stage == 0:
+        if stage == 0:                          # 아무것도 없음
             if crash:
-                nx = min(2, SELL_STAGE)
-                _log_jump(t, 0, nx, div, prev_div, st)
-                ref_div = div; first_i = t
-                if nx >= SELL_STAGE:
-                    if _try_sell(cnote + ' (단계 건너뜀)', '급변점프'):
-                        sold = True
-                    else:
-                        stage = SELL_STAGE - 1     # 차단 -> 매도직전 단계로 park
-                else:
-                    stage = nx
-                    _step(t, f'{_sname(nx)}(flag 건너뜀)', div, cnote)
+                _log_jump(t, 0, 2, div, prev_div, st)
+                stage = 2; ref_div = div; first_i = t          # flagON 건너뛰고 -> 1차
             else:
-                stage = 1; ref_div = div; first_i = t
-                if stage >= SELL_STAGE:             # CONFIRM_STAGES=0 같은 극단 설정
-                    if _try_sell('flag즉시', 'flag'):
-                        sold = True
-                    else:
-                        stage = SELL_STAGE - 1
-                else:
-                    _step(t, _sname(1), div, f'기준 {DIV_THRESHOLD*100:.0f}%')
-        else:
-            adv = 0
+                stage = 1; ref_div = div                       # flag ON(대기)
+        elif stage == 1:                        # flag ON(대기)
             if crash:
-                adv = 2; note = cnote
+                _log_jump(t, 1, 2, div, prev_div, st)
+                stage = 2; ref_div = div; first_i = t          # -> 1차(확정)
             elif div <= ref_div - MIN_DEEPEN:
-                adv = 1; note = f'직전比 {(div-ref_div)*100:.1f}%p'
-            if adv:
-                nx = min(stage + adv, SELL_STAGE)
-                ref_div = div
-                if nx >= SELL_STAGE:
-                    if crash:
-                        _log_jump(t, stage, SELL_STAGE, div, prev_div, st)
-                    if _try_sell(note, '급변점프' if crash else '단계누적'):
-                        sold = True
-                    else:
-                        stage = SELL_STAGE - 1     # 차단 -> 매도직전 단계 park, 더 깊어지면 재시도
-                else:
-                    stage = nx
-                    _step(t, _sname(nx), div, note)
-        prev_div = div
-
-    # 관찰 종료 시점, 아직 매도 안 났고 단계 대기 중이면 현재 상태 기록
-    if not sold and 1 <= stage < SELL_STAGE and ref_div is not None:
-        last = n - 1
-        if CONFIRM_STAGES == 3:
-            nm = {1: '1차 flag', 2: '1차 (다음: 2차 flag)',
-                  3: '2차 flag (전량매도 임박!)'}.get(stage, f'{stage}단계')
-        else:
-            tail = ' (다음: 전량매도!)' if stage == SELL_STAGE - 1 else ''
-            nm = f'{stage}단계 / 매도까지 {SELL_STAGE}단계{tail}'
-        cur = float(stock[last] / twpk[last] - 1) - ((float(index[last] / twip[last] - 1)) if twip[last] else 0.0)
-        trigger = ref_div - MIN_DEEPEN          # 다음 단계 발동 이격
-        need = cur - trigger                    # >0 이면 이만큼 더 깊어져야 다음 단계
-        # 현재 이격이 '무장된 최저점(ref_div)'보다 뚜렷이 위로 회복됐으면 = 반등 중 (임박 아님)
-        if cur > ref_div + MIN_DEEPEN:
-            nm = nm.replace(' (전량매도 임박!)', '').replace(' (다음: 전량매도!)', '')
-            note = (f'반등 중 — 현재 이격 {cur*100:.1f}%, 최저 {ref_div*100:.1f}%까지 갔다 회복. '
-                    f'매도트리거 {trigger*100:.1f}% (리셋은 이격 {DIV_THRESHOLD*100:.0f}% 회복 시)')
-            _step(last, f'[현재] {nm} · 반등 중', cur, note)
-        elif need > 0:
-            _step(last, f'[현재] {nm}', cur, f'다음 단계까지 {need*100:.1f}%p 더 하락 필요')
-        else:
-            _step(last, f'[현재] {nm}', cur, '조건 충족상태(다음봉 확인)')
-    return sells, jumps, steps
-
-
-def find_rs_a4_sells(stock, index, dates, start_pos, ma60=None, ma240=None,
-                     low=None, bbl=None, ma240_est=None, ma120=None):
-    """RS_A4 엔진: RS선(종목/지수)이 시장보다 약해지면(RS<RS_MA, RS_PERSIST일 지속) '무장',
-       그 상태에서 A-4 추세필터가 확인되는 즉시 전량매도. 단계 안 거침 -> 일찍 운다.
-       반환은 STAGE 엔진과 동일 형식 (sells, jumps, steps)."""
-    n = len(stock)
-    twpk, twip = _trailing_peaks(stock, index, PEAK_WINDOW)
-
-    flat_slopes = None
-    if USE_TREND_FLAT:
-        flat_slopes = {}
-        for ln, arr in ((60, ma60), (120, ma120), (240, ma240)):
-            if arr is not None:
-                flat_slopes[ln] = _smoothed_slope(arr, FLAT_SLOPE_DAYS, FLAT_SMOOTH)
-
-    # RS선(종목/지수) -> 톱니 줄이려 EMA로 부드럽게 -> 그 이동평균과 비교(버퍼밴드)
-    rs_raw = pd.Series([stock[t] / index[t] if index[t] else np.nan for t in range(n)])
-    rs_s = rs_raw.ewm(span=max(1, RS_SMOOTH), adjust=False).mean() if RS_SMOOTH > 1 else rs_raw
-    rs = rs_s.values
-    rs_ma = rs_s.rolling(RS_MA_PERIOD).mean().values
-    # 데드크로스: RS가 MA보다 RS_BUFFER 만큼 '확실히' 아래여야 약화 인정 (스침 무시)
-    rs_weak = np.array([(not np.isnan(rs_ma[t])) and rs[t] < rs_ma[t] * (1 - RS_BUFFER)
-                        for t in range(n)])
-
-    sells = []; jumps = []; steps = []
-    def _step(t, name, div, note=''):
-        if t >= start_pos:
-            steps.append({'date': dates[t], 'name': name, 'div': div, 'note': note})
-
-    def _gate(t):
-        if ma240 is None:
-            return True, ''
-        return trend_ok(t, stock, ma240, ma60, ma120, flat_slopes)
-
-    def _flat_gate(line_no):
-        """CONFIRM_NEEDS_FLAT에 따라 추가 조건. (통과여부, 사유꼬리표) 반환."""
-        def slope_at(ln, t):
-            arr = flat_slopes.get(ln) if flat_slopes else None
-            return arr[t] if (arr is not None and not np.isnan(arr[t])) else None
-        line_arr = {60: ma60, 120: ma120}.get(line_no)
-        if CONFIRM_NEEDS_FLAT == 'SELF':
-            def chk(t):
-                s = slope_at(line_no, t)
-                if s is None:
-                    return True, ''
-                if s > 0:   # 확인선이 우상향 -> 매도 금지
-                    return False, f'{line_no}선 우상향({s*100:+.1f}%)→보류'
-                return True, f'{line_no}선 기울기{s*100:+.1f}%'
-            return chk
-        if CONFIRM_NEEDS_FLAT in ('MARGIN', 'MARGIN+240'):
-            # 기울기(후행) 대신 마진: 종가가 확인선보다 CONFIRM_MARGIN 확실히 아래여야 발동.
-            #  잠깐 눌림(선 살짝 스침)=무시, 진짜 붕괴(선 훨씬 아래)=즉시(선 꺾임 안 기다림).
-            #  '+240'이면 추가로 240선이 너무 가파른 우상향(>FLAT_MAX_240)이면 매도 금지(상승 한복판 눌림).
-            def chk(t):
-                if line_arr is None or np.isnan(line_arr[t]):
-                    return True, ''
-                margin = (1 - stock[t] / line_arr[t])   # 선 대비 얼마나 아래(%)
-                if margin < CONFIRM_MARGIN:
-                    return False, f'{line_no}선 살짝(-{margin*100:.1f}%<{CONFIRM_MARGIN*100:.0f}%)→보류'
-                if CONFIRM_NEEDS_FLAT == 'MARGIN+240':
-                    s240 = slope_at(240, t)
-                    if s240 is not None and s240 > FLAT_MAX_240:
-                        return False, f'240 가파른상승({s240*100:+.1f}%>{FLAT_MAX_240*100:.0f}%)=눌림→보류'
-                return True, f'{line_no}선 -{margin*100:.1f}%(붕괴)'
-            return chk
-        if CONFIRM_NEEDS_FLAT == '240':
-            def chk(t):
-                s = slope_at(240, t)
-                if s is None:
-                    return True, ''
-                if not (FLAT_MIN_240 < s <= FLAT_MAX_240):
-                    return False, f'240기울기 {s*100:+.1f}%∉({FLAT_MIN_240*100:.0f},{FLAT_MAX_240*100:.0f}]→보류'
-                return True, f'240기울기 {s*100:+.1f}%'
-            return chk
-        return lambda t: (True, '')   # 'OFF'
-
-    _g60 = _flat_gate(60); _g120 = _flat_gate(120)
-
-    def _confirm(t):
-        """무장 후 '매도 확인' 신호. 모드별:
-           A4=이평선 평평(느림/안전) / MA60=종가<60선(빠름) / MA120=종가<120선(중간) / NONE=RS만.
-           MA60/120은 CONFIRM_NEEDS_FLAT 기울기 게이트도 통과해야 함(오를 때 매도 금지)."""
-        if RS_CONFIRM == 'NONE':
-            return True, 'RS단독'
-        if RS_CONFIRM == 'MA60':
-            if ma60 is None or np.isnan(ma60[t]):
-                return False, '60선없음'
-            if stock[t] >= ma60[t]:
-                return False, f'60선위(종가 {stock[t]:,.0f}>{ma60[t]:,.0f})'
-            gok, gwhy = _g60(t)
-            if not gok:
-                return False, gwhy
-            return True, f'종가<60선({ma60[t]:,.0f}) {gwhy}'.strip()
-        if RS_CONFIRM == 'MA120':
-            if ma120 is None or np.isnan(ma120[t]):
-                return False, '120선없음'
-            if stock[t] >= ma120[t]:
-                return False, f'120선위(종가 {stock[t]:,.0f}>{ma120[t]:,.0f})'
-            gok, gwhy = _g120(t)
-            if not gok:
-                return False, gwhy
-            return True, f'종가<120선({ma120[t]:,.0f}) {gwhy}'.strip()
-        return _gate(t)   # 'A4'
-
-    armed = False; armed_date = None; sold = False; weak_run = 0
-    locked = False; lock_i = -1
-    for t in range(n):
-        div = (stock[t] / twpk[t] - 1) - ((index[t] / twip[t] - 1) if twip[t] else 0.0)
-
-        # SELL_ONCE 잠금: 매도 후 (1)RELOCK_LINE 회복 AND (2)최소기간 경과 둘 다여야 풀림
-        if locked:
-            line = {60: ma60, 120: ma120, 240: ma240}.get(RELOCK_LINE, ma240)
-            if line is None:
-                line = ma120 if ma120 is not None else ma60
-            above = (line is not None and not np.isnan(line[t]) and stock[t] > line[t])
-            enough_days = (t - lock_i) >= RELOCK_MIN_DAYS
-            if above and enough_days:
-                locked = False; armed = False; weak_run = 0; sold = False
+                stage = 2; ref_div = div; first_i = t          # -> 1차(확정)
+        elif stage == 2:                        # 1차(확정)
+            if crash and within:
+                _log_jump(t, 2, 4, div, prev_div, st)
+                stage = 4; ref_div = div                       # 2차flagON 건너뛰고 -> 매도
                 if t >= start_pos:
-                    _step(t, f'대기 재개 가능({RELOCK_LINE}선 회복+{t-lock_i}일경과=새 사이클)', div)
-            else:
-                continue   # 잠겨있으면 침묵
-
-        if rs_weak[t]:
-            weak_run += 1
-        else:
-            # RS가 다시 시장보다 강해짐 -> 무장 해제
-            if armed and t >= start_pos:
-                _step(t, '대기 해제(RS 회복)', div)
-            armed = False; weak_run = 0
-            if not SELL_ONCE:
-                sold = False
-            continue
-
-        # RS_PERSIST일 연속 약하면 무장 (이미 판 상태면 무장 안 함)
-        if not armed and not sold and weak_run >= RS_PERSIST:
-            # (1) 종가가 240선보다 깊이 아래 = 추세 무너짐 -> 무장 금지
-            deep_below = False
-            if NO_ARM_BELOW_240 is not None and ma240 is not None and not np.isnan(ma240[t]):
-                deep_below = (stock[t] / ma240[t] - 1) <= NO_ARM_BELOW_240
-            # (2) 이격(고점 대비 낙폭)이 이미 너무 깊음 = 최후보루 시점 지남 -> 무장 금지
-            deep_div = (NO_ARM_DIV_BELOW is not None and div <= NO_ARM_DIV_BELOW)
-            if deep_below or deep_div:
-                if t >= start_pos:
-                    why = (f'이격 {div*100:.0f}%≤{NO_ARM_DIV_BELOW*100:.0f}%(고점대비 한참 빠짐)'
-                           if deep_div else
-                           f'종가 240선 {(stock[t]/ma240[t]-1)*100:.0f}%(추세이탈)')
-                    _step(t, '대기 보류(최후보루 대상 아님)', div, why)
-            else:
-                armed = True; armed_date = dates[t]
-                rsd = (rs[t] / rs_ma[t] - 1) * 100
-                _step(t, '매도대기 진입(RS 약화)', div, f'RS {rsd:.1f}% < MA{RS_MA_PERIOD}')
-
-        if armed and not sold:
-            ok, why = _confirm(t)
-            # 강한 상승추세(240올) 중이면 매도 보류 = 상승 한복판 눌림 false alarm 방지
-            if ok and NO_SELL_STRONG_UPTREND and ma240 is not None and in_240_run(stock, ma240, t):
-                ok = False
+                    sells.append({'i': t, 'price': st, 'div': div, 'date': dates[t]})
+                sold = True
+            elif div <= ref_div - MIN_DEEPEN and within:
+                stage = 3; ref_div = div                       # -> 2차 flag ON(대기)
+        elif stage == 3:                        # 2차 flag ON(대기)
+            if crash and within:
+                _log_jump(t, 3, 4, div, prev_div, st)
+                stage = 4; ref_div = div
                 if t >= start_pos:
-                    _step(t, '매도 보류(강한 상승추세=240올, 눌림)', div,
-                          f'종가 {stock[t]:,.0f} > 240선+{TREND_MIN_GAP*100:.0f}%, {TREND_MIN_DAYS}일연속 240위')
-            if ok:
+                    sells.append({'i': t, 'price': st, 'div': div, 'date': dates[t]})
+                sold = True
+            elif div <= ref_div - MIN_DEEPEN and within:
+                stage = 4; ref_div = div                       # -> 2차 매도(확정)
                 if t >= start_pos:
-                    est = bool(ma240_est[t]) if ma240_est is not None else False
-                    sells.append({'i': t, 'price': float(stock[t]), 'div': div,
-                                  'date': dates[t], 'trend': why,
-                                  'via': f'RS약화({armed_date})', 'est': est})
-                    _step(t, '전량매도 ★발동', div, f'RS약화 후 확인[{RS_CONFIRM}]: {why}')
+                    sells.append({'i': t, 'price': st, 'div': div, 'date': dates[t]})
                 sold = True
-                if SELL_ONCE:
-                    locked = True; lock_i = t   # 한 번 팔면 잠금(해제선+기간 둘 다 충족까지)
-            else:
-                pass  # 무장됐지만 확인신호 아직(또는 상승추세 보류) -> 대기
-
-    # 현재 상태
-    last = n - 1
-    if not sold:
-        div = (stock[last] / twpk[last] - 1) - ((index[last] / twip[last] - 1) if twip[last] else 0.0)
-        if armed:
-            ok, why = _confirm(last)
-            # 매도 확인선까지 남은 거리(가격 기준) = 임박 경고
-            line_arr = {'MA60': ma60, 'MA120': ma120}.get(RS_CONFIRM)
-            dist = None; lname = ''
-            if line_arr is not None and not np.isnan(line_arr[last]):
-                use_margin = CONFIRM_NEEDS_FLAT in ('MARGIN', 'MARGIN+240')
-                trigger = line_arr[last] * (1 - CONFIRM_MARGIN) if use_margin else line_arr[last]
-                dist = stock[last] / trigger - 1     # >0 이면 이만큼 더 빠져야 매도
-                lname = '60선' if RS_CONFIRM == 'MA60' else '120선'
-            if dist is not None and dist > 0:
-                if dist <= 0.03:
-                    nm = f'⚠️ 매도 대기 ({lname}까지 -{dist*100:.1f}%) 매도 임박!'
-                else:
-                    nm = f'매도 대기 ({lname}까지 -{dist*100:.1f}%)'
-                note = ''
-            elif dist is not None:   # 붕괴선 도달했으나 다른 조건(상승추세 등)에 막힘
-                nm = '매도 대기'; note = f'{lname} 도달했으나 보류 ({why})'
-            else:
-                nm = '매도 대기'; note = f'확인[{RS_CONFIRM}] 대기중 ({why})'
-            _step(last, f'[현재] {nm}', div, note)
-        else:
-            _step(last, '[현재] 관망', div, '')
-    return sells, jumps, steps
+        prev_div = div
+    return sells, jumps
 
 
 def in_240_run(stock, ma240, i):
@@ -637,16 +195,17 @@ def in_240_run(stock, ma240, i):
     return True
 
 
-def classify_240(stock, ma240, i, price):
-    """('EARLY'|'STILL_UP'|'ALREADY_DOWN'|'UNKNOWN', 이탈까지 일수)"""
+def classify_240(stock, low, ma240, i, price):
+    """('EARLY'|'STILL_UP'|'ALREADY_DOWN'|'UNKNOWN', 이탈까지 일수)
+       ALREADY_DOWN 은 '저가(장중)가 240선을 터치/이탈'하면 해당 (종가 아님)."""
     m = ma240[i]
     if np.isnan(m):
         return ('UNKNOWN', None)
-    if stock[i] <= m:
+    if low[i] <= m:                     # 장중 저가가 240선 터치/이탈 -> 이미 위험
         return ('ALREADY_DOWN', None)
     end = min(i + 1 + LOOK_AHEAD, len(stock))
     for k in range(i + 1, end):
-        if not np.isnan(ma240[k]) and stock[k] < ma240[k]:
+        if not np.isnan(ma240[k]) and low[k] <= ma240[k]:
             return ('EARLY', k - i)
     return ('STILL_UP', None)
 
@@ -661,7 +220,7 @@ def protected(stock, i, price):
 
 def load_one(ticker, market):
     try:
-        sdf = fdr.DataReader(ticker, DATA_START, _end_date())
+        sdf = fdr.DataReader(ticker, DATA_START, ANALYZE_TO)
     except Exception:
         return None
     if not isinstance(sdf, pd.DataFrame) or 'Close' not in sdf.columns or len(sdf) == 0:
@@ -670,7 +229,7 @@ def load_one(ticker, market):
     idf = None
     for c in (idx_code, '^' + idx_code):
         try:
-            t = fdr.DataReader(c, DATA_START, _end_date())
+            t = fdr.DataReader(c, DATA_START, ANALYZE_TO)
             if isinstance(t, pd.DataFrame) and 'Close' in t.columns and len(t) > 0:
                 idf = t; break
         except Exception:
@@ -684,20 +243,7 @@ def load_one(ticker, market):
     merged = merged.dropna()
     if len(merged) == 0:
         return None
-    # 240선: 정식(240일 다 있음) 우선. 부족하면 '있는 만큼 최장 평균'으로 추정.
-    ma240_full = merged['stock'].rolling(240).mean()
-    if ESTIMATE_MA240:
-        # min_periods=MA240_MIN: 데이터가 MA240_MIN일 이상이면 있는 만큼 평균으로 채움
-        ma240_est = merged['stock'].rolling(240, min_periods=MA240_MIN).mean()
-        merged['ma240'] = ma240_est
-        merged['ma240_est'] = ma240_full.isna() & ma240_est.notna()   # 추정으로 채운 구간 True
-    else:
-        merged['ma240'] = ma240_full
-        merged['ma240_est'] = False
-    merged['ma60'] = merged['stock'].rolling(60).mean()
-    merged['ma120'] = merged['stock'].rolling(120).mean()
-    merged['bbl'] = (merged['stock'].rolling(20).mean()
-                     - 2 * merged['stock'].rolling(20).std())   # BB 하단(생명선 앵커용)
+    merged['ma240'] = merged['stock'].rolling(240).mean()
     dates = [str(d)[:10] for d in merged.index]
     start_pos = next((k for k, d in enumerate(dates) if d >= ANALYZE_FROM), 0)
     return {
@@ -705,10 +251,6 @@ def load_one(ticker, market):
         'low': merged['low'].values.astype(float),
         'index': merged['index'].values.astype(float),
         'ma240': merged['ma240'].values.astype(float),
-        'ma240_est': merged['ma240_est'].values.astype(bool),
-        'ma60': merged['ma60'].values.astype(float),
-        'ma120': merged['ma120'].values.astype(float),
-        'bbl': merged['bbl'].values.astype(float),
         'dates': dates, 'start_pos': start_pos,
     }
 
@@ -719,28 +261,9 @@ def pct(a, b):
 
 def main():
     print("=" * 88)
-    print(f"이격 재확인 백테스트 [lower-low] | {ANALYZE_FROM} ~ {_end_date()} | 종목 "
+    print(f"이격 재확인 백테스트 [lower-low] | {ANALYZE_FROM} ~ {ANALYZE_TO} | 종목 "
           f"{sum(len(v) for v in TICKERS.values())}개")
-    if USE_TREND and USE_TREND_FLAT:
-        cb = FLAT_COMBINE
-        def _b(lo, hi):
-            return f"≤{hi*100:.0f}%" if lo <= -1 else f"({lo*100:.0f},{hi*100:.0f}]%"
-        tf_s = (f"추세필터=ON[돌파후{RUN_MIN_DAYS}일 AND A-4평평 "
-                f"60{_b(FLAT_MIN_60,FLAT_MAX_60)} {cb} "
-                f"120{_b(FLAT_MIN_120,FLAT_MAX_120)} {cb} "
-                f"240{_b(FLAT_MIN_240,FLAT_MAX_240)}]")
-    else:
-        tf_s = "추세필터=OFF"
-    if ENGINE == 'RS_A4':
-        rs_confirm = {'A4': 'A-4평평', 'MA60': '종가<60선', 'MA120': '종가<120선',
-                      'NONE': 'RS단독'}.get(RS_CONFIRM, RS_CONFIRM)
-        print(f"엔진=RS_A4 | RS(EMA{RS_SMOOTH})<MA{RS_MA_PERIOD}×(1-{RS_BUFFER*100:.0f}%) "
-              f"{RS_PERSIST}일연속 RS약화 -> 확인[{rs_confirm}] 즉시매도 | {tf_s}")
-    else:
-        div_s = f"이격기준={DIV_THRESHOLD*100:.0f}%(고정)"
-        jmp_s = f"하루급변({DAILY_JUMP*100:.0f}%p)점프"
-        print(f"엔진=STAGE | 고점=최근{PEAK_WINDOW}일내최고 | {div_s} | 단계누적({MIN_DEEPEN*100:.1f}%p+, "
-              f"매도까지 {CONFIRM_STAGES+1}단계) | {jmp_s} | {tf_s}")
+    print(f"규칙: 고점=최근{PEAK_WINDOW}일내최고 | 단계누적({MIN_DEEPEN*100:.1f}%p+) | 하루급변({DAILY_JUMP*100:.0f}%p)점프 | 1차~2차 22일내 | 회복시재시작")
     print(f"채점: 관찰 {LOOK_AHEAD}일 | E율=240이탈(조기경보) | P율=매도가대비 {PROTECT_DROP*100:.0f}% 추가하락 회피")
     print("=" * 88)
 
@@ -760,27 +283,29 @@ def main():
     all_jumps = []     # (tk, market, jump) 전체 급변 점프
     for (tk, market), r in cache.items():
         stock, index, ma240 = r['stock'], r['index'], r['ma240']
-        ma60 = r.get('ma60'); ma120 = r.get('ma120')
-        # 디버깅용 기울기: A-4가 쓰는 파라미터로 계산(라인 표시값=실제 판정값)
-        _sd, _sm = FLAT_SLOPE_DAYS, FLAT_SMOOTH
-        sl60 = _smoothed_slope(ma60, _sd, _sm) if ma60 is not None else None
-        sl120 = _smoothed_slope(ma120, _sd, _sm) if ma120 is not None else None
-        sl240 = _smoothed_slope(ma240, _sd, _sm) if ma240 is not None else None
-        _engine = find_rs_a4_sells if ENGINE == 'RS_A4' else find_confirmed_sells
-        sells, jumps, steps = _engine(stock, index, r['dates'], r['start_pos'],
-                                            ma60=ma60, ma240=ma240,
-                                            low=r.get('low'), bbl=r.get('bbl'),
-                                            ma240_est=r.get('ma240_est'), ma120=ma120)
+        low = r['low']
+        sells, jumps = find_confirmed_sells(stock, index, r['dates'], r['start_pos'])
         for j in jumps:
             all_jumps.append((tk, market, j))
         lines = []
         for s in sells:
             i = s['i']; price = s['price']
-            cat, days = classify_240(stock, ma240, i, price)   # 요약통계용(라인엔 안찍음)
+            cat, days = classify_240(stock, low, ma240, i, price)
+            # --- 알람 억제 필터 ---
+            if SKIP_IF_NO_240 and cat == 'UNKNOWN':
+                continue                      # 240선 없음 -> 알람 끔
+            if SKIP_IF_BELOW_240 and cat == 'ALREADY_DOWN':
+                continue                      # 매도 시점 이미 240 아래 -> 알람 끔
+            if MAX_EARLY_DAYS is not None and cat == 'EARLY' and days is not None \
+               and days > MAX_EARLY_DAYS:
+                continue                      # 130일+ 뒤에야 240이탈 = 너무 일찍 판 것 -> 끔
+            if SKIP_IF_STILL_UP and cat == 'STILL_UP':
+                continue                      # 매도 후 추세유지(240 안깨짐) = 헛매도 -> 끔
             isP = bool(protected(stock, i, price))
             is_run = in_240_run(stock, ma240, i)
             if cat == 'ALREADY_DOWN':
                 down_n += 1
+                where = '이미240아래'
             elif cat == 'EARLY':
                 b = run if is_run else edge
                 b['n'] += 1; b['E'] += 1
@@ -788,29 +313,17 @@ def main():
                 if is_run:
                     drop = stock[min(i + 1 + LOOK_AHEAD, len(stock)) - 1] / price - 1
                     run['drops'].append(drop)
+                where = f"{'240올' if is_run else '경계'}, {days}일뒤 240이탈"
             elif cat == 'STILL_UP':
                 b = run if is_run else edge
                 b['n'] += 1
                 if isP: b['P'] += 1
-            avoid = '하락회피O' if isP else '하락회피X'
-            via = s.get('via', '')
-            tr = s.get('trend', '')
-            est = '240추정' if s.get('est') else ''
-            # 기울기 디버깅: 매도 시점의 60/120/240선 기울기(스무딩) 항상 표시
-            def _slv(arr):
-                if arr is None or i >= len(arr) or np.isnan(arr[i]):
-                    return '-'
-                return f'{arr[i]*100:.1f}%'
-            slp = f'기울기[60={_slv(sl60)} 120={_slv(sl120)} 240={_slv(sl240)}]'
-            parts = [p for p in (via, tr, est, avoid, slp) if p]
+                where = f"{'240올' if is_run else '경계'}, 추세유지"
+            else:
+                where = '판정불가'
+            avoid = ', 하락회피O' if isP else ''
             lines.append(f"      매도 {s['date']} @ {price:,.0f} (이�� {s['div']*100:.0f}%) "
-                         f"[{', '.join(parts)}]")
-        # 단계 상세 로그
-        if SHOW_STEPS and steps:
-            lines.append(f"      [단계 상세]")
-            for stp in steps:
-                nt = f"  ({stp['note']})" if stp['note'] else ''
-                lines.append(f"        {stp['date']}  {stp['name']:<24} 이격 {stp['div']*100:+.1f}%{nt}")
+                         f"[{where}{avoid}]")
         detail.append((tk, market, lines))
 
     tot = run['n'] + edge['n'] + down_n
@@ -833,23 +346,22 @@ def main():
         else:
             print(f"  {tk} {market}  - 매도 없음")
 
-    # ---- 하루 급변 점프 발동 내역 (STAGE 엔진 전용. RS_A4는 단계개념 없어서 생략) ----
-    if ENGINE != 'RS_A4':
-        print("\n" + "=" * 88)
-        print(f"[하루 급변 점프 발동 내역]  (전일 이격 대비 {DAILY_JUMP*100:.0f}%p+ 급락 -> 대기단계 건너뜀)")
-        print("=" * 88)
-        if not all_jumps:
-            print("  발동 없음")
-        else:
-            n_skip = sum(1 for _, _, j in all_jumps if j['skip'])
-            print(f"  총 {len(all_jumps)}회 발동 (이 중 '대기 건너뜀(SKIP)' {n_skip}회)\n")
-            print(f"  {'종목':<8}{'시장':<7}{'날짜':<12}{'하루낙폭':>8}{'이격':>8}  단계전환")
-            print("  " + "-" * 70)
-            for tk, market, j in sorted(all_jumps, key=lambda z: z[2]['date']):
-                mark = ' ★건너뜀' if j['skip'] else ''
-                print(f"  {tk:<8}{market:<7}{j['date']:<12}"
-                      f"{j['drop']*100:>7.1f}%{j['div']*100:>7.1f}%  "
-                      f"{j['from']} -> {j['to']}{mark}")
+    # ---- 하루 급변 점프(flagON/2차flagON 대기 건너뜀) 발동 내역 ----
+    print("\n" + "=" * 88)
+    print(f"[하루 급변 점프 발동 내역]  (전일 이격 대비 {DAILY_JUMP*100:.0f}%p+ 급락 -> 대기단계 건너뜀)")
+    print("=" * 88)
+    if not all_jumps:
+        print("  발동 없음")
+    else:
+        n_skip = sum(1 for _, _, j in all_jumps if j['skip'])
+        print(f"  총 {len(all_jumps)}회 발동 (이 중 '대기 건너뜀(SKIP)' {n_skip}회)\n")
+        print(f"  {'종목':<8}{'시장':<7}{'날짜':<12}{'하루낙폭':>8}{'이격':>8}  단계전환")
+        print("  " + "-" * 70)
+        for tk, market, j in sorted(all_jumps, key=lambda z: z[2]['date']):
+            mark = ' ★건너뜀' if j['skip'] else ''
+            print(f"  {tk:<8}{market:<7}{j['date']:<12}"
+                  f"{j['drop']*100:>7.1f}%{j['div']*100:>7.1f}%  "
+                  f"{j['from']} -> {j['to']}{mark}")
 
 
 if __name__ == '__main__':