Merge pull request #410 from easygap/fix/basket-paper-account-attribution

fix: 바스켓 paper 계정·귀속 격리 — 적대적 자기검토 발견 결함 5건 해소

Author: easygap

core/basket_evaluation.py

@@ -149,37 +149,47 @@ def collect_basket_paper_evaluation(
     config=None,
     min_days: int = 60,
     include_benchmark: bool = True,
+    basket_name: str | None = None,
 ) -> tuple[dict[str, Any], str]:
-    """DB·설정에서 바스켓 paper 운영 데이터를 수집해 (평가결과, 바스켓 라벨) 반환.
+    """DB·설정에서 **특정 바스켓**의 paper 운영 데이터를 수집해 (평가결과, 바스켓 이름) 반환.
 
     CLI(tools/basket_paper_evaluation.py)와 바스켓 live gate가 공유하는 단일 수집 경로.
-    include_benchmark=False면 KS11 조회(네트워크)를 생략한다 — 게이트 경로에서는
-    참고 지표 때문에 판정을 지연/실패시키지 않기 위함.
+    거래·스냅샷·dead-letter 모두 바스켓 전용 키(basket_rebalance:<name>)로 필터한다 —
+    바스켓별 귀속 없이 합산하면 A 바스켓의 트랙레코드로 B 바스켓이 승격되는 구멍이 생긴다.
+    basket_name 미지정 시 enabled 바스켓이 정확히 1개면 그것을 쓰고, 0개·복수면
+    ValueError(어느 기록을 평가하는지 모호 — fail-closed).
+    include_benchmark=False면 KS11 조회(네트워크)를 생략한다(게이트 경로용).
     """
     from datetime import date, datetime, timedelta
 
     from config.config_loader import Config
-    from core.basket_rebalancer import BasketRebalancer
+    from core.basket_rebalancer import BasketRebalancer, rebalance_live_strategy_id
     from core.trading_hours import TradingHours
     from database.models import get_session, PortfolioSnapshot, TradeHistory, init_database
     from database.repositories import get_pending_failed_orders
 
     init_database()
     config = config or Config.get()
-    enabled = BasketRebalancer.get_enabled_baskets()
-    basket_label = ",".join(enabled) if enabled else "(enabled 바스켓 없음)"
+    if not basket_name:
+        enabled = BasketRebalancer.get_enabled_baskets()
+        if len(enabled) != 1:
+            raise ValueError(
+                f"평가 대상 바스켓이 모호합니다 (enabled={enabled}) — basket_name을 명시하세요."
+            )
+        basket_name = enabled[0]
+    basket_key = rebalance_live_strategy_id(basket_name)
 
     session = get_session()
     try:
         trades = (
             session.query(TradeHistory)
-            .filter(TradeHistory.strategy.like("basket_rebalance%"))
+            .filter(TradeHistory.strategy == basket_key)
             .filter(TradeHistory.mode == "paper")
             .all()
         )
         snaps = (
             session.query(PortfolioSnapshot)
-            .filter(PortfolioSnapshot.account_key == "")
+            .filter(PortfolioSnapshot.account_key == basket_key)
             .order_by(PortfolioSnapshot.date.asc())
             .all()
         )
@@ -201,6 +211,10 @@ def _d(v):
     d = operation_start
     while d <= today:
         if th.is_trading_day(datetime(d.year, d.month, d.day)):
+            # 오늘은 스냅샷이 이미 찍힌 경우에만 분모에 포함한다 — 장전(스냅샷 저장 전)
+            # 게이트 실행에서 분모만 +1 되어 커버리지가 경계에서 오판되는 것을 방지.
+            if d == today and d not in snapshot_dates:
+                break
             trading_days_total += 1
             if d in snapshot_dates:
                 snapshot_days += 1
@@ -234,11 +248,13 @@ def _d(v):
         today=today,
         trading_days_total=trading_days_total,
         snapshot_days=snapshot_days,
-        pending_failed_orders=len(get_pending_failed_orders() or []),
+        # dead-letter도 이 바스켓 계정 것만 집계 — 다른 전략의 잔여 실패 주문이
+        # 바스켓 승격을 막는 오판 방지(바스켓 자신의 실패는 여전히 fail-closed).
+        pending_failed_orders=len(get_pending_failed_orders(account_key=basket_key) or []),
         total_costs=total_costs,
         initial_capital=initial_capital,
         nav_return_pct=nav_return_pct,
         benchmark_return_pct=benchmark_return_pct,
         min_trading_days=min_days,
     )
-    return result, basket_label
+    return result, basket_name

core/basket_rebalancer.py

@@ -35,24 +35,20 @@ def check_basket_account_isolation(basket_names, config, mode: str) -> list[str]
     """여러 enabled 바스켓이 같은 계좌(자본 풀)를 공유하는지 검사한다. fail-closed.
 
     각 BasketRebalancer는 자기 목표 비중을 '총자산 × stock_fraction'에 독립적으로
-    배분한다. 두 바스켓이 같은 자본을 공유하면 예컨대 80% + 80% = 160%를 배분하려
-    들어 과배분·상호 간섭이 생기고, paper에서는 동일 default 계정의 NAV 시계열이
-    섞여 60영업일 트랙레코드가 오염된다. 바스켓을 여러 개 운영하려면 계좌를
-    분리해야 한다(live: kis_api.accounts에 basket_rebalance:<name>별 계좌 지정).
+    배분한다. 두 바스켓이 같은 자본(계좌)을 공유하면 예컨대 80% + 80% = 160%를
+    배분하려 들어 과배분·상호 간섭이 생긴다.
+
+    paper: 바스켓별 가상 계정 키(basket_rebalance:<name>)로 DB가 격리되고 각자
+    initial_capital 기준으로 독립 집계되므로 자연 격리 — 통과.
+    live: 같은 KIS 실계좌(잔고)를 공유하면 차단. 다중 바스켓 live 운영은
+    kis_api.accounts에 basket_rebalance:<name>별 계좌를 분리 지정해야 한다.
 
     반환: 이슈 문자열 리스트 (빈 리스트 = 통과).
     """
     names = list(basket_names or [])
-    if len(names) <= 1:
+    if len(names) <= 1 or str(mode).lower() != "live":
         return []
 
-    if str(mode).lower() != "live":
-        return [
-            f"enabled 바스켓 {len(names)}개({', '.join(names)})가 paper 기본 계정(자본 풀)을 "
-            "공유합니다 — 각 바스켓이 같은 자본에 목표 비중을 독립 배분해 과배분되고 "
-            "트랙레코드(NAV 시계열)가 섞입니다. 하나만 enabled로 두거나 운영을 분리하세요."
-        ]
-
     by_account: dict[str, list[str]] = {}
     for name in names:
         try:
@@ -98,11 +94,16 @@ def __init__(
         basket_name: str,
         config: Config = None,
         account_key: str = "",
-        execution_strategy: str = "basket_rebalance",
+        execution_strategy: str = "",
     ):
         self.config = config or Config.get()
-        self.account_key = account_key
-        self.execution_strategy = execution_strategy or "basket_rebalance"
+        # 계정·귀속 키 기본값: paper/live 공통으로 바스켓 전용 키(basket_rebalance:<name>).
+        # 기본 계정("")은 전 계정 합산 뷰라서 다른 전략의 paper 거래 한 건에도 NAV·드리프트·
+        # 평가가 오염되고, 이름 없는 strategy("basket_rebalance")로는 어느 바스켓의 트랙레코드
+        # 인지 귀속이 불가능하다(다른 바스켓 기록으로 승격되는 구멍). 키로 격리·귀속한다.
+        default_key = rebalance_live_strategy_id(basket_name)
+        self.account_key = account_key or default_key
+        self.execution_strategy = execution_strategy or default_key
         self.basket_name = basket_name
 
         baskets_cfg = self._load_baskets_config()
@@ -146,6 +147,58 @@ def _is_live(self) -> bool:
         """실전(live) 모드 여부."""
         return str(self.config.trading.get("mode", "paper")).lower() == "live"
 
+    def save_daily_nav_snapshot(self) -> bool:
+        """바스켓 계정의 일일 NAV 스냅샷 저장. 트랙레코드 시계열의 1행.
+
+        보유 종목 가격이 전부 확보됐을 때만 저장한다 — 가격 미확보 시
+        avg_price 폴백으로 평가된 가짜 NAV가 '커버된 영업일'로 집계되는 것보다,
+        스킵하고 health의 끊김 감지에 노출되는 편이 정직하다.
+
+        귀속 날짜는 NAV의 가격 기준일이다: 비거래일(주말·휴장일) 보충 실행에서
+        조회되는 가격은 직전 거래일 종가이므로 그 거래일로 귀속한다 — PC가 꺼져
+        있던 거래일을 다음날 보충 실행이 정당하게 커버한다(주말 날짜 스냅샷은
+        커버리지에 영원히 안 잡히는 낭비였다). (account_key, date) upsert 멱등.
+        """
+        try:
+            snapshot = getattr(self, "_market_snapshot", None) or self._fetch_market_snapshot()
+            prices = {s: v["price"] for s, v in snapshot.items()}
+            positions = get_all_positions(account_key=self.account_key)
+            missing = [p.symbol for p in positions if p.symbol not in prices]
+            if missing:
+                logger.warning(
+                    "바스켓 '{}' NAV 스냅샷 스킵 — 가격 미확보 종목: {} (가짜 NAV 방지)",
+                    self.basket_name, missing,
+                )
+                return False
+            self.portfolio_mgr.save_daily_snapshot(
+                current_prices=prices or None,
+                snapshot_date=self._nav_attribution_date(),
+            )
+            return True
+        except Exception as e:
+            logger.warning("바스켓 '{}' NAV 스냅샷 저장 실패: {}", self.basket_name, e)
+            return False
+
+    def _nav_attribution_date(self) -> datetime:
+        """NAV 스냅샷 귀속 날짜: 오늘이 거래일이면 오늘, 아니면 직전 거래일.
+
+        조회 가격이 직전 거래일 종가이므로 그 날짜가 정직한 귀속일이다.
+        거래일 판정 실패 시 오늘로 폴백(보수적 — 기존 동작).
+        """
+        now = datetime.now(_KST).replace(tzinfo=None)
+        try:
+            from core.trading_hours import TradingHours
+
+            th = TradingHours(self.config)
+            d = now
+            for _ in range(15):  # 최장 연휴 커버
+                if th.is_trading_day(d):
+                    return d
+                d -= timedelta(days=1)
+        except Exception as e:
+            logger.debug("거래일 판정 실패 — 오늘로 귀속: {}", e)
+        return now
+
     # ------------------------------------------------------------------
     # Config
     # ------------------------------------------------------------------

core/live_readiness.py

@@ -52,8 +52,10 @@ def check_basket_live_readiness(config, strategy_name: str) -> list[str]:
     try:
         from core.basket_evaluation import collect_basket_paper_evaluation
 
+        # 반드시 '이 바스켓'의 기록으로 판정한다 — 이름 없이 합산 평가하면
+        # 다른 바스켓의 60일 트랙레코드로 신규 바스켓이 승격되는 구멍이 생긴다.
         result, _label = collect_basket_paper_evaluation(
-            config=config, include_benchmark=False,
+            config=config, include_benchmark=False, basket_name=basket_name,
         )
         if result["verdict"] != "PASS_CANDIDATE":
             detail = "; ".join(result["issues"]) if result["issues"] else (

core/portfolio_manager.py

@@ -183,8 +183,12 @@ def get_portfolio_summary(self, current_prices: dict = None) -> dict:
             "broker_balance_error": broker_balance_error,
         }
 
-    def save_daily_snapshot(self, current_prices: dict = None):
-        """일일 포트폴리오 스냅샷 저장"""
+    def save_daily_snapshot(self, current_prices: dict = None, snapshot_date=None):
+        """일일 포트폴리오 스냅샷 저장.
+
+        snapshot_date: 귀속 날짜 지정(미지정 시 오늘). 비거래일 보충 실행에서
+        NAV의 가격 기준일(직전 거래일)로 귀속할 때 사용.
+        """
         summary = self.get_portfolio_summary(current_prices)
 
         save_portfolio_snapshot(
@@ -196,6 +200,7 @@ def save_daily_snapshot(self, current_prices: dict = None):
             position_count=summary["position_count"],
             account_key=self.account_key,
             peak_value=self._peak_value,
+            snapshot_date=snapshot_date,
         )
 
         logger.info(

core/scheduler.py

@@ -1552,15 +1552,12 @@ def _run_basket_rebalance_check(self):
                             self.discord.send_message(msg, critical=True)
                             continue
 
+                    # 계정·귀속 키는 paper/live·CLI/스케줄러 공통(basket_rebalance:<name>)
+                    # — 트랙레코드가 바스켓별 한 곳에 쌓인다.
                     rebalancer = BasketRebalancer(
                         basket_name=name, config=self.config,
-                        # paper는 CLI(--mode rebalance)와 동일한 기본 계정("")을 쓴다 —
-                        # 스케줄러가 전략명 계정에 기록하면 일일 CLI로 쌓던 트랙레코드
-                        # (NAV 시계열·평가·health 감시 모두 기본 계정 기준)와 찢어진다.
-                        account_key=live_strategy_name if is_live else "",
-                        execution_strategy=(
-                            live_strategy_name if is_live else "basket_rebalance"
-                        ),
+                        account_key=live_strategy_name,
+                        execution_strategy=live_strategy_name,
                     )
                     if is_live:
                         sync_result = rebalancer.portfolio_mgr.sync_with_broker()
@@ -1574,26 +1571,27 @@ def _run_basket_rebalance_check(self):
                             continue
 
                     should, reason = rebalancer.should_rebalance()
-                    if not should:
+                    if should:
+                        orders = rebalancer.plan_rebalance()
+                        if orders:
+                            result = rebalancer.execute(
+                                orders,
+                                live_confirmed=(
+                                    is_live and self._live_gate_validated
+                                ),
+                            )
+                            summary = (
+                                f"🔄 바스켓 '{name}' 리밸런싱 완료: "
+                                f"실행 {result['executed']}건, 실패 {result['failed']}건"
+                            )
+                            logger.info(summary)
+                            self.discord.send_message(summary)
+                    else:
                         logger.info("바스켓 '{}' 리밸런싱 불필요: {}", name, reason)
-                        continue
 
-                    orders = rebalancer.plan_rebalance()
-                    if not orders:
-                        continue
-
-                    result = rebalancer.execute(
-                        orders,
-                        live_confirmed=(
-                            is_live and self._live_gate_validated
-                        ),
-                    )
-                    summary = (
-                        f"🔄 바스켓 '{name}' 리밸런싱 완료: "
-                        f"실행 {result['executed']}건, 실패 {result['failed']}건"
-                    )
-                    logger.info(summary)
-                    self.discord.send_message(summary)
+                    # 트랙레코드: 스케줄러 단독 운영(상시 구동)에서도 바스켓 계정의
+                    # 일일 NAV 스냅샷이 쌓이도록 거래 여부와 무관하게 저장(멱등 upsert).
+                    rebalancer.save_daily_nav_snapshot()
 
                 except Exception as e:
                     logger.error("바스켓 '{}' 리밸런싱 오류: {}", name, e)

database/repositories.py

@@ -687,11 +687,19 @@ def save_portfolio_snapshot(
     position_count: int = 0,
     account_key: str = "",
     peak_value: float = None,
+    snapshot_date: datetime = None,
 ):
-    """일일 포트폴리오 스냅샷 저장 (account_key: 전략별 계좌 구분)."""
+    """일일 포트폴리오 스냅샷 저장 (account_key: 전략별 계좌 구분).
+
+    snapshot_date: 스냅샷 귀속 날짜(자정으로 정규화). 미지정 시 오늘.
+    비거래일 보충 실행에서 NAV의 가격 기준일(직전 거래일)로 귀속할 때 사용.
+    """
     session = get_session()
     try:
-        today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+        base = snapshot_date or datetime.now()
+        if not isinstance(base, datetime):
+            base = datetime(base.year, base.month, base.day)
+        today = base.replace(hour=0, minute=0, second=0, microsecond=0)
         ak = account_key or ""
         snapshot = PortfolioSnapshot(
             account_key=ak,