feat: 일일 리포트 v2 — 시장/설계/일정 대비 지표 추가

한 달 운영 리뷰(docs/PAPER_MONTH1_REVIEW_AND_PLAN.md P0-3)의 처방을 구현했다.
기존 일일 카드는 절대 수익만 있어 -5.47%가 전략 탓인지 판단할 수 없었다.
아래 세 축을 카드에 추가해 왜 그런지 한눈에 보이게 한다.

추가 필드:
- 📊 vs KS11: NAV vs 벤치마크 격차 (시장 대비)
- 🎯 주식 배치율: 실제 주식비중 vs 설계 80% (설계 대비)
- 📅 진행률: n/60일 · 커버리지 % · 잔여 결측예산 (일정 대비)
- 💸 누적 비용: 누적/연환산(기간 미충족 시 참고 표기)
- ⚠️ 미체결 슬롯: 현재 자본으로 못 채우는 슬롯 경고(#422)

구조:
- core/basket_evaluation.py: 순수 포맷터 build_daily_report_extras + 평가결과에
  snapshot_days 노출(결측예산 계산). 테스트 용이하게 분리.
- core/basket_rebalancer.py: 읽기전용 diagnose_deployment — 종목별 드리프트가
  못 보는 집계 배치율 이탈 + 미체결 슬롯을 함께 드러낸다.
- main.py: 일일 사이클 배선. 부가필드 실패해도 기본 카드는 발송(채널 보조).
- core/notifier.py: 값 있을 때만 렌더링(하위 호환).

적대적 리뷰 반영: 스냅샷 결측일 NAV 단일소스화(카드 누적수익률과 일치),
결측예산 게이트 정합(max(min_days, progress_days)), min_trading_days=0 방어,
경계 테스트 보강(>3 슬롯 요약, min_trade arm, 가격/총자산 0).

전체 스위트 1548 통과, 실데이터 스모크 확인.

Author: easygap

core/basket_evaluation.py

@@ -91,6 +91,7 @@ def evaluate_basket_paper_operation(
         "operation_start": str(operation_start),
         "today": str(today),
         "progress_days": trading_days_total,
+        "snapshot_days": snapshot_days,
         "min_trading_days": min_trading_days,
         "progress_pct": min(1.0, trading_days_total / min_trading_days) if min_trading_days > 0 else 1.0,
         "snapshot_coverage": round(coverage, 4),
@@ -145,6 +146,101 @@ def format_evaluation_report(result: dict[str, Any], basket_name: str = "") -> s
     return "\n".join(lines)
 
 
+def build_daily_report_extras(
+    *,
+    eval_result: dict[str, Any] | None = None,
+    deployment: dict[str, Any] | None = None,
+    nav_return_pct: float | None = None,
+) -> dict[str, str]:
+    """일일 리포트 v2의 부가 필드(문자열)를 만든다 — 순수 함수(테스트 용이).
+
+    한 달 운영 리뷰(docs/PAPER_MONTH1_REVIEW_AND_PLAN.md)의 결론: 기존 리포트는
+    절대 수익만 있어 "시장 대비/설계 대비/일정 대비" 판단이 불가능했다. 이 함수는
+    그 세 축을 한눈에 보이게 한다.
+
+      - 시장 대비: NAV vs KS11 격차 (benchmark_gap)
+      - 설계 대비: 주식 배치율, 미체결 슬롯 (deployment, slot_warning)
+      - 일정 대비: 진행률·커버리지·잔여 결측 예산 (progress)
+      - 실행 품질: 누적 비용 (cost)
+
+    nav_return_pct를 명시하면 그 값으로 NAV 격차를 계산한다 — 호출부(리포트 카드)의
+    '누적 수익률'과 같은 소스를 쓰게 해, 스냅샷 결측일에 카드의 '누적 수익률'(오늘 시가
+    기준)과 평가의 nav(직전 스냅샷 기준)가 갈려 같은 카드에 📊 수치 두 개가 어긋나는 것을
+    막는다(미지정 시 평가결과의 nav 사용).
+
+    데이터 부재 시 해당 키를 생략한다(리포트가 조용히 축소 — 표시할 게 없으면 안 낸다).
+    notifier.send_daily_report가 이 키들을 선택 필드로 렌더링한다.
+    """
+    extras: dict[str, str] = {}
+
+    if eval_result:
+        m = eval_result.get("metrics") or {}
+
+        # 시장 대비 — NAV vs KS11 격차 (베타 전략이라 격차가 '판정'은 아니지만 가시화 대상)
+        nav = nav_return_pct if nav_return_pct is not None else m.get("nav_return_pct")
+        bench = m.get("benchmark_return_pct")
+        if nav is not None:
+            if bench is not None:
+                extras["benchmark_gap"] = (
+                    f"NAV {nav:+.2f}% vs KS11 {bench:+.2f}% (격차 {nav - bench:+.2f}%p)"
+                )
+            else:
+                extras["benchmark_gap"] = f"NAV {nav:+.2f}% (KS11 조회 불가)"
+
+        # 일정 대비 — 진행률·커버리지·잔여 결측 예산
+        progress_days = int(eval_result.get("progress_days", 0) or 0)
+        min_days_raw = eval_result.get("min_trading_days")
+        min_days = int(min_days_raw) if min_days_raw not in (None, "") else 60
+        snapshot_days = int(eval_result.get("snapshot_days", 0) or 0)
+        coverage = float(eval_result.get("snapshot_coverage", 0.0) or 0.0)
+        pct = float(eval_result.get("progress_pct", 0.0) or 0.0)
+        # 최종 커버리지 95%를 지키며 앞으로 더 놓쳐도 되는 영업일 수.
+        # 허용 결측은 실제 게이트와 같은 기준(운영일수의 5%)이라 기간을 넘겨 운영하면
+        # 분모가 늘어난다 — max(min_days, progress_days)로 게이트와 일치시킨다.
+        denom_days = max(min_days, progress_days)
+        max_allowed_miss = int(denom_days * 0.05)
+        already_missed = max(0, progress_days - snapshot_days)
+        budget = max(0, max_allowed_miss - already_missed)
+        # 표시 분모는 목표 기간(min_days) — 기간 진척을 보여준다. 0(무의미 설정)이면
+        # 운영일수로 폴백해 '5/0일' 같은 문자열을 피한다.
+        disp_denom = min_days if min_days > 0 else progress_days
+        extras["progress"] = (
+            f"{progress_days}/{disp_denom}일 ({pct:.0%}) · 커버리지 {coverage:.0%} · 결측예산 {budget}일"
+        )
+
+        # 실행 품질 — 누적 비용 (연환산은 기간 미충족 시 과장되므로 라벨로 구분)
+        cum = eval_result.get("cost_drag_cum")
+        ann = eval_result.get("cost_drag_annualized")
+        if cum is not None:
+            cost = f"누적 {cum:.3%}"
+            if ann is not None:
+                period_complete = progress_days >= min_days
+                cost += f" · 연환산 {ann:.2%}" + ("" if period_complete else " (참고)")
+            extras["cost"] = cost
+
+    if deployment:
+        actual = float(deployment.get("deployment_ratio", 0.0) or 0.0)
+        design = float(deployment.get("design_fraction", 0.0) or 0.0)
+        extras["deployment"] = (
+            f"주식 {actual:.0%} / 설계 {design:.0%} ({(actual - design) * 100:+.1f}%p)"
+        )
+        slots = deployment.get("unfilled_slots") or []
+        if slots:
+            # Discord 필드값 1024자 한도 — 최대 3개만 명시하고 나머지는 요약.
+            shown = slots[:3]
+            parts = [
+                f"{s.get('symbol')} 1주 {float(s.get('price', 0)):,.0f}원 > 슬롯 "
+                f"{float(s.get('slot_amount', 0)):,.0f}원"
+                for s in shown
+            ]
+            more = f" 외 {len(slots) - len(shown)}개" if len(slots) > len(shown) else ""
+            extras["slot_warning"] = (
+                f"미체결 {len(slots)}개: " + "; ".join(parts) + more + " — 자본 결정 대기(#422)"
+            )
+
+    return extras
+
+
 def collect_basket_paper_evaluation(
     config=None,
     min_days: int | None = None,

core/basket_rebalancer.py

@@ -307,6 +307,58 @@ def calculate_drift(self, prices: dict[str, float] = None) -> dict[str, dict]:
 
         return result
 
+    def diagnose_deployment(self, prices: dict[str, float] = None) -> dict:
+        """읽기전용 배치 진단 — 일일 리포트 v2용. 주문을 만들지 않는다.
+
+        한 달 운영 리뷰(docs/PAPER_MONTH1_REVIEW_AND_PLAN.md)에서 드러난 문제:
+        종목별 드리프트 트리거는 '집계 배치율' 이탈(예: 실효 61% vs 설계 80%)을
+        영영 못 본다. 이 진단은 총자산 대비 실제 주식 비중과, 현재 자본으로는
+        영원히 못 채우는 슬롯(#422)을 함께 드러낸다.
+
+        반환: {total_value, stock_value, cash, deployment_ratio(실제 주식비중),
+               design_fraction(설계 주식비중), unfilled_slots(list[dict])}
+        unfilled_slots 각 항목: {symbol, price, slot_amount, target_weight}
+        """
+        prices = prices or self._fetch_current_prices()
+        summary = self.portfolio_mgr.get_portfolio_summary(current_prices=prices)
+        total_value = float(summary.get("total_value", 0) or 0)
+        cash = float(summary.get("cash", 0) or 0)
+        stock_value = max(0.0, total_value - cash)
+        deployment_ratio = (stock_value / total_value) if total_value > 0 else 0.0
+        design_fraction = self._stock_fraction()
+
+        investable = total_value * design_fraction
+        targets = self.get_target_weights()
+        actuals = self.get_current_weights(prices)
+        min_trade = self.rebalance_cfg.get("min_trade_amount", 100000)
+
+        unfilled: list[dict] = []
+        for symbol, target_w in targets.items():
+            if actuals.get(symbol, 0.0) > 0:
+                continue  # 이미 보유 — 슬롯 채워짐
+            price = prices.get(symbol, 0)
+            if price <= 0:
+                continue  # 가격 미확보는 별도 문제(스냅샷 스킵) — 여기선 판정 보류
+            slot_amount = investable * target_w
+            # plan_rebalance와 같은 판정: 슬롯 목표금액이 최소 거래금액 미만이거나
+            # 1주 가격이 슬롯 목표금액을 초과하면 현재 자본으론 못 채운다.
+            if slot_amount < min_trade or price > slot_amount:
+                unfilled.append({
+                    "symbol": symbol,
+                    "price": float(price),
+                    "slot_amount": float(slot_amount),
+                    "target_weight": float(target_w),
+                })
+
+        return {
+            "total_value": total_value,
+            "stock_value": stock_value,
+            "cash": cash,
+            "deployment_ratio": deployment_ratio,
+            "design_fraction": design_fraction,
+            "unfilled_slots": unfilled,
+        }
+
     # ------------------------------------------------------------------
     # 트리거 판단
     # ------------------------------------------------------------------

core/notifier.py

@@ -314,6 +314,18 @@ def send_daily_report(self, report: dict) -> None:
             {"name": "📋 보유 종목", "value": f"{report.get('position_count', 0)}개", "inline": True},
             {"name": "🔄 당일 매매", "value": f"{report.get('total_trades', 0)}건", "inline": True},
         ]
+        # 리포트 v2 부가 필드(있을 때만) — 시장/설계/일정 대비 판단용.
+        # 값은 core.basket_evaluation.build_daily_report_extras가 만든 문자열이다.
+        for key, label, inline in (
+            ("benchmark_gap", "📊 vs KS11", False),
+            ("deployment", "🎯 주식 배치율", False),
+            ("progress", "📅 진행률", False),
+            ("cost", "💸 누적 비용", True),
+            ("slot_warning", "⚠️ 미체결 슬롯", False),
+        ):
+            val = report.get(key)
+            if val:
+                fields.append({"name": label, "value": str(val), "inline": inline})
         diag = report.get("strategy_diagnosis")
         if diag:
             if isinstance(diag, (list, tuple)):

docs/PAPER_MONTH1_REVIEW_AND_PLAN.md

@@ -152,6 +152,17 @@ P0-1(하트비트·재시도)을 먼저 머지하고 재시작하는 순서를 
 
 각 항목에 [축]과 수용 기준을 명시한다. 축 = 안정성 / 편의성 / 수익성 / 기능.
 
+> **구현 현황** (PR로 갱신)
+> - ✅ **P0-3 일일 리포트 v2** — 벤치마크 격차·배치율·진행률(결측예산)·미체결 슬롯·누적비용 추가.
+>   순수 포맷터 `build_daily_report_extras` + 읽기전용 진단 `BasketRebalancer.diagnose_deployment`,
+>   실데이터 스모크 확인. 다중 에이전트 적대적 리뷰 반영(스냅샷 결측일 NAV 단일소스화,
+>   결측예산 게이트 정합, min_days=0 방어, 경계 테스트 보강).
+>   - 남은 저순위: KS11 벤치마크 조회 캐시 없음 → 바스켓 수(N)만큼 매일 재조회(현재 N=1이라 무해).
+>     공유 함수(`fetch_benchmark_return`) 변경이라 별도 처리 — P1에서 검토.
+> - ⬜ P0-1 사이클 하트비트/결측경보/재시도 — 재시작 전에 머지 예정
+> - ⬜ P0-2 SMTP 재발급 — 오너 액션
+> - ⬜ P1~P3 — 대기
+
 ### P0 — 자본 결정과 같은 주에
 
 | # | 항목 | 축 | 내용 · 수용 기준 |

main.py

@@ -791,7 +791,7 @@ def run_rebalance(args):
                                 daily_ret = (last / prev - 1) * 100
                     except Exception:
                         pass
-                    notifier.send_daily_report({
+                    report_card = {
                         "total_value": summary_data.get("total_value", 0),
                         "cash": summary_data.get("cash", 0),
                         "daily_return": daily_ret,
@@ -800,7 +800,26 @@ def run_rebalance(args):
                         "position_count": summary_data.get("position_count", 0),
                         "total_trades": (result.get("executed", 0) if executed else 0),
                         "strategy_diagnosis": f"바스켓 {name} · paper 트랙레코드 일일 사이클",
-                    })
+                    }
+                    # 리포트 v2 부가 필드(시장/설계/일정 대비) — 실패해도 기본 카드는 발송.
+                    try:
+                        from core.basket_evaluation import (
+                            build_daily_report_extras,
+                            collect_basket_paper_evaluation,
+                        )
+                        deployment = rebalancer.diagnose_deployment(_prices or None)
+                        eval_result, _ = collect_basket_paper_evaluation(basket_name=name)
+                        report_card.update(
+                            build_daily_report_extras(
+                                eval_result=eval_result, deployment=deployment,
+                                # 카드의 '누적 수익률'과 같은 소스(오늘 시가 기준)로 격차 계산
+                                # — 스냅샷 결측일에 📊 수치가 어긋나지 않게.
+                                nav_return_pct=summary_data.get("total_return"),
+                            )
+                        )
+                    except Exception as e:
+                        logger.debug("바스켓 '{}' 리포트 v2 부가필드 생략: {}", name, e)
+                    notifier.send_daily_report(report_card)
                 except Exception as e:
                     logger.debug("바스켓 '{}' 일일 리포트 발송 실패(무시): {}", name, e)
 

tests/test_basket_rebalancer.py

@@ -729,3 +729,85 @@ def test_portfolio_mgr_gets_resolved_account_key(self, monkeypatch):
         """인자 생략 시 portfolio_mgr는 ''(전 계정 합산)가 아니라 바스켓 키를 봐야 한다."""
         rb = self._make(monkeypatch, {"holdings": {"005930": 1.0}})
         assert rb.portfolio_mgr.account_key == "basket_rebalance:t"
+
+
+class TestDiagnoseDeployment:
+    """읽기전용 배치 진단(리포트 v2용): 집계 배치율 + 미체결 슬롯(#422)."""
+
+    def _prep(self, rebalancer, *, total_value, cash, prices, actual_weights):
+        rebalancer._fetch_current_prices = MagicMock(return_value=prices)
+        rebalancer.portfolio_mgr.get_portfolio_summary = MagicMock(
+            return_value={"total_value": total_value, "cash": cash}
+        )
+        rebalancer.get_current_weights = MagicMock(return_value=actual_weights)
+
+    def test_deployment_ratio_from_cash(self, rebalancer):
+        self._prep(
+            rebalancer,
+            total_value=1_000_000, cash=400_000,
+            prices={"005930": 60_000, "000660": 2_129_000, "035420": 100_000},
+            actual_weights={"005930": 0.5, "000660": 0.0, "035420": 0.0},
+        )
+        d = rebalancer.diagnose_deployment()
+        assert d["total_value"] == 1_000_000
+        assert d["stock_value"] == 600_000
+        assert d["deployment_ratio"] == pytest.approx(0.60)
+        assert d["design_fraction"] == pytest.approx(0.80)  # min_cash_ratio 0.20
+
+    def test_unfilled_slot_when_share_exceeds_slot(self, rebalancer):
+        # investable = 1M*0.8 = 800k. 000660 슬롯 280k < 1주 2.13M → 미체결.
+        # 035420 슬롯 200k > 1주 10만 → 채움 가능(미체결 아님).
+        self._prep(
+            rebalancer,
+            total_value=1_000_000, cash=400_000,
+            prices={"005930": 60_000, "000660": 2_129_000, "035420": 100_000},
+            actual_weights={"005930": 0.5, "000660": 0.0, "035420": 0.0},
+        )
+        d = rebalancer.diagnose_deployment()
+        syms = [s["symbol"] for s in d["unfilled_slots"]]
+        assert syms == ["000660"]
+        assert d["unfilled_slots"][0]["price"] == 2_129_000
+
+    def test_held_slot_not_flagged(self, rebalancer):
+        # 전 종목 보유(actual>0) → 미체결 없음
+        self._prep(
+            rebalancer,
+            total_value=1_000_000, cash=200_000,
+            prices={"005930": 60_000, "000660": 100_000, "035420": 100_000},
+            actual_weights={"005930": 0.5, "000660": 0.5, "035420": 0.5},
+        )
+        assert rebalancer.diagnose_deployment()["unfilled_slots"] == []
+
+    def test_unfilled_when_slot_below_min_trade(self, rebalancer):
+        # 두 번째 판정 arm: 슬롯 목표금액 < 최소 거래금액(50k)이라 1주는 살 수 있어도 못 채움.
+        # 총자산 100k → investable 80k. 035420 슬롯 = 80k*0.25 = 20k < 50k → 미체결(가격은 저렴해도).
+        self._prep(
+            rebalancer,
+            total_value=100_000, cash=80_000,
+            prices={"005930": 5_000, "000660": 5_000, "035420": 5_000},
+            actual_weights={"005930": 0.0, "000660": 0.0, "035420": 0.0},
+        )
+        d = rebalancer.diagnose_deployment()
+        # 세 슬롯 모두 목표금액(32k/28k/20k)이 min_trade 50k 미만 → 전부 미체결
+        assert {s["symbol"] for s in d["unfilled_slots"]} == {"005930", "000660", "035420"}
+
+    def test_zero_price_symbol_skipped(self, rebalancer):
+        # 가격 미확보(0)는 판정 보류(스냅샷 스킵이 별도로 처리) — 미체결로 잘못 표기하지 않음.
+        self._prep(
+            rebalancer,
+            total_value=1_000_000, cash=1_000_000,
+            prices={"005930": 0, "000660": 0, "035420": 0},
+            actual_weights={"005930": 0.0, "000660": 0.0, "035420": 0.0},
+        )
+        assert rebalancer.diagnose_deployment()["unfilled_slots"] == []
+
+    def test_zero_total_value_ratio_is_zero(self, rebalancer):
+        self._prep(
+            rebalancer,
+            total_value=0, cash=0,
+            prices={"005930": 60_000, "000660": 100_000, "035420": 100_000},
+            actual_weights={"005930": 0.0, "000660": 0.0, "035420": 0.0},
+        )
+        d = rebalancer.diagnose_deployment()
+        assert d["deployment_ratio"] == 0.0
+        assert d["total_value"] == 0