fix: use actual held quantity for SELL orders instead of hardcoded 1 (#164 )

_determine_order_quantity()에서 SELL 시 항상 1을 반환하던 버그 수정. DB에서 실제 보유 수량을 조회해 전량 청산이 가능하도록 변경. - _determine_order_quantity에 open_position 파라미터 추가 - SELL 시 open_position["quantity"] 반환, 포지션 없으면 0 반환 - trading_cycle 및 run_daily_session 호출 지점 모두 수정 - _determine_order_quantity 임포트 및 유닛 테스트 클래스 추가 (6개) - SELL 실제 수량 사용 통합 테스트 추가 (quantity=5 검증) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-02-20 03:03:50 +09:00
32 changed files with 112 additions and 4737 deletions
--- a/.env.example
+++ b/.env.example
@@ -1,82 +1,36 @@
 # ============================================================
 # The Ouroboros — Environment Configuration
 # ============================================================
 # Copy this file to .env and fill in your values.
 # Lines starting with # are comments.
 # ============================================================
 # Korea Investment Securities API
 # ============================================================
 KIS_APP_KEY=your_app_key_here
 KIS_APP_SECRET=your_app_secret_here
 KIS_ACCOUNT_NO=12345678-01
 KIS_BASE_URL=https://openapivts.koreainvestment.com:9443
 # Paper trading (VTS): https://openapivts.koreainvestment.com:29443
 # Live trading:        https://openapi.koreainvestment.com:9443
 KIS_BASE_URL=https://openapivts.koreainvestment.com:29443
 # ============================================================
 # Trading Mode
 # ============================================================
 # paper = 모의투자 (safe for testing), live = 실전투자 (real money)
 MODE=paper
 # daily = batch per session, realtime = per-stock continuous scan
 TRADE_MODE=daily
 # Comma-separated market codes: KR, US, JP, HK, CN, VN
 ENABLED_MARKETS=KR,US
 # Simulated USD cash for paper (VTS) overseas trading.
 # VTS overseas balance API often returns 0; this value is used as fallback.
 # Set to 0 to disable fallback (not used in live mode).
 PAPER_OVERSEAS_CASH=50000.0
 # ============================================================
 # Google Gemini
 # ============================================================
 GEMINI_API_KEY=your_gemini_api_key_here
-# Recommended: gemini-2.0-flash-exp or gemini-1.5-pro
+GEMINI_MODEL=gemini-pro
 GEMINI_MODEL=gemini-2.0-flash-exp
 # ============================================================
 # Risk Management
 # ============================================================
 CIRCUIT_BREAKER_PCT=-3.0
 FAT_FINGER_PCT=30.0
 CONFIDENCE_THRESHOLD=80
 # ============================================================
 # Database
 # ============================================================
 DB_PATH=data/trade_logs.db
-# ============================================================
+# Rate Limiting (requests per second for KIS API)
-# Rate Limiting
+# Reduced to 5.0 to avoid "초당 거래건수 초과" errors (EGW00201)
-# ============================================================
+RATE_LIMIT_RPS=5.0
 # KIS API real limit is ~2 RPS. Keep at 2.0 for maximum safety.
 # Increasing this risks EGW00201 "초당 거래건수 초과" errors.
 RATE_LIMIT_RPS=2.0
-# ============================================================
+# Trading Mode (paper / live)
-# External Data APIs (optional)
+MODE=paper
-# ============================================================
+
 # External Data APIs (optional — for enhanced decision-making)
 # NEWS_API_KEY=your_news_api_key_here
 # NEWS_API_PROVIDER=alphavantage
 # MARKET_DATA_API_KEY=your_market_data_key_here
 # ============================================================
 # Telegram Notifications (optional)
 # ============================================================
 # Get bot token from @BotFather on Telegram
 # Get chat ID from @userinfobot or your chat
 # TELEGRAM_BOT_TOKEN=1234567890:ABCdefGHIjklMNOpqrsTUVwxyz
 # TELEGRAM_CHAT_ID=123456789
 # TELEGRAM_ENABLED=true
 # ============================================================
 # Dashboard (optional)
 # ============================================================
 # DASHBOARD_ENABLED=false
 # DASHBOARD_HOST=127.0.0.1
 # DASHBOARD_PORT=8080
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -170,7 +170,7 @@ Markets auto-detected based on timezone and enabled in `ENABLED_MARKETS` env var
 - `src/core/risk_manager.py` is **READ-ONLY** — changes require human approval
 - Circuit breaker at -3.0% P&L — may only be made **stricter**
 - Fat-finger protection: max 30% of cash per order — always enforced
- Confidence 임계값 (market_outlook별, 낮출 수 없음): BEARISH ≥ 90, NEUTRAL/기본 ≥ 80, BULLISH ≥ 75
+- Confidence < 80 → force HOLD — cannot be weakened
 - All code changes → corresponding tests → coverage ≥ 80%
 ## Contributing
--- a/docs/commands.md
+++ b/docs/commands.md
@@ -192,27 +192,6 @@ When `TELEGRAM_COMMANDS_ENABLED=true` (default), the bot accepts these interacti
 Commands are only processed from the authorized `TELEGRAM_CHAT_ID`.
 ## KIS API TR_ID 참조 문서
 **TR_ID를 추가하거나 수정할 때 반드시 공식 문서를 먼저 확인할 것.**
 공식 문서: `docs/한국투자증권_오픈API_전체문서_20260221_030000.xlsx`
 > ⚠️ 커뮤니티 블로그, GitHub 예제 등 비공식 자료의 TR_ID는 오래되거나 틀릴 수 있음.
 > 실제로 `VTTT1006U`(미국 매도 — 잘못됨)가 오랫동안 코드에 남아있던 사례가 있음 (Issue #189).
 ### 주요 TR_ID 목록
 | 구분 | 모의투자 TR_ID | 실전투자 TR_ID | 시트명 |
 |------|---------------|---------------|--------|
 | 해외주식 매수 (미국) | `VTTT1002U` | `TTTT1002U` | 해외주식 주문 |
 | 해외주식 매도 (미국) | `VTTT1001U` | `TTTT1006U` | 해외주식 주문 |
 새로운 TR_ID가 필요할 때:
 1. 위 xlsx 파일에서 해당 거래 유형의 시트를 찾는다.
 2. 모의투자(`VTTT`) / 실전투자(`TTTT`) 컬럼을 구분하여 정확한 값을 사용한다.
 3. 코드에 출처 주석을 남긴다: `# Source: 한국투자증권_오픈API_전체문서 — '<시트명>' 시트`
 ## Environment Setup
 ```bash
--- a/docs/requirements-log.md
+++ b/docs/requirements-log.md
@@ -7,32 +7,6 @@
 ---
 ## 2026-02-21
 ### 거래 상태 확인 중 발견된 버그 (#187)
 - 거래 상태 점검 요청 → SELL 주문(손절/익절)이 Fat Finger에 막혀 전혀 실행 안 됨 발견
 - **#187 (Critical)**: SELL 주문에서 Fat Finger 오탐 — `order_amount/total_cash > 30%`가 SELL에도 적용되어 대형 포지션 매도 불가
  - JELD stop-loss -6.20% → 차단, RXT take-profit +46.13% → 차단
  - 수정: SELL은 `check_circuit_breaker`만 호출, `validate_order`(Fat Finger 포함) 미호출
 ---
 ## 2026-02-20
 ### 지속적 모니터링 및 개선점 도출 (이슈 #178~#182)
 - Dashboard 포함해서 실행하며 간헐적 문제 모니터링 및 개선점 자동 도출 요청
 - 모니터링 결과 발견된 이슈 목록:
  - **#178**: uvicorn 미설치 → dashboard 미작동 + 오해의 소지 있는 시작 로그 → uvicorn 설치 완료
  - **#179 (Critical)**: 잔액 부족 주문 실패 후 매 사이클마다 무한 재시도 (MLECW 20분 이상 반복)
  - **#180**: 다중 인스턴스 실행 시 Telegram 409 충돌
  - **#181**: implied_rsi 공식 포화 문제 (change_rate≥12.5% → RSI=100)
  - **#182 (Critical)**: 보유 종목이 SmartScanner 변동성 필터에 걸려 SELL 신호 미생성 → SELL 체결 0건, 잔고 소진
 - 요구사항: 모니터링 자동화 및 주기적 개선점 리포트 도출
 ---
 ## 2026-02-05
 ### API 효율화
--- a/src/analysis/smart_scanner.py
+++ b/src/analysis/smart_scanner.py
@@ -175,7 +175,7 @@ class SmartVolatilityScanner:
                liquidity_score = volume_rank_bonus.get(stock_code, 0.0)
                score = min(100.0, volatility_score + liquidity_score)
                signal = "momentum" if change_rate >= 0 else "oversold"
-                implied_rsi = max(0.0, min(100.0, 50.0 + (change_rate * 2.0)))
+                implied_rsi = max(0.0, min(100.0, 50.0 + (change_rate * 4.0)))
                candidates.append(
                    ScanCandidate(
@@ -282,7 +282,7 @@ class SmartVolatilityScanner:
            liquidity_score = volume_rank_bonus.get(stock_code, 0.0)
            score = min(100.0, volatility_score + liquidity_score)
            signal = "momentum" if change_rate >= 0 else "oversold"
-            implied_rsi = max(0.0, min(100.0, 50.0 + (change_rate * 2.0)))
+            implied_rsi = max(0.0, min(100.0, 50.0 + (change_rate * 4.0)))
            candidates.append(
                ScanCandidate(
                    stock_code=stock_code,
@@ -338,7 +338,7 @@ class SmartVolatilityScanner:
                score = min(volatility_pct / 10.0, 1.0) * 100.0
                signal = "momentum" if change_rate >= 0 else "oversold"
-                implied_rsi = max(0.0, min(100.0, 50.0 + (change_rate * 2.0)))
+                implied_rsi = max(0.0, min(100.0, 50.0 + (change_rate * 4.0)))
                candidates.append(
                    ScanCandidate(
                        stock_code=stock_code,
--- a/src/broker/kis_api.py
+++ b/src/broker/kis_api.py
@@ -285,10 +285,7 @@ class KISBroker:
        await self._rate_limiter.acquire()
        session = self._get_session()
-        # TR_ID: 실전 TTTC8434R, 모의 VTTC8434R
+        headers = await self._auth_headers("VTTC8434R")  # 모의투자 잔고조회
        # Source: 한국투자증권 오픈API 전체문서 (20260221) — '국내주식 잔고조회' 시트
        tr_id = "TTTC8434R" if self._settings.MODE == "live" else "VTTC8434R"
        headers = await self._auth_headers(tr_id)
        params = {
            "CANO": self._account_no,
            "ACNT_PRDT_CD": self._product_cd,
@@ -333,13 +330,7 @@ class KISBroker:
        await self._rate_limiter.acquire()
        session = self._get_session()
-        # TR_ID: 실전 BUY=TTTC0012U SELL=TTTC0011U, 모의 BUY=VTTC0012U SELL=VTTC0011U
+        tr_id = "VTTC0802U" if order_type == "BUY" else "VTTC0801U"
        # Source: 한국투자증권 오픈API 전체문서 (20260221) — '주식주문(현금)' 시트
        # ※ TTTC0802U/VTTC0802U는 미수매수(증거금40% 계좌 전용) — 현금주문에 사용 금지
        if self._settings.MODE == "live":
            tr_id = "TTTC0012U" if order_type == "BUY" else "TTTC0011U"
        else:
            tr_id = "VTTC0012U" if order_type == "BUY" else "VTTC0011U"
        # KRX requires limit orders to be rounded down to the tick unit.
        # ORD_DVSN: "00"=지정가, "01"=시장가
--- a/src/broker/overseas.py
+++ b/src/broker/overseas.py
@@ -175,12 +175,8 @@ class OverseasBroker:
        await self._broker._rate_limiter.acquire()
        session = self._broker._get_session()
-        # TR_ID: 실전 TTTS3012R, 모의 VTTS3012R
+        # Virtual trading TR_ID for overseas balance inquiry
-        # Source: 한국투자증권 오픈API 전체문서 (20260221) — '해외주식 잔고조회' 시트
+        headers = await self._broker._auth_headers("VTTS3012R")
        balance_tr_id = (
            "TTTS3012R" if self._broker._settings.MODE == "live" else "VTTS3012R"
        )
        headers = await self._broker._auth_headers(balance_tr_id)
        params = {
            "CANO": self._broker._account_no,
            "ACNT_PRDT_CD": self._broker._product_cd,
@@ -233,12 +229,8 @@ class OverseasBroker:
        await self._broker._rate_limiter.acquire()
        session = self._broker._get_session()
-        # TR_ID: 실전 BUY=TTTT1002U SELL=TTTT1006U, 모의 BUY=VTTT1002U SELL=VTTT1001U
+        # Virtual trading TR_IDs for overseas orders
-        # Source: 한국투자증권 오픈API 전체문서 (20260221) — '해외주식 주문' 시트
+        tr_id = "VTTT1002U" if order_type == "BUY" else "VTTT1006U"
        if self._broker._settings.MODE == "live":
            tr_id = "TTTT1002U" if order_type == "BUY" else "TTTT1006U"
        else:
            tr_id = "VTTT1002U" if order_type == "BUY" else "VTTT1001U"
        body = {
            "CANO": self._broker._account_no,
--- a/src/config.py
+++ b/src/config.py
@@ -13,7 +13,7 @@ class Settings(BaseSettings):
    KIS_APP_KEY: str
    KIS_APP_SECRET: str
    KIS_ACCOUNT_NO: str  # format: "XXXXXXXX-XX"
-    KIS_BASE_URL: str = "https://openapivts.koreainvestment.com:29443"
+    KIS_BASE_URL: str = "https://openapivts.koreainvestment.com:9443"
    # Google Gemini
    GEMINI_API_KEY: str
--- a/src/dashboard/app.py
+++ b/src/dashboard/app.py
@@ -3,9 +3,8 @@
 from __future__ import annotations
 import json
 import os
 import sqlite3
-from datetime import UTC, datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
@@ -80,35 +79,6 @@ def create_dashboard_app(db_path: str) -> FastAPI:
                total_pnl += market_status[market]["total_pnl"]
                total_decisions += market_status[market]["decision_count"]
            cb_threshold = float(os.getenv("CIRCUIT_BREAKER_PCT", "-3.0"))
            pnl_pct_rows = conn.execute(
                """
                SELECT key, value
                FROM system_metrics
                WHERE key LIKE 'portfolio_pnl_pct_%'
                ORDER BY updated_at DESC
                LIMIT 20
                """
            ).fetchall()
            current_pnl_pct: float | None = None
            if pnl_pct_rows:
                values = [
                    json.loads(row["value"]).get("pnl_pct")
                    for row in pnl_pct_rows
                    if json.loads(row["value"]).get("pnl_pct") is not None
                ]
                if values:
                    current_pnl_pct = round(min(values), 4)
            if current_pnl_pct is None:
                cb_status = "unknown"
            elif current_pnl_pct <= cb_threshold:
                cb_status = "tripped"
            elif current_pnl_pct <= cb_threshold + 1.0:
                cb_status = "warning"
            else:
                cb_status = "ok"
            return {
                "date": today,
                "markets": market_status,
@@ -117,11 +87,6 @@ def create_dashboard_app(db_path: str) -> FastAPI:
                    "total_pnl": round(total_pnl, 2),
                    "decision_count": total_decisions,
                },
                "circuit_breaker": {
                    "threshold_pct": cb_threshold,
                    "current_pnl_pct": current_pnl_pct,
                    "status": cb_status,
                },
            }
    @app.get("/api/playbook/{date_str}")
@@ -376,68 +341,12 @@ def create_dashboard_app(db_path: str) -> FastAPI:
                )
            return {"market": market, "date": date_str, "count": len(matches), "matches": matches}
    @app.get("/api/positions")
    def get_positions() -> dict[str, Any]:
        """Return all currently open positions (last trade per symbol is BUY)."""
        with _connect(db_path) as conn:
            rows = conn.execute(
                """
                SELECT stock_code, market, exchange_code,
                       price AS entry_price, quantity, timestamp AS entry_time,
                       decision_id
                FROM (
                    SELECT stock_code, market, exchange_code, price, quantity,
                           timestamp, decision_id, action,
                           ROW_NUMBER() OVER (
                               PARTITION BY stock_code, market
                               ORDER BY timestamp DESC
                           ) AS rn
                    FROM trades
                )
                WHERE rn = 1 AND action = 'BUY'
                ORDER BY entry_time DESC
                """
            ).fetchall()
            now = datetime.now(timezone.utc)
            positions = []
            for row in rows:
                entry_time_str = row["entry_time"]
                try:
                    entry_dt = datetime.fromisoformat(entry_time_str.replace("Z", "+00:00"))
                    held_seconds = int((now - entry_dt).total_seconds())
                    held_hours = held_seconds // 3600
                    held_minutes = (held_seconds % 3600) // 60
                    if held_hours >= 1:
                        held_display = f"{held_hours}h {held_minutes}m"
                    else:
                        held_display = f"{held_minutes}m"
                except (ValueError, TypeError):
                    held_display = "--"
                positions.append(
                    {
                        "stock_code": row["stock_code"],
                        "market": row["market"],
                        "exchange_code": row["exchange_code"],
                        "entry_price": row["entry_price"],
                        "quantity": row["quantity"],
                        "entry_time": entry_time_str,
                        "held": held_display,
                        "decision_id": row["decision_id"],
                    }
                )
            return {"count": len(positions), "positions": positions}
    return app
 def _connect(db_path: str) -> sqlite3.Connection:
    conn = sqlite3.connect(db_path)
    conn.row_factory = sqlite3.Row
    conn.execute("PRAGMA journal_mode=WAL")
    conn.execute("PRAGMA busy_timeout=8000")
    return conn
--- a/src/dashboard/static/index.html
+++ b/src/dashboard/static/index.html
@@ -13,7 +13,6 @@
        --muted: #9fb3c8;
        --accent: #3cb371;
        --red: #e05555;
        --warn: #e8a040;
        --border: #28455f;
      }
      * { box-sizing: border-box; margin: 0; padding: 0; }
@@ -44,25 +43,6 @@
      }
      .refresh-btn:hover { border-color: var(--accent); color: var(--accent); }
      /* CB Gauge */
      .cb-gauge-wrap {
        display: flex; align-items: center; gap: 8px;
        font-size: 11px; color: var(--muted);
      }
      .cb-dot {
        width: 8px; height: 8px; border-radius: 50%; flex-shrink: 0;
      }
      .cb-dot.ok      { background: var(--accent); }
      .cb-dot.warning { background: var(--warn); animation: pulse-warn 1.2s ease-in-out infinite; }
      .cb-dot.tripped { background: var(--red);  animation: pulse-warn 0.6s ease-in-out infinite; }
      .cb-dot.unknown { background: var(--border); }
      @keyframes pulse-warn {
        0%, 100% { opacity: 1; }
        50%       { opacity: 0.35; }
      }
      .cb-bar-wrap { width: 64px; height: 5px; background: rgba(255,255,255,0.08); border-radius: 3px; overflow: hidden; }
      .cb-bar-fill { height: 100%; border-radius: 3px; transition: width 0.4s, background 0.4s; }
      /* Summary cards */
      .cards { display: grid; grid-template-columns: repeat(4, 1fr); gap: 12px; margin-bottom: 20px; }
      @media (max-width: 700px) { .cards { grid-template-columns: repeat(2, 1fr); } }
@@ -143,80 +123,9 @@
      .rationale-cell { max-width: 200px; overflow: hidden; text-overflow: ellipsis; color: var(--muted); }
      .empty-row td { text-align: center; color: var(--muted); padding: 24px; }
      /* Positions panel */
      .positions-panel {
        background: var(--panel);
        border: 1px solid var(--border);
        border-radius: 10px;
        padding: 16px;
        margin-bottom: 20px;
      }
      .positions-table { width: 100%; border-collapse: collapse; margin-top: 14px; }
      .positions-table th {
        text-align: left; color: var(--muted); font-size: 11px; font-weight: 600;
        padding: 6px 8px; border-bottom: 1px solid var(--border); white-space: nowrap;
      }
      .positions-table td {
        padding: 8px 8px; border-bottom: 1px solid rgba(40, 69, 95, 0.5);
        vertical-align: middle; white-space: nowrap;
      }
      .positions-table tr:last-child td { border-bottom: none; }
      .positions-table tr:hover td { background: rgba(255,255,255,0.02); }
      .pos-empty { color: var(--muted); text-align: center; padding: 20px 0; font-size: 12px; }
      .pos-count {
        display: inline-block; background: rgba(60, 179, 113, 0.12);
        color: var(--accent); font-size: 11px; font-weight: 700;
        padding: 2px 8px; border-radius: 10px; margin-left: 8px;
      }
      /* Spinner */
      .spinner { display: inline-block; width: 12px; height: 12px; border: 2px solid var(--border); border-top-color: var(--accent); border-radius: 50%; animation: spin 0.8s linear infinite; }
      @keyframes spin { to { transform: rotate(360deg); } }
      /* Generic panel */
      .panel {
        background: var(--panel);
        border: 1px solid var(--border);
        border-radius: 10px;
        padding: 16px;
        margin-top: 20px;
      }
      /* Playbook panel - details/summary accordion */
      .playbook-panel details { border: 1px solid var(--border); border-radius: 4px; margin-bottom: 6px; }
      .playbook-panel summary { padding: 8px 12px; cursor: pointer; font-weight: 600; background: var(--bg); color: var(--fg); }
      .playbook-panel summary:hover { color: var(--accent); }
      .playbook-panel pre { margin: 0; padding: 12px; background: var(--bg); overflow-x: auto;
                            font-size: 11px; color: #a0c4ff; white-space: pre-wrap; }
      /* Scorecard KPI card grid */
      .scorecard-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(140px, 1fr)); gap: 10px; }
      .kpi-card { background: var(--bg); border: 1px solid var(--border); border-radius: 6px; padding: 12px; text-align: center; }
      .kpi-card .kpi-label { font-size: 11px; color: var(--muted); margin-bottom: 4px; }
      .kpi-card .kpi-value { font-size: 20px; font-weight: 700; color: var(--fg); }
      /* Scenarios table */
      .scenarios-table { width: 100%; border-collapse: collapse; font-size: 13px; }
      .scenarios-table th { background: var(--bg); padding: 8px; text-align: left; border-bottom: 1px solid var(--border);
                            color: var(--muted); font-size: 11px; font-weight: 600; white-space: nowrap; }
      .scenarios-table td { padding: 7px 8px; border-bottom: 1px solid rgba(40,69,95,0.5); }
      .scenarios-table tr:hover td { background: rgba(255,255,255,0.02); }
      /* Context table */
      .context-table { width: 100%; border-collapse: collapse; font-size: 12px; }
      .context-table th { background: var(--bg); padding: 8px; text-align: left; border-bottom: 1px solid var(--border);
                          color: var(--muted); font-size: 11px; font-weight: 600; white-space: nowrap; }
      .context-table td { padding: 6px 8px; border-bottom: 1px solid rgba(40,69,95,0.5); vertical-align: top; }
      .context-value { max-height: 60px; overflow-y: auto; color: #a0c4ff; word-break: break-all; }
      /* Common panel select controls */
      .panel-controls { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
      .panel-controls select, .panel-controls input[type="number"] {
        background: var(--bg); color: var(--fg); border: 1px solid var(--border);
        border-radius: 4px; padding: 4px 8px; font-size: 13px; font-family: inherit;
      }
      .panel-date { color: var(--muted); font-size: 12px; }
      .empty-msg { color: var(--muted); text-align: center; padding: 20px 0; font-size: 12px; }
    </style>
  </head>
  <body>
@@ -225,13 +134,6 @@
      <header>
        <h1>&#x1F40D; The Ouroboros</h1>
        <div class="header-right">
          <div class="cb-gauge-wrap" id="cb-gauge" title="Circuit Breaker">
            <span class="cb-dot unknown" id="cb-dot"></span>
            <span id="cb-label">CB --</span>
            <div class="cb-bar-wrap">
              <div class="cb-bar-fill" id="cb-bar" style="width:0%;background:var(--accent)"></div>
            </div>
          </div>
          <span id="last-updated">--</span>
          <button class="refresh-btn" onclick="refreshAll()">&#x21BA; 새로고침</button>
        </div>
@@ -261,30 +163,6 @@
        </div>
      </div>
      <!-- Open Positions -->
      <div class="positions-panel">
        <div class="panel-header">
          <span class="panel-title">
            현재 보유 포지션
            <span class="pos-count" id="positions-count">0</span>
          </span>
        </div>
        <table class="positions-table">
          <thead>
            <tr>
              <th>종목</th>
              <th>시장</th>
              <th>수량</th>
              <th>진입가</th>
              <th>보유 시간</th>
            </tr>
          </thead>
          <tbody id="positions-body">
            <tr><td colspan="5" class="pos-empty"><span class="spinner"></span></td></tr>
          </tbody>
        </table>
      </div>
      <!-- P&L Chart -->
      <div class="chart-panel">
        <div class="panel-header">
@@ -328,72 +206,6 @@
          </tbody>
        </table>
      </div>
      <!-- playbook panel -->
      <div class="panel playbook-panel">
        <div class="panel-header">
          <span class="panel-title">&#x1F4CB; 프리마켓 플레이북</span>
          <div class="panel-controls">
            <select id="pb-market-select" onchange="fetchPlaybook()">
              <option value="KR">KR</option>
              <option value="US_NASDAQ">US_NASDAQ</option>
              <option value="US_NYSE">US_NYSE</option>
            </select>
            <span id="pb-date" class="panel-date"></span>
          </div>
        </div>
        <div id="playbook-content"><p class="empty-msg">데이터 없음</p></div>
      </div>
      <!-- scorecard panel -->
      <div class="panel">
        <div class="panel-header">
          <span class="panel-title">&#x1F4CA; 일간 스코어카드</span>
          <div class="panel-controls">
            <select id="sc-market-select" onchange="fetchScorecard()">
              <option value="KR">KR</option>
              <option value="US_NASDAQ">US_NASDAQ</option>
            </select>
            <span id="sc-date" class="panel-date"></span>
          </div>
        </div>
        <div id="scorecard-grid" class="scorecard-grid"><p class="empty-msg">데이터 없음</p></div>
      </div>
      <!-- scenarios panel -->
      <div class="panel">
        <div class="panel-header">
          <span class="panel-title">&#x1F3AF; 활성 시나리오 매칭</span>
          <div class="panel-controls">
            <select id="scen-market-select" onchange="fetchScenarios()">
              <option value="KR">KR</option>
              <option value="US_NASDAQ">US_NASDAQ</option>
            </select>
          </div>
        </div>
        <div id="scenarios-content"><p class="empty-msg">데이터 없음</p></div>
      </div>
      <!-- context layer panel -->
      <div class="panel">
        <div class="panel-header">
          <span class="panel-title">&#x1F9E0; 컨텍스트 트리</span>
          <div class="panel-controls">
            <select id="ctx-layer-select" onchange="fetchContext()">
              <option value="L7_REALTIME">L7_REALTIME</option>
              <option value="L6_DAILY">L6_DAILY</option>
              <option value="L5_WEEKLY">L5_WEEKLY</option>
              <option value="L4_MONTHLY">L4_MONTHLY</option>
              <option value="L3_QUARTERLY">L3_QUARTERLY</option>
              <option value="L2_YEARLY">L2_YEARLY</option>
              <option value="L1_LIFETIME">L1_LIFETIME</option>
            </select>
            <input id="ctx-limit" type="number" value="20" min="1" max="200"
                   style="width:60px;" onchange="fetchContext()">
          </div>
        </div>
        <div id="context-content"><p class="empty-msg">데이터 없음</p></div>
      </div>
    </div>
    <script>
@@ -430,71 +242,6 @@
        </div>`;
      }
      function fmtPrice(v, market) {
        if (v === null || v === undefined) return '--';
        const n = parseFloat(v);
        const sym = market === 'KR' ? '₩' : market === 'JP' ? '¥' : market === 'HK' ? 'HK$' : '$';
        return sym + n.toLocaleString('en-US', { minimumFractionDigits: 0, maximumFractionDigits: 4 });
      }
      async function fetchPositions() {
        const tbody = document.getElementById('positions-body');
        const countEl = document.getElementById('positions-count');
        try {
          const r = await fetch('/api/positions');
          if (!r.ok) throw new Error('fetch failed');
          const d = await r.json();
          countEl.textContent = d.count ?? 0;
          if (!d.positions || d.positions.length === 0) {
            tbody.innerHTML = '<tr><td colspan="5" class="pos-empty">현재 보유 중인 포지션 없음</td></tr>';
            return;
          }
          tbody.innerHTML = d.positions.map(p => `
            <tr>
              <td><strong>${p.stock_code || '--'}</strong></td>
              <td><span style="color:var(--muted);font-size:11px">${p.market || '--'}</span></td>
              <td>${p.quantity ?? '--'}</td>
              <td>${fmtPrice(p.entry_price, p.market)}</td>
              <td style="color:var(--muted);font-size:11px">${p.held || '--'}</td>
            </tr>
          `).join('');
        } catch {
          tbody.innerHTML = '<tr><td colspan="5" class="pos-empty">데이터 로드 실패</td></tr>';
        }
      }
      function renderCbGauge(cb) {
        if (!cb) return;
        const dot = document.getElementById('cb-dot');
        const label = document.getElementById('cb-label');
        const bar = document.getElementById('cb-bar');
        const status = cb.status || 'unknown';
        const threshold = cb.threshold_pct ?? -3.0;
        const current = cb.current_pnl_pct;
        // dot color
        dot.className = `cb-dot ${status}`;
        // label
        if (current !== null && current !== undefined) {
          const sign = current > 0 ? '+' : '';
          label.textContent = `CB ${sign}${current.toFixed(2)}%`;
        } else {
          label.textContent = 'CB --';
        }
        // bar: fill = how much of the threshold has been consumed (0%=safe, 100%=tripped)
        const colorMap = { ok: 'var(--accent)', warning: 'var(--warn)', tripped: 'var(--red)', unknown: 'var(--border)' };
        bar.style.background = colorMap[status] || 'var(--border)';
        if (current !== null && current !== undefined && threshold < 0) {
          const fillPct = Math.min(Math.max((current / threshold) * 100, 0), 100);
          bar.style.width = `${fillPct}%`;
        } else {
          bar.style.width = '0%';
        }
      }
      async function fetchStatus() {
        try {
          const r = await fetch('/api/status');
@@ -511,7 +258,6 @@
            pnlEl.className = `card-value ${n > 0 ? 'positive' : n < 0 ? 'negative' : 'neutral'}`;
          }
          document.getElementById('card-pnl-sub').textContent = `결정 ${t.decision_count ?? 0}건`;
          renderCbGauge(d.circuit_breaker);
        } catch {}
      }
@@ -632,129 +378,13 @@
        fetchDecisions(currentMarket);
      }
      function todayStr() {
        return new Date().toISOString().slice(0, 10);
      }
      function esc(s) {
        return String(s ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
      }
      async function fetchJSON(url) {
        const r = await fetch(url);
        if (!r.ok) throw new Error(`HTTP ${r.status}`);
        return r.json();
      }
      async function fetchPlaybook() {
        const market = document.getElementById('pb-market-select').value;
        const date = todayStr();
        document.getElementById('pb-date').textContent = date;
        const el = document.getElementById('playbook-content');
        try {
          const data = await fetchJSON(`/api/playbook/${date}?market=${market}`);
          const stocks = data.stock_playbooks ?? [];
          if (stocks.length === 0) {
            el.innerHTML = '<p class="empty-msg">오늘 플레이북 없음</p>';
            return;
          }
          el.innerHTML = stocks.map(sp =>
            `<details><summary>${esc(sp.stock_code ?? '?')} — ${esc(sp.signal ?? '')}</summary>` +
            `<pre>${esc(JSON.stringify(sp, null, 2))}</pre></details>`
          ).join('');
        } catch {
          el.innerHTML = '<p class="empty-msg">플레이북 없음 (오늘 미생성 또는 API 오류)</p>';
        }
      }
      async function fetchScorecard() {
        const market = document.getElementById('sc-market-select').value;
        const date = todayStr();
        document.getElementById('sc-date').textContent = date;
        const el = document.getElementById('scorecard-grid');
        try {
          const data = await fetchJSON(`/api/scorecard/${date}?market=${market}`);
          const sc = data.scorecard ?? {};
          const entries = Object.entries(sc);
          if (entries.length === 0) {
            el.innerHTML = '<p class="empty-msg">스코어카드 없음</p>';
            return;
          }
          el.className = 'scorecard-grid';
          el.innerHTML = entries.map(([k, v]) => `
            <div class="kpi-card">
              <div class="kpi-label">${esc(k)}</div>
              <div class="kpi-value">${typeof v === 'number' ? v.toFixed(2) : esc(String(v))}</div>
            </div>`).join('');
        } catch {
          el.innerHTML = '<p class="empty-msg">스코어카드 없음 (오늘 미생성 또는 API 오류)</p>';
        }
      }
      async function fetchScenarios() {
        const market = document.getElementById('scen-market-select').value;
        const date = todayStr();
        const el = document.getElementById('scenarios-content');
        try {
          const data = await fetchJSON(`/api/scenarios/active?market=${market}&date_str=${date}&limit=50`);
          const matches = data.matches ?? [];
          if (matches.length === 0) {
            el.innerHTML = '<p class="empty-msg">활성 시나리오 없음</p>';
            return;
          }
          el.innerHTML = `<table class="scenarios-table">
            <thead><tr><th>종목</th><th>신호</th><th>신뢰도</th><th>매칭 조건</th></tr></thead>
            <tbody>${matches.map(m => `
              <tr>
                <td>${esc(m.stock_code)}</td>
                <td>${esc(m.signal ?? '-')}</td>
                <td>${esc(m.confidence ?? '-')}</td>
                <td><code style="font-size:11px">${esc(JSON.stringify(m.scenario_match ?? {}))}</code></td>
              </tr>`).join('')}
            </tbody></table>`;
        } catch {
          el.innerHTML = '<p class="empty-msg">데이터 없음</p>';
        }
      }
      async function fetchContext() {
        const layer = document.getElementById('ctx-layer-select').value;
        const limit = Math.min(Math.max(parseInt(document.getElementById('ctx-limit').value, 10) || 20, 1), 200);
        const el = document.getElementById('context-content');
        try {
          const data = await fetchJSON(`/api/context/${layer}?limit=${limit}`);
          const entries = data.entries ?? [];
          if (entries.length === 0) {
            el.innerHTML = '<p class="empty-msg">컨텍스트 없음</p>';
            return;
          }
          el.innerHTML = `<table class="context-table">
            <thead><tr><th>timeframe</th><th>key</th><th>value</th><th>updated</th></tr></thead>
            <tbody>${entries.map(e => `
              <tr>
                <td>${esc(e.timeframe)}</td>
                <td>${esc(e.key)}</td>
                <td><div class="context-value">${esc(JSON.stringify(e.value ?? e.raw_value))}</div></td>
                <td style="font-size:11px;color:var(--muted)">${esc((e.updated_at ?? '').slice(0, 16))}</td>
              </tr>`).join('')}
            </tbody></table>`;
        } catch {
          el.innerHTML = '<p class="empty-msg">데이터 없음</p>';
        }
      }
      async function refreshAll() {
        document.getElementById('last-updated').textContent = '업데이트 중...';
        await Promise.all([
          fetchStatus(),
          fetchPerformance(),
          fetchPositions(),
          fetchPnlHistory(currentDays),
          fetchDecisions(currentMarket),
          fetchPlaybook(),
          fetchScorecard(),
          fetchScenarios(),
          fetchContext(),
        ]);
        const now = new Date();
        const timeStr = now.toLocaleTimeString('ko-KR', { hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false });
--- a/src/db.py
+++ b/src/db.py
@@ -14,11 +14,6 @@ def init_db(db_path: str) -> sqlite3.Connection:
    if db_path != ":memory:":
        Path(db_path).parent.mkdir(parents=True, exist_ok=True)
    conn = sqlite3.connect(db_path)
    # Enable WAL mode for concurrent read/write (dashboard + trading loop).
    # WAL does not apply to in-memory databases.
    if db_path != ":memory:":
        conn.execute("PRAGMA journal_mode=WAL")
        conn.execute("PRAGMA busy_timeout=5000")
    conn.execute(
        """
        CREATE TABLE IF NOT EXISTS trades (
@@ -33,13 +28,12 @@ def init_db(db_path: str) -> sqlite3.Connection:
            pnl REAL DEFAULT 0.0,
            market TEXT DEFAULT 'KR',
            exchange_code TEXT DEFAULT 'KRX',
-            decision_id TEXT,
+            decision_id TEXT
            mode TEXT DEFAULT 'paper'
        )
        """
    )
-    # Migration: Add columns if they don't exist (backward-compatible schema upgrades)
+    # Migration: Add market and exchange_code columns if they don't exist
    cursor = conn.execute("PRAGMA table_info(trades)")
    columns = {row[1] for row in cursor.fetchall()}
@@ -51,8 +45,6 @@ def init_db(db_path: str) -> sqlite3.Connection:
        conn.execute("ALTER TABLE trades ADD COLUMN selection_context TEXT")
    if "decision_id" not in columns:
        conn.execute("ALTER TABLE trades ADD COLUMN decision_id TEXT")
    if "mode" not in columns:
        conn.execute("ALTER TABLE trades ADD COLUMN mode TEXT DEFAULT 'paper'")
    # Context tree tables for multi-layered memory management
    conn.execute(
@@ -139,25 +131,6 @@ def init_db(db_path: str) -> sqlite3.Connection:
    conn.execute(
        "CREATE INDEX IF NOT EXISTS idx_decision_logs_confidence ON decision_logs(confidence)"
    )
    # Index for open-position queries (partition by stock_code, market, ordered by timestamp)
    conn.execute(
        "CREATE INDEX IF NOT EXISTS idx_trades_stock_market_ts"
        " ON trades (stock_code, market, timestamp DESC)"
    )
    # Lightweight key-value store for trading system runtime metrics (dashboard use only)
    # Intentionally separate from the AI context tree to preserve separation of concerns.
    conn.execute(
        """
        CREATE TABLE IF NOT EXISTS system_metrics (
            key        TEXT PRIMARY KEY,
            value      TEXT NOT NULL,
            updated_at TEXT NOT NULL
        )
        """
    )
    conn.commit()
    return conn
@@ -175,7 +148,6 @@ def log_trade(
    exchange_code: str = "KRX",
    selection_context: dict[str, any] | None = None,
    decision_id: str | None = None,
    mode: str = "paper",
 ) -> None:
    """Insert a trade record into the database.
@@ -191,8 +163,6 @@ def log_trade(
        market: Market code
        exchange_code: Exchange code
        selection_context: Scanner selection data (RSI, volume_ratio, signal, score)
        decision_id: Unique decision identifier for audit linking
        mode: Trading mode ('paper' or 'live') for data separation
    """
    # Serialize selection context to JSON
    context_json = json.dumps(selection_context) if selection_context else None
@@ -201,10 +171,9 @@ def log_trade(
        """
        INSERT INTO trades (
            timestamp, stock_code, action, confidence, rationale,
-            quantity, price, pnl, market, exchange_code, selection_context, decision_id,
+            quantity, price, pnl, market, exchange_code, selection_context, decision_id
            mode
        )
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        """,
        (
            datetime.now(UTC).isoformat(),
@@ -219,7 +188,6 @@ def log_trade(
            exchange_code,
            context_json,
            decision_id,
            mode,
        ),
    )
    conn.commit()
--- a/src/main.py
+++ b/src/main.py
@@ -42,7 +42,7 @@ from src.logging.decision_logger import DecisionLogger
 from src.logging_config import setup_logging
 from src.markets.schedule import MarketInfo, get_next_market_open, get_open_markets
 from src.notifications.telegram_client import NotificationFilter, TelegramClient, TelegramCommandHandler
-from src.strategy.models import DayPlaybook, MarketOutlook
+from src.strategy.models import DayPlaybook
 from src.strategy.playbook_store import PlaybookStore
 from src.strategy.pre_market_planner import PreMarketPlanner
 from src.strategy.scenario_engine import ScenarioEngine
@@ -81,54 +81,12 @@ def safe_float(value: str | float | None, default: float = 0.0) -> float:
 TRADE_INTERVAL_SECONDS = 60
 SCAN_INTERVAL_SECONDS = 60  # Scan markets every 60 seconds
 MAX_CONNECTION_RETRIES = 3
 _BUY_COOLDOWN_SECONDS = 600  # 10-minute cooldown after insufficient-balance rejection
 # Daily trading mode constants (for Free tier API efficiency)
 DAILY_TRADE_SESSIONS = 4  # Number of trading sessions per day
 TRADE_SESSION_INTERVAL_HOURS = 6  # Hours between sessions
 async def _retry_connection(coro_factory: Any, *args: Any, label: str = "", **kwargs: Any) -> Any:
    """Call an async function retrying on ConnectionError with exponential backoff.
    Retries up to MAX_CONNECTION_RETRIES times (exclusive of the first attempt),
    sleeping 2^attempt seconds between attempts.  Use only for idempotent read
    operations — never for order submission.
    Args:
        coro_factory: Async callable (method or function) to invoke.
        *args: Positional arguments forwarded to coro_factory.
        label: Human-readable label for log messages.
        **kwargs: Keyword arguments forwarded to coro_factory.
    Raises:
        ConnectionError: If all retries are exhausted.
    """
    for attempt in range(1, MAX_CONNECTION_RETRIES + 1):
        try:
            return await coro_factory(*args, **kwargs)
        except ConnectionError as exc:
            if attempt < MAX_CONNECTION_RETRIES:
                wait_secs = 2 ** attempt
                logger.warning(
                    "Connection error %s (attempt %d/%d), retrying in %ds: %s",
                    label,
                    attempt,
                    MAX_CONNECTION_RETRIES,
                    wait_secs,
                    exc,
                )
                await asyncio.sleep(wait_secs)
            else:
                logger.error(
                    "Connection error %s — all %d retries exhausted: %s",
                    label,
                    MAX_CONNECTION_RETRIES,
                    exc,
                )
                raise
 def _extract_symbol_from_holding(item: dict[str, Any]) -> str:
    """Extract symbol from overseas holding payload variants."""
    for key in (
@@ -148,82 +106,6 @@ def _extract_symbol_from_holding(item: dict[str, Any]) -> str:
    return ""
 def _extract_held_codes_from_balance(
    balance_data: dict[str, Any],
    *,
    is_domestic: bool,
 ) -> list[str]:
    """Return stock codes with a positive orderable quantity from a balance response.
    Uses the broker's live output1 as the source of truth so that partial fills
    and manual external trades are always reflected correctly.
    """
    output1 = balance_data.get("output1", [])
    if isinstance(output1, dict):
        output1 = [output1]
    if not isinstance(output1, list):
        return []
    codes: list[str] = []
    for holding in output1:
        if not isinstance(holding, dict):
            continue
        code_key = "pdno" if is_domestic else "ovrs_pdno"
        code = str(holding.get(code_key, "")).strip().upper()
        if not code:
            continue
        if is_domestic:
            qty = int(holding.get("ord_psbl_qty") or holding.get("hldg_qty") or 0)
        else:
            qty = int(holding.get("ovrs_cblc_qty") or holding.get("hldg_qty") or 0)
        if qty > 0:
            codes.append(code)
    return codes
 def _extract_held_qty_from_balance(
    balance_data: dict[str, Any],
    stock_code: str,
    *,
    is_domestic: bool,
 ) -> int:
    """Extract the broker-confirmed orderable quantity for a stock.
    Uses the broker's live balance response (output1) as the source of truth
    rather than the local DB, because DB records reflect order quantity which
    may differ from actual fill quantity due to partial fills.
    Domestic fields (VTTC8434R output1):
        pdno          — 종목코드
        ord_psbl_qty  — 주문가능수량 (preferred: excludes unsettled)
        hldg_qty      — 보유수량 (fallback)
    Overseas fields (output1):
        ovrs_pdno     — 종목코드
        ovrs_cblc_qty — 해외잔고수량 (preferred)
        hldg_qty      — 보유수량 (fallback)
    """
    output1 = balance_data.get("output1", [])
    if isinstance(output1, dict):
        output1 = [output1]
    if not isinstance(output1, list):
        return 0
    for holding in output1:
        if not isinstance(holding, dict):
            continue
        code_key = "pdno" if is_domestic else "ovrs_pdno"
        held_code = str(holding.get(code_key, "")).strip().upper()
        if held_code != stock_code.strip().upper():
            continue
        if is_domestic:
            qty = int(holding.get("ord_psbl_qty") or holding.get("hldg_qty") or 0)
        else:
            qty = int(holding.get("ovrs_cblc_qty") or holding.get("hldg_qty") or 0)
        return qty
    return 0
 def _determine_order_quantity(
    *,
    action: str,
@@ -231,40 +113,19 @@ def _determine_order_quantity(
    total_cash: float,
    candidate: ScanCandidate | None,
    settings: Settings | None,
-    broker_held_qty: int = 0,
+    open_position: dict[str, Any] | None = None,
    playbook_allocation_pct: float | None = None,
    scenario_confidence: int = 80,
 ) -> int:
-    """Determine order quantity using volatility-aware position sizing.
+    """Determine order quantity using volatility-aware position sizing."""
    Priority:
    1. playbook_allocation_pct (AI-specified) scaled by scenario_confidence
    2. Fallback: volatility-score-based allocation from scanner candidate
    """
    if action == "SELL":
-        return broker_held_qty
+        if open_position is None:
            return 0
        return int(open_position.get("quantity") or 0)
    if current_price <= 0 or total_cash <= 0:
        return 0
    if settings is None or not settings.POSITION_SIZING_ENABLED:
        return 1
    # Use AI-specified allocation_pct if available
    if playbook_allocation_pct is not None:
        # Confidence scaling: confidence 80 → 1.0x, confidence 95 → 1.19x
        confidence_scale = scenario_confidence / 80.0
        effective_pct = min(
            settings.POSITION_MAX_ALLOCATION_PCT,
            max(
                settings.POSITION_MIN_ALLOCATION_PCT,
                playbook_allocation_pct * confidence_scale,
            ),
        )
        budget = total_cash * (effective_pct / 100.0)
        quantity = int(budget // current_price)
        return max(0, quantity)
    # Fallback: volatility-score-based allocation
    target_score = max(1.0, settings.POSITION_VOLATILITY_TARGET_SCORE)
    observed_score = candidate.score if candidate else target_score
    observed_score = max(1.0, min(100.0, observed_score))
@@ -340,7 +201,6 @@ async def trading_cycle(
    stock_code: str,
    scan_candidates: dict[str, dict[str, ScanCandidate]],
    settings: Settings | None = None,
    buy_cooldown: dict[str, float] | None = None,
 ) -> None:
    """Execute one trading cycle for a single stock."""
    cycle_start_time = asyncio.get_event_loop().time()
@@ -381,13 +241,7 @@ async def trading_cycle(
        purchase_total = safe_float(balance_info.get("frcr_buy_amt_smtl", "0") or "0")
        # Paper mode fallback: VTS overseas balance API often fails for many accounts.
-        # Only activate in paper mode — live mode must use real balance from KIS.
+        if total_cash <= 0 and settings and settings.PAPER_OVERSEAS_CASH > 0:
        if (
            total_cash <= 0
            and settings
            and settings.MODE == "paper"
            and settings.PAPER_OVERSEAS_CASH > 0
        ):
            logger.debug(
                "Overseas cash balance is 0 for %s; using paper fallback %.2f USD",
                market.exchange_code,
@@ -477,17 +331,6 @@ async def trading_cycle(
            {"volume_ratio": candidate.volume_ratio},
        )
    # Write pnl_pct to system_metrics (dashboard-only table, separate from AI context tree)
    db_conn.execute(
        "INSERT OR REPLACE INTO system_metrics (key, value, updated_at) VALUES (?, ?, ?)",
        (
            f"portfolio_pnl_pct_{market.code}",
            json.dumps({"pnl_pct": round(pnl_pct, 4)}),
            datetime.now(UTC).isoformat(),
        ),
    )
    db_conn.commit()
    # Build portfolio data for global rule evaluation
    portfolio_data = {
        "portfolio_pnl_pct": pnl_pct,
@@ -540,61 +383,6 @@ async def trading_cycle(
    )
    stock_playbook = playbook.get_stock_playbook(stock_code)
    # 2.1. Apply market_outlook-based BUY confidence threshold
    if decision.action == "BUY":
        base_threshold = (settings.CONFIDENCE_THRESHOLD if settings else 80)
        outlook = playbook.market_outlook
        if outlook == MarketOutlook.BEARISH:
            min_confidence = 90
        elif outlook == MarketOutlook.BULLISH:
            min_confidence = 75
        else:
            min_confidence = base_threshold
        if match.confidence < min_confidence:
            logger.info(
                "BUY suppressed for %s (%s): confidence %d < %d (market_outlook=%s)",
                stock_code,
                market.name,
                match.confidence,
                min_confidence,
                outlook.value,
            )
            decision = TradeDecision(
                action="HOLD",
                confidence=match.confidence,
                rationale=(
                    f"BUY confidence {match.confidence} < {min_confidence} "
                    f"(market_outlook={outlook.value})"
                ),
            )
    # BUY 결정 전 기존 포지션 체크 (중복 매수 방지)
    if decision.action == "BUY":
        existing_position = get_open_position(db_conn, stock_code, market.code)
        if not existing_position and not market.is_domestic:
            # SELL 지정가 접수 후 미체결 시 DB는 종료로 기록되나 브로커는 여전히 보유 중.
            # 이중 매수 방지를 위해 라이브 브로커 잔고를 authoritative source로 사용.
            broker_qty = _extract_held_qty_from_balance(
                balance_data, stock_code, is_domestic=False
            )
            if broker_qty > 0:
                existing_position = {"price": 0.0, "quantity": broker_qty}
        if existing_position:
            decision = TradeDecision(
                action="HOLD",
                confidence=decision.confidence,
                rationale=(
                    f"Already holding {stock_code} "
                    f"(entry={existing_position['price']:.4f}, "
                    f"qty={existing_position['quantity']})"
                ),
            )
            logger.info(
                "BUY suppressed for %s (%s): already holding open position",
                stock_code,
                market.name,
            )
    if decision.action == "HOLD":
        open_position = get_open_position(db_conn, stock_code, market.code)
        if open_position:
@@ -602,10 +390,8 @@ async def trading_cycle(
            if entry_price > 0:
                loss_pct = (current_price - entry_price) / entry_price * 100
                stop_loss_threshold = -2.0
                take_profit_threshold = 3.0
                if stock_playbook and stock_playbook.scenarios:
                    stop_loss_threshold = stock_playbook.scenarios[0].stop_loss_pct
                    take_profit_threshold = stock_playbook.scenarios[0].take_profit_pct
                if loss_pct <= stop_loss_threshold:
                    decision = TradeDecision(
@@ -623,22 +409,6 @@ async def trading_cycle(
                        loss_pct,
                        stop_loss_threshold,
                    )
                elif loss_pct >= take_profit_threshold:
                    decision = TradeDecision(
                        action="SELL",
                        confidence=90,
                        rationale=(
                            f"Take-profit triggered ({loss_pct:.2f}% >= "
                            f"{take_profit_threshold:.2f}%)"
                        ),
                    )
                    logger.info(
                        "Take-profit override for %s (%s): %.2f%% >= %.2f%%",
                        stock_code,
                        market.name,
                        loss_pct,
                        take_profit_threshold,
                    )
    logger.info(
        "Decision for %s (%s): %s (confidence=%d)",
        stock_code,
@@ -699,23 +469,18 @@ async def trading_cycle(
    trade_price = current_price
    trade_pnl = 0.0
    if decision.action in ("BUY", "SELL"):
-        broker_held_qty = (
+        sell_position = (
-            _extract_held_qty_from_balance(
+            get_open_position(db_conn, stock_code, market.code)
                balance_data, stock_code, is_domestic=market.is_domestic
            )
            if decision.action == "SELL"
-            else 0
+            else None
        )
        matched_scenario = match.matched_scenario
        quantity = _determine_order_quantity(
            action=decision.action,
            current_price=current_price,
            total_cash=total_cash,
            candidate=candidate,
            settings=settings,
-            broker_held_qty=broker_held_qty,
+            open_position=sell_position,
            playbook_allocation_pct=matched_scenario.allocation_pct if matched_scenario else None,
            scenario_confidence=match.confidence,
        )
        if quantity <= 0:
            logger.info(
@@ -729,33 +494,13 @@ async def trading_cycle(
            return
        order_amount = current_price * quantity
-        # 4. Check BUY cooldown (set when a prior BUY failed due to insufficient balance)
+        # 4. Risk check BEFORE order
        if decision.action == "BUY" and buy_cooldown is not None:
            cooldown_key = f"{market.code}:{stock_code}"
            cooldown_until = buy_cooldown.get(cooldown_key, 0.0)
            now = asyncio.get_event_loop().time()
            if now < cooldown_until:
                remaining = int(cooldown_until - now)
                logger.info(
                    "Skip BUY %s (%s): insufficient-balance cooldown active (%ds remaining)",
                    stock_code,
                    market.name,
                    remaining,
                )
                return
        # 5a. Risk check BEFORE order
        # SELL orders do not consume cash (they receive it), so fat-finger check
        # is skipped for SELLs — only circuit breaker applies.
        try:
-            if decision.action == "SELL":
+            risk.validate_order(
-                risk.check_circuit_breaker(pnl_pct)
+                current_pnl_pct=pnl_pct,
-            else:
+                order_amount=order_amount,
-                risk.validate_order(
+                total_cash=total_cash,
-                    current_pnl_pct=pnl_pct,
+            )
                    order_amount=order_amount,
                    total_cash=total_cash,
                )
        except FatFingerRejected as exc:
            try:
                await telegram.notify_fat_finger(
@@ -797,24 +542,12 @@ async def trading_cycle(
            # Check if KIS rejected the order (rt_cd != "0")
            if result.get("rt_cd", "") != "0":
                order_succeeded = False
                msg1 = result.get("msg1") or ""
                logger.warning(
                    "Overseas order not accepted for %s: rt_cd=%s msg=%s",
                    stock_code,
                    result.get("rt_cd"),
-                    msg1,
+                    result.get("msg1"),
                )
                # Set BUY cooldown when the rejection is due to insufficient balance
                if decision.action == "BUY" and buy_cooldown is not None and "주문가능금액" in msg1:
                    cooldown_key = f"{market.code}:{stock_code}"
                    buy_cooldown[cooldown_key] = (
                        asyncio.get_event_loop().time() + _BUY_COOLDOWN_SECONDS
                    )
                    logger.info(
                        "BUY cooldown set for %s: %.0fs (insufficient balance)",
                        stock_code,
                        _BUY_COOLDOWN_SECONDS,
                    )
        logger.info("Order result: %s", result.get("msg1", "OK"))
        # 5.5. Notify trade execution (only on success)
@@ -869,7 +602,6 @@ async def trading_cycle(
        exchange_code=market.exchange_code,
        selection_context=selection_context,
        decision_id=decision_id,
        mode=settings.MODE if settings else "paper",
    )
    # 7. Latency monitoring
@@ -923,9 +655,6 @@ async def run_daily_session(
    logger.info("Starting daily trading session for %d markets", len(open_markets))
    # BUY cooldown: prevents retrying stocks rejected for insufficient balance
    daily_buy_cooldown: dict[str, float] = {}  # "{market_code}:{stock_code}" -> expiry timestamp
    # Process each open market
    for market in open_markets:
        # Use market-local date for playbook keying
@@ -1005,18 +734,11 @@ async def run_daily_session(
            try:
                if market.is_domestic:
                    current_price, price_change_pct, foreigner_net = (
-                        await _retry_connection(
+                        await broker.get_current_price(stock_code)
                            broker.get_current_price,
                            stock_code,
                            label=stock_code,
                        )
                    )
                else:
-                    price_data = await _retry_connection(
+                    price_data = await overseas_broker.get_overseas_price(
-                        overseas_broker.get_overseas_price,
+                        market.exchange_code, stock_code
                        market.exchange_code,
                        stock_code,
                        label=f"{stock_code}@{market.exchange_code}",
                    )
                    current_price = safe_float(
                        price_data.get("output", {}).get("last", "0")
@@ -1067,27 +789,9 @@ async def run_daily_session(
            logger.warning("No valid stock data for market %s", market.code)
            continue
-        # Get balance data once for the market (read-only — safe to retry)
+        # Get balance data once for the market
        try:
            if market.is_domestic:
                balance_data = await _retry_connection(
                    broker.get_balance, label=f"balance:{market.code}"
                )
            else:
                balance_data = await _retry_connection(
                    overseas_broker.get_overseas_balance,
                    market.exchange_code,
                    label=f"overseas_balance:{market.exchange_code}",
                )
        except ConnectionError as exc:
            logger.error(
                "Balance fetch failed for market %s after all retries — skipping market: %s",
                market.code,
                exc,
            )
            continue
        if market.is_domestic:
            balance_data = await broker.get_balance()
            output2 = balance_data.get("output2", [{}])
            total_eval = safe_float(
                output2[0].get("tot_evlu_amt", "0")
@@ -1099,6 +803,7 @@ async def run_daily_session(
                output2[0].get("pchs_amt_smtl_amt", "0")
            ) if output2 else 0
        else:
            balance_data = await overseas_broker.get_overseas_balance(market.exchange_code)
            output2 = balance_data.get("output2", [{}])
            if isinstance(output2, list) and output2:
                balance_info = output2[0]
@@ -1113,12 +818,11 @@ async def run_daily_session(
                balance_info.get("frcr_buy_amt_smtl", "0") or "0"
            )
            # Paper mode fallback: VTS overseas balance API often fails for many accounts.
-            # Only activate in paper mode — live mode must use real balance from KIS.
+            if total_cash <= 0 and settings.PAPER_OVERSEAS_CASH > 0:
-            if (
+                total_cash = settings.PAPER_OVERSEAS_CASH
-                total_cash <= 0
+
-                and settings.MODE == "paper"
+            # VTS overseas balance API often returns 0; use paper fallback.
-                and settings.PAPER_OVERSEAS_CASH > 0
+            if total_cash <= 0 and settings.PAPER_OVERSEAS_CASH > 0:
            ):
                total_cash = settings.PAPER_OVERSEAS_CASH
        # Calculate daily P&L %
@@ -1157,33 +861,6 @@ async def run_daily_session(
                decision.confidence,
            )
            # BUY 중복 방지: 브로커 잔고 기반 (미체결 SELL 리밋 주문 보호)
            if decision.action == "BUY":
                daily_existing = get_open_position(db_conn, stock_code, market.code)
                if not daily_existing and not market.is_domestic:
                    # SELL 지정가 접수 후 미체결 시 DB는 종료로 기록되나 브로커는 여전히 보유 중.
                    # 이중 매수 방지를 위해 라이브 브로커 잔고를 authoritative source로 사용.
                    broker_qty = _extract_held_qty_from_balance(
                        balance_data, stock_code, is_domestic=False
                    )
                    if broker_qty > 0:
                        daily_existing = {"price": 0.0, "quantity": broker_qty}
                if daily_existing:
                    decision = TradeDecision(
                        action="HOLD",
                        confidence=decision.confidence,
                        rationale=(
                            f"Already holding {stock_code} "
                            f"(entry={daily_existing['price']:.4f}, "
                            f"qty={daily_existing['quantity']})"
                        ),
                    )
                    logger.info(
                        "BUY suppressed for %s (%s): already holding open position",
                        stock_code,
                        market.name,
                    )
            # Log decision
            context_snapshot = {
                "L1": {
@@ -1223,12 +900,10 @@ async def run_daily_session(
            trade_pnl = 0.0
            order_succeeded = True
            if decision.action in ("BUY", "SELL"):
-                daily_broker_held_qty = (
+                daily_sell_position = (
-                    _extract_held_qty_from_balance(
+                    get_open_position(db_conn, stock_code, market.code)
                        balance_data, stock_code, is_domestic=market.is_domestic
                    )
                    if decision.action == "SELL"
-                    else 0
+                    else None
                )
                quantity = _determine_order_quantity(
                    action=decision.action,
@@ -1236,7 +911,7 @@ async def run_daily_session(
                    total_cash=total_cash,
                    candidate=candidate_map.get(stock_code),
                    settings=settings,
-                    broker_held_qty=daily_broker_held_qty,
+                    open_position=daily_sell_position,
                )
                if quantity <= 0:
                    logger.info(
@@ -1250,33 +925,13 @@ async def run_daily_session(
                    continue
                order_amount = stock_data["current_price"] * quantity
                # Check BUY cooldown (insufficient balance)
                if decision.action == "BUY":
                    daily_cooldown_key = f"{market.code}:{stock_code}"
                    daily_cooldown_until = daily_buy_cooldown.get(daily_cooldown_key, 0.0)
                    now = asyncio.get_event_loop().time()
                    if now < daily_cooldown_until:
                        remaining = int(daily_cooldown_until - now)
                        logger.info(
                            "Skip BUY %s (%s): insufficient-balance cooldown active (%ds remaining)",
                            stock_code,
                            market.name,
                            remaining,
                        )
                        continue
                # Risk check
                # SELL orders do not consume cash (they receive it), so fat-finger
                # check is skipped for SELLs — only circuit breaker applies.
                try:
-                    if decision.action == "SELL":
+                    risk.validate_order(
-                        risk.check_circuit_breaker(pnl_pct)
+                        current_pnl_pct=pnl_pct,
-                    else:
+                        order_amount=order_amount,
-                        risk.validate_order(
+                        total_cash=total_cash,
-                            current_pnl_pct=pnl_pct,
+                    )
                            order_amount=order_amount,
                            total_cash=total_cash,
                        )
                except FatFingerRejected as exc:
                    try:
                        await telegram.notify_fat_finger(
@@ -1326,23 +981,12 @@ async def run_daily_session(
                        )
                        if result.get("rt_cd", "") != "0":
                            order_succeeded = False
                            daily_msg1 = result.get("msg1") or ""
                            logger.warning(
                                "Overseas order not accepted for %s: rt_cd=%s msg=%s",
                                stock_code,
                                result.get("rt_cd"),
-                                daily_msg1,
+                                result.get("msg1"),
                            )
                            if decision.action == "BUY" and "주문가능금액" in daily_msg1:
                                daily_cooldown_key = f"{market.code}:{stock_code}"
                                daily_buy_cooldown[daily_cooldown_key] = (
                                    asyncio.get_event_loop().time() + _BUY_COOLDOWN_SECONDS
                                )
                                logger.info(
                                    "BUY cooldown set for %s: %.0fs (insufficient balance)",
                                    stock_code,
                                    _BUY_COOLDOWN_SECONDS,
                                )
                    logger.info("Order result: %s", result.get("msg1", "OK"))
                    # Notify trade execution (only on success)
@@ -1391,7 +1035,6 @@ async def run_daily_session(
                market=market.code,
                exchange_code=market.exchange_code,
                decision_id=decision_id,
                mode=settings.MODE,
            )
    logger.info("Daily trading session completed")
@@ -1507,18 +1150,10 @@ def _start_dashboard_server(settings: Settings) -> threading.Thread | None:
    if not settings.DASHBOARD_ENABLED:
        return None
    # Validate dependencies before spawning the thread so startup failures are
    # reported synchronously (avoids the misleading "started" → "failed" log pair).
    try:
        import uvicorn  # noqa: F401
        from src.dashboard import create_dashboard_app  # noqa: F401
    except ImportError as exc:
        logger.warning("Dashboard server unavailable (missing dependency): %s", exc)
        return None
    def _serve() -> None:
        try:
            import uvicorn
            from src.dashboard import create_dashboard_app
            app = create_dashboard_app(settings.DB_PATH)
@@ -1529,7 +1164,7 @@ def _start_dashboard_server(settings: Settings) -> threading.Thread | None:
                log_level="info",
            )
        except Exception as exc:
-            logger.warning("Dashboard server stopped unexpectedly: %s", exc)
+            logger.warning("Dashboard server failed to start: %s", exc)
    thread = threading.Thread(
        target=_serve,
@@ -1970,9 +1605,6 @@ async def run(settings: Settings) -> None:
    # Active stocks per market (dynamically discovered by scanner)
    active_stocks: dict[str, list[str]] = {}  # market_code -> [stock_codes]
    # BUY cooldown: prevents retrying a stock rejected for insufficient balance
    buy_cooldown: dict[str, float] = {}  # "{market_code}:{stock_code}" -> expiry timestamp
    # Initialize latency control system
    criticality_assessor = CriticalityAssessor(
        critical_pnl_threshold=-2.5,  # Near circuit breaker at -3.0%
@@ -2053,10 +1685,6 @@ async def run(settings: Settings) -> None:
                    )
                except CircuitBreakerTripped:
                    logger.critical("Circuit breaker tripped — shutting down")
                    await telegram.notify_circuit_breaker(
                        pnl_pct=settings.CIRCUIT_BREAKER_PCT,
                        threshold=settings.CIRCUIT_BREAKER_PCT,
                    )
                    shutdown.set()
                    break
                except Exception as exc:
@@ -2250,38 +1878,8 @@ async def run(settings: Settings) -> None:
                        except Exception as exc:
                            logger.error("Smart Scanner failed for %s: %s", market.name, exc)
-                    # Get active stocks from scanner (dynamic, no static fallback).
+                    # Get active stocks from scanner (dynamic, no static fallback)
-                    # Also include currently-held positions so stop-loss /
+                    stock_codes = active_stocks.get(market.code, [])
                    # take-profit can fire even when a holding drops off the
                    # scanner.  Broker balance is the source of truth here —
                    # unlike the local DB it reflects actual fills and any
                    # manual trades done outside the bot.
                    scanner_codes = active_stocks.get(market.code, [])
                    try:
                        if market.is_domestic:
                            held_balance = await broker.get_balance()
                        else:
                            held_balance = await overseas_broker.get_overseas_balance(
                                market.exchange_code
                            )
                        held_codes = _extract_held_codes_from_balance(
                            held_balance, is_domestic=market.is_domestic
                        )
                    except Exception as exc:
                        logger.warning(
                            "Failed to fetch holdings for %s: %s — skipping holdings merge",
                            market.name, exc,
                        )
                        held_codes = []
                    stock_codes = list(dict.fromkeys(scanner_codes + held_codes))
                    extra_held = [c for c in held_codes if c not in set(scanner_codes)]
                    if extra_held:
                        logger.info(
                            "Holdings added to loop for %s (not in scanner): %s",
                            market.name, extra_held,
                        )
                    if not stock_codes:
                        logger.debug("No active stocks for market %s", market.code)
                        continue
@@ -2319,7 +1917,6 @@ async def run(settings: Settings) -> None:
                                    stock_code,
                                    scan_candidates,
                                    settings,
                                    buy_cooldown,
                                )
                                break  # Success — exit retry loop
                            except CircuitBreakerTripped as exc:
@@ -2374,8 +1971,6 @@ async def run(settings: Settings) -> None:
                except TimeoutError:
                    pass  # Normal — timeout means it's time for next cycle
    finally:
        # Notify shutdown before closing resources
        await telegram.notify_system_shutdown("Normal shutdown")
        # Clean up resources
        await command_handler.stop_polling()
        await broker.close()
--- a/src/notifications/telegram_client.py
+++ b/src/notifications/telegram_client.py
@@ -604,19 +604,9 @@ class TelegramCommandHandler:
            async with session.post(url, json=payload) as resp:
                if resp.status != 200:
                    error_text = await resp.text()
-                    if resp.status == 409:
+                    logger.error(
-                        # Another bot instance is already polling — stop this poller entirely.
+                        "getUpdates API error (status=%d): %s", resp.status, error_text
-                        # Retrying would keep conflicting with the other instance.
+                    )
                        self._running = False
                        logger.warning(
                            "Telegram conflict (409): another instance is already polling. "
                            "Disabling Telegram commands for this process. "
                            "Ensure only one instance of The Ouroboros is running at a time.",
                        )
                    else:
                        logger.error(
                            "getUpdates API error (status=%d): %s", resp.status, error_text
                        )
                    return []
                data = await resp.json()
--- a/src/strategies/v20260220_210124_evolved.py
+++ b/src/strategies/v20260220_210124_evolved.py
@@ -1,114 +0,0 @@
 """Auto-generated strategy: v20260220_210124
 Generated at: 2026-02-20T21:01:24.706847+00:00
 Rationale: Auto-evolved from 6 failures. Primary failure markets: ['US_AMEX', 'US_NYSE', 'US_NASDAQ']. Average loss: -194.69
 """
 from __future__ import annotations
 from typing import Any
 from src.strategies.base import BaseStrategy
 class Strategy_v20260220_210124(BaseStrategy):
    """Strategy: v20260220_210124"""
    def evaluate(self, market_data: dict[str, Any]) -> dict[str, Any]:
        import datetime
        # --- Strategy Constants ---
        # Minimum price for a stock to be considered for trading (avoids penny stocks)
        MIN_PRICE = 5.0
        # Momentum signal thresholds (stricter than previous failures)
        MOMENTUM_PRICE_CHANGE_THRESHOLD = 7.0  # % price change
        MOMENTUM_VOLUME_RATIO_THRESHOLD = 4.0  # X times average volume
        # Oversold signal thresholds (more conservative)
        OVERSOLD_RSI_THRESHOLD = 25.0  # RSI value (lower means more oversold)
        # Confidence levels
        CONFIDENCE_HOLD = 30
        CONFIDENCE_BUY_OVERSOLD = 65
        CONFIDENCE_BUY_MOMENTUM = 85
        CONFIDENCE_BUY_STRONG_MOMENTUM = 90  # For higher-priced stocks with strong momentum
        # Market hours in UTC (9:30 AM ET to 4:00 PM ET)
        MARKET_OPEN_UTC = datetime.time(14, 30)
        MARKET_CLOSE_UTC = datetime.time(21, 0)
        # Volatile periods within market hours (UTC) to avoid
        # First hour after open (14:30 UTC - 15:30 UTC)
        VOLATILE_OPEN_END_UTC = datetime.time(15, 30)
        # Last 30 minutes before close (20:30 UTC - 21:00 UTC)
        VOLATILE_CLOSE_START_UTC = datetime.time(20, 30)
        current_price = market_data.get('current_price')
        price_change_pct = market_data.get('price_change_pct')
        volume_ratio = market_data.get('volume_ratio')  # Assumed pre-computed indicator
        rsi = market_data.get('rsi')                    # Assumed pre-computed indicator
        timestamp_str = market_data.get('timestamp')
        action = "HOLD"
        confidence = CONFIDENCE_HOLD
        rationale = "Initial HOLD: No clear signal or conditions not met."
        # --- 1. Basic Data Validation ---
        if current_price is None or price_change_pct is None:
            return {"action": "HOLD", "confidence": CONFIDENCE_HOLD,
                    "rationale": "Insufficient core data (price or price change) to evaluate."}
        # --- 2. Price Filter: Avoid low-priced/penny stocks ---
        if current_price < MIN_PRICE:
            return {"action": "HOLD", "confidence": CONFIDENCE_HOLD,
                    "rationale": f"Avoiding low-priced stock (${current_price:.2f} < ${MIN_PRICE:.2f})."}
        # --- 3. Time Filter: Only trade during core market hours ---
        if timestamp_str:
            try:
                dt_object = datetime.datetime.fromisoformat(timestamp_str)
                current_time_utc = dt_object.time()
                if not (MARKET_OPEN_UTC <= current_time_utc < MARKET_CLOSE_UTC):
                    return {"action": "HOLD", "confidence": CONFIDENCE_HOLD,
                            "rationale": f"Avoiding trade outside core market hours ({current_time_utc} UTC)."}
                if (MARKET_OPEN_UTC <= current_time_utc < VOLATILE_OPEN_END_UTC) or \
                   (VOLATILE_CLOSE_START_UTC <= current_time_utc < MARKET_CLOSE_UTC):
                    return {"action": "HOLD", "confidence": CONFIDENCE_HOLD,
                            "rationale": f"Avoiding trade during volatile market open/close periods ({current_time_utc} UTC)."}
            except ValueError:
                rationale += " (Warning: Malformed timestamp, time filters skipped)"
        # --- Initialize signal states ---
        has_momentum_buy_signal = False
        has_oversold_buy_signal = False
        # --- 4. Evaluate Enhanced Buy Signals ---
        # Momentum Buy Signal
        if volume_ratio is not None and \
           price_change_pct > MOMENTUM_PRICE_CHANGE_THRESHOLD and \
           volume_ratio > MOMENTUM_VOLUME_RATIO_THRESHOLD:
            has_momentum_buy_signal = True
            rationale = f"Momentum BUY: Price change {price_change_pct:.2f}%, Volume {volume_ratio:.2f}x."
            confidence = CONFIDENCE_BUY_MOMENTUM
            if current_price >= 10.0:
                confidence = CONFIDENCE_BUY_STRONG_MOMENTUM
        # Oversold Buy Signal
        if rsi is not None and rsi < OVERSOLD_RSI_THRESHOLD:
            has_oversold_buy_signal = True
            if not has_momentum_buy_signal:
                rationale = f"Oversold BUY: RSI {rsi:.2f}."
                confidence = CONFIDENCE_BUY_OVERSOLD
                if current_price >= 10.0:
                    confidence = min(CONFIDENCE_BUY_OVERSOLD + 5, 80)
        # --- 5. Decision Logic ---
        if has_momentum_buy_signal:
            action = "BUY"
        elif has_oversold_buy_signal:
            action = "BUY"
        return {"action": action, "confidence": confidence, "rationale": rationale}
--- a/src/strategies/v20260220_210159_evolved.py
+++ b/src/strategies/v20260220_210159_evolved.py
@@ -1,97 +0,0 @@
 """Auto-generated strategy: v20260220_210159
 Generated at: 2026-02-20T21:01:59.391523+00:00
 Rationale: Auto-evolved from 6 failures. Primary failure markets: ['US_AMEX', 'US_NYSE', 'US_NASDAQ']. Average loss: -194.69
 """
 from __future__ import annotations
 from typing import Any
 from src.strategies.base import BaseStrategy
 class Strategy_v20260220_210159(BaseStrategy):
    """Strategy: v20260220_210159"""
    def evaluate(self, market_data: dict[str, Any]) -> dict[str, Any]:
        import datetime
        current_price = market_data.get('current_price')
        price_change_pct = market_data.get('price_change_pct')
        volume_ratio = market_data.get('volume_ratio')
        rsi = market_data.get('rsi')
        timestamp_str = market_data.get('timestamp')
        market_name = market_data.get('market')
        # Default action
        action = "HOLD"
        confidence = 0
        rationale = "No strong signal or conditions not met."
        # --- FAILURE PATTERN AVOIDANCE ---
        # 1. Avoid low-priced/penny stocks
        MIN_PRICE_THRESHOLD = 5.0  # USD
        if current_price is not None and current_price < MIN_PRICE_THRESHOLD:
            rationale = (
                f"HOLD: Stock price (${current_price:.2f}) is below minimum threshold "
                f"(${MIN_PRICE_THRESHOLD:.2f}). Past failures consistently involved low-priced stocks."
            )
            return {"action": action, "confidence": confidence, "rationale": rationale}
        # 2. Avoid early market hour volatility
        if timestamp_str:
            try:
                dt_obj = datetime.datetime.fromisoformat(timestamp_str)
                utc_hour = dt_obj.hour
                utc_minute = dt_obj.minute
                if (utc_hour == 14 and utc_minute < 45) or (utc_hour == 13 and utc_minute >= 30):
                    rationale = (
                        f"HOLD: Trading during early market hours (UTC {utc_hour}:{utc_minute}), "
                        f"a period identified with past failures due to high volatility."
                    )
                    return {"action": action, "confidence": confidence, "rationale": rationale}
            except ValueError:
                pass
        # --- IMPROVED BUY STRATEGY ---
        # Momentum BUY signal
        if volume_ratio is not None and price_change_pct is not None:
            if price_change_pct > 7.0 and volume_ratio > 3.0:
                action = "BUY"
                confidence = 70
                rationale = "Improved BUY: Momentum signal with high volume and above price threshold."
                if market_name == 'US_AMEX':
                    confidence = max(55, confidence - 5)
                    rationale += " (Adjusted lower for AMEX market's higher risk profile)."
                elif market_name == 'US_NASDAQ' and price_change_pct > 20:
                    confidence = max(50, confidence - 10)
                    rationale += " (Adjusted lower for aggressive NASDAQ momentum volatility)."
                if price_change_pct > 15.0:
                    confidence = max(50, confidence - 5)
                    rationale += " (Caution: Very high daily price change, potential for reversal)."
                return {"action": action, "confidence": confidence, "rationale": rationale}
        # Oversold BUY signal
        if rsi is not None and price_change_pct is not None:
            if rsi < 30 and price_change_pct < -3.0:
                action = "BUY"
                confidence = 65
                rationale = "Improved BUY: Oversold signal with recent decline and above price threshold."
                if market_name == 'US_AMEX':
                    confidence = max(50, confidence - 5)
                    rationale += " (Adjusted lower for AMEX market's higher risk on oversold assets)."
                if price_change_pct < -10.0:
                    confidence = max(45, confidence - 10)
                    rationale += " (Caution: Very steep decline, potential falling knife)."
                return {"action": action, "confidence": confidence, "rationale": rationale}
        # If no specific BUY signal, default to HOLD
        return {"action": action, "confidence": confidence, "rationale": rationale}
--- a/src/strategies/v20260220_210244_evolved.py
+++ b/src/strategies/v20260220_210244_evolved.py
@@ -1,88 +0,0 @@
 """Auto-generated strategy: v20260220_210244
 Generated at: 2026-02-20T21:02:44.387355+00:00
 Rationale: Auto-evolved from 6 failures. Primary failure markets: ['US_AMEX', 'US_NYSE', 'US_NASDAQ']. Average loss: -194.69
 """
 from __future__ import annotations
 from typing import Any
 from src.strategies.base import BaseStrategy
 class Strategy_v20260220_210244(BaseStrategy):
    """Strategy: v20260220_210244"""
    def evaluate(self, market_data: dict[str, Any]) -> dict[str, Any]:
        from datetime import datetime
        # Extract required data points safely
        current_price = market_data.get("current_price")
        price_change_pct = market_data.get("price_change_pct")
        volume_ratio = market_data.get("volume_ratio")
        rsi = market_data.get("rsi")
        timestamp_str = market_data.get("timestamp")
        market_name = market_data.get("market")
        stock_code = market_data.get("stock_code", "UNKNOWN")
        # Default action is HOLD with conservative confidence and rationale
        action = "HOLD"
        confidence = 50
        rationale = f"No strong BUY signal for {stock_code} or awaiting more favorable conditions after avoiding known failure patterns."
        # --- 1. Failure Pattern Avoidance Filters ---
        # A. Avoid low-priced (penny) stocks
        if current_price is not None and current_price < 5.0:
            return {
                "action": "HOLD",
                "confidence": 50,
                "rationale": f"AVOID {stock_code}: Stock price (${current_price:.2f}) is below minimum threshold ($5.00) for BUY action. Identified past failures on highly volatile, low-priced stocks."
            }
        # B. Avoid initiating BUY trades during identified high-volatility hours
        if timestamp_str:
            try:
                trade_hour = datetime.fromisoformat(timestamp_str).hour
                if trade_hour in [14, 20]:
                    return {
                        "action": "HOLD",
                        "confidence": 50,
                        "rationale": f"AVOID {stock_code}: Trading during historically volatile hour ({trade_hour} UTC) where previous BUYs resulted in losses. Prefer to observe market stability."
                    }
            except ValueError:
                pass
        # C. Be cautious with extreme momentum spikes
        if volume_ratio is not None and price_change_pct is not None:
            if volume_ratio >= 9.0 and price_change_pct >= 15.0:
                return {
                    "action": "HOLD",
                    "confidence": 50,
                    "rationale": f"AVOID {stock_code}: Extreme short-term momentum detected (price change: +{price_change_pct:.2f}%, volume ratio: {volume_ratio:.1f}x). Historical failures indicate buying into such rapid spikes often leads to reversals."
                }
        # D. Be cautious with "oversold" signals without further confirmation
        if rsi is not None and rsi < 30:
            return {
                "action": "HOLD",
                "confidence": 50,
                "rationale": f"AVOID {stock_code}: Oversold signal (RSI={rsi:.1f}) detected. While often a BUY signal, historical failures on similar 'oversold' trades suggest waiting for stronger confirmation."
            }
        # --- 2. Improved BUY Signal Generation ---
        if volume_ratio is not None and 2.0 <= volume_ratio < 9.0 and \
           price_change_pct is not None and 2.0 <= price_change_pct < 15.0:
            action = "BUY"
            confidence = 70
            rationale = f"BUY {stock_code}: Moderate momentum detected (price change: +{price_change_pct:.2f}%, volume ratio: {volume_ratio:.1f}x). Passed filters for price and extreme momentum, avoiding past failure patterns."
            if market_name in ["US_AMEX", "US_NASDAQ"]:
                confidence = max(60, confidence - 5)
                rationale += f" Adjusted confidence for {market_name} market characteristics."
            elif market_name == "US_NYSE":
                confidence = max(65, confidence)
            confidence = max(50, min(85, confidence))
        return {"action": action, "confidence": confidence, "rationale": rationale}
--- a/src/strategy/models.py
+++ b/src/strategy/models.py
@@ -46,18 +46,6 @@ class StockCondition(BaseModel):
    The ScenarioEngine evaluates all non-None fields as AND conditions.
    A condition matches only if ALL specified fields are satisfied.
    Technical indicator fields:
        rsi_below / rsi_above — RSI threshold
        volume_ratio_above / volume_ratio_below — volume vs previous day
        price_above / price_below — absolute price level
        price_change_pct_above / price_change_pct_below — intraday % change
    Position-aware fields (require market_data enrichment from open position):
        unrealized_pnl_pct_above — matches if unrealized P&L > threshold (e.g. 3.0 → +3%)
        unrealized_pnl_pct_below — matches if unrealized P&L < threshold (e.g. -2.0 → -2%)
        holding_days_above — matches if position held for more than N days
        holding_days_below — matches if position held for fewer than N days
    """
    rsi_below: float | None = None
@@ -68,10 +56,6 @@ class StockCondition(BaseModel):
    price_below: float | None = None
    price_change_pct_above: float | None = None
    price_change_pct_below: float | None = None
    unrealized_pnl_pct_above: float | None = None
    unrealized_pnl_pct_below: float | None = None
    holding_days_above: int | None = None
    holding_days_below: int | None = None
    def has_any_condition(self) -> bool:
        """Check if at least one condition field is set."""
@@ -86,10 +70,6 @@ class StockCondition(BaseModel):
                self.price_below,
                self.price_change_pct_above,
                self.price_change_pct_below,
                self.unrealized_pnl_pct_above,
                self.unrealized_pnl_pct_below,
                self.holding_days_above,
                self.holding_days_below,
            )
        )
--- a/src/strategy/pre_market_planner.py
+++ b/src/strategy/pre_market_planner.py
@@ -75,7 +75,6 @@ class PreMarketPlanner:
        market: str,
        candidates: list[ScanCandidate],
        today: date | None = None,
        current_holdings: list[dict] | None = None,
    ) -> DayPlaybook:
        """Generate a DayPlaybook for a market using Gemini.
@@ -83,10 +82,6 @@ class PreMarketPlanner:
            market: Market code ("KR" or "US")
            candidates: Stock candidates from SmartVolatilityScanner
            today: Override date (defaults to date.today()). Use market-local date.
            current_holdings: Currently held positions with entry_price and unrealized_pnl_pct.
                Each dict: {"stock_code": str, "name": str, "qty": int,
                            "entry_price": float, "unrealized_pnl_pct": float,
                            "holding_days": int}
        Returns:
            DayPlaybook with scenarios. Empty/defensive if no candidates or failure.
@@ -111,7 +106,6 @@ class PreMarketPlanner:
                context_data,
                self_market_scorecard,
                cross_market,
                current_holdings=current_holdings,
            )
            # 3. Call Gemini
@@ -124,8 +118,7 @@ class PreMarketPlanner:
            # 4. Parse response
            playbook = self._parse_response(
-                decision.rationale, today, market, candidates, cross_market,
+                decision.rationale, today, market, candidates, cross_market
                current_holdings=current_holdings,
            )
            playbook_with_tokens = playbook.model_copy(
                update={"token_count": decision.token_count}
@@ -237,7 +230,6 @@ class PreMarketPlanner:
        context_data: dict[str, Any],
        self_market_scorecard: dict[str, Any] | None,
        cross_market: CrossMarketContext | None,
        current_holdings: list[dict] | None = None,
    ) -> str:
        """Build a structured prompt for Gemini to generate scenario JSON."""
        max_scenarios = self._settings.MAX_SCENARIOS_PER_STOCK
@@ -249,26 +241,6 @@ class PreMarketPlanner:
            for c in candidates
        )
        holdings_text = ""
        if current_holdings:
            lines = []
            for h in current_holdings:
                code = h.get("stock_code", "")
                name = h.get("name", "")
                qty = h.get("qty", 0)
                entry_price = h.get("entry_price", 0.0)
                pnl_pct = h.get("unrealized_pnl_pct", 0.0)
                holding_days = h.get("holding_days", 0)
                lines.append(
                    f"  - {code} ({name}): {qty}주 @ {entry_price:,.0f}, "
                    f"미실현손익 {pnl_pct:+.2f}%, 보유 {holding_days}일"
                )
            holdings_text = (
                "\n## Current Holdings (보유 중 — SELL/HOLD 전략 고려 필요)\n"
                + "\n".join(lines)
                + "\n"
            )
        cross_market_text = ""
        if cross_market:
            cross_market_text = (
@@ -301,20 +273,10 @@ class PreMarketPlanner:
                    for key, value in list(layer_data.items())[:5]:
                        context_text += f"  - {key}: {value}\n"
        holdings_instruction = ""
        if current_holdings:
            holding_codes = [h.get("stock_code", "") for h in current_holdings]
            holdings_instruction = (
                f"- Also include SELL/HOLD scenarios for held stocks: "
                f"{', '.join(holding_codes)} "
                f"(even if not in candidates list)\n"
            )
        return (
            f"You are a pre-market trading strategist for the {market} market.\n"
            f"Generate structured trading scenarios for today.\n\n"
            f"## Candidates (from volatility scanner)\n{candidates_text}\n"
            f"{holdings_text}"
            f"{self_market_text}"
            f"{cross_market_text}"
            f"{context_text}\n"
@@ -332,8 +294,7 @@ class PreMarketPlanner:
            f'      "stock_code": "...",\n'
            f'      "scenarios": [\n'
            f'        {{\n'
-            f'          "condition": {{"rsi_below": 30, "volume_ratio_above": 2.0,'
+            f'          "condition": {{"rsi_below": 30, "volume_ratio_above": 2.0}},\n'
            f' "unrealized_pnl_pct_above": 3.0, "holding_days_above": 5}},\n'
            f'          "action": "BUY|SELL|HOLD",\n'
            f'          "confidence": 85,\n'
            f'          "allocation_pct": 10.0,\n'
@@ -347,8 +308,7 @@ class PreMarketPlanner:
            f'}}\n\n'
            f"Rules:\n"
            f"- Max {max_scenarios} scenarios per stock\n"
-            f"- Candidates list is the primary source for BUY candidates\n"
+            f"- Only use stocks from the candidates list\n"
            f"{holdings_instruction}"
            f"- Confidence 0-100 (80+ for actionable trades)\n"
            f"- stop_loss_pct must be <= 0, take_profit_pct must be >= 0\n"
            f"- Return ONLY the JSON, no markdown fences or explanation\n"
@@ -361,19 +321,12 @@ class PreMarketPlanner:
        market: str,
        candidates: list[ScanCandidate],
        cross_market: CrossMarketContext | None,
        current_holdings: list[dict] | None = None,
    ) -> DayPlaybook:
        """Parse Gemini's JSON response into a validated DayPlaybook."""
        cleaned = self._extract_json(response_text)
        data = json.loads(cleaned)
        valid_codes = {c.stock_code for c in candidates}
        # Holdings are also valid — AI may generate SELL/HOLD scenarios for them
        if current_holdings:
            for h in current_holdings:
                code = h.get("stock_code", "")
                if code:
                    valid_codes.add(code)
        # Parse market outlook
        outlook_str = data.get("market_outlook", "neutral")
@@ -437,10 +390,6 @@ class PreMarketPlanner:
                price_below=cond_data.get("price_below"),
                price_change_pct_above=cond_data.get("price_change_pct_above"),
                price_change_pct_below=cond_data.get("price_change_pct_below"),
                unrealized_pnl_pct_above=cond_data.get("unrealized_pnl_pct_above"),
                unrealized_pnl_pct_below=cond_data.get("unrealized_pnl_pct_below"),
                holding_days_above=cond_data.get("holding_days_above"),
                holding_days_below=cond_data.get("holding_days_below"),
            )
            if not condition.has_any_condition():
--- a/src/strategy/scenario_engine.py
+++ b/src/strategy/scenario_engine.py
@@ -206,37 +206,6 @@ class ScenarioEngine:
        if condition.price_change_pct_below is not None:
            checks.append(price_change_pct is not None and price_change_pct < condition.price_change_pct_below)
        # Position-aware conditions
        unrealized_pnl_pct = self._safe_float(market_data.get("unrealized_pnl_pct"))
        if condition.unrealized_pnl_pct_above is not None or condition.unrealized_pnl_pct_below is not None:
            if "unrealized_pnl_pct" not in market_data:
                self._warn_missing_key("unrealized_pnl_pct")
        if condition.unrealized_pnl_pct_above is not None:
            checks.append(
                unrealized_pnl_pct is not None
                and unrealized_pnl_pct > condition.unrealized_pnl_pct_above
            )
        if condition.unrealized_pnl_pct_below is not None:
            checks.append(
                unrealized_pnl_pct is not None
                and unrealized_pnl_pct < condition.unrealized_pnl_pct_below
            )
        holding_days = self._safe_float(market_data.get("holding_days"))
        if condition.holding_days_above is not None or condition.holding_days_below is not None:
            if "holding_days" not in market_data:
                self._warn_missing_key("holding_days")
        if condition.holding_days_above is not None:
            checks.append(
                holding_days is not None
                and holding_days > condition.holding_days_above
            )
        if condition.holding_days_below is not None:
            checks.append(
                holding_days is not None
                and holding_days < condition.holding_days_below
            )
        return len(checks) > 0 and all(checks)
    def _evaluate_global_condition(
@@ -297,9 +266,5 @@ class ScenarioEngine:
            details["current_price"] = self._safe_float(market_data.get("current_price"))
        if condition.price_change_pct_above is not None or condition.price_change_pct_below is not None:
            details["price_change_pct"] = self._safe_float(market_data.get("price_change_pct"))
        if condition.unrealized_pnl_pct_above is not None or condition.unrealized_pnl_pct_below is not None:
            details["unrealized_pnl_pct"] = self._safe_float(market_data.get("unrealized_pnl_pct"))
        if condition.holding_days_above is not None or condition.holding_days_below is not None:
            details["holding_days"] = self._safe_float(market_data.get("holding_days"))
        return details
--- a/tests/test_backup.py
+++ b/tests/test_backup.py
@@ -3,11 +3,9 @@
 from __future__ import annotations
 import sqlite3
 import sys
 import tempfile
 from datetime import UTC, datetime, timedelta
 from pathlib import Path
 from unittest.mock import MagicMock, patch
 import pytest
@@ -365,435 +363,3 @@ class TestHealthMonitor:
        assert "timestamp" in report
        assert "checks" in report
        assert len(report["checks"]) == 3
 # ---------------------------------------------------------------------------
 # BackupExporter — additional coverage for previously uncovered branches
 # ---------------------------------------------------------------------------
@pytest.fixture
 def empty_db(tmp_path: Path) -> Path:
    """Create a temporary database with NO trade records."""
    db_path = tmp_path / "empty_trades.db"
    conn = sqlite3.connect(str(db_path))
    conn.execute(
        """CREATE TABLE trades (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            timestamp TEXT NOT NULL,
            stock_code TEXT NOT NULL,
            action TEXT NOT NULL,
            quantity INTEGER NOT NULL,
            price REAL NOT NULL,
            confidence INTEGER NOT NULL,
            rationale TEXT,
            pnl REAL DEFAULT 0.0
        )"""
    )
    conn.commit()
    conn.close()
    return db_path
 class TestBackupExporterAdditional:
    """Cover branches missed in the original TestBackupExporter suite."""
    def test_export_all_default_formats(self, temp_db: Path, tmp_path: Path) -> None:
        """export_all with formats=None must default to JSON+CSV+Parquet path."""
        exporter = BackupExporter(str(temp_db))
        # formats=None triggers the default list assignment (line 62)
        results = exporter.export_all(tmp_path / "out", formats=None, compress=False)
        # JSON and CSV must always succeed; Parquet needs pyarrow
        assert ExportFormat.JSON in results
        assert ExportFormat.CSV in results
    def test_export_all_logs_error_on_failure(
        self, temp_db: Path, tmp_path: Path
    ) -> None:
        """export_all must log an error and continue when one format fails."""
        exporter = BackupExporter(str(temp_db))
        # Patch _export_format to raise on JSON, succeed on CSV
        original = exporter._export_format
        def failing_export(fmt, *args, **kwargs):  # type: ignore[no-untyped-def]
            if fmt == ExportFormat.JSON:
                raise RuntimeError("simulated failure")
            return original(fmt, *args, **kwargs)
        exporter._export_format = failing_export  # type: ignore[method-assign]
        results = exporter.export_all(
            tmp_path / "out",
            formats=[ExportFormat.JSON, ExportFormat.CSV],
            compress=False,
        )
        # JSON failed → not in results; CSV succeeded → in results
        assert ExportFormat.JSON not in results
        assert ExportFormat.CSV in results
    def test_export_csv_empty_trades_no_compress(
        self, empty_db: Path, tmp_path: Path
    ) -> None:
        """CSV export with no trades and compress=False must write header row only."""
        exporter = BackupExporter(str(empty_db))
        results = exporter.export_all(
            tmp_path / "out",
            formats=[ExportFormat.CSV],
            compress=False,
        )
        assert ExportFormat.CSV in results
        out = results[ExportFormat.CSV]
        assert out.exists()
        content = out.read_text()
        assert "timestamp" in content
    def test_export_csv_empty_trades_compressed(
        self, empty_db: Path, tmp_path: Path
    ) -> None:
        """CSV export with no trades and compress=True must write gzipped header."""
        import gzip
        exporter = BackupExporter(str(empty_db))
        results = exporter.export_all(
            tmp_path / "out",
            formats=[ExportFormat.CSV],
            compress=True,
        )
        assert ExportFormat.CSV in results
        out = results[ExportFormat.CSV]
        assert out.suffix == ".gz"
        with gzip.open(out, "rt", encoding="utf-8") as f:
            content = f.read()
        assert "timestamp" in content
    def test_export_csv_with_data_compressed(
        self, temp_db: Path, tmp_path: Path
    ) -> None:
        """CSV export with data and compress=True must write gzipped rows."""
        import gzip
        exporter = BackupExporter(str(temp_db))
        results = exporter.export_all(
            tmp_path / "out",
            formats=[ExportFormat.CSV],
            compress=True,
        )
        assert ExportFormat.CSV in results
        out = results[ExportFormat.CSV]
        with gzip.open(out, "rt", encoding="utf-8") as f:
            lines = f.readlines()
        # Header + 3 data rows
        assert len(lines) == 4
    def test_export_parquet_raises_import_error_without_pyarrow(
        self, temp_db: Path, tmp_path: Path
    ) -> None:
        """Parquet export must raise ImportError when pyarrow is not installed."""
        exporter = BackupExporter(str(temp_db))
        with patch.dict(sys.modules, {"pyarrow": None, "pyarrow.parquet": None}):
            try:
                import pyarrow  # noqa: F401
                pytest.skip("pyarrow is installed; cannot test ImportError path")
            except ImportError:
                pass
            results = exporter.export_all(
                tmp_path / "out",
                formats=[ExportFormat.PARQUET],
                compress=False,
            )
            # Parquet export fails gracefully; result dict should not contain it
            assert ExportFormat.PARQUET not in results
 # ---------------------------------------------------------------------------
 # CloudStorage — mocked boto3 tests
 # ---------------------------------------------------------------------------
@pytest.fixture
 def mock_boto3_module():
    """Inject a fake boto3 into sys.modules for the duration of the test."""
    mock = MagicMock()
    with patch.dict(sys.modules, {"boto3": mock}):
        yield mock
@pytest.fixture
 def s3_config():
    """Minimal S3Config for tests."""
    from src.backup.cloud_storage import S3Config
    return S3Config(
        endpoint_url="http://localhost:9000",
        access_key="minioadmin",
        secret_key="minioadmin",
        bucket_name="test-bucket",
        region="us-east-1",
    )
 class TestCloudStorage:
    """Test CloudStorage using mocked boto3."""
    def test_init_creates_s3_client(self, mock_boto3_module, s3_config) -> None:
        """CloudStorage.__init__ must call boto3.client with the correct args."""
        from src.backup.cloud_storage import CloudStorage
        storage = CloudStorage(s3_config)
        mock_boto3_module.client.assert_called_once()
        call_kwargs = mock_boto3_module.client.call_args[1]
        assert call_kwargs["aws_access_key_id"] == "minioadmin"
        assert call_kwargs["aws_secret_access_key"] == "minioadmin"
        assert storage.config == s3_config
    def test_init_raises_if_boto3_missing(self, s3_config) -> None:
        """CloudStorage.__init__ must raise ImportError when boto3 is absent."""
        with patch.dict(sys.modules, {"boto3": None}):  # type: ignore[dict-item]
            with pytest.raises((ImportError, TypeError)):
                # Re-import to trigger the try/except inside __init__
                import importlib
                import src.backup.cloud_storage as m
                importlib.reload(m)
                m.CloudStorage(s3_config)
    def test_upload_file_success(
        self, mock_boto3_module, s3_config, tmp_path: Path
    ) -> None:
        """upload_file must call client.upload_file and return the object key."""
        from src.backup.cloud_storage import CloudStorage
        test_file = tmp_path / "backup.json.gz"
        test_file.write_bytes(b"data")
        storage = CloudStorage(s3_config)
        key = storage.upload_file(test_file, object_key="backups/backup.json.gz")
        assert key == "backups/backup.json.gz"
        storage.client.upload_file.assert_called_once()
    def test_upload_file_default_key(
        self, mock_boto3_module, s3_config, tmp_path: Path
    ) -> None:
        """upload_file without object_key must use the filename as key."""
        from src.backup.cloud_storage import CloudStorage
        test_file = tmp_path / "myfile.gz"
        test_file.write_bytes(b"data")
        storage = CloudStorage(s3_config)
        key = storage.upload_file(test_file)
        assert key == "myfile.gz"
    def test_upload_file_not_found(
        self, mock_boto3_module, s3_config, tmp_path: Path
    ) -> None:
        """upload_file must raise FileNotFoundError for missing files."""
        from src.backup.cloud_storage import CloudStorage
        storage = CloudStorage(s3_config)
        with pytest.raises(FileNotFoundError):
            storage.upload_file(tmp_path / "nonexistent.gz")
    def test_upload_file_propagates_client_error(
        self, mock_boto3_module, s3_config, tmp_path: Path
    ) -> None:
        """upload_file must re-raise exceptions from the boto3 client."""
        from src.backup.cloud_storage import CloudStorage
        test_file = tmp_path / "backup.gz"
        test_file.write_bytes(b"data")
        storage = CloudStorage(s3_config)
        storage.client.upload_file.side_effect = RuntimeError("network error")
        with pytest.raises(RuntimeError, match="network error"):
            storage.upload_file(test_file)
    def test_download_file_success(
        self, mock_boto3_module, s3_config, tmp_path: Path
    ) -> None:
        """download_file must call client.download_file and return local path."""
        from src.backup.cloud_storage import CloudStorage
        storage = CloudStorage(s3_config)
        dest = tmp_path / "downloads" / "backup.gz"
        result = storage.download_file("backups/backup.gz", dest)
        assert result == dest
        storage.client.download_file.assert_called_once()
    def test_download_file_propagates_error(
        self, mock_boto3_module, s3_config, tmp_path: Path
    ) -> None:
        """download_file must re-raise exceptions from the boto3 client."""
        from src.backup.cloud_storage import CloudStorage
        storage = CloudStorage(s3_config)
        storage.client.download_file.side_effect = RuntimeError("timeout")
        with pytest.raises(RuntimeError, match="timeout"):
            storage.download_file("key", tmp_path / "dest.gz")
    def test_list_files_returns_objects(
        self, mock_boto3_module, s3_config
    ) -> None:
        """list_files must return parsed file metadata from S3 response."""
        from datetime import timezone
        from src.backup.cloud_storage import CloudStorage
        storage = CloudStorage(s3_config)
        storage.client.list_objects_v2.return_value = {
            "Contents": [
                {
                    "Key": "backups/a.gz",
                    "Size": 1024,
                    "LastModified": datetime(2026, 1, 1, tzinfo=timezone.utc),
                    "ETag": '"abc123"',
                }
            ]
        }
        files = storage.list_files(prefix="backups/")
        assert len(files) == 1
        assert files[0]["key"] == "backups/a.gz"
        assert files[0]["size_bytes"] == 1024
    def test_list_files_empty_bucket(
        self, mock_boto3_module, s3_config
    ) -> None:
        """list_files must return empty list when bucket has no objects."""
        from src.backup.cloud_storage import CloudStorage
        storage = CloudStorage(s3_config)
        storage.client.list_objects_v2.return_value = {}
        files = storage.list_files()
        assert files == []
    def test_list_files_propagates_error(
        self, mock_boto3_module, s3_config
    ) -> None:
        """list_files must re-raise exceptions from the boto3 client."""
        from src.backup.cloud_storage import CloudStorage
        storage = CloudStorage(s3_config)
        storage.client.list_objects_v2.side_effect = RuntimeError("auth error")
        with pytest.raises(RuntimeError):
            storage.list_files()
    def test_delete_file_success(
        self, mock_boto3_module, s3_config
    ) -> None:
        """delete_file must call client.delete_object with the correct key."""
        from src.backup.cloud_storage import CloudStorage
        storage = CloudStorage(s3_config)
        storage.delete_file("backups/old.gz")
        storage.client.delete_object.assert_called_once_with(
            Bucket="test-bucket", Key="backups/old.gz"
        )
    def test_delete_file_propagates_error(
        self, mock_boto3_module, s3_config
    ) -> None:
        """delete_file must re-raise exceptions from the boto3 client."""
        from src.backup.cloud_storage import CloudStorage
        storage = CloudStorage(s3_config)
        storage.client.delete_object.side_effect = RuntimeError("permission denied")
        with pytest.raises(RuntimeError):
            storage.delete_file("backups/old.gz")
    def test_get_storage_stats_success(
        self, mock_boto3_module, s3_config
    ) -> None:
        """get_storage_stats must aggregate file sizes correctly."""
        from datetime import timezone
        from src.backup.cloud_storage import CloudStorage
        storage = CloudStorage(s3_config)
        storage.client.list_objects_v2.return_value = {
            "Contents": [
                {
                    "Key": "a.gz",
                    "Size": 1024 * 1024,
                    "LastModified": datetime(2026, 1, 1, tzinfo=timezone.utc),
                    "ETag": '"x"',
                },
                {
                    "Key": "b.gz",
                    "Size": 1024 * 1024,
                    "LastModified": datetime(2026, 1, 2, tzinfo=timezone.utc),
                    "ETag": '"y"',
                },
            ]
        }
        stats = storage.get_storage_stats()
        assert stats["total_files"] == 2
        assert stats["total_size_bytes"] == 2 * 1024 * 1024
        assert stats["total_size_mb"] == pytest.approx(2.0)
    def test_get_storage_stats_on_error(
        self, mock_boto3_module, s3_config
    ) -> None:
        """get_storage_stats must return error dict without raising on failure."""
        from src.backup.cloud_storage import CloudStorage
        storage = CloudStorage(s3_config)
        storage.client.list_objects_v2.side_effect = RuntimeError("no connection")
        stats = storage.get_storage_stats()
        assert "error" in stats
        assert stats["total_files"] == 0
    def test_verify_connection_success(
        self, mock_boto3_module, s3_config
    ) -> None:
        """verify_connection must return True when head_bucket succeeds."""
        from src.backup.cloud_storage import CloudStorage
        storage = CloudStorage(s3_config)
        result = storage.verify_connection()
        assert result is True
    def test_verify_connection_failure(
        self, mock_boto3_module, s3_config
    ) -> None:
        """verify_connection must return False when head_bucket raises."""
        from src.backup.cloud_storage import CloudStorage
        storage = CloudStorage(s3_config)
        storage.client.head_bucket.side_effect = RuntimeError("no such bucket")
        result = storage.verify_connection()
        assert result is False
    def test_enable_versioning(
        self, mock_boto3_module, s3_config
    ) -> None:
        """enable_versioning must call put_bucket_versioning."""
        from src.backup.cloud_storage import CloudStorage
        storage = CloudStorage(s3_config)
        storage.enable_versioning()
        storage.client.put_bucket_versioning.assert_called_once()
    def test_enable_versioning_propagates_error(
        self, mock_boto3_module, s3_config
    ) -> None:
        """enable_versioning must re-raise exceptions from the boto3 client."""
        from src.backup.cloud_storage import CloudStorage
        storage = CloudStorage(s3_config)
        storage.client.put_bucket_versioning.side_effect = RuntimeError("denied")
        with pytest.raises(RuntimeError):
            storage.enable_versioning()
--- a/tests/test_broker.py
+++ b/tests/test_broker.py
@@ -572,156 +572,4 @@ class TestSendOrderTickRounding:
        order_call = mock_post.call_args_list[1]
        body = order_call[1].get("json", {})
        assert body["ORD_DVSN"] == "01"
-
+        assert body["ORD_UNPR"] == "0"
 # ---------------------------------------------------------------------------
 # TR_ID live/paper branching (issues #201, #202, #203)
 # ---------------------------------------------------------------------------
 class TestTRIDBranchingDomestic:
    """get_balance and send_order must use correct TR_ID for live vs paper mode."""
    def _make_broker(self, settings, mode: str) -> KISBroker:
        from src.config import Settings
        s = Settings(
            KIS_APP_KEY=settings.KIS_APP_KEY,
            KIS_APP_SECRET=settings.KIS_APP_SECRET,
            KIS_ACCOUNT_NO=settings.KIS_ACCOUNT_NO,
            GEMINI_API_KEY=settings.GEMINI_API_KEY,
            DB_PATH=":memory:",
            ENABLED_MARKETS="KR",
            MODE=mode,
        )
        b = KISBroker(s)
        b._access_token = "tok"
        b._token_expires_at = float("inf")
        b._rate_limiter.acquire = AsyncMock()
        return b
    @pytest.mark.asyncio
    async def test_get_balance_paper_uses_vttc8434r(self, settings) -> None:
        broker = self._make_broker(settings, "paper")
        mock_resp = AsyncMock()
        mock_resp.status = 200
        mock_resp.json = AsyncMock(
            return_value={"output1": [], "output2": {}}
        )
        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
        mock_resp.__aexit__ = AsyncMock(return_value=False)
        with patch("aiohttp.ClientSession.get", return_value=mock_resp) as mock_get:
            await broker.get_balance()
        headers = mock_get.call_args[1].get("headers", {})
        assert headers["tr_id"] == "VTTC8434R"
    @pytest.mark.asyncio
    async def test_get_balance_live_uses_tttc8434r(self, settings) -> None:
        broker = self._make_broker(settings, "live")
        mock_resp = AsyncMock()
        mock_resp.status = 200
        mock_resp.json = AsyncMock(
            return_value={"output1": [], "output2": {}}
        )
        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
        mock_resp.__aexit__ = AsyncMock(return_value=False)
        with patch("aiohttp.ClientSession.get", return_value=mock_resp) as mock_get:
            await broker.get_balance()
        headers = mock_get.call_args[1].get("headers", {})
        assert headers["tr_id"] == "TTTC8434R"
    @pytest.mark.asyncio
    async def test_send_order_buy_paper_uses_vttc0012u(self, settings) -> None:
        broker = self._make_broker(settings, "paper")
        mock_hash = AsyncMock()
        mock_hash.status = 200
        mock_hash.json = AsyncMock(return_value={"HASH": "h"})
        mock_hash.__aenter__ = AsyncMock(return_value=mock_hash)
        mock_hash.__aexit__ = AsyncMock(return_value=False)
        mock_order = AsyncMock()
        mock_order.status = 200
        mock_order.json = AsyncMock(return_value={"rt_cd": "0"})
        mock_order.__aenter__ = AsyncMock(return_value=mock_order)
        mock_order.__aexit__ = AsyncMock(return_value=False)
        with patch(
            "aiohttp.ClientSession.post", side_effect=[mock_hash, mock_order]
        ) as mock_post:
            await broker.send_order("005930", "BUY", 1)
        order_headers = mock_post.call_args_list[1][1].get("headers", {})
        assert order_headers["tr_id"] == "VTTC0012U"
    @pytest.mark.asyncio
    async def test_send_order_buy_live_uses_tttc0012u(self, settings) -> None:
        broker = self._make_broker(settings, "live")
        mock_hash = AsyncMock()
        mock_hash.status = 200
        mock_hash.json = AsyncMock(return_value={"HASH": "h"})
        mock_hash.__aenter__ = AsyncMock(return_value=mock_hash)
        mock_hash.__aexit__ = AsyncMock(return_value=False)
        mock_order = AsyncMock()
        mock_order.status = 200
        mock_order.json = AsyncMock(return_value={"rt_cd": "0"})
        mock_order.__aenter__ = AsyncMock(return_value=mock_order)
        mock_order.__aexit__ = AsyncMock(return_value=False)
        with patch(
            "aiohttp.ClientSession.post", side_effect=[mock_hash, mock_order]
        ) as mock_post:
            await broker.send_order("005930", "BUY", 1)
        order_headers = mock_post.call_args_list[1][1].get("headers", {})
        assert order_headers["tr_id"] == "TTTC0012U"
    @pytest.mark.asyncio
    async def test_send_order_sell_paper_uses_vttc0011u(self, settings) -> None:
        broker = self._make_broker(settings, "paper")
        mock_hash = AsyncMock()
        mock_hash.status = 200
        mock_hash.json = AsyncMock(return_value={"HASH": "h"})
        mock_hash.__aenter__ = AsyncMock(return_value=mock_hash)
        mock_hash.__aexit__ = AsyncMock(return_value=False)
        mock_order = AsyncMock()
        mock_order.status = 200
        mock_order.json = AsyncMock(return_value={"rt_cd": "0"})
        mock_order.__aenter__ = AsyncMock(return_value=mock_order)
        mock_order.__aexit__ = AsyncMock(return_value=False)
        with patch(
            "aiohttp.ClientSession.post", side_effect=[mock_hash, mock_order]
        ) as mock_post:
            await broker.send_order("005930", "SELL", 1)
        order_headers = mock_post.call_args_list[1][1].get("headers", {})
        assert order_headers["tr_id"] == "VTTC0011U"
    @pytest.mark.asyncio
    async def test_send_order_sell_live_uses_tttc0011u(self, settings) -> None:
        broker = self._make_broker(settings, "live")
        mock_hash = AsyncMock()
        mock_hash.status = 200
        mock_hash.json = AsyncMock(return_value={"HASH": "h"})
        mock_hash.__aenter__ = AsyncMock(return_value=mock_hash)
        mock_hash.__aexit__ = AsyncMock(return_value=False)
        mock_order = AsyncMock()
        mock_order.status = 200
        mock_order.json = AsyncMock(return_value={"rt_cd": "0"})
        mock_order.__aenter__ = AsyncMock(return_value=mock_order)
        mock_order.__aexit__ = AsyncMock(return_value=False)
        with patch(
            "aiohttp.ClientSession.post", side_effect=[mock_hash, mock_order]
        ) as mock_post:
            await broker.send_order("005930", "SELL", 1)
        order_headers = mock_post.call_args_list[1][1].get("headers", {})
        assert order_headers["tr_id"] == "TTTC0011U"
--- a/tests/test_context.py
+++ b/tests/test_context.py
@@ -10,7 +10,6 @@ import pytest
 from src.context.aggregator import ContextAggregator
 from src.context.layer import LAYER_CONFIG, ContextLayer
 from src.context.store import ContextStore
 from src.context.summarizer import ContextSummarizer
 from src.db import init_db, log_trade
@@ -371,259 +370,3 @@ class TestLayerMetadata:
        # L1 aggregates from L2
        assert LAYER_CONFIG[ContextLayer.L1_LEGACY].aggregation_source == ContextLayer.L2_ANNUAL
 # ---------------------------------------------------------------------------
 # ContextSummarizer tests
 # ---------------------------------------------------------------------------
@pytest.fixture
 def summarizer(db_conn: sqlite3.Connection) -> ContextSummarizer:
    """Provide a ContextSummarizer backed by an in-memory store."""
    return ContextSummarizer(ContextStore(db_conn))
 class TestContextSummarizer:
    """Test suite for ContextSummarizer."""
    # ------------------------------------------------------------------
    # summarize_numeric_values
    # ------------------------------------------------------------------
    def test_summarize_empty_values(self, summarizer: ContextSummarizer) -> None:
        """Empty list must return SummaryStats with count=0 and no other fields."""
        stats = summarizer.summarize_numeric_values([])
        assert stats.count == 0
        assert stats.mean is None
        assert stats.min is None
        assert stats.max is None
    def test_summarize_single_value(self, summarizer: ContextSummarizer) -> None:
        """Single-element list must return correct stats with std=0 and trend=flat."""
        stats = summarizer.summarize_numeric_values([42.0])
        assert stats.count == 1
        assert stats.mean == 42.0
        assert stats.std == 0.0
        assert stats.trend == "flat"
    def test_summarize_upward_trend(self, summarizer: ContextSummarizer) -> None:
        """Increasing values must produce trend='up'."""
        values = [1.0, 2.0, 3.0, 10.0, 20.0, 30.0]
        stats = summarizer.summarize_numeric_values(values)
        assert stats.trend == "up"
    def test_summarize_downward_trend(self, summarizer: ContextSummarizer) -> None:
        """Decreasing values must produce trend='down'."""
        values = [30.0, 20.0, 10.0, 3.0, 2.0, 1.0]
        stats = summarizer.summarize_numeric_values(values)
        assert stats.trend == "down"
    def test_summarize_flat_trend(self, summarizer: ContextSummarizer) -> None:
        """Stable values must produce trend='flat'."""
        values = [100.0, 100.1, 99.9, 100.0, 100.2, 99.8]
        stats = summarizer.summarize_numeric_values(values)
        assert stats.trend == "flat"
    # ------------------------------------------------------------------
    # summarize_layer
    # ------------------------------------------------------------------
    def test_summarize_layer_no_data(
        self, summarizer: ContextSummarizer
    ) -> None:
        """summarize_layer with no data must return the 'No data' sentinel."""
        result = summarizer.summarize_layer(ContextLayer.L6_DAILY)
        assert result["count"] == 0
        assert "No data" in result["summary"]
    def test_summarize_layer_numeric(
        self, summarizer: ContextSummarizer, db_conn: sqlite3.Connection
    ) -> None:
        """summarize_layer must collect numeric values and produce stats."""
        store = summarizer.store
        store.set_context(ContextLayer.L6_DAILY, "2026-02-01", "total_pnl", 100.0)
        store.set_context(ContextLayer.L6_DAILY, "2026-02-02", "total_pnl", 200.0)
        result = summarizer.summarize_layer(ContextLayer.L6_DAILY)
        assert "total_entries" in result
    def test_summarize_layer_with_dict_values(
        self, summarizer: ContextSummarizer
    ) -> None:
        """summarize_layer must handle dict values by extracting numeric subkeys."""
        store = summarizer.store
        # set_context serialises the value as JSON, so passing a dict works
        store.set_context(
            ContextLayer.L6_DAILY, "2026-02-01", "metrics",
            {"win_rate": 65.0, "label": "good"}
        )
        result = summarizer.summarize_layer(ContextLayer.L6_DAILY)
        assert "total_entries" in result
        # numeric subkey "win_rate" should appear as "metrics.win_rate"
        assert "metrics.win_rate" in result
    def test_summarize_layer_with_string_values(
        self, summarizer: ContextSummarizer
    ) -> None:
        """summarize_layer must count string values separately."""
        store = summarizer.store
        # set_context stores string values as JSON-encoded strings
        store.set_context(ContextLayer.L6_DAILY, "2026-02-01", "outlook", "BULLISH")
        result = summarizer.summarize_layer(ContextLayer.L6_DAILY)
        # String fields contribute a `<key>_count` entry
        assert "outlook_count" in result
    # ------------------------------------------------------------------
    # rolling_window_summary
    # ------------------------------------------------------------------
    def test_rolling_window_summary_basic(
        self, summarizer: ContextSummarizer
    ) -> None:
        """rolling_window_summary must return the expected structure."""
        store = summarizer.store
        store.set_context(ContextLayer.L6_DAILY, "2026-02-01", "pnl", 500.0)
        result = summarizer.rolling_window_summary(ContextLayer.L6_DAILY)
        assert "window_days" in result
        assert "recent_data" in result
        assert "historical_summary" in result
    def test_rolling_window_summary_no_older_data(
        self, summarizer: ContextSummarizer
    ) -> None:
        """rolling_window_summary with summarize_older=False skips history."""
        result = summarizer.rolling_window_summary(
            ContextLayer.L6_DAILY, summarize_older=False
        )
        assert result["historical_summary"] == {}
    # ------------------------------------------------------------------
    # aggregate_to_higher_layer
    # ------------------------------------------------------------------
    def test_aggregate_to_higher_layer_mean(
        self, summarizer: ContextSummarizer
    ) -> None:
        """aggregate_to_higher_layer with 'mean' via dict subkeys returns average."""
        store = summarizer.store
        # Use different outer keys but same inner metric key so get_all_contexts
        # returns multiple rows with the target subkey.
        store.set_context(ContextLayer.L6_DAILY, "2026-02-01", "day1", {"pnl": 100.0})
        store.set_context(ContextLayer.L6_DAILY, "2026-02-01", "day2", {"pnl": 200.0})
        result = summarizer.aggregate_to_higher_layer(
            ContextLayer.L6_DAILY, ContextLayer.L5_WEEKLY, "pnl", "mean"
        )
        assert result == pytest.approx(150.0)
    def test_aggregate_to_higher_layer_sum(
        self, summarizer: ContextSummarizer
    ) -> None:
        """aggregate_to_higher_layer with 'sum' must return the total."""
        store = summarizer.store
        store.set_context(ContextLayer.L6_DAILY, "2026-02-01", "day1", {"pnl": 100.0})
        store.set_context(ContextLayer.L6_DAILY, "2026-02-01", "day2", {"pnl": 200.0})
        result = summarizer.aggregate_to_higher_layer(
            ContextLayer.L6_DAILY, ContextLayer.L5_WEEKLY, "pnl", "sum"
        )
        assert result == pytest.approx(300.0)
    def test_aggregate_to_higher_layer_max(
        self, summarizer: ContextSummarizer
    ) -> None:
        """aggregate_to_higher_layer with 'max' must return the maximum."""
        store = summarizer.store
        store.set_context(ContextLayer.L6_DAILY, "2026-02-01", "day1", {"pnl": 100.0})
        store.set_context(ContextLayer.L6_DAILY, "2026-02-01", "day2", {"pnl": 200.0})
        result = summarizer.aggregate_to_higher_layer(
            ContextLayer.L6_DAILY, ContextLayer.L5_WEEKLY, "pnl", "max"
        )
        assert result == pytest.approx(200.0)
    def test_aggregate_to_higher_layer_min(
        self, summarizer: ContextSummarizer
    ) -> None:
        """aggregate_to_higher_layer with 'min' must return the minimum."""
        store = summarizer.store
        store.set_context(ContextLayer.L6_DAILY, "2026-02-01", "day1", {"pnl": 100.0})
        store.set_context(ContextLayer.L6_DAILY, "2026-02-01", "day2", {"pnl": 200.0})
        result = summarizer.aggregate_to_higher_layer(
            ContextLayer.L6_DAILY, ContextLayer.L5_WEEKLY, "pnl", "min"
        )
        assert result == pytest.approx(100.0)
    def test_aggregate_to_higher_layer_no_data(
        self, summarizer: ContextSummarizer
    ) -> None:
        """aggregate_to_higher_layer with no matching key must return None."""
        result = summarizer.aggregate_to_higher_layer(
            ContextLayer.L6_DAILY, ContextLayer.L5_WEEKLY, "nonexistent", "mean"
        )
        assert result is None
    def test_aggregate_to_higher_layer_unknown_func_defaults_to_mean(
        self, summarizer: ContextSummarizer
    ) -> None:
        """Unknown aggregation function must fall back to mean."""
        store = summarizer.store
        store.set_context(ContextLayer.L6_DAILY, "2026-02-01", "day1", {"pnl": 100.0})
        store.set_context(ContextLayer.L6_DAILY, "2026-02-01", "day2", {"pnl": 200.0})
        result = summarizer.aggregate_to_higher_layer(
            ContextLayer.L6_DAILY, ContextLayer.L5_WEEKLY, "pnl", "unknown_func"
        )
        assert result == pytest.approx(150.0)
    # ------------------------------------------------------------------
    # create_compact_summary + format_summary_for_prompt
    # ------------------------------------------------------------------
    def test_create_compact_summary(
        self, summarizer: ContextSummarizer
    ) -> None:
        """create_compact_summary must produce a dict keyed by layer value."""
        store = summarizer.store
        store.set_context(ContextLayer.L6_DAILY, "2026-02-01", "pnl", 100.0)
        result = summarizer.create_compact_summary([ContextLayer.L6_DAILY])
        assert ContextLayer.L6_DAILY.value in result
    def test_format_summary_for_prompt_with_numeric_metrics(
        self, summarizer: ContextSummarizer
    ) -> None:
        """format_summary_for_prompt must render avg/trend fields."""
        store = summarizer.store
        store.set_context(ContextLayer.L6_DAILY, "2026-02-01", "pnl", 100.0)
        store.set_context(ContextLayer.L6_DAILY, "2026-02-02", "pnl", 200.0)
        compact = summarizer.create_compact_summary([ContextLayer.L6_DAILY])
        text = summarizer.format_summary_for_prompt(compact)
        assert isinstance(text, str)
    def test_format_summary_for_prompt_skips_empty_layers(
        self, summarizer: ContextSummarizer
    ) -> None:
        """format_summary_for_prompt must skip layers with no metrics."""
        summary = {ContextLayer.L6_DAILY.value: {}}
        text = summarizer.format_summary_for_prompt(summary)
        assert text == ""
    def test_format_summary_non_dict_value(
        self, summarizer: ContextSummarizer
    ) -> None:
        """format_summary_for_prompt must render non-dict values as plain text."""
        summary = {
            "daily": {
                "plain_count": 42,
            }
        }
        text = summarizer.format_summary_for_prompt(summary)
        assert "plain_count" in text
        assert "42" in text
--- a/tests/test_dashboard.py
+++ b/tests/test_dashboard.py
@@ -316,100 +316,3 @@ def test_pnl_history_market_filter(tmp_path: Path) -> None:
    # KR has 1 trade with pnl=2.0
    assert len(body["labels"]) >= 1
    assert body["pnl"][0] == 2.0
 def test_positions_returns_open_buy(tmp_path: Path) -> None:
    """BUY가 마지막 거래인 종목은 포지션으로 반환되어야 한다."""
    app = _app(tmp_path)
    get_positions = _endpoint(app, "/api/positions")
    body = get_positions()
    # seed_db: 005930은 BUY (오픈), AAPL은 SELL (마지막)
    assert body["count"] == 1
    pos = body["positions"][0]
    assert pos["stock_code"] == "005930"
    assert pos["market"] == "KR"
    assert pos["quantity"] == 1
    assert pos["entry_price"] == 70000
 def test_positions_excludes_closed_sell(tmp_path: Path) -> None:
    """마지막 거래가 SELL인 종목은 포지션에 나타나지 않아야 한다."""
    app = _app(tmp_path)
    get_positions = _endpoint(app, "/api/positions")
    body = get_positions()
    codes = [p["stock_code"] for p in body["positions"]]
    assert "AAPL" not in codes
 def test_positions_empty_when_no_trades(tmp_path: Path) -> None:
    """거래 내역이 없으면 빈 포지션 목록을 반환해야 한다."""
    db_path = tmp_path / "empty.db"
    conn = init_db(str(db_path))
    conn.close()
    app = create_dashboard_app(str(db_path))
    get_positions = _endpoint(app, "/api/positions")
    body = get_positions()
    assert body["count"] == 0
    assert body["positions"] == []
 def _seed_cb_context(conn: sqlite3.Connection, pnl_pct: float, market: str = "KR") -> None:
    import json as _json
    conn.execute(
        "INSERT OR REPLACE INTO system_metrics (key, value, updated_at) VALUES (?, ?, ?)",
        (
            f"portfolio_pnl_pct_{market}",
            _json.dumps({"pnl_pct": pnl_pct}),
            "2026-02-22T10:00:00+00:00",
        ),
    )
    conn.commit()
 def test_status_circuit_breaker_ok(tmp_path: Path) -> None:
    """pnl_pct가 -2.0%보다 높으면 status=ok를 반환해야 한다."""
    db_path = tmp_path / "cb_ok.db"
    conn = init_db(str(db_path))
    _seed_cb_context(conn, -1.0)
    conn.close()
    app = create_dashboard_app(str(db_path))
    get_status = _endpoint(app, "/api/status")
    body = get_status()
    cb = body["circuit_breaker"]
    assert cb["status"] == "ok"
    assert cb["current_pnl_pct"] == -1.0
    assert cb["threshold_pct"] == -3.0
 def test_status_circuit_breaker_warning(tmp_path: Path) -> None:
    """pnl_pct가 -2.0% 이하이면 status=warning을 반환해야 한다."""
    db_path = tmp_path / "cb_warn.db"
    conn = init_db(str(db_path))
    _seed_cb_context(conn, -2.5)
    conn.close()
    app = create_dashboard_app(str(db_path))
    get_status = _endpoint(app, "/api/status")
    body = get_status()
    assert body["circuit_breaker"]["status"] == "warning"
 def test_status_circuit_breaker_tripped(tmp_path: Path) -> None:
    """pnl_pct가 임계값(-3.0%) 이하이면 status=tripped를 반환해야 한다."""
    db_path = tmp_path / "cb_tripped.db"
    conn = init_db(str(db_path))
    _seed_cb_context(conn, -3.5)
    conn.close()
    app = create_dashboard_app(str(db_path))
    get_status = _endpoint(app, "/api/status")
    body = get_status()
    assert body["circuit_breaker"]["status"] == "tripped"
 def test_status_circuit_breaker_unknown_when_no_data(tmp_path: Path) -> None:
    """L7 context에 pnl_pct 데이터가 없으면 status=unknown을 반환해야 한다."""
    app = _app(tmp_path)  # seed_db에는 portfolio_pnl_pct 없음
    get_status = _endpoint(app, "/api/status")
    body = get_status()
    cb = body["circuit_breaker"]
    assert cb["status"] == "unknown"
    assert cb["current_pnl_pct"] is None
--- a/tests/test_db.py
+++ b/tests/test_db.py
@@ -1,8 +1,5 @@
 """Tests for database helper functions."""
 import tempfile
 import os
 from src.db import get_open_position, init_db, log_trade
@@ -61,135 +58,3 @@ def test_get_open_position_returns_none_when_latest_is_sell() -> None:
 def test_get_open_position_returns_none_when_no_trades() -> None:
    conn = init_db(":memory:")
    assert get_open_position(conn, "AAPL", "US_NASDAQ") is None
 # ---------------------------------------------------------------------------
 # WAL mode tests (issue #210)
 # ---------------------------------------------------------------------------
 def test_wal_mode_applied_to_file_db() -> None:
    """File-based DB must use WAL journal mode for dashboard concurrent reads."""
    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
        db_path = f.name
    try:
        conn = init_db(db_path)
        cursor = conn.execute("PRAGMA journal_mode")
        mode = cursor.fetchone()[0]
        assert mode == "wal", f"Expected WAL mode, got {mode}"
        conn.close()
    finally:
        os.unlink(db_path)
        # Clean up WAL auxiliary files if they exist
        for ext in ("-wal", "-shm"):
            path = db_path + ext
            if os.path.exists(path):
                os.unlink(path)
 def test_wal_mode_not_applied_to_memory_db() -> None:
    """:memory: DB must not apply WAL (SQLite does not support WAL for in-memory)."""
    conn = init_db(":memory:")
    cursor = conn.execute("PRAGMA journal_mode")
    mode = cursor.fetchone()[0]
    # In-memory DBs default to 'memory' journal mode
    assert mode != "wal", "WAL should not be set on in-memory database"
    conn.close()
 # ---------------------------------------------------------------------------
 # mode column tests (issue #212)
 # ---------------------------------------------------------------------------
 def test_log_trade_stores_mode_paper() -> None:
    """log_trade must persist mode='paper' in the trades table."""
    conn = init_db(":memory:")
    log_trade(
        conn=conn,
        stock_code="005930",
        action="BUY",
        confidence=85,
        rationale="test",
        mode="paper",
    )
    row = conn.execute("SELECT mode FROM trades ORDER BY id DESC LIMIT 1").fetchone()
    assert row is not None
    assert row[0] == "paper"
 def test_log_trade_stores_mode_live() -> None:
    """log_trade must persist mode='live' in the trades table."""
    conn = init_db(":memory:")
    log_trade(
        conn=conn,
        stock_code="005930",
        action="BUY",
        confidence=85,
        rationale="test",
        mode="live",
    )
    row = conn.execute("SELECT mode FROM trades ORDER BY id DESC LIMIT 1").fetchone()
    assert row is not None
    assert row[0] == "live"
 def test_log_trade_default_mode_is_paper() -> None:
    """log_trade without explicit mode must default to 'paper'."""
    conn = init_db(":memory:")
    log_trade(
        conn=conn,
        stock_code="005930",
        action="HOLD",
        confidence=50,
        rationale="test",
    )
    row = conn.execute("SELECT mode FROM trades ORDER BY id DESC LIMIT 1").fetchone()
    assert row is not None
    assert row[0] == "paper"
 def test_mode_column_exists_in_schema() -> None:
    """trades table must have a mode column after init_db."""
    conn = init_db(":memory:")
    cursor = conn.execute("PRAGMA table_info(trades)")
    columns = {row[1] for row in cursor.fetchall()}
    assert "mode" in columns
 def test_mode_migration_adds_column_to_existing_db() -> None:
    """init_db must add mode column to existing DBs that lack it (migration)."""
    import sqlite3
    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
        db_path = f.name
    try:
        # Create DB without mode column (simulate old schema)
        old_conn = sqlite3.connect(db_path)
        old_conn.execute(
            """CREATE TABLE trades (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                timestamp TEXT NOT NULL,
                stock_code TEXT NOT NULL,
                action TEXT NOT NULL,
                confidence INTEGER NOT NULL,
                rationale TEXT,
                quantity INTEGER,
                price REAL,
                pnl REAL DEFAULT 0.0,
                market TEXT DEFAULT 'KR',
                exchange_code TEXT DEFAULT 'KRX',
                decision_id TEXT
            )"""
        )
        old_conn.commit()
        old_conn.close()
        # Run init_db — should add mode column via migration
        conn = init_db(db_path)
        cursor = conn.execute("PRAGMA table_info(trades)")
        columns = {row[1] for row in cursor.fetchall()}
        assert "mode" in columns
        conn.close()
    finally:
        os.unlink(db_path)
--- a/tests/test_logging_config.py
+++ b/tests/test_logging_config.py
@@ -1,117 +0,0 @@
 """Tests for JSON structured logging configuration."""
 from __future__ import annotations
 import json
 import logging
 import sys
 from src.logging_config import JSONFormatter, setup_logging
 class TestJSONFormatter:
    """Test JSONFormatter output."""
    def test_basic_log_record(self) -> None:
        """JSONFormatter must emit valid JSON with required fields."""
        formatter = JSONFormatter()
        record = logging.LogRecord(
            name="test.logger",
            level=logging.INFO,
            pathname="",
            lineno=0,
            msg="Hello %s",
            args=("world",),
            exc_info=None,
        )
        output = formatter.format(record)
        data = json.loads(output)
        assert data["level"] == "INFO"
        assert data["logger"] == "test.logger"
        assert data["message"] == "Hello world"
        assert "timestamp" in data
    def test_includes_exception_info(self) -> None:
        """JSONFormatter must include exception info when present."""
        formatter = JSONFormatter()
        try:
            raise ValueError("test error")
        except ValueError:
            exc_info = sys.exc_info()
        record = logging.LogRecord(
            name="test",
            level=logging.ERROR,
            pathname="",
            lineno=0,
            msg="oops",
            args=(),
            exc_info=exc_info,
        )
        output = formatter.format(record)
        data = json.loads(output)
        assert "exception" in data
        assert "ValueError" in data["exception"]
    def test_extra_trading_fields_included(self) -> None:
        """Extra trading fields attached to the record must appear in JSON."""
        formatter = JSONFormatter()
        record = logging.LogRecord(
            name="test",
            level=logging.INFO,
            pathname="",
            lineno=0,
            msg="trade",
            args=(),
            exc_info=None,
        )
        record.stock_code = "005930"  # type: ignore[attr-defined]
        record.action = "BUY"  # type: ignore[attr-defined]
        record.confidence = 85  # type: ignore[attr-defined]
        record.pnl_pct = -1.5  # type: ignore[attr-defined]
        record.order_amount = 1_000_000  # type: ignore[attr-defined]
        output = formatter.format(record)
        data = json.loads(output)
        assert data["stock_code"] == "005930"
        assert data["action"] == "BUY"
        assert data["confidence"] == 85
        assert data["pnl_pct"] == -1.5
        assert data["order_amount"] == 1_000_000
    def test_none_extra_fields_excluded(self) -> None:
        """Extra fields that are None must not appear in JSON output."""
        formatter = JSONFormatter()
        record = logging.LogRecord(
            name="test",
            level=logging.INFO,
            pathname="",
            lineno=0,
            msg="no extras",
            args=(),
            exc_info=None,
        )
        output = formatter.format(record)
        data = json.loads(output)
        assert "stock_code" not in data
        assert "action" not in data
        assert "confidence" not in data
 class TestSetupLogging:
    """Test setup_logging function."""
    def test_configures_root_logger(self) -> None:
        """setup_logging must attach a JSON handler to the root logger."""
        setup_logging(level=logging.DEBUG)
        root = logging.getLogger()
        json_handlers = [
            h for h in root.handlers if isinstance(h.formatter, JSONFormatter)
        ]
        assert len(json_handlers) == 1
        assert root.level == logging.DEBUG
    def test_avoids_duplicate_handlers(self) -> None:
        """Calling setup_logging twice must not add duplicate handlers."""
        setup_logging()
        setup_logging()
        root = logging.getLogger()
        assert len(root.handlers) == 1
--- a/tests/test_main.py
+++ b/tests/test_main.py
--- a/tests/test_overseas_broker.py
+++ b/tests/test_overseas_broker.py
@@ -414,7 +414,7 @@ class TestSendOverseasOrder:
    @pytest.mark.asyncio
    async def test_sell_limit_order(self, overseas_broker: OverseasBroker) -> None:
-        """Limit sell order should use VTTT1001U and ORD_DVSN=00."""
+        """Limit sell order should use VTTT1006U and ORD_DVSN=00."""
        mock_resp = AsyncMock()
        mock_resp.status = 200
        mock_resp.json = AsyncMock(return_value={"rt_cd": "0"})
@@ -428,7 +428,7 @@ class TestSendOverseasOrder:
        result = await overseas_broker.send_overseas_order("NYSE", "MSFT", "SELL", 5, price=350.0)
        assert result["rt_cd"] == "0"
-        overseas_broker._broker._auth_headers.assert_called_with("VTTT1001U")
+        overseas_broker._broker._auth_headers.assert_called_with("VTTT1006U")
        call_args = mock_session.post.call_args
        body = call_args[1]["json"]
@@ -640,176 +640,4 @@ class TestPaperOverseasCash:
            GEMINI_API_KEY="g",
        )
        assert settings.PAPER_OVERSEAS_CASH == 0.0
-
+        del os.environ["PAPER_OVERSEAS_CASH"]
 # ---------------------------------------------------------------------------
 # TR_ID live/paper branching — overseas (issues #201, #203)
 # ---------------------------------------------------------------------------
 def _make_overseas_broker_with_mode(mode: str) -> OverseasBroker:
    s = Settings(
        KIS_APP_KEY="k",
        KIS_APP_SECRET="s",
        KIS_ACCOUNT_NO="12345678-01",
        GEMINI_API_KEY="g",
        DB_PATH=":memory:",
        MODE=mode,
    )
    kis = KISBroker(s)
    kis._access_token = "tok"
    kis._token_expires_at = float("inf")
    kis._rate_limiter.acquire = AsyncMock()
    return OverseasBroker(kis)
 class TestOverseasTRIDBranching:
    """get_overseas_balance and send_overseas_order must use correct TR_ID."""
    @pytest.mark.asyncio
    async def test_get_overseas_balance_paper_uses_vtts3012r(self) -> None:
        broker = _make_overseas_broker_with_mode("paper")
        captured: list[str] = []
        async def mock_auth_headers(tr_id: str) -> dict:
            captured.append(tr_id)
            return {"tr_id": tr_id, "authorization": "Bearer tok"}
        broker._broker._auth_headers = mock_auth_headers  # type: ignore[method-assign]
        mock_resp = AsyncMock()
        mock_resp.status = 200
        mock_resp.json = AsyncMock(return_value={"output1": [], "output2": []})
        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
        mock_resp.__aexit__ = AsyncMock(return_value=False)
        mock_session = MagicMock()
        mock_session.get = MagicMock(return_value=mock_resp)
        broker._broker._get_session = MagicMock(return_value=mock_session)
        await broker.get_overseas_balance("NASD")
        assert "VTTS3012R" in captured
    @pytest.mark.asyncio
    async def test_get_overseas_balance_live_uses_ttts3012r(self) -> None:
        broker = _make_overseas_broker_with_mode("live")
        captured: list[str] = []
        async def mock_auth_headers(tr_id: str) -> dict:
            captured.append(tr_id)
            return {"tr_id": tr_id, "authorization": "Bearer tok"}
        broker._broker._auth_headers = mock_auth_headers  # type: ignore[method-assign]
        mock_resp = AsyncMock()
        mock_resp.status = 200
        mock_resp.json = AsyncMock(return_value={"output1": [], "output2": []})
        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
        mock_resp.__aexit__ = AsyncMock(return_value=False)
        mock_session = MagicMock()
        mock_session.get = MagicMock(return_value=mock_resp)
        broker._broker._get_session = MagicMock(return_value=mock_session)
        await broker.get_overseas_balance("NASD")
        assert "TTTS3012R" in captured
    @pytest.mark.asyncio
    async def test_send_overseas_order_buy_paper_uses_vttt1002u(self) -> None:
        broker = _make_overseas_broker_with_mode("paper")
        captured: list[str] = []
        async def mock_auth_headers(tr_id: str) -> dict:
            captured.append(tr_id)
            return {"tr_id": tr_id, "authorization": "Bearer tok"}
        broker._broker._auth_headers = mock_auth_headers  # type: ignore[method-assign]
        broker._broker._get_hash_key = AsyncMock(return_value="h")  # type: ignore[method-assign]
        mock_resp = AsyncMock()
        mock_resp.status = 200
        mock_resp.json = AsyncMock(return_value={"rt_cd": "0", "msg1": "OK"})
        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
        mock_resp.__aexit__ = AsyncMock(return_value=False)
        mock_session = MagicMock()
        mock_session.post = MagicMock(return_value=mock_resp)
        broker._broker._get_session = MagicMock(return_value=mock_session)
        await broker.send_overseas_order("NASD", "AAPL", "BUY", 1)
        assert "VTTT1002U" in captured
    @pytest.mark.asyncio
    async def test_send_overseas_order_buy_live_uses_tttt1002u(self) -> None:
        broker = _make_overseas_broker_with_mode("live")
        captured: list[str] = []
        async def mock_auth_headers(tr_id: str) -> dict:
            captured.append(tr_id)
            return {"tr_id": tr_id, "authorization": "Bearer tok"}
        broker._broker._auth_headers = mock_auth_headers  # type: ignore[method-assign]
        broker._broker._get_hash_key = AsyncMock(return_value="h")  # type: ignore[method-assign]
        mock_resp = AsyncMock()
        mock_resp.status = 200
        mock_resp.json = AsyncMock(return_value={"rt_cd": "0", "msg1": "OK"})
        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
        mock_resp.__aexit__ = AsyncMock(return_value=False)
        mock_session = MagicMock()
        mock_session.post = MagicMock(return_value=mock_resp)
        broker._broker._get_session = MagicMock(return_value=mock_session)
        await broker.send_overseas_order("NASD", "AAPL", "BUY", 1)
        assert "TTTT1002U" in captured
    @pytest.mark.asyncio
    async def test_send_overseas_order_sell_paper_uses_vttt1001u(self) -> None:
        broker = _make_overseas_broker_with_mode("paper")
        captured: list[str] = []
        async def mock_auth_headers(tr_id: str) -> dict:
            captured.append(tr_id)
            return {"tr_id": tr_id, "authorization": "Bearer tok"}
        broker._broker._auth_headers = mock_auth_headers  # type: ignore[method-assign]
        broker._broker._get_hash_key = AsyncMock(return_value="h")  # type: ignore[method-assign]
        mock_resp = AsyncMock()
        mock_resp.status = 200
        mock_resp.json = AsyncMock(return_value={"rt_cd": "0", "msg1": "OK"})
        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
        mock_resp.__aexit__ = AsyncMock(return_value=False)
        mock_session = MagicMock()
        mock_session.post = MagicMock(return_value=mock_resp)
        broker._broker._get_session = MagicMock(return_value=mock_session)
        await broker.send_overseas_order("NASD", "AAPL", "SELL", 1)
        assert "VTTT1001U" in captured
    @pytest.mark.asyncio
    async def test_send_overseas_order_sell_live_uses_tttt1006u(self) -> None:
        broker = _make_overseas_broker_with_mode("live")
        captured: list[str] = []
        async def mock_auth_headers(tr_id: str) -> dict:
            captured.append(tr_id)
            return {"tr_id": tr_id, "authorization": "Bearer tok"}
        broker._broker._auth_headers = mock_auth_headers  # type: ignore[method-assign]
        broker._broker._get_hash_key = AsyncMock(return_value="h")  # type: ignore[method-assign]
        mock_resp = AsyncMock()
        mock_resp.status = 200
        mock_resp.json = AsyncMock(return_value={"rt_cd": "0", "msg1": "OK"})
        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
        mock_resp.__aexit__ = AsyncMock(return_value=False)
        mock_session = MagicMock()
        mock_session.post = MagicMock(return_value=mock_resp)
        broker._broker._get_session = MagicMock(return_value=mock_session)
        await broker.send_overseas_order("NASD", "AAPL", "SELL", 1)
        assert "TTTT1006U" in captured
--- a/tests/test_pre_market_planner.py
+++ b/tests/test_pre_market_planner.py
@@ -830,171 +830,3 @@ class TestSmartFallbackPlaybook:
        ]
        assert len(buy_scenarios) == 1
        assert buy_scenarios[0].condition.volume_ratio_above == 2.0  # VOL_MULTIPLIER default
 # ---------------------------------------------------------------------------
 # Holdings in prompt (#170)
 # ---------------------------------------------------------------------------
 class TestHoldingsInPrompt:
    """Tests for current_holdings parameter in generate_playbook / _build_prompt."""
    def _make_holdings(self) -> list[dict]:
        return [
            {
                "stock_code": "005930",
                "name": "Samsung",
                "qty": 10,
                "entry_price": 71000.0,
                "unrealized_pnl_pct": 2.3,
                "holding_days": 3,
            }
        ]
    def test_build_prompt_includes_holdings_section(self) -> None:
        """Prompt should contain a Current Holdings section when holdings are given."""
        planner = _make_planner()
        candidates = [_candidate()]
        holdings = self._make_holdings()
        prompt = planner._build_prompt(
            "KR",
            candidates,
            context_data={},
            self_market_scorecard=None,
            cross_market=None,
            current_holdings=holdings,
        )
        assert "## Current Holdings" in prompt
        assert "005930" in prompt
        assert "+2.30%" in prompt
        assert "보유 3일" in prompt
    def test_build_prompt_no_holdings_omits_section(self) -> None:
        """Prompt should NOT contain a Current Holdings section when holdings=None."""
        planner = _make_planner()
        candidates = [_candidate()]
        prompt = planner._build_prompt(
            "KR",
            candidates,
            context_data={},
            self_market_scorecard=None,
            cross_market=None,
            current_holdings=None,
        )
        assert "## Current Holdings" not in prompt
    def test_build_prompt_empty_holdings_omits_section(self) -> None:
        """Empty list should also omit the holdings section."""
        planner = _make_planner()
        candidates = [_candidate()]
        prompt = planner._build_prompt(
            "KR",
            candidates,
            context_data={},
            self_market_scorecard=None,
            cross_market=None,
            current_holdings=[],
        )
        assert "## Current Holdings" not in prompt
    def test_build_prompt_holdings_instruction_included(self) -> None:
        """Prompt should include instruction to generate scenarios for held stocks."""
        planner = _make_planner()
        candidates = [_candidate()]
        holdings = self._make_holdings()
        prompt = planner._build_prompt(
            "KR",
            candidates,
            context_data={},
            self_market_scorecard=None,
            cross_market=None,
            current_holdings=holdings,
        )
        assert "005930" in prompt
        assert "SELL/HOLD" in prompt
    @pytest.mark.asyncio
    async def test_generate_playbook_passes_holdings_to_prompt(self) -> None:
        """generate_playbook should pass current_holdings through to the prompt."""
        planner = _make_planner()
        candidates = [_candidate()]
        holdings = self._make_holdings()
        # Capture the actual prompt sent to Gemini
        captured_prompts: list[str] = []
        original_decide = planner._gemini.decide
        async def capture_and_call(data: dict) -> TradeDecision:
            captured_prompts.append(data.get("prompt_override", ""))
            return await original_decide(data)
        planner._gemini.decide = capture_and_call  # type: ignore[method-assign]
        await planner.generate_playbook(
            "KR", candidates, today=date(2026, 2, 8), current_holdings=holdings
        )
        assert len(captured_prompts) == 1
        assert "## Current Holdings" in captured_prompts[0]
        assert "005930" in captured_prompts[0]
    @pytest.mark.asyncio
    async def test_holdings_stock_allowed_in_parse_response(self) -> None:
        """Holdings stocks not in candidates list should be accepted in the response."""
        holding_code = "000660"  # Not in candidates
        stocks = [
            {
                "stock_code": "005930",  # candidate
                "scenarios": [
                    {
                        "condition": {"rsi_below": 30},
                        "action": "BUY",
                        "confidence": 85,
                        "rationale": "oversold",
                    }
                ],
            },
            {
                "stock_code": holding_code,  # holding only
                "scenarios": [
                    {
                        "condition": {"price_change_pct_below": -2.0},
                        "action": "SELL",
                        "confidence": 90,
                        "rationale": "stop-loss",
                    }
                ],
            },
        ]
        planner = _make_planner(gemini_response=_gemini_response_json(stocks=stocks))
        candidates = [_candidate()]  # only 005930
        holdings = [
            {
                "stock_code": holding_code,
                "name": "SK Hynix",
                "qty": 5,
                "entry_price": 180000.0,
                "unrealized_pnl_pct": -1.5,
                "holding_days": 7,
            }
        ]
        pb = await planner.generate_playbook(
            "KR",
            candidates,
            today=date(2026, 2, 8),
            current_holdings=holdings,
        )
        codes = [sp.stock_code for sp in pb.stock_playbooks]
        assert "005930" in codes
        assert holding_code in codes
--- a/tests/test_scenario_engine.py
+++ b/tests/test_scenario_engine.py
@@ -440,135 +440,3 @@ class TestEvaluate:
        assert result.action == ScenarioAction.BUY
        assert result.match_details["rsi"] == 25.0
        assert isinstance(result.match_details["rsi"], float)
 # ---------------------------------------------------------------------------
 # Position-aware condition tests (#171)
 # ---------------------------------------------------------------------------
 class TestPositionAwareConditions:
    """Tests for unrealized_pnl_pct and holding_days condition fields."""
    def test_evaluate_condition_unrealized_pnl_above_matches(
        self, engine: ScenarioEngine
    ) -> None:
        """unrealized_pnl_pct_above should match when P&L exceeds threshold."""
        condition = StockCondition(unrealized_pnl_pct_above=3.0)
        assert engine.evaluate_condition(condition, {"unrealized_pnl_pct": 5.0}) is True
    def test_evaluate_condition_unrealized_pnl_above_no_match(
        self, engine: ScenarioEngine
    ) -> None:
        """unrealized_pnl_pct_above should NOT match when P&L is below threshold."""
        condition = StockCondition(unrealized_pnl_pct_above=3.0)
        assert engine.evaluate_condition(condition, {"unrealized_pnl_pct": 2.0}) is False
    def test_evaluate_condition_unrealized_pnl_below_matches(
        self, engine: ScenarioEngine
    ) -> None:
        """unrealized_pnl_pct_below should match when P&L is under threshold."""
        condition = StockCondition(unrealized_pnl_pct_below=-2.0)
        assert engine.evaluate_condition(condition, {"unrealized_pnl_pct": -3.5}) is True
    def test_evaluate_condition_unrealized_pnl_below_no_match(
        self, engine: ScenarioEngine
    ) -> None:
        """unrealized_pnl_pct_below should NOT match when P&L is above threshold."""
        condition = StockCondition(unrealized_pnl_pct_below=-2.0)
        assert engine.evaluate_condition(condition, {"unrealized_pnl_pct": -1.0}) is False
    def test_evaluate_condition_holding_days_above_matches(
        self, engine: ScenarioEngine
    ) -> None:
        """holding_days_above should match when position held longer than threshold."""
        condition = StockCondition(holding_days_above=5)
        assert engine.evaluate_condition(condition, {"holding_days": 7}) is True
    def test_evaluate_condition_holding_days_above_no_match(
        self, engine: ScenarioEngine
    ) -> None:
        """holding_days_above should NOT match when position held shorter."""
        condition = StockCondition(holding_days_above=5)
        assert engine.evaluate_condition(condition, {"holding_days": 3}) is False
    def test_evaluate_condition_holding_days_below_matches(
        self, engine: ScenarioEngine
    ) -> None:
        """holding_days_below should match when position held fewer days."""
        condition = StockCondition(holding_days_below=3)
        assert engine.evaluate_condition(condition, {"holding_days": 1}) is True
    def test_evaluate_condition_holding_days_below_no_match(
        self, engine: ScenarioEngine
    ) -> None:
        """holding_days_below should NOT match when held more days."""
        condition = StockCondition(holding_days_below=3)
        assert engine.evaluate_condition(condition, {"holding_days": 5}) is False
    def test_combined_pnl_and_holding_days(self, engine: ScenarioEngine) -> None:
        """Combined position-aware conditions should AND-evaluate correctly."""
        condition = StockCondition(
            unrealized_pnl_pct_above=3.0,
            holding_days_above=5,
        )
        # Both met → match
        assert engine.evaluate_condition(
            condition,
            {"unrealized_pnl_pct": 4.5, "holding_days": 7},
        ) is True
        # Only pnl met → no match
        assert engine.evaluate_condition(
            condition,
            {"unrealized_pnl_pct": 4.5, "holding_days": 3},
        ) is False
    def test_missing_unrealized_pnl_does_not_match(
        self, engine: ScenarioEngine
    ) -> None:
        """Missing unrealized_pnl_pct key should not match the condition."""
        condition = StockCondition(unrealized_pnl_pct_above=3.0)
        assert engine.evaluate_condition(condition, {}) is False
    def test_missing_holding_days_does_not_match(
        self, engine: ScenarioEngine
    ) -> None:
        """Missing holding_days key should not match the condition."""
        condition = StockCondition(holding_days_above=5)
        assert engine.evaluate_condition(condition, {}) is False
    def test_match_details_includes_position_fields(
        self, engine: ScenarioEngine
    ) -> None:
        """match_details should include position fields when condition specifies them."""
        pb = _playbook(
            scenarios=[
                StockScenario(
                    condition=StockCondition(unrealized_pnl_pct_above=3.0),
                    action=ScenarioAction.SELL,
                    confidence=90,
                    rationale="Take profit",
                )
            ]
        )
        result = engine.evaluate(
            pb,
            "005930",
            {"unrealized_pnl_pct": 5.0},
            {},
        )
        assert result.action == ScenarioAction.SELL
        assert "unrealized_pnl_pct" in result.match_details
        assert result.match_details["unrealized_pnl_pct"] == 5.0
    def test_position_conditions_parse_from_planner(self) -> None:
        """StockCondition should accept and store new fields from JSON parsing."""
        condition = StockCondition(
            unrealized_pnl_pct_above=3.0,
            unrealized_pnl_pct_below=None,
            holding_days_above=5,
            holding_days_below=None,
        )
        assert condition.unrealized_pnl_pct_above == 3.0
        assert condition.holding_days_above == 5
        assert condition.has_any_condition() is True
--- a/tests/test_smart_scanner.py
+++ b/tests/test_smart_scanner.py
@@ -350,42 +350,6 @@ class TestSmartVolatilityScanner:
        assert [c.stock_code for c in candidates] == ["ABCD"]
 class TestImpliedRSIFormula:
    """Test the implied_rsi formula in SmartVolatilityScanner (issue #181)."""
    def test_neutral_change_gives_neutral_rsi(self) -> None:
        """0% change → implied_rsi = 50 (neutral)."""
        # formula: 50 + (change_rate * 2.0)
        rsi = max(0.0, min(100.0, 50.0 + (0.0 * 2.0)))
        assert rsi == 50.0
    def test_10pct_change_gives_rsi_70(self) -> None:
        """10% upward change → implied_rsi = 70 (momentum signal)."""
        rsi = max(0.0, min(100.0, 50.0 + (10.0 * 2.0)))
        assert rsi == 70.0
    def test_minus_10pct_gives_rsi_30(self) -> None:
        """-10% change → implied_rsi = 30 (oversold signal)."""
        rsi = max(0.0, min(100.0, 50.0 + (-10.0 * 2.0)))
        assert rsi == 30.0
    def test_saturation_at_25pct(self) -> None:
        """Saturation occurs at >=25% change (not 12.5% as with old coefficient 4.0)."""
        rsi_12pct = max(0.0, min(100.0, 50.0 + (12.5 * 2.0)))
        rsi_25pct = max(0.0, min(100.0, 50.0 + (25.0 * 2.0)))
        rsi_30pct = max(0.0, min(100.0, 50.0 + (30.0 * 2.0)))
        # At 12.5% change: RSI = 75 (not 100, unlike old formula)
        assert rsi_12pct == 75.0
        # At 25%+ saturation
        assert rsi_25pct == 100.0
        assert rsi_30pct == 100.0  # Capped
    def test_negative_saturation(self) -> None:
        """Saturation at -25% gives RSI = 0."""
        rsi = max(0.0, min(100.0, 50.0 + (-25.0 * 2.0)))
        assert rsi == 0.0
 class TestRSICalculation:
    """Test RSI calculation in VolatilityAnalyzer."""
--- a/tests/test_strategies_base.py
+++ b/tests/test_strategies_base.py
@@ -1,32 +0,0 @@
 """Tests for BaseStrategy abstract class."""
 from __future__ import annotations
 from typing import Any
 import pytest
 from src.strategies.base import BaseStrategy
 class ConcreteStrategy(BaseStrategy):
    """Minimal concrete strategy for testing."""
    def evaluate(self, market_data: dict[str, Any]) -> dict[str, Any]:
        return {"action": "HOLD", "confidence": 50, "rationale": "test"}
 def test_base_strategy_cannot_be_instantiated() -> None:
    """BaseStrategy cannot be instantiated directly (it's abstract)."""
    with pytest.raises(TypeError):
        BaseStrategy()  # type: ignore[abstract]
 def test_concrete_strategy_evaluate_returns_decision() -> None:
    """Concrete subclass must implement evaluate and return a dict."""
    strategy = ConcreteStrategy()
    result = strategy.evaluate({"close": [100.0, 101.0]})
    assert isinstance(result, dict)
    assert result["action"] == "HOLD"
    assert result["confidence"] == 50
    assert "rationale" in result
--- a/tests/test_telegram_commands.py
+++ b/tests/test_telegram_commands.py
@@ -876,54 +876,6 @@ class TestGetUpdates:
            assert updates == []
    @pytest.mark.asyncio
    async def test_get_updates_409_stops_polling(self) -> None:
        """409 Conflict response stops the poller (_running = False) and returns empty list."""
        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
        handler = TelegramCommandHandler(client)
        handler._running = True  # simulate active poller
        mock_resp = AsyncMock()
        mock_resp.status = 409
        mock_resp.text = AsyncMock(
            return_value='{"ok":false,"error_code":409,"description":"Conflict"}'
        )
        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
        mock_resp.__aexit__ = AsyncMock(return_value=False)
        with patch("aiohttp.ClientSession.post", return_value=mock_resp):
            updates = await handler._get_updates()
        assert updates == []
        assert handler._running is False  # poller stopped
    @pytest.mark.asyncio
    async def test_poll_loop_exits_after_409(self) -> None:
        """_poll_loop exits naturally after _running is set to False by a 409 response."""
        import asyncio as _asyncio
        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
        handler = TelegramCommandHandler(client)
        call_count = 0
        async def mock_get_updates_409() -> list[dict]:
            nonlocal call_count
            call_count += 1
            # Simulate 409 stopping the poller
            handler._running = False
            return []
        handler._get_updates = mock_get_updates_409  # type: ignore[method-assign]
        handler._running = True
        task = _asyncio.create_task(handler._poll_loop())
        await _asyncio.wait_for(task, timeout=2.0)
        # _get_updates called exactly once, then loop exited
        assert call_count == 1
        assert handler._running is False
 class TestCommandWithArgs:
    """Test register_command_with_args and argument dispatch."""