telegram_commands.py

# ==========================================================
# FILE: telegram_commands.py
# ==========================================================
# 🚨 VERIFIED: [최종 무결점 판정] 5대 헌법 및 48대 엣지 케이스 완벽 결속 교차 검증 완료.
# 🚨 MODIFIED: [제1헌법 철저 준수] 달력 API(mcal) 스캔 전 파편화된 호출망을 소각하고, GlobalThrottle.wait_api_sync()를 강제 주입하여 썬더링 허드 완벽 차단.
# 🚨 MODIFIED: [원인 추적 시스템 락온] /record 명령어 실행 시 KIS 서버 통신 장애의 정확한 원인(Endpoint 및 Timeout 등)을 텔레그램 UI로 직접 표출하도록 에러 파싱 로직 전면 팩트 교정 완료.
# 🚨 MODIFIED: [2차 오인 패러독스(False Alarm) 붕괴 차단] `/add_q` 및 `/clear_q` 수동 조작 시, 진행 중인 슬라이싱 지시서(`vrev_slice_state`, `vrev_aftermarket_state`)를 os.remove()로 물리적 삭제하던 맹독성 로직을 영구 소각. 대신 `hijacked=True`인 빈 지시서를 원자적으로 박제하여 VWAP 스케줄러의 오인 에러 타전을 100% 원천 봉쇄 완료.
# 🚨 NEW: [스레드 풀 고갈(Thread Leak) 궁극 수술] 하위 KIS 통신 지연(최대 35초) 시 상위 `wait_for`가 10~15초 만에 코루틴을 취소시켜 발생하는 '좀비 스레드 누적 및 교착(Deadlock)' 대참사를 원천 봉쇄하기 위해, 모든 비동기 I/O 래퍼의 타임아웃을 45.0초로 상향 팩트 하드 캡핑 완료.
# ==========================================================
import logging
import datetime
import math
import os
import json
import asyncio
import time
import html
import functools
import glob
import tempfile # 🚨 NEW: 원자적 쓰기용 모듈 결속
import yfinance as yf
import pandas_market_calendars as mcal
from zoneinfo import ZoneInfo
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import ContextTypes
import telegram.error

from scheduler_core import get_budget_allocation
from telegram_avwap_console import AvwapConsolePlugin
from plugin_updater import SystemUpdater
from global_throttle import GlobalThrottle # 🚨 NEW: 중앙 통제소 결속

class TelegramCommands:
    def __init__(self, config, broker, strategy, queue_ledger, sync_engine, view, tx_lock):
        self.cfg = config
        self.broker = broker
        self.strategy = strategy
        self.queue_ledger = queue_ledger
        self.sync_engine = sync_engine
        self.view = view
        self.tx_lock = tx_lock

    def _safe_float(self, val):
        try:
            f_val = float(str(val or 0.0).replace(',', ''))
            if math.isnan(f_val) or math.isinf(f_val):
                return 0.0
            return f_val
        except Exception:
            return 0.0

    # 🚨 MODIFIED: [스레드 풀 고갈 붕괴 수술] 15.0 -> 45.0 강제 하드캡
    async def _retry_api(self, func, *args, timeout=45.0, default=None, **kwargs):
        for attempt in range(3):
            try:
                if asyncio.iscoroutinefunction(func):
                    return await asyncio.wait_for(func(*args, **kwargs), timeout=timeout)
                else:
                    p_func = functools.partial(func, *args, **kwargs)
                    return await asyncio.wait_for(asyncio.to_thread(p_func), timeout=timeout)
            except Exception as e:
                if attempt == 2:
                    func_name = getattr(func, '__name__', 'unknown_func')
                    logging.debug(f"🚨 API 래퍼 최종 실패 ({func_name}): {e}")
                    return default
                await asyncio.sleep(1.0 * (2 ** attempt))
        return default

    # 🚨 MODIFIED: [스레드 풀 고갈 붕괴 수술] 15.0 -> 45.0 강제 하드캡
    async def _safe_reply(self, message_obj, text, timeout=45.0, **kwargs):
        if not message_obj: return None
        try:
            return await asyncio.wait_for(message_obj.reply_text(text, **kwargs), timeout=timeout)
        except Exception as e:
            logging.error(f"🚨 텔레그램 발송 실패: {e}")
            return None

    # 🚨 MODIFIED: [스레드 풀 고갈 붕괴 수술] 15.0 -> 45.0 강제 하드캡
    async def _safe_edit(self, message_obj, text, timeout=45.0, **kwargs):
        if not message_obj: return None
        try:
            return await asyncio.wait_for(message_obj.edit_text(text, **kwargs), timeout=timeout)
        except telegram.error.BadRequest as e:
            if "not modified" not in str(e).lower():
                logging.warning(f"⚠️ UI 갱신 예외: {e}")
        except Exception as e:
            logging.error(f"🚨 텔레그램 수정 실패: {e}")
        return None

    # 🚨 MODIFIED: [스레드 풀 고갈 붕괴 수술] 15.0 -> 45.0 강제 하드캡
    async def _safe_send(self, context, chat_id, text, timeout=45.0, **kwargs):
        if not chat_id: return None
        try:
            return await asyncio.wait_for(context.bot.send_message(chat_id=chat_id, text=text, **kwargs), timeout=timeout)
        except Exception as e:
            logging.error(f"🚨 텔레그램 전송 실패: {e}")
            return None

    def _get_dst_info(self):
        est = ZoneInfo('America/New_York')
        now_est = datetime.datetime.now(est)
        is_dst = now_est.dst() != datetime.timedelta(0)
        if is_dst: return (17, "🌞 <b>서머타임 적용 (Summer)</b>")
        else: return (18, "❄️ <b>서머타임 해제 (Winter)</b>")

    async def _get_market_status(self):
        est = ZoneInfo('America/New_York')
        now = datetime.datetime.now(est)
        
        def _fetch_schedule(target_now):
            GlobalThrottle.wait_api_sync()
            nyse = mcal.get_calendar('NYSE')
            return nyse.schedule(start_date=target_now.date(), end_date=target_now.date())

        # 🚨 MODIFIED: 10.0 -> 45.0
        schedule = await self._retry_api(_fetch_schedule, now, timeout=45.0)
        
        if schedule is None or schedule.empty:
            if now.weekday() < 5: return "REG", "🔥 정규장 (Fail-Open)"
            return "CLOSE", "⛔ 장마감"
        
        market_open = schedule.iloc[0]['market_open'].astimezone(est)
        market_close = schedule.iloc[0]['market_close'].astimezone(est)
        pre_start = market_open.replace(hour=4, minute=0)
        after_end = market_close.replace(hour=20, minute=0)

        if pre_start <= now < market_open: return "PRE", "🌅 프리마켓"
        elif market_open <= now < market_close: return "REG", "🔥 정규장"
        elif market_close <= now < after_end: return "AFTER", "🌙 애프터마켓"
        else: return "CLOSE", "⛔ 장마감"

    async def cmd_start(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        target_hour, season_icon = self._get_dst_info()
        latest_version = await self._retry_api(self.cfg.get_latest_version) or "V14.x"
        msg = self.view.get_start_message(target_hour, season_icon, latest_version) 
        await self._safe_reply(update.effective_message, msg, parse_mode='HTML')

    async def cmd_sync(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        chat_id = update.effective_chat.id
        
        is_callback = update.callback_query is not None
        status_msg = update.effective_message if is_callback else None
        
        if not is_callback:
            status_msg = await self._safe_send(context, chat_id, "🛡️ <b>장부 무결성 검증 및 동기화 중...</b>", parse_mode='HTML')
        
        async with self.tx_lock:
            cash, holdings = 0.0, {}
            # 🚨 MODIFIED: 15.0 -> 45.0
            res = await self._retry_api(self.broker.get_account_balance, timeout=45.0)
            if res and (isinstance(res, (list, tuple)) and len(res) > 1 and res[1] is not None):
                cash = self._safe_float(res[0]) if len(res) > 0 else 0.0
                holdings = res[1] if len(res) > 1 and isinstance(res[1], dict) else {}
            else:
                await self._safe_edit(status_msg, "❌ KIS API 통신 오류로 계좌 정보를 불러올 수 없습니다. (get_account_balance 통신 실패) 잠시 후 다시 시도해주세요.")
                return

        target_hour, _ = self._get_dst_info() 
        dst_txt = "🌞 서머타임 (17:30)" if target_hour == 17 else "❄️ 겨울 (18:30)"
        status_code, status_text = await self._get_market_status()
        
        tickers = await self._retry_api(self.cfg.get_active_tickers) or []
        render_tickers = list(tickers) if isinstance(tickers, list) else []
        
        alloc_res = await self._retry_api(get_budget_allocation, cash, render_tickers, self.cfg)
        if alloc_res:
            sorted_tickers = alloc_res[0] if isinstance(alloc_res, (list, tuple)) and len(alloc_res) > 0 else render_tickers
            allocated_cash = alloc_res[1] if isinstance(alloc_res, (list, tuple)) and len(alloc_res) > 1 else {}
        else:
            sorted_tickers, allocated_cash = render_tickers, {}
        
        ticker_data_list = []
        total_buy_needed = 0.0

        app_data = context.bot_data.get('app_data', {})
        if not app_data or not isinstance(app_data, dict): app_data = {}
        tracking_cache = app_data.get('sniper_tracking', {})
        if not isinstance(tracking_cache, dict): tracking_cache = {}

        est = ZoneInfo('America/New_York')
        now_est = datetime.datetime.now(est)
        
        def _check_schedule(target_now):
            GlobalThrottle.wait_api_sync()
            nyse = mcal.get_calendar('NYSE')
            return nyse.schedule(start_date=target_now.date(), end_date=target_now.date())

        schedule = await self._retry_api(_check_schedule, now_est)
        is_sniper_active_time = False
        if schedule is not None and not schedule.empty:
            market_open = schedule.iloc[0]['market_open'].astimezone(est)
            if now_est >= market_open + datetime.timedelta(minutes=30):
                is_sniper_active_time = True
        elif now_est.weekday() < 5 and now_est.time() >= datetime.time(10, 0):
            is_sniper_active_time = True

        for t in sorted_tickers:
            is_avwap_active = False
            avwap_status_txt = "OFF"
            
            h = holdings.get(t) if isinstance(holdings.get(t), dict) else {'qty':0, 'avg':0}
            
            curr = self._safe_float(await self._retry_api(self.broker.get_current_price, t, is_market_closed=(status_code == "CLOSE")))
            prev_close = self._safe_float(await self._retry_api(self.broker.get_previous_close, t))
            ma_5day = self._safe_float(await self._retry_api(self.broker.get_5day_ma, t))
            
            d_hl = await self._retry_api(self.broker.get_day_high_low, t)
            day_high, day_low = (self._safe_float(d_hl[0]), self._safe_float(d_hl[1])) if d_hl else (0.0, 0.0)
            
            actual_avg = self._safe_float(h.get('avg', 0.0))
            actual_qty = int(self._safe_float(h.get('qty', 0)))
            safe_prev_close = prev_close
            
            if status_code in ["AFTER", "CLOSE", "PRE"]:
                def get_exact_prev_close(ticker_name):
                    df = yf.Ticker(ticker_name).history(period="5d", interval="1m", prepost=True, timeout=5)
                    if not df.empty and 'Close' in df.columns:
                        tz_est = ZoneInfo('America/New_York')
                        tz_now = datetime.datetime.now(tz_est)
                        cutoff_date = tz_now.date()
                        if tz_now.time() <= datetime.time(16, 0, 30):
                            cutoff_date -= datetime.timedelta(days=1)
                        
                        if df.index.tzinfo is None:
                            df.index = df.index.tz_localize('UTC').tz_convert(tz_est)
                        else:
                            df.index = df.index.tz_convert(tz_est)
                            
                        past_df = df[df.index.date <= cutoff_date].copy()
                        if not past_df.empty:
                            past_df['Close'] = past_df['Close'].ffill().bfill()
                            regular_past = past_df.between_time('09:30', '15:59')
                            if not regular_past.empty:
                                val = float(regular_past['Close'].iloc[-1])
                            else:
                                val = float(past_df['Close'].iloc[-1])
                            return val if not math.isnan(val) else None
                    return None
        
                yf_close = None
                for attempt in range(3):
                    try:
                        # 🚨 MODIFIED: 10.0 -> 45.0
                        yf_close = await asyncio.wait_for(asyncio.to_thread(get_exact_prev_close, t), timeout=45.0)
                        break
                    except Exception:
                        if attempt == 2: pass
                        else: await asyncio.sleep(1.0 * (2 ** attempt))
                
                if yf_close and yf_close > 0: 
                    safe_prev_close = yf_close
                    prev_close = safe_prev_close

            if status_code == "CLOSE": 
                curr = safe_prev_close

            idx_ticker = "SOXX" if t == "SOXL" else "QQQ"
            dynamic_pct_obj = await self._retry_api(self.broker.get_dynamic_sniper_target, idx_ticker)
            dynamic_pct = self._safe_float(getattr(dynamic_pct_obj, 'base_amp', 0.0)) if hasattr(dynamic_pct_obj, 'base_amp') else (8.79 if t == "SOXL" else 4.95)
            if dynamic_pct == 0.0: dynamic_pct = (8.79 if t == "SOXL" else 4.95)
            
            tracking_status = tracking_cache.get(t, {}) if isinstance(tracking_cache.get(t), dict) else {}
            current_day_high = self._safe_float(tracking_status.get('day_high', day_high)) 
            hybrid_target_price = current_day_high * (1 - (abs(dynamic_pct) / 100.0))
            trigger_reason = f"-{abs(dynamic_pct)}%"
            
            is_locked_reg = await self._retry_api(self.cfg.check_lock, t, "REG", default=False)
            is_locked_sniper = await self._retry_api(self.cfg.check_lock, t, "SNIPER", default=False)
            is_already_ordered = is_locked_reg or is_locked_sniper
             
            ver = await self._retry_api(self.cfg.get_version, t) or "V14"
            is_manual_vwap = await self._retry_api(getattr(self.cfg, 'get_manual_vwap_mode', lambda x: False), t, default=False)
            
            cached_snap = None
            if ver == "V_REV":
                cached_snap = await self._retry_api(self.strategy.v_rev_plugin.load_daily_snapshot, t)
            elif ver == "V14":
                if is_manual_vwap: cached_snap = await self._retry_api(self.strategy.v14_vwap_plugin.load_daily_snapshot, t)
                elif hasattr(self.strategy, 'v14_plugin') and hasattr(self.strategy.v14_plugin, 'load_daily_snapshot'):
                    cached_snap = await self._retry_api(self.strategy.v14_plugin.load_daily_snapshot, t)
            
            if not isinstance(cached_snap, dict): cached_snap = None
            
            real_val = self._safe_float(getattr(dynamic_pct_obj, 'metric_val', 0.0))
            vol_status = "ON" if real_val >= 20.0 else "OFF"

            logic_qty = actual_qty
            is_zero_start_fact = (actual_qty == 0)
            
            if ver == "V_REV" and getattr(self, 'queue_ledger', None):
                q_data_check = await self._retry_api(self.queue_ledger.get_queue, t, default=[])
                if isinstance(q_data_check, list):
                    vrev_ledger_qty_check = sum(int(self._safe_float(item.get("qty"))) for item in q_data_check if isinstance(item, dict))
                    
                    vrev_ledger_inv = sum(int(self._safe_float(item.get("qty"))) * self._safe_float(item.get("price")) for item in q_data_check if isinstance(item, dict))
                    
                    actual_qty = vrev_ledger_qty_check
                    logic_qty = vrev_ledger_qty_check
                    actual_avg = round(vrev_ledger_inv / vrev_ledger_qty_check, 4) if vrev_ledger_qty_check > 0 else 0.0
                    
                    if vrev_ledger_qty_check > 0: is_zero_start_fact = False
                    else: is_zero_start_fact = True

            if cached_snap:
                if not is_zero_start_fact: pass 
                else: is_zero_start_fact = bool(cached_snap.get("is_zero_start", True))

            jobs = context.job_queue.jobs() if context.job_queue else []
            job_data = jobs[0].data if jobs and len(jobs) > 0 and jobs[0].data is not None else {}
            regime_data = job_data.get('regime_data') if isinstance(job_data, dict) else None

            plan = await self._retry_api(
                self.strategy.get_plan, t, curr, actual_avg, logic_qty, safe_prev_close, ma_5day=ma_5day,
                market_type="REG", available_cash=allocated_cash.get(t, 0.0),
                is_simulation=True, regime_data=regime_data, is_snapshot_mode=False
            ) or {}
               
            split = await self._retry_api(self.cfg.get_split_count, t, default=40.0)
            safe_seed = await self._retry_api(self.cfg.get_seed, t, default=0.0)
            
            t_val = self._safe_float(plan.get('t_val', 0.0))
            is_rev = plan.get('is_reverse', False)
            
            v_rev_q_qty, v_rev_q_lots = 0, 0

            if ver == "V_REV":
                q_list = await self._retry_api(self.queue_ledger.get_queue, t, default=[]) if getattr(self, 'queue_ledger', None) else []
                q_list = q_list if isinstance(q_list, list) else []
                v_rev_q_lots = len(q_list)
                v_rev_q_qty = sum(int(self._safe_float(item.get('qty', 0))) for item in q_list if isinstance(item, dict))
                one_portion_cash = safe_seed * 0.15
                plan['one_portion'] = one_portion_cash

            is_avwap_hybrid_on = await self._retry_api(getattr(self.cfg, 'get_avwap_hybrid_mode', lambda x: False), t, default=False)

            if is_avwap_hybrid_on:
                is_avwap_active = True
                avwap_status_txt = "👀 관측 중"
                avwap_base_ticker = 'SOXX' if t == 'SOXL' else ('QQQ' if t == 'TQQQ' else t)
                avwap_ctx = await self._retry_api(self.strategy.v_avwap_plugin.fetch_macro_context, avwap_base_ticker)
      
                if status_code in ["PRE", "REG"]:
                    df_1min_base = await self._retry_api(self.broker.get_1min_candles_df, avwap_base_ticker)
                    base_curr_p = self._safe_float(await self._retry_api(self.broker.get_current_price, avwap_base_ticker))
                   
                    if hasattr(self.strategy, 'v_avwap_plugin'):
                        decision = await self._retry_api(
                            self.strategy.v_avwap_plugin.get_decision,
                            base_ticker=avwap_base_ticker, exec_ticker=t,
                            base_curr_p=base_curr_p, exec_curr_p=curr,
                            df_1min_base=df_1min_base, avwap_qty=0, avwap_alloc_cash=0.0, 
                            now_est=now_est, avwap_state={"strikes": 0, "cooldown_active": False},
                            context_data=avwap_ctx, is_simulation=True,
                            amp5=self._safe_float(getattr(dynamic_pct_obj, 'base_amp', 0.0)) if hasattr(dynamic_pct_obj, 'base_amp') else 0.0,
                            prev_close=safe_prev_close, ma_5day=ma_5day, sortie_mode="SINGLE"
                        ) or {}
                    
                        if decision:
                            avwap_status_txt = f"👁️ 관측 중: {decision.get('reason', '타점 계산중')}"

            upward_sniper_mode_on = await self._retry_api(self.cfg.get_upward_sniper_mode, t, default=False)
            target_val = await self._retry_api(self.cfg.get_target_profit, t, default=10.0)
            
            ticker_data_list.append({
                'ticker': t, 'version': ver, 't_val': t_val, 'split': split, 'curr': curr, 'avg': actual_avg, 'qty': actual_qty,
                'profit_amt': (curr - actual_avg) * actual_qty if actual_qty > 0 else 0, 
                'profit_pct': (curr - actual_avg) / actual_avg * 100 if actual_avg > 0 else 0,
                'upward_sniper': "ON" if upward_sniper_mode_on else "OFF",
                'target': target_val, 'star_pct': round(self._safe_float(plan.get('star_ratio', 0.0)) * 100, 2),
                'seed': safe_seed, 'one_portion': self._safe_float(plan.get('one_portion', 0.0)), 'plan': plan,
                'is_locked': is_already_ordered, 'mode': "REG",
                'is_reverse': is_rev, 'star_price': self._safe_float(plan.get('star_price', 0.0)),
                'hybrid_target': hybrid_target_price,
                'trigger_reason': trigger_reason,
                'sniper_trigger': abs(self._safe_float(dynamic_pct)), 
                'day_high': day_high, 'day_low': day_low,
                'prev_close': safe_prev_close,
                'tracking_info': tracking_status,
                'dynamic_obj': dynamic_pct_obj,
                'is_sniper_active_time': is_sniper_active_time,
                'vol_weight': round(real_val, 2), 
                'vol_status': vol_status,
                'v_rev_q_lots': v_rev_q_lots,
                'v_rev_q_qty': v_rev_q_qty,
                'is_manual_vwap': is_manual_vwap,
                'is_zero_start': is_zero_start_fact,
                'has_snapshot': bool(cached_snap)
            })
            
            plan_orders_raw = plan.get('orders', []) if isinstance(plan.get('orders'), list) else []
            total_buy_needed += sum(
                self._safe_float(o.get('price')) * self._safe_float(o.get('qty'))
                for o in plan_orders_raw if isinstance(o, dict) and o.get('side') == 'BUY'
            )

        surplus = cash - total_buy_needed
        rp_amount = surplus * 0.95 if surplus > 0 else 0
        
        def get_exchange_rate():
            df = yf.Ticker("KRW=X").history(period="1d", timeout=5.0)
            if not df.empty and 'Close' in df.columns and len(df['Close']) > 0:
                val = self._safe_float(df['Close'].iloc[-1])
                return val if val > 0 else 0.0
            return 0.0
            
        exchange_rate = self._safe_float(await self._retry_api(get_exchange_rate, default=0.0))

        final_msg, markup = self.view.create_sync_report(
            status_text, dst_txt, cash, rp_amount, ticker_data_list, 
            status_code in ["PRE", "REG"], p_trade_data={}, exchange_rate=exchange_rate
        )

        await self._safe_edit(status_msg, final_msg, reply_markup=markup, parse_mode='HTML')

    async def cmd_record(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        chat_id = update.effective_chat.id
        
        is_callback = update.callback_query is not None
        status_msg = update.effective_message if is_callback else None
        
        if not is_callback:
            status_msg = await self._safe_send(context, chat_id, "🛡️ <b>장부 무결성 검증 및 동기화 중...</b>", parse_mode='HTML')
        
        success_tickers = []
        locked_tickers = []
        error_tickers = []
        
        active_tickers = await self._retry_api(self.cfg.get_active_tickers, default=[])
        if not isinstance(active_tickers, list): active_tickers = []
        
        for t in active_tickers:
            try:
                if status_msg:
                    await self._safe_edit(status_msg, f"🛡️ <b>[{t}] 장부 무결성 검증 진행 중... (최대 1~2분 소요될 수 있습니다)</b>", parse_mode='HTML')
                
                res = await self.sync_engine.process_auto_sync(t, chat_id, context, silent_ledger=True)
                if res == "SUCCESS": success_tickers.append(t)
                elif res == "LOCKED": locked_tickers.append(t)
                else: error_tickers.append(f"{t} ({res})")
            except Exception as e:
                logging.error(f"🚨 [{t}] 개별 종목 장부 동기화 중 에러 (격리): {e}")
                error_tickers.append(f"{t} (런타임 예외: {str(e)})")
        
        if success_tickers: 
            async with self.tx_lock:
                # 🚨 MODIFIED: 15.0 -> 45.0
                res = await self._retry_api(self.broker.get_account_balance, timeout=45.0)
                holdings = res[1] if res and len(res) > 1 and isinstance(res[1], dict) else {}
            
            for idx, t in enumerate(success_tickers):
                try:
                    if idx == 0:
                        await self.sync_engine._display_ledger(t, chat_id, context, message_obj=status_msg, pre_fetched_holdings=holdings)
                    else:
                        await self.sync_engine._display_ledger(t, chat_id, context, message_obj=None, pre_fetched_holdings=holdings)
                except Exception as e:
                    logging.error(f"🚨 [{t}] 렌더링 실패: {e}")
                    await self._safe_send(context, chat_id, f"❌ <b>[{t}] 렌더링 중 오류 발생:</b> {html.escape(str(e))}", parse_mode='HTML')
                    
            if locked_tickers:
                await self._safe_send(context, chat_id, f"⚠️ <b>[동기화 지연]</b> {', '.join(locked_tickers)} 종목은 현재 백그라운드 스케줄러가 장부를 점유 중입니다. 잠시 후 다시 시도해주세요.", parse_mode='HTML')
            
            if error_tickers:
                err_details = '\n'.join([f"▫️ {err}" for err in error_tickers])
                await self._safe_send(context, chat_id, f"❌ <b>[동기화 에러 상세 진단]</b>\n{err_details}\n\n💡 KIS 서버 일시 장애이거나 토큰 문제일 수 있습니다. 상세 통신 로그는 <code>/log</code> 명령어로 확인하세요.", parse_mode='HTML')
                
        else:
            err_msg = "✅ <b>동기화 완료</b> (진행 중인 장부가 없습니다.)"
            if locked_tickers:
                err_msg = f"⚠️ <b>[동기화 지연]</b> {', '.join(locked_tickers)} 종목은 백그라운드 작업이 장부를 점유 중입니다. 잠시 후 다시 시도해주세요."
            elif error_tickers:
                err_details = '\n'.join([f"▫️ {err}" for err in error_tickers])
                err_msg = f"❌ <b>[동기화 에러 상세 진단]</b>\n{err_details}\n\n💡 KIS 서버 일시 장애이거나 토큰 문제일 수 있습니다. 상세 통신 로그는 <code>/log</code> 명령어로 확인하세요."
                 
            await self._safe_edit(status_msg, err_msg, parse_mode='HTML')

    async def cmd_history(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        is_callback = update.callback_query is not None
        history_data = await self._retry_api(self.cfg.get_history, default=[])
        if not isinstance(history_data, list): history_data = []
        
        if not history_data:
            if is_callback:
                await self._safe_edit(update.effective_message, "📭 <b>명예의 전당 (졸업 기록)이 비어있습니다.</b>", parse_mode='HTML')
            else:
                await self._safe_reply(update.effective_message, "📭 <b>명예의 전당 (졸업 기록)이 비어있습니다.</b>", parse_mode='HTML')
            return
            
        sorted_hist = sorted(history_data, key=lambda x: str(x.get('end_date') or '') if isinstance(x, dict) else '', reverse=True)
        msg = "🏆 <b>[ 명예의 전당 (과거 졸업 기록) ]</b>\n\n상세 내역을 조회할 기록을 선택하세요.\n"
        keyboard = []
        for h in sorted_hist[:15]: 
            if not isinstance(h, dict): continue
            t = h.get('ticker', 'UNK')
            p = self._safe_float(h.get('profit'))
            date_str = str(h.get('end_date') or '')[:10].replace("-", ".")
            sign = "+" if p >= 0 else "-"
            btn_text = f"🏅 {date_str} [{html.escape(str(t))}] {sign}${abs(p):.2f}"
            keyboard.append([InlineKeyboardButton(btn_text, callback_data=f"HIST:VIEW:{h.get('id', 0)}")])
            
        keyboard.append([InlineKeyboardButton("❌ 닫기", callback_data="RESET:CANCEL")])
        
        if is_callback:
            await self._safe_edit(update.effective_message, msg, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode='HTML')
        else:
            await self._safe_reply(update.effective_message, msg, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode='HTML')

    async def cmd_settlement(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        active_tickers = await self._retry_api(self.cfg.get_active_tickers, default=[])
        if not isinstance(active_tickers, list): active_tickers = []
        
        is_callback = update.callback_query is not None
        status_msg = update.effective_message if is_callback else None
        
        if not is_callback:
            status_msg = await self._safe_reply(update.effective_message, "⏳ <b>실시간 시장 지표 연산 중...</b>", parse_mode='HTML')
            
        app_data = context.bot_data.get('app_data', {}) if isinstance(context.bot_data.get('app_data'), dict) else {}
        tracking_cache = app_data.get('sniper_tracking', {}) if isinstance(app_data.get('sniper_tracking'), dict) else {}
        atr_data = {t: (0.0, 0.0) for t in active_tickers}
        
        # 🚨 MODIFIED: 15.0 -> 45.0
        msg, markup = await self._retry_api(self.view.get_settlement_message, active_tickers, self.cfg, atr_data, tracking_cache, timeout=45.0)
        if not msg: msg, markup = "❌ 설정 화면을 불러오는 도중 에러가 발생했습니다.", None
        
        await self._safe_edit(status_msg, msg, reply_markup=markup, parse_mode='HTML')

    async def cmd_seed(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        msg = "💵 <b>[ 종목별 시드머니 관리 ]</b>\n\n"
        keyboard = []
        active_tickers = await self._retry_api(self.cfg.get_active_tickers, default=[])
        if not isinstance(active_tickers, list): active_tickers = []
        for t in active_tickers:
            current_seed = self._safe_float(await self._retry_api(self.cfg.get_seed, t))
            msg += f"💎 <b>{html.escape(str(t))}</b>: ${current_seed:,.0f}\n"
            keyboard.append([
                InlineKeyboardButton(f"➕ {html.escape(str(t))} 추가", callback_data=f"SEED:ADD:{html.escape(str(t))}"), 
                InlineKeyboardButton(f"➖ {html.escape(str(t))} 감소", callback_data=f"SEED:SUB:{html.escape(str(t))}"),
                InlineKeyboardButton(f"🔢 {html.escape(str(t))} 고정", callback_data=f"SEED:SET:{html.escape(str(t))}")
            ])
            
        is_callback = update.callback_query is not None
        if is_callback:
            await self._safe_edit(update.effective_message, msg, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode='HTML')
        else:
            await self._safe_reply(update.effective_message, msg, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode='HTML')

    async def cmd_ticker(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        active_tickers = await self._retry_api(self.cfg.get_active_tickers, default=[])
        if not isinstance(active_tickers, list): active_tickers = []
        msg, markup = self.view.get_ticker_menu(active_tickers)
        
        is_callback = update.callback_query is not None
        if is_callback:
            await self._safe_edit(update.effective_message, msg, reply_markup=markup, parse_mode='HTML')
        else:
            await self._safe_reply(update.effective_message, msg, reply_markup=markup, parse_mode='HTML')

    async def cmd_mode(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        active_tickers = await self._retry_api(self.cfg.get_active_tickers, default=[])
        if not isinstance(active_tickers, list): active_tickers = []
        
        report = "📊 <b>[ 자율주행 변동성 마스터 지표 상세 분석 ]</b>\n\n"
        report += "<b>[ 🧭 지수 범위 범례 (ON/OFF 권장) ]</b>\n"
        report += "🧊 <code>~ 15.00</code> : 극저변동성 (OFF)\n"
        report += "🟩 <code>15.00 ~ 20.00</code> : 정상 궤도 (OFF)\n"
        report += "🟨 <code>20.00 ~ 25.00</code> : 변동성 확대 (ON)\n"
        report += "🟥 <code>25.00 이상 </code> : 패닉 셀링 (ON)\n\n"
        
        for t in active_tickers:
            idx_ticker = "SOXX" if t == "SOXL" else "QQQ"
            dynamic_pct_obj = await self._retry_api(self.broker.get_dynamic_sniper_target, idx_ticker)
            
            real_val = self._safe_float(getattr(dynamic_pct_obj, 'metric_val', 0.0))
            real_name = html.escape(str(getattr(dynamic_pct_obj, 'metric_name', '지표')))
            
            if real_val <= 15.0: diag_text = "극저변동성 (우측 꼬리 절단 방지를 위해 스나이퍼 OFF)"; status_icon = "🧊"
            elif real_val <= 20.0: diag_text = "정상 궤도 안착 (스나이퍼 OFF)"; status_icon = "🟩"
            elif real_val <= 25.0: diag_text = "변동성 확대 장세 (계좌 방어를 위해 스나이퍼 ON)"; status_icon = "🟨"
            else: diag_text = "패닉 셀링 및 시스템 충격 (스나이퍼 필수 가동)"; status_icon = "🟥"
            report += f"💠 <b>[ {html.escape(str(t))} 국면 분석 ]</b>\n▫️ 당일 절대 지수({real_name}): {real_val:.2f}\n▫️ 진단 : {status_icon} {diag_text}\n\n"
                 
        report += "🎯 <b>[ 수동 상방 스나이퍼 독립 제어 ]</b>\n"
        keyboard = []
        for t in active_tickers:
            is_sniper = await self._retry_api(self.cfg.get_upward_sniper_mode, t, default=False)
            status_txt = 'ON (가동중)' if is_sniper else 'OFF (대기중)'
            report += f"▫️ {html.escape(str(t))} 현재 상태 : {status_txt}\n"
            keyboard.append([InlineKeyboardButton(f"{html.escape(str(t))} ⚪ OFF", callback_data=f"MODE:OFF:{html.escape(str(t))}"), InlineKeyboardButton(f"{html.escape(str(t))} 🎯 ON", callback_data=f"MODE:ON:{html.escape(str(t))}")])
        
        is_callback = update.callback_query is not None
        if is_callback:
            await self._safe_edit(update.effective_message, report, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode='HTML')
        else:
            await self._safe_reply(update.effective_message, report, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode='HTML')

    async def cmd_version(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        history_data = await self._retry_api(self.cfg.get_full_version_history, default=[])
        msg, markup = self.view.get_version_message(history_data, page_index=None)
         
        is_callback = update.callback_query is not None
        if is_callback:
            await self._safe_edit(update.effective_message, msg, parse_mode='HTML', reply_markup=markup)
        else:
            await self._safe_reply(update.effective_message, msg, parse_mode='HTML', reply_markup=markup)

    async def cmd_queue(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        args = context.args
        if not args: 
            await self._safe_reply(update.effective_message, "❌ 종목명을 입력하세요. 예: /queue SOXL")
            return
            
        ticker = args[0].upper()
        if not getattr(self, 'queue_ledger', None):
            from queue_ledger import QueueLedger
            self.queue_ledger = await asyncio.to_thread(QueueLedger)
            
        q_data = await self._retry_api(self.queue_ledger.get_queue, ticker, default=[])
        msg, reply_markup = self.view.get_queue_management_menu(ticker, q_data if isinstance(q_data, list) else [])
        
        await self._safe_reply(update.effective_message, msg, reply_markup=reply_markup, parse_mode='HTML')

    async def cmd_add_q(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        args = context.args
        if not args or len(args) < 4:
            await self._safe_reply(update.effective_message, "❌ 정확한 양식: <code>/add_q SOXL 2026-04-06 20 52.16</code>", parse_mode='HTML')
            return
            
        ticker = args[0].upper()
        date_str = args[1]
        qty = int(self._safe_float(args[2]))
        price = self._safe_float(args[3])
        
        if qty <= 0 or price <= 0.0:
            await self._safe_reply(update.effective_message, "❌ 수량과 평단가는 0보다 큰 숫자여야 합니다. (혹은 형식 오류)", parse_mode='HTML')
            return
            
        curr_p_val = await self._retry_api(self.broker.get_current_price, ticker)
        curr_p = self._safe_float(curr_p_val)
                
        if curr_p > 0:
            if price < curr_p * 0.4 or price > curr_p * 1.6:
                await self._safe_reply(update.effective_message, f"🚨 <b>오입력 차단:</b> 입력하신 평단가(<b>${price:.2f}</b>)가 현재가 대비 ±60%를 벗어납니다. 오타를 확인하세요!", parse_mode='HTML')
                return
            
        if not getattr(self, 'queue_ledger', None):
            from queue_ledger import QueueLedger
            self.queue_ledger = await asyncio.to_thread(QueueLedger)
            
        q_data = await self._retry_api(self.queue_ledger.get_queue, ticker, default=[])
        if not isinstance(q_data, list): q_data = [] 
       
        q_data.append({"qty": qty, "price": price, "date": f"{date_str} 23:59:59", "type": "MANUAL_OVERRIDE"})
        q_data.sort(key=lambda x: str(x.get('date', '')) if isinstance(x, dict) else '', reverse=True)
 
        await self._retry_api(self.queue_ledger.overwrite_queue, ticker, q_data)
        
        # 🚨 MODIFIED: [이중 타격 방어] 큐 수동 추가 시에도 로컬 슬라이싱 및 애프터장 지시서 원자적 영구 소각
        def _nuke_snapshot_and_state():
            for f in glob.glob(f"data/daily_snapshot_*_{ticker}.json"):
                with GlobalThrottle.get_file_lock(f):
                    try: os.remove(f)
                    except OSError: pass
            for f in glob.glob(f"data/vwap_state_*_{ticker}.json"):
                with GlobalThrottle.get_file_lock(f):
                    try: os.remove(f)
                    except OSError: pass
            
            # 🚨 MODIFIED: 2차 오인 패러독스 차단 (물리적 삭제 대신 빈 지시서 박제)
            est_now = datetime.datetime.now(ZoneInfo('America/New_York'))
            today_str = est_now.strftime('%Y-%m-%d')
            empty_state = {"date": today_str, "hijacked": True, "orders": []}
            
            for f_path in [f"data/vrev_slice_state_{ticker}.json", f"data/vrev_aftermarket_state_{ticker}.json"]:
                with GlobalThrottle.get_file_lock(f_path):
                    dir_name = os.path.dirname(f_path) or '.'
                    try: os.makedirs(dir_name, exist_ok=True)
                    except OSError: pass
                    try:
                        fd, tmp_path = tempfile.mkstemp(dir=dir_name, text=True)
                        with os.fdopen(fd, 'w', encoding='utf-8') as f_out:
                            json.dump(empty_state, f_out, ensure_ascii=False, indent=4)
                            f_out.flush()
                            os.fsync(f_out.fileno())
                        os.replace(tmp_path, f_path)
                    except Exception: pass
                    
        await asyncio.to_thread(_nuke_snapshot_and_state)
        
        chat_id = update.effective_chat.id
        if ticker not in self.sync_engine.sync_locks: self.sync_engine.sync_locks[ticker] = asyncio.Lock()
        if not self.sync_engine.sync_locks[ticker].locked(): await self.sync_engine.process_auto_sync(ticker, chat_id, context, silent_ledger=False)
        
        date_str_safe = html.escape(str(date_str))
        ticker_safe = html.escape(str(ticker))
        await self._safe_reply(update.effective_message, f"✅ <b>[{ticker_safe}] 수동 지층 삽입 완료 및 오염 기억 자동 삭제!</b>\n▫️ {date_str_safe} | {qty}주 | ${price:.2f}", parse_mode='HTML')

    async def cmd_clear_q(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        args = context.args
        if not args: 
            await self._safe_reply(update.effective_message, "❌ 종목명을 입력하세요. 예: /clear_q SOXL")
            return
            
        ticker = args[0].upper()
        ticker_safe = html.escape(str(ticker))

        if not getattr(self, 'queue_ledger', None):
            from queue_ledger import QueueLedger
            self.queue_ledger = await asyncio.to_thread(QueueLedger)
            
        await self._retry_api(self.queue_ledger.clear_queue, ticker)
        
        # 🚨 MODIFIED: [이중 타격 방어] 큐 전체 삭제 시 로컬 슬라이싱 및 애프터장 지시서 원자적 영구 소각
        def _nuke_snapshot_and_state():
            for f in glob.glob(f"data/daily_snapshot_*_{ticker}.json"):
                with GlobalThrottle.get_file_lock(f):
                    try: os.remove(f)
                    except OSError: pass
            for f in glob.glob(f"data/vwap_state_*_{ticker}.json"):
                with GlobalThrottle.get_file_lock(f):
                    try: os.remove(f)
                    except OSError: pass
                    
            # 🚨 MODIFIED: 2차 오인 패러독스 차단 (물리적 삭제 대신 빈 지시서 박제)
            est_now = datetime.datetime.now(ZoneInfo('America/New_York'))
            today_str = est_now.strftime('%Y-%m-%d')
            empty_state = {"date": today_str, "hijacked": True, "orders": []}
            
            for f_path in [f"data/vrev_slice_state_{ticker}.json", f"data/vrev_aftermarket_state_{ticker}.json"]:
                with GlobalThrottle.get_file_lock(f_path):
                    dir_name = os.path.dirname(f_path) or '.'
                    try: os.makedirs(dir_name, exist_ok=True)
                    except OSError: pass
                    try:
                        fd, tmp_path = tempfile.mkstemp(dir=dir_name, text=True)
                        with os.fdopen(fd, 'w', encoding='utf-8') as f_out:
                            json.dump(empty_state, f_out, ensure_ascii=False, indent=4)
                            f_out.flush()
                            os.fsync(f_out.fileno())
                        os.replace(tmp_path, f_path)
                    except Exception: pass
                    
        await asyncio.to_thread(_nuke_snapshot_and_state)
        
        chat_id = update.effective_chat.id
        if ticker not in self.sync_engine.sync_locks: self.sync_engine.sync_locks[ticker] = asyncio.Lock()
        if not self.sync_engine.sync_locks[ticker].locked(): await self.sync_engine.process_auto_sync(ticker, chat_id, context, silent_ledger=True)
        await self._safe_reply(update.effective_message, f"🗑️ <b>[{ticker_safe}] 장부가 완전히 소각되고 당일 오염 기억이 파기되었습니다.</b>\n새로운 지층을 구축할 준비가 완료되었습니다.", parse_mode='HTML')

    async def cmd_update(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        updater = SystemUpdater()
        allowed, fail_msg = await updater.is_update_allowed()
        if not allowed:
            await self._safe_reply(update.effective_message, f"🛑 <b>[작전 중 업데이트 거부]</b>\n\n{fail_msg}", parse_mode='HTML')
            return
            
        is_callback = update.callback_query is not None
        status_msg = update.effective_message if is_callback else None
        
        if not is_callback:
             status_msg = await self._safe_reply(update.effective_message, "⏳ <b>[시스템 업데이트]</b> 깃허브 원격 서버와 통신을 시작합니다...", parse_mode='HTML')
        
        success, msg = await updater.pull_latest_code()
        safe_msg = html.escape(str(msg)) 
        if success:
            await self._safe_edit(status_msg, f"✅ <b>[동기화 완료]</b> {safe_msg}\n\n🔄 시스템 데몬(pipiosbot)을 OS 단에서 재가동합니다. 다운타임 후 봇이 다시 깨어납니다.", parse_mode='HTML')
            await updater.restart_daemon()
        else:
            await self._safe_edit(status_msg, f"❌ <b>[동기화 실패]</b>\n▫️ 사유: {safe_msg}", parse_mode='HTML')

    async def cmd_avwap(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        is_callback = update.callback_query is not None
        status_msg = update.effective_message if is_callback else None
        
        if not is_callback:
            status_msg = await self._safe_reply(update.effective_message, "⏳ <b>[AVWAP 듀얼 모멘텀 관제탑]</b>\n레이더망을 가동하여 시장 데이터를 스캔 중...", parse_mode='HTML')
        
        plugin = AvwapConsolePlugin(self.cfg, self.broker, self.strategy, self.tx_lock)
        app_data = context.bot_data.get('app_data', {})
        if not app_data or not isinstance(app_data, dict):
            try:
                jobs = context.job_queue.jobs() if context.job_queue else []
                if jobs and len(jobs) > 0 and jobs[0].data is not None: app_data = jobs[0].data
            except Exception: app_data = {}
        if not isinstance(app_data, dict): app_data = {}

        # 🚨 MODIFIED: 15.0 -> 45.0
        msg, markup = await self._retry_api(plugin.get_console_message, app_data, timeout=45.0)
        
        if msg:
            await self._safe_edit(status_msg, msg, reply_markup=markup, parse_mode='HTML')
        else:
            await self._safe_edit(status_msg, "❌ <b>[네트워크 지연 발생]</b>\n야후 파이낸스 또는 증권사 서버 응답이 지연되어 스캔을 강제 종료했습니다.", parse_mode='HTML')

    async def cmd_log(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        is_callback = update.callback_query is not None
        status_msg = update.effective_message if is_callback else None
        
        if not is_callback:
            status_msg = await self._safe_reply(update.effective_message, "🔍 <b>[원격 진단]</b> 최근 시스템 에러 로그를 핀셋 추출 중...", parse_mode='HTML')
        
        log_path = "logs/bot_app.log" 
        def _grep_tail_logs(path, limit=50):
            try:
                with open(path, 'r', encoding='utf-8') as f:
                    lines = f.readlines()
                tail_lines = lines[-limit:]
                return [line.strip() for line in reversed(tail_lines)]
            except FileNotFoundError: return None
            
        error_logs = await self._retry_api(_grep_tail_logs, log_path, timeout=10.0)
        
        if error_logs is None:
            await self._safe_edit(status_msg, "📭 <b>[진단 결과]</b> 오늘자 로그 파일이 생성되지 않았습니다.", parse_mode='HTML')
            return
    
        if not error_logs:
            await self._safe_edit(status_msg, "✅ <b>[진단 결과]</b> 최근 감지된 시스템 결함이 없습니다. 무결점 순항 중!", parse_mode='HTML')
            return
            
        report = self.view.format_log_report(error_logs)
        await self._safe_edit(status_msg, report, parse_mode='HTML')

    async def cmd_reset(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        active_tickers = await self._retry_api(self.cfg.get_active_tickers, default=[])
        if not isinstance(active_tickers, list): active_tickers = []
        msg, markup = self.view.get_reset_menu(active_tickers)
        
        is_callback = update.callback_query is not None
        if is_callback:
            await self._safe_edit(update.effective_message, msg, reply_markup=markup, parse_mode='HTML')
        else:
            await self._safe_reply(update.effective_message, msg, reply_markup=markup, parse_mode='HTML')