feat: Daily CB P&L 기준을 당일 시작 평가금액으로 변경 (#207)

- run_daily_session에 daily_start_eval 파라미터 추가 (반환 타입: float)
  - 세션 첫 잔고 조회 시 total_eval을 baseline으로 캡처
  - 이후 세션에서 pnl_pct = (total_eval - daily_start_eval) / daily_start_eval
  - 기존 purchase_total(누적) 기반 계산 제거
- run 함수 daily 루프에서 날짜 변경 시 baseline 리셋 (_cb_last_date 추적)
- early return 시 daily_start_eval 반환하도록 버그 수정 (None 반환 방지)
- TestDailyCBBaseline 클래스 4개 테스트 추가
  - no_markets: 0.0/기존값 그대로 반환
  - first session: total_eval을 baseline으로 캡처
  - subsequent session: 기존 baseline 유지 (덮어쓰기 방지)

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

CLAUDE.md

@@ -94,6 +94,7 @@ Smart Scanner runs in `TRADE_MODE=realtime` only. Daily mode uses static watchli
 - **[Testing](docs/testing.md)** — Test structure, coverage requirements, writing tests
 - **[Agent Policies](docs/agents.md)** — Prime directives, constraints, prohibited actions
 - **[Requirements Log](docs/requirements-log.md)** — User requirements and feedback tracking
+- **[Live Trading Checklist](docs/live-trading-checklist.md)** — 모의→실전 전환 체크리스트
 
 ## Core Principles
 

docs/live-trading-checklist.md

@@ -0,0 +1,131 @@
+# 실전 전환 체크리스트
+
+모의 거래(paper)에서 실전(live)으로 전환하기 전에 아래 항목을 **순서대로** 모두 확인하세요.
+
+---
+
+## 1. 사전 조건
+
+### 1-1. KIS OpenAPI 실전 계좌 준비
+- [ ] 한국투자증권 계좌 개설 완료 (일반 위탁 계좌)
+- [ ] OpenAPI 실전 사용 신청 (KIS 홈페이지 → Open API → 서비스 신청)
+- [ ] 실전용 APP_KEY / APP_SECRET 발급 완료
+- [ ] KIS_ACCOUNT_NO 형식 확인: `XXXXXXXX-XX` (8자리-2자리)
+
+### 1-2. 리스크 파라미터 검토
+- [ ] `CIRCUIT_BREAKER_PCT` 확인: 기본값 -3.0% (더 엄격하게 조정 권장)
+- [ ] `FAT_FINGER_PCT` 확인: 기본값 30.0% (1회 주문 최대 잔고 대비 %)
+- [ ] `CONFIDENCE_THRESHOLD` 확인: BEARISH ≥ 90, NEUTRAL ≥ 80, BULLISH ≥ 75
+- [ ] 초기 투자금 결정 및 해외 주식 운용 한도 설정
+
+### 1-3. 시스템 요건
+- [ ] 커버리지 80% 이상 유지 확인: `pytest --cov=src`
+- [ ] 타입 체크 통과: `mypy src/ --strict`
+- [ ] Lint 통과: `ruff check src/ tests/`
+
+---
+
+## 2. 환경 설정
+
+### 2-1. `.env` 파일 수정
+
+```bash
+# 1. KIS 실전 URL로 변경 (모의: openapivts 포트 29443)
+KIS_BASE_URL=https://openapi.koreainvestment.com:9443
+
+# 2. 실전 APP_KEY / APP_SECRET으로 교체
+KIS_APP_KEY=<실전_APP_KEY>
+KIS_APP_SECRET=<실전_APP_SECRET>
+KIS_ACCOUNT_NO=<실전_계좌번호>
+
+# 3. 모드를 live로 변경
+MODE=live
+
+# 4. PAPER_OVERSEAS_CASH 비활성화 (live 모드에선 무시되지만 명시적으로 0 설정)
+PAPER_OVERSEAS_CASH=0
+```
+
+> ⚠️ `KIS_BASE_URL` 포트 주의:
+> - **모의(VTS)**: `https://openapivts.koreainvestment.com:29443`
+> - **실전**: `https://openapi.koreainvestment.com:9443`
+
+### 2-2. TR_ID 자동 분기 확인
+
+아래 TR_ID는 `MODE` 값에 따라 코드에서 **자동으로 선택**됩니다.
+별도 설정 불필요하나, 문제 발생 시 아래 표를 참조하세요.
+
+| 구분 | 모의 TR_ID | 실전 TR_ID |
+|------|-----------|-----------|
+| 국내 잔고 조회 | `VTTC8434R` | `TTTC8434R` |
+| 국내 현금 매수 | `VTTC0012U` | `TTTC0012U` |
+| 국내 현금 매도 | `VTTC0011U` | `TTTC0011U` |
+| 해외 잔고 조회 | `VTTS3012R` | `TTTS3012R` |
+| 해외 매수 | `VTTT1002U` | `TTTT1002U` |
+| 해외 매도 | `VTTT1001U` | `TTTT1006U` |
+
+> **출처**: `docs/한국투자증권_오픈API_전체문서_20260221_030000.xlsx` (공식 문서 기준)
+
+---
+
+## 3. 최종 확인
+
+### 3-1. 실전 시작 전 점검
+- [ ] DB 백업 완료: `data/trade_logs.db` → `data/backups/`
+- [ ] Telegram 알림 설정 확인 (실전에서는 알림이 더욱 중요)
+- [ ] 소액으로 첫 거래 진행 후 TR_ID/계좌 정상 동작 확인
+
+### 3-2. 실행 명령
+
+```bash
+# 실전 모드로 실행
+python -m src.main --mode=live
+
+# 대시보드 함께 실행 (별도 터미널에서 모니터링)
+python -m src.main --mode=live --dashboard
+```
+
+### 3-3. 실전 시작 직후 확인 사항
+- [ ] 로그에 `MODE=live` 출력 확인
+- [ ] 첫 잔고 조회 성공 (ConnectionError 없음)
+- [ ] Telegram 알림 수신 확인 ("System started")
+- [ ] 첫 주문 후 KIS 앱에서 체결 내역 확인
+
+---
+
+## 4. 비상 정지 방법
+
+### 즉각 정지
+```bash
+# 터미널에서 Ctrl+C (정상 종료 트리거)
+# 또는 Telegram 봇 명령:
+/stop
+```
+
+### Circuit Breaker 발동 시
+- CB가 발동되면 자동으로 거래 중단 및 Telegram 알림 전송
+- CB 임계값: `CIRCUIT_BREAKER_PCT` (기본 -3.0%)
+- **임계값은 엄격하게만 조정 가능** (더 낮은 음수 값으로만 변경)
+
+---
+
+## 5. 롤백 절차
+
+실전 전환 후 문제 발생 시:
+
+```bash
+# 1. 즉시 .env에서 MODE=paper로 복원
+# 2. 재시작
+python -m src.main --mode=paper
+
+# 3. DB에서 최근 거래 확인
+sqlite3 data/trade_logs.db "SELECT * FROM trades ORDER BY id DESC LIMIT 20;"
+```
+
+---
+
+## 관련 문서
+
+- [시스템 아키텍처](architecture.md)
+- [워크플로우 가이드](workflow.md)
+- [재해 복구](disaster_recovery.md)
+- [Agent 제약 조건](agents.md)

src/config.py

@@ -17,7 +17,7 @@ class Settings(BaseSettings):
 
     # Google Gemini
     GEMINI_API_KEY: str
-    GEMINI_MODEL: str = "gemini-pro"
+    GEMINI_MODEL: str = "gemini-2.0-flash"
 
     # External Data APIs (optional — for data-driven decisions)
     NEWS_API_KEY: str | None = None

src/main.py

@@ -908,18 +908,30 @@ async def run_daily_session(
     telegram: TelegramClient,
     settings: Settings,
     smart_scanner: SmartVolatilityScanner | None = None,
-) -> None:
+    daily_start_eval: float = 0.0,
+) -> float:
     """Execute one daily trading session.
 
     V2 proactive strategy: 1 Gemini call for playbook generation,
     then local scenario evaluation per stock (0 API calls).
+
+    Args:
+        daily_start_eval: Portfolio evaluation at the start of the trading day.
+            Used to compute intra-day P&L for the Circuit Breaker.
+            Pass 0.0 on the first session of each day; the function will set
+            it from the first balance query and return it for subsequent
+            sessions.
+
+    Returns:
+        The daily_start_eval value that should be forwarded to the next
+        session of the same trading day.
     """
     # Get currently open markets
     open_markets = get_open_markets(settings.enabled_market_list)
 
     if not open_markets:
         logger.info("No markets open for this session")
-        return
+        return daily_start_eval
 
     logger.info("Starting daily trading session for %d markets", len(open_markets))
 
@@ -1121,12 +1133,27 @@ async def run_daily_session(
             ):
                 total_cash = settings.PAPER_OVERSEAS_CASH
 
-        # Calculate daily P&L %
-        pnl_pct = (
-            ((total_eval - purchase_total) / purchase_total * 100)
-            if purchase_total > 0
-            else 0.0
-        )
+        # Capture the day's opening portfolio value on the first market processed
+        # in this session.  Used to compute intra-day P&L for the CB instead of
+        # the cumulative purchase_total which spans the entire account history.
+        if daily_start_eval <= 0 and total_eval > 0:
+            daily_start_eval = total_eval
+            logger.info(
+                "Daily CB baseline set: total_eval=%.2f (first balance of the day)",
+                daily_start_eval,
+            )
+
+        # Daily P&L: compare current eval vs start-of-day eval.
+        # Falls back to purchase_total if daily_start_eval is unavailable (e.g. paper
+        # mode where balance API returns 0 for all values).
+        if daily_start_eval > 0:
+            pnl_pct = (total_eval - daily_start_eval) / daily_start_eval * 100
+        else:
+            pnl_pct = (
+                ((total_eval - purchase_total) / purchase_total * 100)
+                if purchase_total > 0
+                else 0.0
+            )
         portfolio_data = {
             "portfolio_pnl_pct": pnl_pct,
             "total_cash": total_cash,
@@ -1395,6 +1422,7 @@ async def run_daily_session(
             )
 
     logger.info("Daily trading session completed")
+    return daily_start_eval
 
 
 async def _handle_market_close(
@@ -2030,13 +2058,26 @@ async def run(settings: Settings) -> None:
 
             session_interval = settings.SESSION_INTERVAL_HOURS * 3600  # Convert to seconds
 
+            # daily_start_eval: portfolio eval captured at the first session of each
+            # trading day.  Reset on calendar-date change so the CB measures only
+            # today's drawdown, not cumulative account history.
+            _cb_daily_start_eval: float = 0.0
+            _cb_last_date: str = ""
+
             while not shutdown.is_set():
                 # Wait for trading to be unpaused
                 await pause_trading.wait()
                 _run_context_scheduler(context_scheduler, now=datetime.now(UTC))
 
+                # Reset intra-day CB baseline on a new calendar date
+                today_str = datetime.now(UTC).date().isoformat()
+                if today_str != _cb_last_date:
+                    _cb_last_date = today_str
+                    _cb_daily_start_eval = 0.0
+                    logger.info("New trading day %s — daily CB baseline reset", today_str)
+
                 try:
-                    await run_daily_session(
+                    _cb_daily_start_eval = await run_daily_session(
                         broker,
                         overseas_broker,
                         scenario_engine,
@@ -2050,6 +2091,7 @@ async def run(settings: Settings) -> None:
                         telegram,
                         settings,
                         smart_scanner=smart_scanner,
+                        daily_start_eval=_cb_daily_start_eval,
                     )
                 except CircuitBreakerTripped:
                     logger.critical("Circuit breaker tripped — shutting down")

tests/test_main.py

@@ -22,6 +22,7 @@ from src.main import (
     _run_context_scheduler,
     _run_evolution_loop,
     _start_dashboard_server,
+    run_daily_session,
     safe_float,
     trading_cycle,
 )
@@ -3271,3 +3272,243 @@ class TestRetryConnection:
             await _retry_connection(bad_input, label="bad")
 
         assert call_count == 1  # No retry for non-ConnectionError
+
+
+# ---------------------------------------------------------------------------
+# run_daily_session — daily CB baseline (daily_start_eval) tests (issue #207)
+# ---------------------------------------------------------------------------
+
+
+class TestDailyCBBaseline:
+    """Tests for run_daily_session's daily_start_eval (CB baseline) behaviour.
+
+    Issue #207: CB P&L should be computed relative to the portfolio value at
+    the start of each trading day, not the cumulative purchase_total.
+    """
+
+    def _make_settings(self) -> Settings:
+        return Settings(
+            KIS_APP_KEY="test-key",
+            KIS_APP_SECRET="test-secret",
+            KIS_ACCOUNT_NO="12345678-01",
+            GEMINI_API_KEY="test-gemini",
+            MODE="paper",
+            PAPER_OVERSEAS_CASH=0,
+        )
+
+    def _make_domestic_balance(
+        self, tot_evlu_amt: float = 0.0, dnca_tot_amt: float = 50000.0
+    ) -> dict:
+        return {
+            "output1": [],
+            "output2": [
+                {
+                    "tot_evlu_amt": str(tot_evlu_amt),
+                    "dnca_tot_amt": str(dnca_tot_amt),
+                    "pchs_amt_smtl_amt": "40000.0",
+                }
+            ],
+        }
+
+    @pytest.mark.asyncio
+    async def test_returns_daily_start_eval_when_no_markets_open(self) -> None:
+        """run_daily_session returns the unchanged daily_start_eval when no markets are open."""
+        with patch("src.main.get_open_markets", return_value=[]):
+            result = await run_daily_session(
+                broker=MagicMock(),
+                overseas_broker=MagicMock(),
+                scenario_engine=MagicMock(),
+                playbook_store=MagicMock(),
+                pre_market_planner=MagicMock(),
+                risk=MagicMock(),
+                db_conn=init_db(":memory:"),
+                decision_logger=MagicMock(),
+                context_store=MagicMock(),
+                criticality_assessor=MagicMock(),
+                telegram=MagicMock(),
+                settings=self._make_settings(),
+                smart_scanner=None,
+                daily_start_eval=12345.0,
+            )
+        assert result == 12345.0
+
+    @pytest.mark.asyncio
+    async def test_returns_zero_when_no_markets_and_no_baseline(self) -> None:
+        """run_daily_session returns 0.0 when no markets are open and daily_start_eval=0."""
+        with patch("src.main.get_open_markets", return_value=[]):
+            result = await run_daily_session(
+                broker=MagicMock(),
+                overseas_broker=MagicMock(),
+                scenario_engine=MagicMock(),
+                playbook_store=MagicMock(),
+                pre_market_planner=MagicMock(),
+                risk=MagicMock(),
+                db_conn=init_db(":memory:"),
+                decision_logger=MagicMock(),
+                context_store=MagicMock(),
+                criticality_assessor=MagicMock(),
+                telegram=MagicMock(),
+                settings=self._make_settings(),
+                smart_scanner=None,
+                daily_start_eval=0.0,
+            )
+        assert result == 0.0
+
+    @pytest.mark.asyncio
+    async def test_captures_total_eval_as_baseline_on_first_session(self) -> None:
+        """When daily_start_eval=0 and balance returns a positive total_eval, the returned
+        value equals total_eval (the captured baseline for the day)."""
+        from src.analysis.smart_scanner import ScanCandidate
+
+        settings = self._make_settings()
+        broker = MagicMock()
+        # Domestic balance: tot_evlu_amt=55000
+        broker.get_balance = AsyncMock(
+            return_value=self._make_domestic_balance(tot_evlu_amt=55000.0)
+        )
+        # Price data for the stock
+        broker.get_current_price = AsyncMock(
+            return_value=(100.0, 1.5, 100.0)
+        )
+
+        market = MagicMock()
+        market.name = "KR"
+        market.code = "KR"
+        market.exchange_code = "KRX"
+        market.is_domestic = True
+        market.timezone = __import__("zoneinfo").ZoneInfo("Asia/Seoul")
+
+        smart_scanner = MagicMock()
+        smart_scanner.scan = AsyncMock(
+            return_value=[
+                ScanCandidate(
+                    stock_code="005930",
+                    name="Samsung",
+                    price=100.0,
+                    volume=1_000_000.0,
+                    volume_ratio=2.5,
+                    rsi=45.0,
+                    signal="momentum",
+                    score=80.0,
+                )
+            ]
+        )
+
+        playbook_store = MagicMock()
+        playbook_store.load = MagicMock(return_value=_make_playbook("KR"))
+
+        scenario_engine = MagicMock(spec=ScenarioEngine)
+        scenario_engine.evaluate = MagicMock(return_value=_make_hold_match("005930"))
+
+        risk = MagicMock()
+        risk.check_circuit_breaker = MagicMock()
+        risk.check_fat_finger = MagicMock()
+
+        telegram = MagicMock()
+        telegram.notify_trade_execution = AsyncMock()
+        telegram.notify_scenario_matched = AsyncMock()
+
+        decision_logger = MagicMock()
+        decision_logger.log_decision = MagicMock(return_value="d1")
+
+        async def _passthrough(fn, *a, label: str = "", **kw):  # type: ignore[override]
+            return await fn(*a, **kw)
+
+        with patch("src.main.get_open_markets", return_value=[market]), \
+             patch("src.main._retry_connection", new=_passthrough):
+            result = await run_daily_session(
+                broker=broker,
+                overseas_broker=MagicMock(),
+                scenario_engine=scenario_engine,
+                playbook_store=playbook_store,
+                pre_market_planner=MagicMock(),
+                risk=risk,
+                db_conn=init_db(":memory:"),
+                decision_logger=decision_logger,
+                context_store=MagicMock(),
+                criticality_assessor=MagicMock(),
+                telegram=telegram,
+                settings=settings,
+                smart_scanner=smart_scanner,
+                daily_start_eval=0.0,
+            )
+
+        assert result == 55000.0  # captured from tot_evlu_amt
+
+    @pytest.mark.asyncio
+    async def test_does_not_overwrite_existing_baseline(self) -> None:
+        """When daily_start_eval > 0, it must not be overwritten even if balance returns
+        a different value (baseline is fixed at the start of each trading day)."""
+        from src.analysis.smart_scanner import ScanCandidate
+
+        settings = self._make_settings()
+        broker = MagicMock()
+        # Balance reports a different eval value (market moved during the day)
+        broker.get_balance = AsyncMock(
+            return_value=self._make_domestic_balance(tot_evlu_amt=58000.0)
+        )
+        broker.get_current_price = AsyncMock(return_value=(100.0, 1.5, 100.0))
+
+        market = MagicMock()
+        market.name = "KR"
+        market.code = "KR"
+        market.exchange_code = "KRX"
+        market.is_domestic = True
+        market.timezone = __import__("zoneinfo").ZoneInfo("Asia/Seoul")
+
+        smart_scanner = MagicMock()
+        smart_scanner.scan = AsyncMock(
+            return_value=[
+                ScanCandidate(
+                    stock_code="005930",
+                    name="Samsung",
+                    price=100.0,
+                    volume=1_000_000.0,
+                    volume_ratio=2.5,
+                    rsi=45.0,
+                    signal="momentum",
+                    score=80.0,
+                )
+            ]
+        )
+
+        playbook_store = MagicMock()
+        playbook_store.load = MagicMock(return_value=_make_playbook("KR"))
+
+        scenario_engine = MagicMock(spec=ScenarioEngine)
+        scenario_engine.evaluate = MagicMock(return_value=_make_hold_match("005930"))
+
+        risk = MagicMock()
+        risk.check_circuit_breaker = MagicMock()
+
+        telegram = MagicMock()
+        telegram.notify_trade_execution = AsyncMock()
+        telegram.notify_scenario_matched = AsyncMock()
+
+        decision_logger = MagicMock()
+        decision_logger.log_decision = MagicMock(return_value="d1")
+
+        async def _passthrough(fn, *a, label: str = "", **kw):  # type: ignore[override]
+            return await fn(*a, **kw)
+
+        with patch("src.main.get_open_markets", return_value=[market]), \
+             patch("src.main._retry_connection", new=_passthrough):
+            result = await run_daily_session(
+                broker=broker,
+                overseas_broker=MagicMock(),
+                scenario_engine=scenario_engine,
+                playbook_store=playbook_store,
+                pre_market_planner=MagicMock(),
+                risk=risk,
+                db_conn=init_db(":memory:"),
+                decision_logger=decision_logger,
+                context_store=MagicMock(),
+                criticality_assessor=MagicMock(),
+                telegram=telegram,
+                settings=settings,
+                smart_scanner=smart_scanner,
+                daily_start_eval=55000.0,  # existing baseline
+            )
+
+        # Must return the original baseline, NOT the new total_eval (58000)
+        assert result == 55000.0