Add scanner diagnostics for zero-candidate trade stalls

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

docs/issues/ISSUE-2026-02-17-no-trades-zero-candidates.md

@@ -0,0 +1,29 @@
+# Issue: Realtime 모드에서 거래가 지속적으로 0건
+
+## Summary
+`realtime` 실행 중 주문 단계까지 진입하지 못하고, 스캐너 단계에서 후보가 0건으로 반복 종료된다.
+
+## Observed
+- 로그에서 반복적으로 `Smart Scanner: No candidates ... — no trades` 출력
+- 해외 시장에서 `Overseas ranking endpoint unavailable (404)` 다수 발생
+- fallback 심볼 스캔도 `0 candidates`로 종료
+- `data/trade_logs.db` 기준 최근 구간에 `BUY/SELL` 없음
+
+## Impact
+- 매매 전략 품질과 무관하게 주문 경로가 실행되지 않아 실질 거래 불가
+- 장애 원인을 로그만으로 즉시 분해하기 어려움
+
+## Root-Cause Hypothesis
+- 스캐너 필터(가격/변동성) 단계에서 대부분 탈락
+- 해외 랭킹 API 불가 시 입력 유니버스가 빈 상태가 되어 후보 생성 실패
+- 기존 로그는 최종 결과(0 candidates)만 보여 원인별 분해가 어려움
+
+## Acceptance Criteria
+- 스캔 1회마다 탈락 사유가 구조화되어 로그에 남아야 함
+- 국내/해외(랭킹/폴백) 경로 모두 동일한 진단 지표를 제공해야 함
+- 운영자가 로그만 보고 `왜 0 candidates인지`를 즉시 판단 가능해야 함
+
+## Scope
+- 이번 이슈는 **진단 가능성 개선(Observability)** 에 한정
+- 후보 생성 전략 변경(기본 유니버스 강제 추가 등)은 별도 이슈로 분리
+

docs/prs/PR-2026-02-17-scanner-diagnostics-for-zero-candidates.md

@@ -0,0 +1,32 @@
+# PR: Smart Scanner 진단 로그 추가 (0 candidates 원인 분해)
+
+## Linked Issue
+- `docs/issues/ISSUE-2026-02-17-no-trades-zero-candidates.md`
+
+## What Changed
+- `src/analysis/smart_scanner.py`에 스캔 진단 카운터 추가
+- 국내 스캔 진단 로그 추가
+- 해외 랭킹 스캔 진단 로그 추가
+- 해외 fallback 심볼 스캔 진단 로그 추가
+
+## Diagnostics Keys
+- `total_rows`
+- `missing_code`
+- `invalid_price`
+- `low_volatility`
+- `connection_error` (해당 경로에서만)
+- `unexpected_error` (해당 경로에서만)
+- `qualified`
+
+## Expected Log Examples
+- `Domestic scan diagnostics: {...}`
+- `Overseas ranking scan diagnostics for US_NASDAQ: {...}`
+- `Overseas fallback scan diagnostics for US_NYSE: {...}`
+
+## Out of Scope
+- 해외 랭킹 404 시 기본 심볼 유니버스 강제 주입
+- 국내 경로 fallback 정책 변경
+
+## Validation
+- `.venv/bin/python -m py_compile src/analysis/smart_scanner.py`
+

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 효율화
@@ -191,104 +165,3 @@
 **효과:**
 - 국내/해외 스캐너 기준이 변동성 중심으로 일관화
 - 고변동 구간에서 자동 익스포저 축소, 저변동 구간에서 과소진입 완화
-
-## 2026-02-18
-
-### KIS 해외 랭킹 API 404 에러 수정
-
-**배경:**
-- KIS 해외주식 랭킹 API(`fetch_overseas_rankings`)가 모든 거래소에서 HTTP 404를 반환
-- Smart Scanner가 해외 시장 후보 종목을 찾지 못해 거래가 전혀 실행되지 않음
-
-**근본 원인:**
-- TR_ID, API 경로, 거래소 코드가 모두 KIS 공식 문서와 불일치
-
-**구현 결과:**
-- `src/config.py`: TR_ID/Path 기본값을 KIS 공식 스펙으로 수정
-- `src/broker/overseas.py`: 랭킹 API 전용 거래소 코드 매핑 추가 (NASD→NAS, NYSE→NYS, AMEX→AMS), 올바른 API 파라미터 사용
-- `tests/test_overseas_broker.py`: 19개 단위 테스트 추가
-
-**효과:**
-- 해외 시장 랭킹 스캔이 정상 동작하여 Smart Scanner가 후보 종목 탐지 가능
-
-### Gemini prompt_override 미적용 버그 수정
-
-**배경:**
-- `run_overnight` 실행 시 모든 시장에서 Playbook 생성 실패 (`JSONDecodeError`)
-- defensive playbook으로 폴백되어 모든 종목이 HOLD 처리
-
-**근본 원인:**
-- `pre_market_planner.py`가 `market_data["prompt_override"]`에 Playbook 전용 프롬프트를 넣어 `gemini.decide()` 호출
-- `gemini_client.py`의 `decide()` 메서드가 `prompt_override` 키를 전혀 확인하지 않고 항상 일반 트레이드 결정 프롬프트 생성
-- Gemini가 Playbook JSON 대신 일반 트레이드 결정을 반환하여 파싱 실패
-
-**구현 결과:**
-- `src/brain/gemini_client.py`: `decide()` 메서드에서 `prompt_override` 우선 사용 로직 추가
-- `tests/test_brain.py`: 3개 테스트 추가 (override 전달, optimization 우회, 미지정 시 기존 동작 유지)
-
-**이슈/PR:** #143
-
-### 미국장 거래 미실행 근본 원인 분석 및 수정 (자율 실행 세션)
-
-**배경:**
-- 사용자 요청: "미국장 열면 프로그램 돌려서 거래 한 번도 못 한 거 꼭 원인 찾아서 해결해줘"
-- 프로그램을 미국장 개장(9:30 AM EST) 전부터 실행하여 실시간 로그를 분석
-
-**발견된 근본 원인 #1: Defensive Playbook — BUY 조건 없음**
-
-- Gemini free tier (20 RPD) 소진 → `generate_playbook()` 실패 → `_defensive_playbook()` 폴백
-- Defensive playbook은 `price_change_pct_below: -3.0 → SELL` 조건만 존재, BUY 조건 없음
-- ScenarioEngine이 항상 HOLD 반환 → 거래 0건
-
-**수정 #1 (PR #146, Issue #145):**
-- `src/strategy/pre_market_planner.py`: `_smart_fallback_playbook()` 메서드 추가
-  - 스캐너 signal 기반 BUY 조건 생성: `momentum → volume_ratio_above`, `oversold → rsi_below`
-  - 기존 defensive stop-loss SELL 조건 유지
-- Gemini 실패 시 defensive → smart fallback으로 전환
-- 테스트 10개 추가
-
-**발견된 근본 원인 #2: 가격 API 거래소 코드 불일치 + VTS 잔고 API 오류**
-
-실제 로그:
-```
-Scenario matched for MRNX: BUY (confidence=80)  ✓
-Decision for EWUS (NYSE American): BUY (confidence=80)  ✓
-Skip BUY APLZ (NYSE American): no affordable quantity (cash=0.00, price=0.00)  ✗
-```
-
-- `get_overseas_price()`: `NASD`/`NYSE`/`AMEX` 전송 → API가 `NAS`/`NYS`/`AMS` 기대 → 빈 응답 → `price=0`
-- `VTTS3012R` 잔고 API: "ERROR : INPUT INVALID_CHECK_ACNO" → `total_cash=0`
-- 결과: `_determine_order_quantity()` 가 0 반환 → 주문 건너뜀
-
-**수정 #2 (PR #148, Issue #147):**
-- `src/broker/overseas.py`: `_PRICE_EXCHANGE_MAP = _RANKING_EXCHANGE_MAP` 추가, 가격 API에 매핑 적용
-- `src/config.py`: `PAPER_OVERSEAS_CASH: float = Field(default=50000.0)` — paper 모드 시뮬레이션 잔고
-- `src/main.py`: 잔고 0일 때 PAPER_OVERSEAS_CASH 폴백, 가격 0일 때 candidate.price 폴백
-- 테스트 8개 추가
-
-**효과:**
-- BUY 결정 → 실제 주문 전송까지의 파이프라인이 완전히 동작
-- Paper 모드에서 KIS VTS 해외 잔고 API 오류에 관계없이 시뮬레이션 거래 가능
-
-**이슈/PR:** #145, #146, #147, #148
-
-### 해외주식 시장가 주문 거부 수정 (Fix #3, 연속 발견)
-
-**배경:**
-- Fix #147 적용 후 주문 전송 시작 → KIS VTS가 거부: "지정가만 가능한 상품입니다"
-
-**근본 원인:**
-- `trading_cycle()`, `run_daily_session()` 양쪽에서 `send_overseas_order(price=0.0)` 하드코딩
-- `price=0` → `ORD_DVSN="01"` (시장가) 전송 → KIS VTS 거부
-- Fix #147에서 이미 `current_price`를 올바르게 계산했으나 주문 시 미사용
-
-**구현 결과:**
-- `src/main.py`: 두 곳에서 `price=0.0` → `price=current_price`/`price=stock_data["current_price"]`
-- `tests/test_main.py`: 회귀 테스트 `test_overseas_buy_order_uses_limit_price` 추가
-
-**최종 확인 로그:**
-```
-Order result: 모의투자 매수주문이 완료 되었습니다.  ✓
-```
-
-**이슈/PR:** #149, #150

src/analysis/smart_scanner.py

@@ -128,6 +128,16 @@ class SmartVolatilityScanner:
         if not fluct_rows:
             return []
 
+        diagnostics: dict[str, int | float] = {
+            "total_rows": len(fluct_rows),
+            "missing_code": 0,
+            "invalid_price": 0,
+            "low_volatility": 0,
+            "connection_error": 0,
+            "unexpected_error": 0,
+            "qualified": 0,
+        }
+
         volume_rank_bonus: dict[str, float] = {}
         for idx, row in enumerate(volume_rows):
             code = _extract_stock_code(row)
@@ -139,6 +149,7 @@ class SmartVolatilityScanner:
         for stock in fluct_rows:
             stock_code = _extract_stock_code(stock)
             if not stock_code:
+                diagnostics["missing_code"] += 1
                 continue
 
             try:
@@ -168,14 +179,18 @@ class SmartVolatilityScanner:
                             volume_ratio = max(volume_ratio, volume / prev_day_volume)
 
                 volatility_pct = max(abs(change_rate), intraday_range_pct)
-                if price <= 0 or volatility_pct < 0.8:
+                if price <= 0:
+                    diagnostics["invalid_price"] += 1
+                    continue
+                if volatility_pct < 0.8:
+                    diagnostics["low_volatility"] += 1
                     continue
 
                 volatility_score = min(volatility_pct / 10.0, 1.0) * 85.0
                 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(
@@ -189,14 +204,22 @@ class SmartVolatilityScanner:
                         score=score,
                     )
                 )
+                diagnostics["qualified"] += 1
 
             except ConnectionError as exc:
+                diagnostics["connection_error"] += 1
                 logger.warning("Failed to analyze %s: %s", stock_code, exc)
                 continue
             except Exception as exc:
+                diagnostics["unexpected_error"] += 1
                 logger.error("Unexpected error analyzing %s: %s", stock_code, exc)
                 continue
 
+        logger.info(
+            "Domestic scan diagnostics: %s (volatility_threshold=0.8, top_n=%d)",
+            diagnostics,
+            self.top_n,
+        )
         logger.info("Domestic ranking scan found %d candidates", len(candidates))
         candidates.sort(key=lambda c: c.score, reverse=True)
         return candidates[: self.top_n]
@@ -242,6 +265,14 @@ class SmartVolatilityScanner:
         if not fluct_rows:
             return []
 
+        diagnostics: dict[str, int | float] = {
+            "total_rows": len(fluct_rows),
+            "missing_code": 0,
+            "invalid_price": 0,
+            "low_volatility": 0,
+            "qualified": 0,
+        }
+
         volume_rank_bonus: dict[str, float] = {}
         try:
             volume_rows = await self.overseas_broker.fetch_overseas_rankings(
@@ -266,6 +297,7 @@ class SmartVolatilityScanner:
         for row in fluct_rows:
             stock_code = _extract_stock_code(row)
             if not stock_code:
+                diagnostics["missing_code"] += 1
                 continue
 
             price = _extract_last_price(row)
@@ -275,14 +307,18 @@ class SmartVolatilityScanner:
             volatility_pct = max(abs(change_rate), intraday_range_pct)
 
             # Volatility-first filter (not simple gainers/value ranking).
-            if price <= 0 or volatility_pct < 0.8:
+            if price <= 0:
+                diagnostics["invalid_price"] += 1
+                continue
+            if volatility_pct < 0.8:
+                diagnostics["low_volatility"] += 1
                 continue
 
             volatility_score = min(volatility_pct / 10.0, 1.0) * 85.0
             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,
@@ -295,7 +331,14 @@ class SmartVolatilityScanner:
                     score=score,
                 )
             )
+            diagnostics["qualified"] += 1
 
+        logger.info(
+            "Overseas ranking scan diagnostics for %s: %s (volatility_threshold=0.8, top_n=%d)",
+            market.code,
+            diagnostics,
+            self.top_n,
+        )
         if candidates:
             logger.info(
                 "Overseas ranking scan found %d candidates for %s",
@@ -320,6 +363,14 @@ class SmartVolatilityScanner:
             len(symbols),
             market.name,
         )
+        diagnostics: dict[str, int | float] = {
+            "total_rows": len(symbols),
+            "invalid_price": 0,
+            "low_volatility": 0,
+            "connection_error": 0,
+            "unexpected_error": 0,
+            "qualified": 0,
+        }
         candidates: list[ScanCandidate] = []
         for stock_code in symbols:
             try:
@@ -333,12 +384,16 @@ class SmartVolatilityScanner:
                 intraday_range_pct = _extract_intraday_range_pct(output, price)
                 volatility_pct = max(abs(change_rate), intraday_range_pct)
 
-                if price <= 0 or volatility_pct < 0.8:
+                if price <= 0:
+                    diagnostics["invalid_price"] += 1
+                    continue
+                if volatility_pct < 0.8:
+                    diagnostics["low_volatility"] += 1
                     continue
 
                 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,
@@ -351,10 +406,19 @@ class SmartVolatilityScanner:
                         score=score,
                     )
                 )
+                diagnostics["qualified"] += 1
             except ConnectionError as exc:
+                diagnostics["connection_error"] += 1
                 logger.warning("Failed to analyze overseas %s: %s", stock_code, exc)
             except Exception as exc:
+                diagnostics["unexpected_error"] += 1
                 logger.error("Unexpected error analyzing overseas %s: %s", stock_code, exc)
+        logger.info(
+            "Overseas fallback scan diagnostics for %s: %s (volatility_threshold=0.8, top_n=%d)",
+            market.code,
+            diagnostics,
+            self.top_n,
+        )
         logger.info(
             "Overseas symbol fallback scan found %d candidates for %s",
             len(candidates),

src/brain/gemini_client.py

@@ -410,10 +410,8 @@ class GeminiClient:
                     cached=True,
                 )
 
-        # Build prompt (prompt_override takes priority for callers like pre_market_planner)
-        if "prompt_override" in market_data:
-            prompt = market_data["prompt_override"]
-        elif self._enable_optimization:
+        # Build optimized prompt
+        if self._enable_optimization:
             prompt = self._optimizer.build_compressed_prompt(market_data)
         else:
             prompt = await self.build_prompt(market_data, news_sentiment)

src/broker/kis_api.py

@@ -20,39 +20,6 @@ _KIS_VTS_HOST = "openapivts.koreainvestment.com"
 logger = logging.getLogger(__name__)
 
 
-def kr_tick_unit(price: float) -> int:
-    """Return KRX tick size for the given price level.
-
-    KRX price tick rules (domestic stocks):
-        price < 2,000        →   1원
-        2,000  ≤ price < 5,000     →   5원
-        5,000  ≤ price < 20,000    →  10원
-        20,000 ≤ price < 50,000    →  50원
-        50,000 ≤ price < 200,000   → 100원
-        200,000 ≤ price < 500,000  → 500원
-        500,000 ≤ price            → 1,000원
-    """
-    if price < 2_000:
-        return 1
-    if price < 5_000:
-        return 5
-    if price < 20_000:
-        return 10
-    if price < 50_000:
-        return 50
-    if price < 200_000:
-        return 100
-    if price < 500_000:
-        return 500
-    return 1_000
-
-
-def kr_round_down(price: float) -> int:
-    """Round *down* price to the nearest KRX tick unit."""
-    tick = kr_tick_unit(price)
-    return int(price // tick * tick)
-
-
 class LeakyBucket:
     """Simple leaky-bucket rate limiter for async code."""
 
@@ -231,55 +198,6 @@ class KISBroker:
         except (TimeoutError, aiohttp.ClientError) as exc:
             raise ConnectionError(f"Network error fetching orderbook: {exc}") from exc
 
-    async def get_current_price(
-        self, stock_code: str
-    ) -> tuple[float, float, float]:
-        """Fetch current price data for a domestic stock.
-
-        Uses the ``inquire-price`` API (FHKST01010100), which works in both
-        real and VTS environments and returns the actual last-traded price.
-
-        Returns:
-            (current_price, prdy_ctrt, frgn_ntby_qty)
-            - current_price: Last traded price in KRW.
-            - prdy_ctrt: Day change rate (%).
-            - frgn_ntby_qty: Foreigner net buy quantity.
-        """
-        await self._rate_limiter.acquire()
-        session = self._get_session()
-
-        headers = await self._auth_headers("FHKST01010100")
-        params = {
-            "FID_COND_MRKT_DIV_CODE": "J",
-            "FID_INPUT_ISCD": stock_code,
-        }
-        url = f"{self._base_url}/uapi/domestic-stock/v1/quotations/inquire-price"
-
-        def _f(val: str | None) -> float:
-            try:
-                return float(val or "0")
-            except ValueError:
-                return 0.0
-
-        try:
-            async with session.get(url, headers=headers, params=params) as resp:
-                if resp.status != 200:
-                    text = await resp.text()
-                    raise ConnectionError(
-                        f"get_current_price failed ({resp.status}): {text}"
-                    )
-                data = await resp.json()
-                out = data.get("output", {})
-                return (
-                    _f(out.get("stck_prpr")),
-                    _f(out.get("prdy_ctrt")),
-                    _f(out.get("frgn_ntby_qty")),
-                )
-        except (TimeoutError, aiohttp.ClientError) as exc:
-            raise ConnectionError(
-                f"Network error fetching current price: {exc}"
-            ) from exc
-
     async def get_balance(self) -> dict[str, Any]:
         """Fetch current account balance and holdings."""
         await self._rate_limiter.acquire()
@@ -331,23 +249,13 @@ class KISBroker:
         session = self._get_session()
 
         tr_id = "VTTC0802U" if order_type == "BUY" else "VTTC0801U"
-
-        # KRX requires limit orders to be rounded down to the tick unit.
-        # ORD_DVSN: "00"=지정가, "01"=시장가
-        if price > 0:
-            ord_dvsn = "00"  # 지정가
-            ord_price = kr_round_down(price)
-        else:
-            ord_dvsn = "01"  # 시장가
-            ord_price = 0
-
         body = {
             "CANO": self._account_no,
             "ACNT_PRDT_CD": self._product_cd,
             "PDNO": stock_code,
-            "ORD_DVSN": ord_dvsn,
+            "ORD_DVSN": "01" if price > 0 else "06",  # 01=지정가, 06=시장가
             "ORD_QTY": str(quantity),
-            "ORD_UNPR": str(ord_price),
+            "ORD_UNPR": str(price),
         }
 
         hash_key = await self._get_hash_key(body)
@@ -396,45 +304,25 @@ class KISBroker:
         await self._rate_limiter.acquire()
         session = self._get_session()
 
-        if ranking_type == "volume":
-            # 거래량순위: FHPST01710000 / /quotations/volume-rank
-            tr_id = "FHPST01710000"
-            url = f"{self._base_url}/uapi/domestic-stock/v1/quotations/volume-rank"
-            params: dict[str, str] = {
-                "FID_COND_MRKT_DIV_CODE": "J",
-                "FID_COND_SCR_DIV_CODE": "20171",
-                "FID_INPUT_ISCD": "0000",
-                "FID_DIV_CLS_CODE": "0",
+        # TR_ID for volume ranking
+        tr_id = "FHPST01710000" if ranking_type == "volume" else "FHPST01710100"
+        headers = await self._auth_headers(tr_id)
+
+        params = {
+            "FID_COND_MRKT_DIV_CODE": "J",  # Stock/ETF/ETN
+            "FID_COND_SCR_DIV_CODE": "20001",  # Volume surge
+            "FID_INPUT_ISCD": "0000",  # All stocks
+            "FID_DIV_CLS_CODE": "0",  # All types
             "FID_BLNG_CLS_CODE": "0",
             "FID_TRGT_CLS_CODE": "111111111",
-                "FID_TRGT_EXLS_CLS_CODE": "0000000000",
+            "FID_TRGT_EXLS_CLS_CODE": "000000",
             "FID_INPUT_PRICE_1": "0",
             "FID_INPUT_PRICE_2": "0",
             "FID_VOL_CNT": "0",
             "FID_INPUT_DATE_1": "",
         }
-        else:
-            # 등락률순위: FHPST01700000 / /ranking/fluctuation (소문자 파라미터)
-            tr_id = "FHPST01700000"
-            url = f"{self._base_url}/uapi/domestic-stock/v1/ranking/fluctuation"
-            params = {
-                "fid_cond_mrkt_div_code": "J",
-                "fid_cond_scr_div_code": "20170",
-                "fid_input_iscd": "0000",
-                "fid_rank_sort_cls_code": "0000",
-                "fid_input_cnt_1": str(limit),
-                "fid_prc_cls_code": "0",
-                "fid_input_price_1": "0",
-                "fid_input_price_2": "0",
-                "fid_vol_cnt": "0",
-                "fid_trgt_cls_code": "0",
-                "fid_trgt_exls_cls_code": "0",
-                "fid_div_cls_code": "0",
-                "fid_rsfl_rate1": "0",
-                "fid_rsfl_rate2": "0",
-            }
 
-        headers = await self._auth_headers(tr_id)
+        url = f"{self._base_url}/uapi/domestic-stock/v1/quotations/volume-rank"
 
         try:
             async with session.get(url, headers=headers, params=params) as resp:

src/broker/overseas.py

@@ -12,24 +12,6 @@ from src.broker.kis_api import KISBroker
 logger = logging.getLogger(__name__)
 
 
-# Ranking API uses different exchange codes than order/quote APIs.
-_RANKING_EXCHANGE_MAP: dict[str, str] = {
-    "NASD": "NAS",
-    "NYSE": "NYS",
-    "AMEX": "AMS",
-    "SEHK": "HKS",
-    "SHAA": "SHS",
-    "SZAA": "SZS",
-    "HSX": "HSX",
-    "HNX": "HNX",
-    "TSE": "TSE",
-}
-
-# Price inquiry API (HHDFS00000300) uses the same short exchange codes as rankings.
-# NASD → NAS, NYSE → NYS, AMEX → AMS (confirmed: AMEX returns empty, AMS returns price).
-_PRICE_EXCHANGE_MAP: dict[str, str] = _RANKING_EXCHANGE_MAP
-
-
 class OverseasBroker:
     """KIS Overseas Stock API wrapper that reuses KISBroker infrastructure."""
 
@@ -62,11 +44,9 @@ class OverseasBroker:
         session = self._broker._get_session()
 
         headers = await self._broker._auth_headers("HHDFS00000300")
-        # Map internal exchange codes to the short form expected by the price API.
-        price_excd = _PRICE_EXCHANGE_MAP.get(exchange_code, exchange_code)
         params = {
             "AUTH": "",
-            "EXCD": price_excd,
+            "EXCD": exchange_code,
             "SYMB": stock_code,
         }
         url = f"{self._broker._base_url}/uapi/overseas-price/v1/quotations/price"
@@ -90,7 +70,7 @@ class OverseasBroker:
         ranking_type: str = "fluctuation",
         limit: int = 30,
     ) -> list[dict[str, Any]]:
-        """Fetch overseas rankings (price change or volume surge).
+        """Fetch overseas rankings (price change or volume amount).
 
         Ranking API specs may differ by account/product. Endpoint paths and
         TR_IDs are configurable via settings and can be overridden in .env.
@@ -101,63 +81,66 @@ class OverseasBroker:
         await self._broker._rate_limiter.acquire()
         session = self._broker._get_session()
 
-        ranking_excd = _RANKING_EXCHANGE_MAP.get(exchange_code, exchange_code)
-
         if ranking_type == "volume":
-            tr_id = self._broker._settings.OVERSEAS_RANKING_VOLUME_TR_ID
-            path = self._broker._settings.OVERSEAS_RANKING_VOLUME_PATH
-            params: dict[str, str] = {
-                "AUTH": "",
-                "EXCD": ranking_excd,
-                "MIXN": "0",
-                "VOL_RANG": "0",
-            }
+            configured_tr_id = self._broker._settings.OVERSEAS_RANKING_VOLUME_TR_ID
+            configured_path = self._broker._settings.OVERSEAS_RANKING_VOLUME_PATH
+            default_tr_id = "HHDFS76200200"
+            default_path = "/uapi/overseas-price/v1/quotations/inquire-volume-rank"
         else:
-            tr_id = self._broker._settings.OVERSEAS_RANKING_FLUCT_TR_ID
-            path = self._broker._settings.OVERSEAS_RANKING_FLUCT_PATH
-            params = {
-                "AUTH": "",
-                "EXCD": ranking_excd,
-                "NDAY": "0",
-                "GUBN": "1",
-                "VOL_RANG": "0",
-            }
+            configured_tr_id = self._broker._settings.OVERSEAS_RANKING_FLUCT_TR_ID
+            configured_path = self._broker._settings.OVERSEAS_RANKING_FLUCT_PATH
+            default_tr_id = "HHDFS76200100"
+            default_path = "/uapi/overseas-price/v1/quotations/inquire-updown-rank"
 
+        endpoint_specs: list[tuple[str, str]] = [(configured_tr_id, configured_path)]
+        if (configured_tr_id, configured_path) != (default_tr_id, default_path):
+            endpoint_specs.append((default_tr_id, default_path))
+
+        # Try common param variants used by KIS overseas quotation APIs.
+        param_variants = [
+            {"AUTH": "", "EXCD": exchange_code, "NREC": str(max(limit, 30))},
+            {"AUTH": "", "OVRS_EXCG_CD": exchange_code, "NREC": str(max(limit, 30))},
+            {"AUTH": "", "EXCD": exchange_code},
+            {"AUTH": "", "OVRS_EXCG_CD": exchange_code},
+        ]
+
+        last_error: str | None = None
+        saw_http_404 = False
+        for tr_id, path in endpoint_specs:
             headers = await self._broker._auth_headers(tr_id)
             url = f"{self._broker._base_url}{path}"
-
+            for params in param_variants:
                 try:
                     async with session.get(url, headers=headers, params=params) as resp:
-                if resp.status != 200:
                         text = await resp.text()
+                        if resp.status != 200:
+                            last_error = f"HTTP {resp.status}: {text}"
                             if resp.status == 404:
-                        logger.warning(
-                            "Overseas ranking endpoint unavailable (404) for %s/%s; "
-                            "using symbol fallback scan",
-                            exchange_code,
-                            ranking_type,
-                        )
-                        return []
-                    raise ConnectionError(
-                        f"fetch_overseas_rankings failed ({resp.status}): {text}"
-                    )
+                                saw_http_404 = True
+                            continue
 
                         data = await resp.json()
                         rows = self._extract_ranking_rows(data)
                         if rows:
                             return rows[:limit]
 
-                logger.debug(
-                    "Overseas ranking returned empty for %s/%s (keys=%s)",
+                        # keep trying another param variant if response has no usable rows
+                        last_error = f"empty output (keys={list(data.keys())})"
+                except (TimeoutError, aiohttp.ClientError) as exc:
+                    last_error = str(exc)
+                    continue
+
+        if saw_http_404:
+            logger.warning(
+                "Overseas ranking endpoint unavailable (404) for %s/%s; using symbol fallback scan",
                 exchange_code,
                 ranking_type,
-                    list(data.keys()),
             )
             return []
-        except (TimeoutError, aiohttp.ClientError) as exc:
+
         raise ConnectionError(
-                f"Network error fetching overseas rankings: {exc}"
-            ) from exc
+            f"fetch_overseas_rankings failed for {exchange_code}/{ranking_type}: {last_error}"
+        )
 
     async def get_overseas_balance(self, exchange_code: str) -> dict[str, Any]:
         """
@@ -230,9 +213,7 @@ class OverseasBroker:
         session = self._broker._get_session()
 
         # Virtual trading TR_IDs for overseas orders
-        # Source: 한국투자증권 오픈API 전체문서 (20260221) — '해외주식 주문' 시트
-        # VTTT1002U: 모의투자 미국 매수, VTTT1001U: 모의투자 미국 매도
-        tr_id = "VTTT1002U" if order_type == "BUY" else "VTTT1001U"
+        tr_id = "VTTT1002U" if order_type == "BUY" else "VTTT1006U"
 
         body = {
             "CANO": self._broker._account_no,
@@ -259,9 +240,6 @@ class OverseasBroker:
                         f"send_overseas_order failed ({resp.status}): {text}"
                     )
                 data = await resp.json()
-                rt_cd = data.get("rt_cd", "")
-                msg1 = data.get("msg1", "")
-                if rt_cd == "0":
                 logger.info(
                     "Overseas order submitted",
                     extra={
@@ -270,16 +248,6 @@ class OverseasBroker:
                         "action": order_type,
                     },
                 )
-                else:
-                    logger.warning(
-                        "Overseas order rejected (rt_cd=%s): %s [%s %s %s qty=%d]",
-                        rt_cd,
-                        msg1,
-                        order_type,
-                        stock_code,
-                        exchange_code,
-                        quantity,
-                    )
                 return data
         except (TimeoutError, aiohttp.ClientError) as exc:
             raise ConnectionError(

src/config.py

@@ -55,11 +55,6 @@ class Settings(BaseSettings):
     # Trading mode
     MODE: str = Field(default="paper", pattern="^(paper|live)$")
 
-    # Simulated USD cash for VTS (paper) overseas trading.
-    # KIS VTS overseas balance API returns errors for most accounts.
-    # This value is used as a fallback when the balance API returns 0 in paper mode.
-    PAPER_OVERSEAS_CASH: float = Field(default=50000.0, ge=0.0)
-
     # Trading frequency mode (daily = batch API calls, realtime = per-stock calls)
     TRADE_MODE: str = Field(default="daily", pattern="^(daily|realtime)$")
     DAILY_SESSIONS: int = Field(default=4, ge=1, le=10)
@@ -93,26 +88,16 @@ class Settings(BaseSettings):
     TELEGRAM_COMMANDS_ENABLED: bool = True
     TELEGRAM_POLLING_INTERVAL: float = 1.0  # seconds
 
-    # Telegram notification type filters (granular control)
-    # circuit_breaker is always sent regardless — safety-critical
-    TELEGRAM_NOTIFY_TRADES: bool = True           # BUY/SELL execution alerts
-    TELEGRAM_NOTIFY_MARKET_OPEN_CLOSE: bool = True  # Market open/close alerts
-    TELEGRAM_NOTIFY_FAT_FINGER: bool = True       # Fat-finger rejection alerts
-    TELEGRAM_NOTIFY_SYSTEM_EVENTS: bool = True    # System start/shutdown alerts
-    TELEGRAM_NOTIFY_PLAYBOOK: bool = True         # Playbook generated/failed alerts
-    TELEGRAM_NOTIFY_SCENARIO_MATCH: bool = True   # Scenario matched alerts (most frequent)
-    TELEGRAM_NOTIFY_ERRORS: bool = True           # Error alerts
-
     # Overseas ranking API (KIS endpoint/TR_ID may vary by account/product)
     # Override these from .env if your account uses different specs.
     OVERSEAS_RANKING_ENABLED: bool = True
-    OVERSEAS_RANKING_FLUCT_TR_ID: str = "HHDFS76290000"
-    OVERSEAS_RANKING_VOLUME_TR_ID: str = "HHDFS76270000"
+    OVERSEAS_RANKING_FLUCT_TR_ID: str = "HHDFS76200100"
+    OVERSEAS_RANKING_VOLUME_TR_ID: str = "HHDFS76200200"
     OVERSEAS_RANKING_FLUCT_PATH: str = (
-        "/uapi/overseas-stock/v1/ranking/updown-rate"
+        "/uapi/overseas-price/v1/quotations/inquire-updown-rank"
     )
     OVERSEAS_RANKING_VOLUME_PATH: str = (
-        "/uapi/overseas-stock/v1/ranking/volume-surge"
+        "/uapi/overseas-price/v1/quotations/inquire-volume-rank"
     )
 
     # Dashboard (optional)

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}")
@@ -294,50 +259,6 @@ def create_dashboard_app(db_path: str) -> FastAPI:
                 )
             return {"market": market, "count": len(decisions), "decisions": decisions}
 
-    @app.get("/api/pnl/history")
-    def get_pnl_history(
-        days: int = Query(default=30, ge=1, le=365),
-        market: str = Query("all"),
-    ) -> dict[str, Any]:
-        """Return daily P&L history for charting."""
-        with _connect(db_path) as conn:
-            if market == "all":
-                rows = conn.execute(
-                    """
-                    SELECT DATE(timestamp) AS date,
-                           SUM(pnl) AS daily_pnl,
-                           COUNT(*) AS trade_count
-                    FROM trades
-                    WHERE pnl IS NOT NULL
-                      AND DATE(timestamp) >= DATE('now', ?)
-                    GROUP BY DATE(timestamp)
-                    ORDER BY DATE(timestamp)
-                    """,
-                    (f"-{days} days",),
-                ).fetchall()
-            else:
-                rows = conn.execute(
-                    """
-                    SELECT DATE(timestamp) AS date,
-                           SUM(pnl) AS daily_pnl,
-                           COUNT(*) AS trade_count
-                    FROM trades
-                    WHERE pnl IS NOT NULL
-                      AND market = ?
-                      AND DATE(timestamp) >= DATE('now', ?)
-                    GROUP BY DATE(timestamp)
-                    ORDER BY DATE(timestamp)
-                    """,
-                    (market, f"-{days} days"),
-                ).fetchall()
-            return {
-                "days": days,
-                "market": market,
-                "labels": [row["date"] for row in rows],
-                "pnl": [round(float(row["daily_pnl"]), 2) for row in rows],
-                "trades": [int(row["trade_count"]) for row in rows],
-            }
-
     @app.get("/api/scenarios/active")
     def get_active_scenarios(
         market: str = Query("US"),
@@ -376,68 +297,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
 
 

src/dashboard/static/index.html

@@ -1,10 +1,9 @@
 <!doctype html>
-<html lang="ko">
+<html lang="en">
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>The Ouroboros Dashboard</title>
-    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.min.js"></script>
     <style>
       :root {
         --bg: #0b1724;
@@ -12,760 +11,51 @@
         --fg: #e6eef7;
         --muted: #9fb3c8;
         --accent: #3cb371;
-        --red: #e05555;
-        --warn: #e8a040;
-        --border: #28455f;
       }
-      * { box-sizing: border-box; margin: 0; padding: 0; }
       body {
+        margin: 0;
         font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
         background: radial-gradient(circle at top left, #173b58, var(--bg));
         color: var(--fg);
-        min-height: 100vh;
-        font-size: 13px;
       }
-      .wrap { max-width: 1100px; margin: 0 auto; padding: 20px 16px; }
-
-      /* Header */
-      header {
-        display: flex;
-        align-items: center;
-        justify-content: space-between;
-        margin-bottom: 20px;
-        padding-bottom: 12px;
-        border-bottom: 1px solid var(--border);
+      .wrap {
+        max-width: 900px;
+        margin: 48px auto;
+        padding: 0 16px;
       }
-      header h1 { font-size: 18px; color: var(--accent); letter-spacing: 0.5px; }
-      .header-right { display: flex; align-items: center; gap: 12px; color: var(--muted); font-size: 12px; }
-      .refresh-btn {
-        background: none; border: 1px solid var(--border); color: var(--muted);
-        padding: 4px 10px; border-radius: 6px; cursor: pointer; font-family: inherit;
-        font-size: 12px; transition: border-color 0.2s;
-      }
-      .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); } }
       .card {
-        background: var(--panel);
-        border: 1px solid var(--border);
-        border-radius: 10px;
-        padding: 16px;
+        background: color-mix(in oklab, var(--panel), black 12%);
+        border: 1px solid #28455f;
+        border-radius: 12px;
+        padding: 20px;
       }
-      .card-label { color: var(--muted); font-size: 11px; margin-bottom: 6px; text-transform: uppercase; letter-spacing: 0.5px; }
-      .card-value { font-size: 22px; font-weight: 700; }
-      .card-sub { color: var(--muted); font-size: 11px; margin-top: 4px; }
-      .positive { color: var(--accent); }
-      .negative { color: var(--red); }
-      .neutral { color: var(--fg); }
-
-      /* Chart panel */
-      .chart-panel {
-        background: var(--panel);
-        border: 1px solid var(--border);
-        border-radius: 10px;
-        padding: 16px;
-        margin-bottom: 20px;
+      h1 {
+        margin-top: 0;
       }
-      .panel-header {
-        display: flex;
-        align-items: center;
-        justify-content: space-between;
-        margin-bottom: 16px;
+      code {
+        color: var(--accent);
       }
-      .panel-title { font-size: 13px; color: var(--muted); font-weight: 600; }
-      .chart-container { position: relative; height: 180px; }
-      .chart-error { color: var(--muted); text-align: center; padding: 40px 0; font-size: 12px; }
-
-      /* Days selector */
-      .days-selector { display: flex; gap: 4px; }
-      .day-btn {
-        background: none; border: 1px solid var(--border); color: var(--muted);
-        padding: 3px 8px; border-radius: 4px; cursor: pointer; font-family: inherit; font-size: 11px;
+      li {
+        margin: 6px 0;
+        color: var(--muted);
       }
-      .day-btn.active { border-color: var(--accent); color: var(--accent); background: rgba(60, 179, 113, 0.08); }
-
-      /* Decisions panel */
-      .decisions-panel {
-        background: var(--panel);
-        border: 1px solid var(--border);
-        border-radius: 10px;
-        padding: 16px;
-      }
-      .market-tabs { display: flex; gap: 6px; flex-wrap: wrap; }
-      .tab-btn {
-        background: none; border: 1px solid var(--border); color: var(--muted);
-        padding: 4px 10px; border-radius: 6px; cursor: pointer; font-family: inherit; font-size: 11px;
-      }
-      .tab-btn.active { border-color: var(--accent); color: var(--accent); background: rgba(60, 179, 113, 0.08); }
-      .decisions-table { width: 100%; border-collapse: collapse; margin-top: 14px; }
-      .decisions-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;
-      }
-      .decisions-table td {
-        padding: 8px 8px; border-bottom: 1px solid rgba(40, 69, 95, 0.5);
-        vertical-align: middle; white-space: nowrap;
-      }
-      .decisions-table tr:last-child td { border-bottom: none; }
-      .decisions-table tr:hover td { background: rgba(255,255,255,0.02); }
-      .badge {
-        display: inline-block; padding: 2px 7px; border-radius: 4px;
-        font-size: 11px; font-weight: 700; letter-spacing: 0.5px;
-      }
-      .badge-buy { background: rgba(60, 179, 113, 0.15); color: var(--accent); }
-      .badge-sell { background: rgba(224, 85, 85, 0.15); color: var(--red); }
-      .badge-hold { background: rgba(159, 179, 200, 0.12); color: var(--muted); }
-      .conf-bar-wrap { display: flex; align-items: center; gap: 6px; min-width: 90px; }
-      .conf-bar { flex: 1; height: 6px; background: rgba(255,255,255,0.08); border-radius: 3px; overflow: hidden; }
-      .conf-fill { height: 100%; border-radius: 3px; background: var(--accent); transition: width 0.3s; }
-      .conf-val { color: var(--muted); font-size: 11px; min-width: 26px; text-align: right; }
-      .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>
     <div class="wrap">
-      <!-- Header -->
-      <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>
-      </header>
-
-      <!-- Summary cards -->
-      <div class="cards">
       <div class="card">
-          <div class="card-label">오늘 거래</div>
-          <div class="card-value neutral" id="card-trades">--</div>
-          <div class="card-sub" id="card-trades-sub">거래 건수</div>
-        </div>
-        <div class="card">
-          <div class="card-label">오늘 P&amp;L</div>
-          <div class="card-value" id="card-pnl">--</div>
-          <div class="card-sub" id="card-pnl-sub">실현 손익</div>
-        </div>
-        <div class="card">
-          <div class="card-label">승률</div>
-          <div class="card-value neutral" id="card-winrate">--</div>
-          <div class="card-sub">전체 누적</div>
-        </div>
-        <div class="card">
-          <div class="card-label">누적 거래</div>
-          <div class="card-value neutral" id="card-total">--</div>
-          <div class="card-sub">전체 기간</div>
+        <h1>The Ouroboros Dashboard API</h1>
+        <p>Use the following endpoints:</p>
+        <ul>
+          <li><code>/api/status</code></li>
+          <li><code>/api/playbook/{date}?market=KR</code></li>
+          <li><code>/api/scorecard/{date}?market=KR</code></li>
+          <li><code>/api/performance?market=all</code></li>
+          <li><code>/api/context/{layer}</code></li>
+          <li><code>/api/decisions?market=KR</code></li>
+          <li><code>/api/scenarios/active?market=US</code></li>
+        </ul>
       </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">
-          <span class="panel-title">P&amp;L 추이</span>
-          <div class="days-selector">
-            <button class="day-btn active" data-days="7" onclick="selectDays(this)">7일</button>
-            <button class="day-btn" data-days="30" onclick="selectDays(this)">30일</button>
-            <button class="day-btn" data-days="90" onclick="selectDays(this)">90일</button>
-          </div>
-        </div>
-        <div class="chart-container">
-          <canvas id="pnl-chart"></canvas>
-          <div class="chart-error" id="chart-error" style="display:none">데이터 없음</div>
-        </div>
-      </div>
-
-      <!-- Decisions log -->
-      <div class="decisions-panel">
-        <div class="panel-header">
-          <span class="panel-title">최근 결정 로그</span>
-          <div class="market-tabs" id="market-tabs">
-            <button class="tab-btn active" data-market="KR" onclick="selectMarket(this)">KR</button>
-            <button class="tab-btn" data-market="US_NASDAQ" onclick="selectMarket(this)">US_NASDAQ</button>
-            <button class="tab-btn" data-market="US_NYSE" onclick="selectMarket(this)">US_NYSE</button>
-            <button class="tab-btn" data-market="JP" onclick="selectMarket(this)">JP</button>
-            <button class="tab-btn" data-market="HK" onclick="selectMarket(this)">HK</button>
-          </div>
-        </div>
-        <table class="decisions-table">
-          <thead>
-            <tr>
-              <th>시각</th>
-              <th>종목</th>
-              <th>액션</th>
-              <th>신뢰도</th>
-              <th>사유</th>
-            </tr>
-          </thead>
-          <tbody id="decisions-body">
-            <tr class="empty-row"><td colspan="5"><span class="spinner"></span></td></tr>
-          </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>
-      let pnlChart = null;
-      let currentDays = 7;
-      let currentMarket = 'KR';
-
-      function fmt(dt) {
-        try {
-          const d = new Date(dt);
-          return d.toLocaleTimeString('ko-KR', { hour: '2-digit', minute: '2-digit', hour12: false });
-        } catch { return dt || '--'; }
-      }
-
-      function fmtPnl(v) {
-        if (v === null || v === undefined) return '--';
-        const n = parseFloat(v);
-        const cls = n > 0 ? 'positive' : n < 0 ? 'negative' : 'neutral';
-        const sign = n > 0 ? '+' : '';
-        return `<span class="${cls}">${sign}${n.toFixed(2)}</span>`;
-      }
-
-      function badge(action) {
-        const a = (action || '').toUpperCase();
-        const cls = a === 'BUY' ? 'badge-buy' : a === 'SELL' ? 'badge-sell' : 'badge-hold';
-        return `<span class="badge ${cls}">${a}</span>`;
-      }
-
-      function confBar(conf) {
-        const pct = Math.min(Math.max(conf || 0, 0), 100);
-        return `<div class="conf-bar-wrap">
-          <div class="conf-bar"><div class="conf-fill" style="width:${pct}%"></div></div>
-          <span class="conf-val">${pct}</span>
-        </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');
-          if (!r.ok) return;
-          const d = await r.json();
-          const t = d.totals || {};
-          document.getElementById('card-trades').textContent = t.trade_count ?? '--';
-          const pnlEl = document.getElementById('card-pnl');
-          const pnlV = t.total_pnl;
-          if (pnlV !== undefined) {
-            const n = parseFloat(pnlV);
-            const sign = n > 0 ? '+' : '';
-            pnlEl.textContent = `${sign}${n.toFixed(2)}`;
-            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 {}
-      }
-
-      async function fetchPerformance() {
-        try {
-          const r = await fetch('/api/performance?market=all');
-          if (!r.ok) return;
-          const d = await r.json();
-          const c = d.combined || {};
-          document.getElementById('card-winrate').textContent = c.win_rate !== undefined ? `${c.win_rate}%` : '--';
-          document.getElementById('card-total').textContent = c.total_trades ?? '--';
-        } catch {}
-      }
-
-      async function fetchPnlHistory(days) {
-        try {
-          const r = await fetch(`/api/pnl/history?days=${days}`);
-          if (!r.ok) throw new Error('fetch failed');
-          const d = await r.json();
-          renderChart(d);
-        } catch {
-          document.getElementById('chart-error').style.display = 'block';
-        }
-      }
-
-      function renderChart(data) {
-        const errEl = document.getElementById('chart-error');
-        if (!data.labels || data.labels.length === 0) {
-          errEl.style.display = 'block';
-          return;
-        }
-        errEl.style.display = 'none';
-
-        const colors = data.pnl.map(v => v >= 0 ? 'rgba(60,179,113,0.75)' : 'rgba(224,85,85,0.75)');
-        const borderColors = data.pnl.map(v => v >= 0 ? '#3cb371' : '#e05555');
-
-        if (pnlChart) { pnlChart.destroy(); pnlChart = null; }
-        const ctx = document.getElementById('pnl-chart').getContext('2d');
-        pnlChart = new Chart(ctx, {
-          type: 'bar',
-          data: {
-            labels: data.labels,
-            datasets: [{
-              label: 'Daily P&L',
-              data: data.pnl,
-              backgroundColor: colors,
-              borderColor: borderColors,
-              borderWidth: 1,
-              borderRadius: 3,
-            }]
-          },
-          options: {
-            responsive: true,
-            maintainAspectRatio: false,
-            plugins: {
-              legend: { display: false },
-              tooltip: {
-                callbacks: {
-                  label: ctx => {
-                    const v = ctx.parsed.y;
-                    const sign = v >= 0 ? '+' : '';
-                    const trades = data.trades[ctx.dataIndex];
-                    return [`P&L: ${sign}${v.toFixed(2)}`, `거래: ${trades}건`];
-                  }
-                }
-              }
-            },
-            scales: {
-              x: {
-                ticks: { color: '#9fb3c8', font: { size: 10 }, maxRotation: 0 },
-                grid: { color: 'rgba(40,69,95,0.4)' }
-              },
-              y: {
-                ticks: { color: '#9fb3c8', font: { size: 10 } },
-                grid: { color: 'rgba(40,69,95,0.4)' }
-              }
-            }
-          }
-        });
-      }
-
-      async function fetchDecisions(market) {
-        const tbody = document.getElementById('decisions-body');
-        tbody.innerHTML = '<tr class="empty-row"><td colspan="5"><span class="spinner"></span></td></tr>';
-        try {
-          const r = await fetch(`/api/decisions?market=${market}&limit=50`);
-          if (!r.ok) throw new Error('fetch failed');
-          const d = await r.json();
-          if (!d.decisions || d.decisions.length === 0) {
-            tbody.innerHTML = '<tr class="empty-row"><td colspan="5">결정 로그 없음</td></tr>';
-            return;
-          }
-          tbody.innerHTML = d.decisions.map(dec => `
-            <tr>
-              <td>${fmt(dec.timestamp)}</td>
-              <td>${dec.stock_code || '--'}</td>
-              <td>${badge(dec.action)}</td>
-              <td>${confBar(dec.confidence)}</td>
-              <td class="rationale-cell" title="${(dec.rationale || '').replace(/"/g, '&quot;')}">${dec.rationale || '--'}</td>
-            </tr>
-          `).join('');
-        } catch {
-          tbody.innerHTML = '<tr class="empty-row"><td colspan="5">데이터 로드 실패</td></tr>';
-        }
-      }
-
-      function selectDays(btn) {
-        document.querySelectorAll('.day-btn').forEach(b => b.classList.remove('active'));
-        btn.classList.add('active');
-        currentDays = parseInt(btn.dataset.days, 10);
-        fetchPnlHistory(currentDays);
-      }
-
-      function selectMarket(btn) {
-        document.querySelectorAll('.tab-btn').forEach(b => b.classList.remove('active'));
-        btn.classList.add('active');
-        currentMarket = btn.dataset.market;
-        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 });
-        document.getElementById('last-updated').textContent = `마지막 업데이트: ${timeStr}`;
-      }
-
-      // Initial load
-      refreshAll();
-
-      // Auto-refresh every 30 seconds
-      setInterval(refreshAll, 30000);
-    </script>
   </body>
 </html>

src/db.py

@@ -131,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
 

src/main.py

@@ -41,8 +41,8 @@ from src.evolution.optimizer import EvolutionOptimizer
 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.notifications.telegram_client import TelegramClient, TelegramCommandHandler
+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,7 +81,6 @@ 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
@@ -107,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,
@@ -190,40 +113,16 @@ def _determine_order_quantity(
     total_cash: float,
     candidate: ScanCandidate | None,
     settings: Settings | None,
-    broker_held_qty: int = 0,
-    playbook_allocation_pct: float | None = None,
-    scenario_confidence: int = 80,
 ) -> int:
-    """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
+    """Determine order quantity using volatility-aware position sizing."""
+    if action != "BUY":
+        return 1
     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))
@@ -299,16 +198,13 @@ 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()
 
     # 1. Fetch market data
     if market.is_domestic:
-        current_price, price_change_pct, foreigner_net = await broker.get_current_price(
-            stock_code
-        )
+        orderbook = await broker.get_orderbook(stock_code)
         balance_data = await broker.get_balance()
 
         output2 = balance_data.get("output2", [{}])
@@ -319,6 +215,10 @@ async def trading_cycle(
             else "0"
         )
         purchase_total = safe_float(output2[0].get("pchs_amt_smtl_amt", "0")) if output2 else 0
+
+        current_price = safe_float(orderbook.get("output1", {}).get("stck_prpr", "0"))
+        foreigner_net = safe_float(orderbook.get("output1", {}).get("frgn_ntby_qty", "0"))
+        price_change_pct = safe_float(orderbook.get("output1", {}).get("prdy_ctrt", "0"))
     else:
         # Overseas market
         price_data = await overseas_broker.get_overseas_price(
@@ -339,43 +239,10 @@ async def trading_cycle(
         total_cash = safe_float(balance_info.get("frcr_dncl_amt_2", "0") or "0")
         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.
-        if total_cash <= 0 and settings and settings.PAPER_OVERSEAS_CASH > 0:
-            logger.debug(
-                "Overseas cash balance is 0 for %s; using paper fallback %.2f USD",
-                market.exchange_code,
-                settings.PAPER_OVERSEAS_CASH,
-            )
-            total_cash = settings.PAPER_OVERSEAS_CASH
-
         current_price = safe_float(price_data.get("output", {}).get("last", "0"))
-        # Fallback: if price API returns 0, use scanner candidate price
-        if current_price <= 0:
-            market_candidates_lookup = scan_candidates.get(market.code, {})
-            cand_lookup = market_candidates_lookup.get(stock_code)
-            if cand_lookup and cand_lookup.price > 0:
-                logger.debug(
-                    "Price API returned 0 for %s; using scanner candidate price %.4f",
-                    stock_code,
-                    cand_lookup.price,
-                )
-                current_price = cand_lookup.price
         foreigner_net = 0.0  # Not available for overseas
         price_change_pct = safe_float(price_data.get("output", {}).get("rate", "0"))
 
-        # Price API may return 0/empty for certain VTS exchange codes.
-        # Fall back to the scanner candidate's price so order sizing still works.
-        if current_price <= 0:
-            market_candidates_lookup = scan_candidates.get(market.code, {})
-            cand_lookup = market_candidates_lookup.get(stock_code)
-            if cand_lookup and cand_lookup.price > 0:
-                current_price = cand_lookup.price
-                logger.debug(
-                    "Price API returned 0 for %s; using scanner price %.4f",
-                    stock_code,
-                    current_price,
-                )
-
     # Calculate daily P&L %
     pnl_pct = (
         ((total_eval - purchase_total) / purchase_total * 100)
@@ -430,17 +297,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,
@@ -493,53 +349,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 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:
@@ -547,10 +356,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(
@@ -568,22 +375,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,
@@ -644,23 +435,12 @@ async def trading_cycle(
     trade_price = current_price
     trade_pnl = 0.0
     if decision.action in ("BUY", "SELL"):
-        broker_held_qty = (
-            _extract_held_qty_from_balance(
-                balance_data, stock_code, is_domestic=market.is_domestic
-            )
-            if decision.action == "SELL"
-            else 0
-        )
-        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,
-            playbook_allocation_pct=matched_scenario.allocation_pct if matched_scenario else None,
-            scenario_confidence=match.confidence,
         )
         if quantity <= 0:
             logger.info(
@@ -674,28 +454,8 @@ async def trading_cycle(
             return
         order_amount = current_price * quantity
 
-        # 4. Check BUY cooldown (set when a prior BUY failed due to insufficient balance)
-        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.
+        # 4. Risk check BEFORE order
         try:
-            if decision.action == "SELL":
-                risk.check_circuit_breaker(pnl_pct)
-            else:
             risk.validate_order(
                 current_pnl_pct=pnl_pct,
                 order_amount=order_amount,
@@ -714,7 +474,6 @@ async def trading_cycle(
             raise  # Re-raise to prevent trade
 
         # 5. Send order
-        order_succeeded = True
         if market.is_domestic:
             result = await broker.send_order(
                 stock_code=stock_code,
@@ -723,47 +482,16 @@ async def trading_cycle(
                 price=0,  # market order
             )
         else:
-            # For overseas orders:
-            # - KIS VTS only accepts limit orders (지정가만 가능)
-            # - BUY: use 0.5% premium over last price to improve fill probability
-            #   (ask price is typically slightly above last, and VTS won't fill below ask)
-            # - SELL: use last price as the limit
-            if decision.action == "BUY":
-                order_price = round(current_price * 1.005, 4)
-            else:
-                order_price = current_price
             result = await overseas_broker.send_overseas_order(
                 exchange_code=market.exchange_code,
                 stock_code=stock_code,
                 order_type=decision.action,
                 quantity=quantity,
-                price=order_price,  # limit order — KIS VTS rejects market orders
-            )
-            # 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,
-                )
-                # 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,
+                price=0.0,  # market order
             )
         logger.info("Order result: %s", result.get("msg1", "OK"))
 
-        # 5.5. Notify trade execution (only on success)
-        if order_succeeded:
+        # 5.5. Notify trade execution
         try:
             await telegram.notify_trade_execution(
                 stock_code=stock_code,
@@ -776,7 +504,7 @@ async def trading_cycle(
         except Exception as exc:
             logger.warning("Telegram notification failed: %s", exc)
 
-        if decision.action == "SELL" and order_succeeded:
+        if decision.action == "SELL":
             buy_trade = get_latest_buy_trade(db_conn, stock_code, market.code)
             if buy_trade and buy_trade.get("price") is not None:
                 buy_price = float(buy_trade["price"])
@@ -788,9 +516,7 @@ async def trading_cycle(
                     accuracy=1 if trade_pnl > 0 else 0,
                 )
 
-    # 6. Log trade with selection context (skip if order was rejected)
-    if decision.action in ("BUY", "SELL") and not order_succeeded:
-        return
+    # 6. Log trade with selection context
     selection_context = None
     if stock_code in market_candidates:
         candidate = market_candidates[stock_code]
@@ -867,9 +593,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
@@ -948,8 +671,15 @@ async def run_daily_session(
         for stock_code in watchlist:
             try:
                 if market.is_domestic:
-                    current_price, price_change_pct, foreigner_net = (
-                        await broker.get_current_price(stock_code)
+                    orderbook = await broker.get_orderbook(stock_code)
+                    current_price = safe_float(
+                        orderbook.get("output1", {}).get("stck_prpr", "0")
+                    )
+                    foreigner_net = safe_float(
+                        orderbook.get("output1", {}).get("frgn_ntby_qty", "0")
+                    )
+                    price_change_pct = safe_float(
+                        orderbook.get("output1", {}).get("prdy_ctrt", "0")
                     )
                 else:
                     price_data = await overseas_broker.get_overseas_price(
@@ -958,30 +688,10 @@ async def run_daily_session(
                     current_price = safe_float(
                         price_data.get("output", {}).get("last", "0")
                     )
-                    # Fallback: if price API returns 0, use scanner candidate price
-                    if current_price <= 0:
-                        cand_lookup = candidate_map.get(stock_code)
-                        if cand_lookup and cand_lookup.price > 0:
-                            logger.debug(
-                                "Price API returned 0 for %s; using scanner candidate price %.4f",
-                                stock_code,
-                                cand_lookup.price,
-                            )
-                            current_price = cand_lookup.price
                     foreigner_net = 0.0
                     price_change_pct = safe_float(
                         price_data.get("output", {}).get("rate", "0")
                     )
-                    # Fall back to scanner candidate price if API returns 0.
-                    if current_price <= 0:
-                        cand_lookup = candidate_map.get(stock_code)
-                        if cand_lookup and cand_lookup.price > 0:
-                            current_price = cand_lookup.price
-                            logger.debug(
-                                "Price API returned 0 for %s; using scanner price %.4f",
-                                stock_code,
-                                current_price,
-                            )
 
                 stock_data: dict[str, Any] = {
                     "stock_code": stock_code,
@@ -1032,13 +742,6 @@ async def run_daily_session(
             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.
-            if total_cash <= 0 and settings.PAPER_OVERSEAS_CASH > 0:
-                total_cash = settings.PAPER_OVERSEAS_CASH
-
-            # VTS overseas balance API often returns 0; use paper fallback.
-            if total_cash <= 0 and settings.PAPER_OVERSEAS_CASH > 0:
-                total_cash = settings.PAPER_OVERSEAS_CASH
 
         # Calculate daily P&L %
         pnl_pct = (
@@ -1113,22 +816,13 @@ async def run_daily_session(
             quantity = 0
             trade_price = stock_data["current_price"]
             trade_pnl = 0.0
-            order_succeeded = True
             if decision.action in ("BUY", "SELL"):
-                daily_broker_held_qty = (
-                    _extract_held_qty_from_balance(
-                        balance_data, stock_code, is_domestic=market.is_domestic
-                    )
-                    if decision.action == "SELL"
-                    else 0
-                )
                 quantity = _determine_order_quantity(
                     action=decision.action,
                     current_price=stock_data["current_price"],
                     total_cash=total_cash,
                     candidate=candidate_map.get(stock_code),
                     settings=settings,
-                    broker_held_qty=daily_broker_held_qty,
                 )
                 if quantity <= 0:
                     logger.info(
@@ -1142,28 +836,8 @@ 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.check_circuit_breaker(pnl_pct)
-                    else:
                     risk.validate_order(
                         current_pnl_pct=pnl_pct,
                         order_amount=order_amount,
@@ -1194,7 +868,6 @@ async def run_daily_session(
                     raise
 
                 # Send order
-                order_succeeded = True
                 try:
                     if market.is_domestic:
                         result = await broker.send_order(
@@ -1204,41 +877,16 @@ async def run_daily_session(
                             price=0,  # market order
                         )
                     else:
-                        # KIS VTS only accepts limit orders; use 0.5% premium for BUY
-                        if decision.action == "BUY":
-                            order_price = round(stock_data["current_price"] * 1.005, 4)
-                        else:
-                            order_price = stock_data["current_price"]
                         result = await overseas_broker.send_overseas_order(
                             exchange_code=market.exchange_code,
                             stock_code=stock_code,
                             order_type=decision.action,
                             quantity=quantity,
-                            price=order_price,  # limit order
-                        )
-                        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,
-                            )
-                            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,
+                            price=0.0,  # market order
                         )
                     logger.info("Order result: %s", result.get("msg1", "OK"))
 
-                    # Notify trade execution (only on success)
-                    if order_succeeded:
+                    # Notify trade execution
                     try:
                         await telegram.notify_trade_execution(
                             stock_code=stock_code,
@@ -1256,7 +904,7 @@ async def run_daily_session(
                     )
                     continue
 
-                if decision.action == "SELL" and order_succeeded:
+                if decision.action == "SELL":
                     buy_trade = get_latest_buy_trade(db_conn, stock_code, market.code)
                     if buy_trade and buy_trade.get("price") is not None:
                         buy_price = float(buy_trade["price"])
@@ -1268,9 +916,7 @@ async def run_daily_session(
                             accuracy=1 if trade_pnl > 0 else 0,
                         )
 
-            # Log trade (skip if order was rejected by API)
-            if decision.action in ("BUY", "SELL") and not order_succeeded:
-                continue
+            # Log trade
             log_trade(
                 conn=db_conn,
                 stock_code=stock_code,
@@ -1398,18 +1044,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)
@@ -1420,7 +1058,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,
@@ -1479,15 +1117,6 @@ async def run(settings: Settings) -> None:
         bot_token=settings.TELEGRAM_BOT_TOKEN,
         chat_id=settings.TELEGRAM_CHAT_ID,
         enabled=settings.TELEGRAM_ENABLED,
-        notification_filter=NotificationFilter(
-            trades=settings.TELEGRAM_NOTIFY_TRADES,
-            market_open_close=settings.TELEGRAM_NOTIFY_MARKET_OPEN_CLOSE,
-            fat_finger=settings.TELEGRAM_NOTIFY_FAT_FINGER,
-            system_events=settings.TELEGRAM_NOTIFY_SYSTEM_EVENTS,
-            playbook=settings.TELEGRAM_NOTIFY_PLAYBOOK,
-            scenario_match=settings.TELEGRAM_NOTIFY_SCENARIO_MATCH,
-            errors=settings.TELEGRAM_NOTIFY_ERRORS,
-        ),
     )
 
     # Initialize Telegram command handler
@@ -1506,11 +1135,7 @@ async def run(settings: Settings) -> None:
             "/review - Recent scorecards\n"
             "/dashboard - Dashboard URL/status\n"
             "/stop - Pause trading\n"
-            "/resume - Resume trading\n"
-            "/notify - Show notification filter status\n"
-            "/notify [key] [on|off] - Toggle notification type\n"
-            "  Keys: trades, market, scenario, playbook,\n"
-            "        system, fatfinger, errors, all"
+            "/resume - Resume trading"
         )
         await telegram.send_message(message)
 
@@ -1763,63 +1388,6 @@ async def run(settings: Settings) -> None:
                 "<b>⚠️ Error</b>\n\nFailed to retrieve reviews."
             )
 
-    async def handle_notify(args: list[str]) -> None:
-        """Handle /notify [key] [on|off] — query or change notification filters."""
-        status = telegram.filter_status()
-
-        # /notify — show current state
-        if not args:
-            lines = ["<b>🔔 알림 필터 현재 상태</b>\n"]
-            for key, enabled in status.items():
-                icon = "✅" if enabled else "❌"
-                lines.append(f"{icon} <code>{key}</code>")
-            lines.append("\n<i>예) /notify scenario off</i>")
-            lines.append("<i>예) /notify all off</i>")
-            await telegram.send_message("\n".join(lines))
-            return
-
-        # /notify [key] — missing on/off
-        if len(args) == 1:
-            key = args[0].lower()
-            if key == "all":
-                lines = ["<b>🔔 알림 필터 현재 상태</b>\n"]
-                for k, enabled in status.items():
-                    icon = "✅" if enabled else "❌"
-                    lines.append(f"{icon} <code>{k}</code>")
-                await telegram.send_message("\n".join(lines))
-            elif key in status:
-                icon = "✅" if status[key] else "❌"
-                await telegram.send_message(
-                    f"<b>🔔 {key}</b>: {icon} {'켜짐' if status[key] else '꺼짐'}\n"
-                    f"<i>/notify {key} on  또는  /notify {key} off</i>"
-                )
-            else:
-                valid = ", ".join(list(status.keys()) + ["all"])
-                await telegram.send_message(
-                    f"❌ 알 수 없는 키: <code>{key}</code>\n"
-                    f"유효한 키: {valid}"
-                )
-            return
-
-        # /notify [key] [on|off]
-        key, toggle = args[0].lower(), args[1].lower()
-        if toggle not in ("on", "off"):
-            await telegram.send_message("❌ on 또는 off 를 입력해 주세요.")
-            return
-        value = toggle == "on"
-        if telegram.set_notification(key, value):
-            icon = "✅" if value else "❌"
-            label = f"전체 알림" if key == "all" else f"<code>{key}</code> 알림"
-            state = "켜짐" if value else "꺼짐"
-            await telegram.send_message(f"{icon} {label} → {state}")
-            logger.info("Notification filter changed via Telegram: %s=%s", key, value)
-        else:
-            valid = ", ".join(list(telegram.filter_status().keys()) + ["all"])
-            await telegram.send_message(
-                f"❌ 알 수 없는 키: <code>{key}</code>\n"
-                f"유효한 키: {valid}"
-            )
-
     async def handle_dashboard() -> None:
         """Handle /dashboard command - show dashboard URL if enabled."""
         if not settings.DASHBOARD_ENABLED:
@@ -1843,7 +1411,6 @@ async def run(settings: Settings) -> None:
     command_handler.register_command("scenarios", handle_scenarios)
     command_handler.register_command("review", handle_review)
     command_handler.register_command("dashboard", handle_dashboard)
-    command_handler.register_command_with_args("notify", handle_notify)
 
     # Initialize volatility hunter
     volatility_analyzer = VolatilityAnalyzer(min_volume_surge=2.0, min_price_change=1.0)
@@ -1861,9 +1428,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%
@@ -2137,38 +1701,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).
-                    # Also include currently-held positions so stop-loss /
-                    # 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,
-                        )
-
+                    # Get active stocks from scanner (dynamic, no static fallback)
+                    stock_codes = active_stocks.get(market.code, [])
                     if not stock_codes:
                         logger.debug("No active stocks for market %s", market.code)
                         continue
@@ -2206,7 +1740,6 @@ async def run(settings: Settings) -> None:
                                     stock_code,
                                     scan_candidates,
                                     settings,
-                                    buy_cooldown,
                                 )
                                 break  # Success — exit retry loop
                             except CircuitBreakerTripped as exc:

src/notifications/telegram_client.py

@@ -4,9 +4,8 @@ import asyncio
 import logging
 import time
 from collections.abc import Awaitable, Callable
-from dataclasses import dataclass, fields
+from dataclasses import dataclass
 from enum import Enum
-from typing import ClassVar
 
 import aiohttp
 
@@ -59,45 +58,6 @@ class LeakyBucket:
                 self._tokens -= 1.0
 
 
-@dataclass
-class NotificationFilter:
-    """Granular on/off flags for each notification type.
-
-    circuit_breaker is intentionally omitted — it is always sent regardless.
-    """
-
-    # Maps user-facing command keys to dataclass field names
-    KEYS: ClassVar[dict[str, str]] = {
-        "trades": "trades",
-        "market": "market_open_close",
-        "fatfinger": "fat_finger",
-        "system": "system_events",
-        "playbook": "playbook",
-        "scenario": "scenario_match",
-        "errors": "errors",
-    }
-
-    trades: bool = True
-    market_open_close: bool = True
-    fat_finger: bool = True
-    system_events: bool = True
-    playbook: bool = True
-    scenario_match: bool = True
-    errors: bool = True
-
-    def set_flag(self, key: str, value: bool) -> bool:
-        """Set a filter flag by user-facing key. Returns False if key is unknown."""
-        field = self.KEYS.get(key.lower())
-        if field is None:
-            return False
-        setattr(self, field, value)
-        return True
-
-    def as_dict(self) -> dict[str, bool]:
-        """Return {user_key: current_value} for display."""
-        return {k: getattr(self, field) for k, field in self.KEYS.items()}
-
-
 @dataclass
 class NotificationMessage:
     """Internal notification message structure."""
@@ -119,7 +79,6 @@ class TelegramClient:
         chat_id: str | None = None,
         enabled: bool = True,
         rate_limit: float = DEFAULT_RATE,
-        notification_filter: NotificationFilter | None = None,
     ) -> None:
         """
         Initialize Telegram client.
@@ -129,14 +88,12 @@ class TelegramClient:
             chat_id: Target chat ID (user or group)
             enabled: Enable/disable notifications globally
             rate_limit: Maximum messages per second
-            notification_filter: Granular per-type on/off flags
         """
         self._bot_token = bot_token
         self._chat_id = chat_id
         self._enabled = enabled
         self._rate_limiter = LeakyBucket(rate=rate_limit)
         self._session: aiohttp.ClientSession | None = None
-        self._filter = notification_filter if notification_filter is not None else NotificationFilter()
 
         if not enabled:
             logger.info("Telegram notifications disabled via configuration")
@@ -161,26 +118,6 @@ class TelegramClient:
         if self._session is not None and not self._session.closed:
             await self._session.close()
 
-    def set_notification(self, key: str, value: bool) -> bool:
-        """Toggle a notification type by user-facing key at runtime.
-
-        Args:
-            key: User-facing key (e.g. "scenario", "market", "all")
-            value: True to enable, False to disable
-
-        Returns:
-            True if key was valid, False if unknown.
-        """
-        if key == "all":
-            for k in NotificationFilter.KEYS:
-                self._filter.set_flag(k, value)
-            return True
-        return self._filter.set_flag(key, value)
-
-    def filter_status(self) -> dict[str, bool]:
-        """Return current per-type filter state keyed by user-facing names."""
-        return self._filter.as_dict()
-
     async def send_message(self, text: str, parse_mode: str = "HTML") -> bool:
         """
         Send a generic text message to Telegram.
@@ -256,8 +193,6 @@ class TelegramClient:
             price: Execution price
             confidence: AI confidence level (0-100)
         """
-        if not self._filter.trades:
-            return
         emoji = "🟢" if action == "BUY" else "🔴"
         message = (
             f"<b>{emoji} {action}</b>\n"
@@ -277,8 +212,6 @@ class TelegramClient:
         Args:
             market_name: Name of the market (e.g., "Korea", "United States")
         """
-        if not self._filter.market_open_close:
-            return
         message = f"<b>Market Open</b>\n{market_name} trading session started"
         await self._send_notification(
             NotificationMessage(priority=NotificationPriority.LOW, message=message)
@@ -292,8 +225,6 @@ class TelegramClient:
             market_name: Name of the market
             pnl_pct: Final P&L percentage for the session
         """
-        if not self._filter.market_open_close:
-            return
         pnl_sign = "+" if pnl_pct >= 0 else ""
         pnl_emoji = "📈" if pnl_pct >= 0 else "📉"
         message = (
@@ -340,8 +271,6 @@ class TelegramClient:
             total_cash: Total available cash
             max_pct: Maximum allowed percentage
         """
-        if not self._filter.fat_finger:
-            return
         attempted_pct = (order_amount / total_cash) * 100 if total_cash > 0 else 0
         message = (
             f"<b>Fat-Finger Protection</b>\n"
@@ -364,8 +293,6 @@ class TelegramClient:
             mode: Trading mode ("paper" or "live")
             enabled_markets: List of enabled market codes
         """
-        if not self._filter.system_events:
-            return
         mode_emoji = "📝" if mode == "paper" else "💰"
         markets_str = ", ".join(enabled_markets)
         message = (
@@ -393,8 +320,6 @@ class TelegramClient:
             scenario_count: Total number of scenarios
             token_count: Gemini token usage for the playbook
         """
-        if not self._filter.playbook:
-            return
         message = (
             f"<b>Playbook Generated</b>\n"
             f"Market: {market}\n"
@@ -422,8 +347,6 @@ class TelegramClient:
             condition_summary: Short summary of the matched condition
             confidence: Scenario confidence (0-100)
         """
-        if not self._filter.scenario_match:
-            return
         message = (
             f"<b>Scenario Matched</b>\n"
             f"Symbol: <code>{stock_code}</code>\n"
@@ -443,8 +366,6 @@ class TelegramClient:
             market: Market code (e.g., "KR", "US")
             reason: Failure reason summary
         """
-        if not self._filter.playbook:
-            return
         message = (
             f"<b>Playbook Failed</b>\n"
             f"Market: {market}\n"
@@ -461,8 +382,6 @@ class TelegramClient:
         Args:
             reason: Reason for shutdown (e.g., "Normal shutdown", "Circuit breaker")
         """
-        if not self._filter.system_events:
-            return
         message = f"<b>System Shutdown</b>\n{reason}"
         priority = (
             NotificationPriority.CRITICAL
@@ -484,8 +403,6 @@ class TelegramClient:
             error_msg: Error message
             context: Error context (e.g., stock code, market)
         """
-        if not self._filter.errors:
-            return
         message = (
             f"<b>Error: {error_type}</b>\n"
             f"Context: {context}\n"
@@ -512,7 +429,6 @@ class TelegramCommandHandler:
         self._client = client
         self._polling_interval = polling_interval
         self._commands: dict[str, Callable[[], Awaitable[None]]] = {}
-        self._commands_with_args: dict[str, Callable[[list[str]], Awaitable[None]]] = {}
         self._last_update_id = 0
         self._polling_task: asyncio.Task[None] | None = None
         self._running = False
@@ -521,7 +437,7 @@ class TelegramCommandHandler:
         self, command: str, handler: Callable[[], Awaitable[None]]
     ) -> None:
         """
-        Register a command handler (no arguments).
+        Register a command handler.
 
         Args:
             command: Command name (without leading slash, e.g., "start")
@@ -530,19 +446,6 @@ class TelegramCommandHandler:
         self._commands[command] = handler
         logger.debug("Registered command handler: /%s", command)
 
-    def register_command_with_args(
-        self, command: str, handler: Callable[[list[str]], Awaitable[None]]
-    ) -> None:
-        """
-        Register a command handler that receives trailing arguments.
-
-        Args:
-            command: Command name (without leading slash, e.g., "notify")
-            handler: Async function receiving list of argument tokens
-        """
-        self._commands_with_args[command] = handler
-        logger.debug("Registered command handler (with args): /%s", command)
-
     async def start_polling(self) -> None:
         """Start long polling for commands."""
         if self._running:
@@ -604,16 +507,6 @@ class TelegramCommandHandler:
             async with session.post(url, json=payload) as resp:
                 if resp.status != 200:
                     error_text = await resp.text()
-                    if resp.status == 409:
-                        # Another bot instance is already polling — stop this poller entirely.
-                        # 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
                     )
@@ -673,14 +566,11 @@ class TelegramCommandHandler:
             # Remove @botname suffix if present (for group chats)
             command_name = command_parts[0].split("@")[0]
 
-            # Execute handler (args-aware handlers take priority)
-            args_handler = self._commands_with_args.get(command_name)
-            if args_handler:
-                logger.info("Executing command: /%s %s", command_name, command_parts[1:])
-                await args_handler(command_parts[1:])
-            elif command_name in self._commands:
+            # Execute handler
+            handler = self._commands.get(command_name)
+            if handler:
                 logger.info("Executing command: /%s", command_name)
-                await self._commands[command_name]()
+                await handler()
             else:
                 logger.debug("Unknown command: /%s", command_name)
                 await self._client.send_message(

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,
             )
         )
 

src/strategy/pre_market_planner.py

@@ -1,8 +1,7 @@
 """Pre-market planner — generates DayPlaybook via Gemini before market open.
 
 One Gemini API call per market per day. Candidates come from SmartVolatilityScanner.
-On failure, returns a smart rule-based fallback playbook that uses scanner signals
-(momentum/oversold) to generate BUY conditions, avoiding the all-HOLD problem.
+On failure, returns a defensive playbook (all HOLD, no trades).
 """
 
 from __future__ import annotations
@@ -75,7 +74,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 +81,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 +105,6 @@ class PreMarketPlanner:
                 context_data,
                 self_market_scorecard,
                 cross_market,
-                current_holdings=current_holdings,
             )
 
             # 3. Call Gemini
@@ -124,8 +117,7 @@ class PreMarketPlanner:
 
             # 4. Parse response
             playbook = self._parse_response(
-                decision.rationale, today, market, candidates, cross_market,
-                current_holdings=current_holdings,
+                decision.rationale, today, market, candidates, cross_market
             )
             playbook_with_tokens = playbook.model_copy(
                 update={"token_count": decision.token_count}
@@ -142,7 +134,7 @@ class PreMarketPlanner:
         except Exception:
             logger.exception("Playbook generation failed for %s", market)
             if self._settings.DEFENSIVE_PLAYBOOK_ON_FAILURE:
-                return self._smart_fallback_playbook(today, market, candidates, self._settings)
+                return self._defensive_playbook(today, market, candidates)
             return self._empty_playbook(today, market)
 
     def build_cross_market_context(
@@ -237,7 +229,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 +240,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 +272,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 +293,7 @@ class PreMarketPlanner:
             f'      "stock_code": "...",\n'
             f'      "scenarios": [\n'
             f'        {{\n'
-            f'          "condition": {{"rsi_below": 30, "volume_ratio_above": 2.0,'
-            f' "unrealized_pnl_pct_above": 3.0, "holding_days_above": 5}},\n'
+            f'          "condition": {{"rsi_below": 30, "volume_ratio_above": 2.0}},\n'
             f'          "action": "BUY|SELL|HOLD",\n'
             f'          "confidence": 85,\n'
             f'          "allocation_pct": 10.0,\n'
@@ -347,8 +307,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"{holdings_instruction}"
+            f"- Only use stocks from the candidates list\n"
             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 +320,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 +389,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():
@@ -522,99 +470,3 @@ class PreMarketPlanner:
                 ),
             ],
         )
-
-    @staticmethod
-    def _smart_fallback_playbook(
-        today: date,
-        market: str,
-        candidates: list[ScanCandidate],
-        settings: Settings,
-    ) -> DayPlaybook:
-        """Rule-based fallback playbook when Gemini is unavailable.
-
-        Uses scanner signals (RSI, volume_ratio) to generate meaningful BUY
-        conditions instead of the all-SELL defensive playbook.  Candidates are
-        already pre-qualified by SmartVolatilityScanner, so we trust their
-        signals and build actionable scenarios from them.
-
-        Scenario logic per candidate:
-        - momentum signal: BUY when volume_ratio exceeds scanner threshold
-        - oversold signal: BUY when RSI is below oversold threshold
-        - always: SELL stop-loss at -3.0% as guard
-        """
-        stock_playbooks = []
-        for c in candidates:
-            scenarios: list[StockScenario] = []
-
-            if c.signal == "momentum":
-                scenarios.append(
-                    StockScenario(
-                        condition=StockCondition(
-                            volume_ratio_above=settings.VOL_MULTIPLIER,
-                        ),
-                        action=ScenarioAction.BUY,
-                        confidence=80,
-                        allocation_pct=10.0,
-                        stop_loss_pct=-3.0,
-                        take_profit_pct=5.0,
-                        rationale=(
-                            f"Rule-based BUY: momentum signal, "
-                            f"volume={c.volume_ratio:.1f}x (fallback planner)"
-                        ),
-                    )
-                )
-            elif c.signal == "oversold":
-                scenarios.append(
-                    StockScenario(
-                        condition=StockCondition(
-                            rsi_below=settings.RSI_OVERSOLD_THRESHOLD,
-                        ),
-                        action=ScenarioAction.BUY,
-                        confidence=80,
-                        allocation_pct=10.0,
-                        stop_loss_pct=-3.0,
-                        take_profit_pct=5.0,
-                        rationale=(
-                            f"Rule-based BUY: oversold signal, "
-                            f"RSI={c.rsi:.0f} (fallback planner)"
-                        ),
-                    )
-                )
-
-            # Always add stop-loss guard
-            scenarios.append(
-                StockScenario(
-                    condition=StockCondition(price_change_pct_below=-3.0),
-                    action=ScenarioAction.SELL,
-                    confidence=90,
-                    stop_loss_pct=-3.0,
-                    rationale="Rule-based stop-loss (fallback planner)",
-                )
-            )
-
-            stock_playbooks.append(
-                StockPlaybook(
-                    stock_code=c.stock_code,
-                    scenarios=scenarios,
-                )
-            )
-
-        logger.info(
-            "Smart fallback playbook for %s: %d stocks with rule-based BUY/SELL conditions",
-            market,
-            len(stock_playbooks),
-        )
-        return DayPlaybook(
-            date=today,
-            market=market,
-            market_outlook=MarketOutlook.NEUTRAL,
-            default_action=ScenarioAction.HOLD,
-            stock_playbooks=stock_playbooks,
-            global_rules=[
-                GlobalRule(
-                    condition="portfolio_pnl_pct < -2.0",
-                    action=ScenarioAction.REDUCE_ALL,
-                    rationale="Defensive: reduce on loss threshold",
-                ),
-            ],
-        )

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

tests/test_brain.py

@@ -2,10 +2,6 @@
 
 from __future__ import annotations
 
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
 from src.brain.gemini_client import GeminiClient
 
 # ---------------------------------------------------------------------------
@@ -274,97 +270,3 @@ class TestBatchDecisionParsing:
 
         assert decisions["AAPL"].action == "HOLD"
         assert decisions["AAPL"].confidence == 0
-
-
-# ---------------------------------------------------------------------------
-# Prompt Override (used by pre_market_planner)
-# ---------------------------------------------------------------------------
-
-
-class TestPromptOverride:
-    """decide() must use prompt_override when present in market_data."""
-
-    @pytest.mark.asyncio
-    async def test_prompt_override_is_sent_to_gemini(self, settings):
-        """When prompt_override is in market_data, it should be used as the prompt."""
-        client = GeminiClient(settings)
-
-        custom_prompt = "You are a playbook generator. Return JSON with scenarios."
-
-        mock_response = MagicMock()
-        mock_response.text = '{"action": "HOLD", "confidence": 50, "rationale": "test"}'
-
-        with patch.object(
-            client._client.aio.models,
-            "generate_content",
-            new_callable=AsyncMock,
-            return_value=mock_response,
-        ) as mock_generate:
-            market_data = {
-                "stock_code": "PLANNER",
-                "current_price": 0,
-                "prompt_override": custom_prompt,
-            }
-            await client.decide(market_data)
-
-            # Verify the custom prompt was sent, not a built prompt
-            mock_generate.assert_called_once()
-            actual_prompt = mock_generate.call_args[1].get(
-                "contents", mock_generate.call_args[0][1] if len(mock_generate.call_args[0]) > 1 else None
-            )
-            assert actual_prompt == custom_prompt
-
-    @pytest.mark.asyncio
-    async def test_prompt_override_skips_optimization(self, settings):
-        """prompt_override should bypass prompt optimization."""
-        client = GeminiClient(settings)
-        client._enable_optimization = True
-
-        custom_prompt = "Custom playbook prompt"
-
-        mock_response = MagicMock()
-        mock_response.text = '{"action": "HOLD", "confidence": 50, "rationale": "ok"}'
-
-        with patch.object(
-            client._client.aio.models,
-            "generate_content",
-            new_callable=AsyncMock,
-            return_value=mock_response,
-        ) as mock_generate:
-            market_data = {
-                "stock_code": "PLANNER",
-                "current_price": 0,
-                "prompt_override": custom_prompt,
-            }
-            await client.decide(market_data)
-
-            actual_prompt = mock_generate.call_args[1].get(
-                "contents", mock_generate.call_args[0][1] if len(mock_generate.call_args[0]) > 1 else None
-            )
-            assert actual_prompt == custom_prompt
-
-    @pytest.mark.asyncio
-    async def test_without_prompt_override_uses_build_prompt(self, settings):
-        """Without prompt_override, decide() should use build_prompt as before."""
-        client = GeminiClient(settings)
-
-        mock_response = MagicMock()
-        mock_response.text = '{"action": "HOLD", "confidence": 50, "rationale": "ok"}'
-
-        with patch.object(
-            client._client.aio.models,
-            "generate_content",
-            new_callable=AsyncMock,
-            return_value=mock_response,
-        ) as mock_generate:
-            market_data = {
-                "stock_code": "005930",
-                "current_price": 72000,
-            }
-            await client.decide(market_data)
-
-            actual_prompt = mock_generate.call_args[1].get(
-                "contents", mock_generate.call_args[0][1] if len(mock_generate.call_args[0]) > 1 else None
-            )
-            # Should contain stock code from build_prompt, not be a custom override
-            assert "005930" in actual_prompt

tests/test_broker.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import asyncio
-from unittest.mock import AsyncMock, MagicMock, patch
+from unittest.mock import AsyncMock, patch
 
 import pytest
 
@@ -90,12 +90,12 @@ class TestTokenManagement:
         await broker.close()
 
     @pytest.mark.asyncio
-    async def test_token_refresh_cooldown_waits_then_retries(self, settings):
-        """Token refresh should wait out cooldown then retry (issue #54)."""
+    async def test_token_refresh_cooldown_prevents_rapid_retries(self, settings):
+        """Token refresh should enforce cooldown after failure (issue #54)."""
         broker = KISBroker(settings)
-        broker._refresh_cooldown = 0.1  # Short cooldown for testing
+        broker._refresh_cooldown = 2.0  # Short cooldown for testing
 
-        # All attempts fail with 403 (EGW00133)
+        # First refresh attempt fails with 403 (EGW00133)
         mock_resp_403 = AsyncMock()
         mock_resp_403.status = 403
         mock_resp_403.text = AsyncMock(
@@ -109,8 +109,8 @@ class TestTokenManagement:
             with pytest.raises(ConnectionError, match="Token refresh failed"):
                 await broker._ensure_token()
 
-            # Second attempt within cooldown should wait then retry (and still get 403)
-            with pytest.raises(ConnectionError, match="Token refresh failed"):
+            # Second attempt within cooldown should fail with cooldown error
+            with pytest.raises(ConnectionError, match="Token refresh on cooldown"):
                 await broker._ensure_token()
 
         await broker.close()
@@ -296,280 +296,3 @@ class TestHashKey:
                 mock_acquire.assert_called_once()
 
         await broker.close()
-
-
-# ---------------------------------------------------------------------------
-# fetch_market_rankings — TR_ID, path, params (issue #155)
-# ---------------------------------------------------------------------------
-
-
-def _make_ranking_mock(items: list[dict]) -> AsyncMock:
-    """Build a mock HTTP response returning ranking items."""
-    mock_resp = AsyncMock()
-    mock_resp.status = 200
-    mock_resp.json = AsyncMock(return_value={"output": items})
-    mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
-    mock_resp.__aexit__ = AsyncMock(return_value=False)
-    return mock_resp
-
-
-class TestFetchMarketRankings:
-    """Verify correct TR_ID, API path, and params per ranking_type (issue #155)."""
-
-    @pytest.fixture
-    def broker(self, settings) -> KISBroker:
-        b = KISBroker(settings)
-        b._access_token = "tok"
-        b._token_expires_at = float("inf")
-        b._rate_limiter.acquire = AsyncMock()
-        return b
-
-    @pytest.mark.asyncio
-    async def test_volume_uses_correct_tr_id_and_path(self, broker: KISBroker) -> None:
-        mock_resp = _make_ranking_mock([])
-        with patch("aiohttp.ClientSession.get", return_value=mock_resp) as mock_get:
-            await broker.fetch_market_rankings(ranking_type="volume")
-
-        call_kwargs = mock_get.call_args
-        url = call_kwargs[0][0] if call_kwargs[0] else call_kwargs[1].get("url", "")
-        headers = call_kwargs[1].get("headers", {})
-        params = call_kwargs[1].get("params", {})
-
-        assert "volume-rank" in url
-        assert headers.get("tr_id") == "FHPST01710000"
-        assert params.get("FID_COND_SCR_DIV_CODE") == "20171"
-        assert params.get("FID_TRGT_EXLS_CLS_CODE") == "0000000000"
-
-    @pytest.mark.asyncio
-    async def test_fluctuation_uses_correct_tr_id_and_path(self, broker: KISBroker) -> None:
-        mock_resp = _make_ranking_mock([])
-        with patch("aiohttp.ClientSession.get", return_value=mock_resp) as mock_get:
-            await broker.fetch_market_rankings(ranking_type="fluctuation")
-
-        call_kwargs = mock_get.call_args
-        url = call_kwargs[0][0] if call_kwargs[0] else call_kwargs[1].get("url", "")
-        headers = call_kwargs[1].get("headers", {})
-        params = call_kwargs[1].get("params", {})
-
-        assert "ranking/fluctuation" in url
-        assert headers.get("tr_id") == "FHPST01700000"
-        assert params.get("fid_cond_scr_div_code") == "20170"
-
-    @pytest.mark.asyncio
-    async def test_volume_returns_parsed_rows(self, broker: KISBroker) -> None:
-        items = [
-            {
-                "mksc_shrn_iscd": "005930",
-                "hts_kor_isnm": "삼성전자",
-                "stck_prpr": "75000",
-                "acml_vol": "10000000",
-                "prdy_ctrt": "2.5",
-                "vol_inrt": "150",
-            }
-        ]
-        mock_resp = _make_ranking_mock(items)
-        with patch("aiohttp.ClientSession.get", return_value=mock_resp):
-            result = await broker.fetch_market_rankings(ranking_type="volume")
-
-        assert len(result) == 1
-        assert result[0]["stock_code"] == "005930"
-        assert result[0]["price"] == 75000.0
-        assert result[0]["change_rate"] == 2.5
-
-
-# ---------------------------------------------------------------------------
-# KRX tick unit / round-down helpers (issue #157)
-# ---------------------------------------------------------------------------
-
-
-from src.broker.kis_api import kr_tick_unit, kr_round_down  # noqa: E402
-
-
-class TestKrTickUnit:
-    """kr_tick_unit and kr_round_down must implement KRX price tick rules."""
-
-    @pytest.mark.parametrize(
-        "price, expected_tick",
-        [
-            (1999, 1),
-            (2000, 5),
-            (4999, 5),
-            (5000, 10),
-            (19999, 10),
-            (20000, 50),
-            (49999, 50),
-            (50000, 100),
-            (199999, 100),
-            (200000, 500),
-            (499999, 500),
-            (500000, 1000),
-            (1000000, 1000),
-        ],
-    )
-    def test_tick_unit_boundaries(self, price: int, expected_tick: int) -> None:
-        assert kr_tick_unit(price) == expected_tick
-
-    @pytest.mark.parametrize(
-        "price, expected_rounded",
-        [
-            (188150, 188100),   # 100원 단위, 50원 잔여 → 내림
-            (188100, 188100),   # 이미 정렬됨
-            (75050, 75000),     # 100원 단위, 50원 잔여 → 내림
-            (49950, 49950),     # 50원 단위 정렬됨
-            (49960, 49950),     # 50원 단위, 10원 잔여 → 내림
-            (1999, 1999),       # 1원 단위 → 그대로
-            (5003, 5000),       # 10원 단위, 3원 잔여 → 내림
-        ],
-    )
-    def test_round_down_to_tick(self, price: int, expected_rounded: int) -> None:
-        assert kr_round_down(price) == expected_rounded
-
-
-# ---------------------------------------------------------------------------
-# get_current_price (issue #157)
-# ---------------------------------------------------------------------------
-
-
-class TestGetCurrentPrice:
-    """get_current_price must use inquire-price API and return (price, change, foreigner)."""
-
-    @pytest.fixture
-    def broker(self, settings) -> KISBroker:
-        b = KISBroker(settings)
-        b._access_token = "tok"
-        b._token_expires_at = float("inf")
-        b._rate_limiter.acquire = AsyncMock()
-        return b
-
-    @pytest.mark.asyncio
-    async def test_returns_correct_fields(self, broker: KISBroker) -> None:
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(
-            return_value={
-                "rt_cd": "0",
-                "output": {
-                    "stck_prpr": "188600",
-                    "prdy_ctrt": "3.97",
-                    "frgn_ntby_qty": "12345",
-                },
-            }
-        )
-        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:
-            price, change_pct, foreigner = await broker.get_current_price("005930")
-
-        assert price == 188600.0
-        assert change_pct == 3.97
-        assert foreigner == 12345.0
-
-        call_kwargs = mock_get.call_args
-        url = call_kwargs[0][0] if call_kwargs[0] else call_kwargs[1].get("url", "")
-        headers = call_kwargs[1].get("headers", {})
-        assert "inquire-price" in url
-        assert headers.get("tr_id") == "FHKST01010100"
-
-    @pytest.mark.asyncio
-    async def test_http_error_raises_connection_error(self, broker: KISBroker) -> None:
-        mock_resp = AsyncMock()
-        mock_resp.status = 500
-        mock_resp.text = AsyncMock(return_value="Internal Server Error")
-        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
-        mock_resp.__aexit__ = AsyncMock(return_value=False)
-
-        with patch("aiohttp.ClientSession.get", return_value=mock_resp):
-            with pytest.raises(ConnectionError, match="get_current_price failed"):
-                await broker.get_current_price("005930")
-
-
-# ---------------------------------------------------------------------------
-# send_order tick rounding and ORD_DVSN (issue #157)
-# ---------------------------------------------------------------------------
-
-
-class TestSendOrderTickRounding:
-    """send_order must apply KRX tick rounding and correct ORD_DVSN codes."""
-
-    @pytest.fixture
-    def broker(self, settings) -> KISBroker:
-        b = KISBroker(settings)
-        b._access_token = "tok"
-        b._token_expires_at = float("inf")
-        b._rate_limiter.acquire = AsyncMock()
-        return b
-
-    @pytest.mark.asyncio
-    async def test_limit_order_rounds_down_to_tick(self, broker: KISBroker) -> None:
-        """Price 188150 (not on 100-won tick) must be rounded to 188100."""
-        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, price=188150)
-
-        order_call = mock_post.call_args_list[1]
-        body = order_call[1].get("json", {})
-        assert body["ORD_UNPR"] == "188100"  # rounded down
-        assert body["ORD_DVSN"] == "00"       # 지정가
-
-    @pytest.mark.asyncio
-    async def test_limit_order_ord_dvsn_is_00(self, broker: KISBroker) -> None:
-        """send_order with price>0 must use ORD_DVSN='00' (지정가)."""
-        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, price=50000)
-
-        order_call = mock_post.call_args_list[1]
-        body = order_call[1].get("json", {})
-        assert body["ORD_DVSN"] == "00"
-
-    @pytest.mark.asyncio
-    async def test_market_order_ord_dvsn_is_01(self, broker: KISBroker) -> None:
-        """send_order with price=0 must use ORD_DVSN='01' (시장가)."""
-        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, price=0)
-
-        order_call = mock_post.call_args_list[1]
-        body = order_call[1].get("json", {})
-        assert body["ORD_DVSN"] == "01"
-        assert body["ORD_UNPR"] == "0"

tests/test_dashboard.py

@@ -296,120 +296,3 @@ def test_scenarios_active_empty_when_no_matches(tmp_path: Path) -> None:
     get_active_scenarios = _endpoint(app, "/api/scenarios/active")
     body = get_active_scenarios(market="US", date_str="2026-02-14", limit=50)
     assert body["count"] == 0
-
-
-def test_pnl_history_all_markets(tmp_path: Path) -> None:
-    app = _app(tmp_path)
-    get_pnl_history = _endpoint(app, "/api/pnl/history")
-    body = get_pnl_history(days=30, market="all")
-    assert body["market"] == "all"
-    assert isinstance(body["labels"], list)
-    assert isinstance(body["pnl"], list)
-    assert len(body["labels"]) == len(body["pnl"])
-
-
-def test_pnl_history_market_filter(tmp_path: Path) -> None:
-    app = _app(tmp_path)
-    get_pnl_history = _endpoint(app, "/api/pnl/history")
-    body = get_pnl_history(days=30, market="KR")
-    assert body["market"] == "KR"
-    # 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

tests/test_overseas_broker.py

@@ -1,643 +0,0 @@
-"""Tests for OverseasBroker — rankings, price, balance, order, and helpers."""
-
-from __future__ import annotations
-
-from unittest.mock import AsyncMock, MagicMock
-
-import aiohttp
-import pytest
-
-from src.broker.kis_api import KISBroker
-from src.broker.overseas import OverseasBroker, _PRICE_EXCHANGE_MAP, _RANKING_EXCHANGE_MAP
-from src.config import Settings
-
-
-def _make_async_cm(mock_resp: AsyncMock) -> MagicMock:
-    """Create an async context manager that returns mock_resp on __aenter__."""
-    cm = MagicMock()
-    cm.__aenter__ = AsyncMock(return_value=mock_resp)
-    cm.__aexit__ = AsyncMock(return_value=False)
-    return cm
-
-
-@pytest.fixture
-def mock_settings() -> Settings:
-    """Provide mock settings with correct default TR_IDs/paths."""
-    return Settings(
-        KIS_APP_KEY="test_key",
-        KIS_APP_SECRET="test_secret",
-        KIS_ACCOUNT_NO="12345678-01",
-        GEMINI_API_KEY="test_gemini_key",
-    )
-
-
-@pytest.fixture
-def mock_broker(mock_settings: Settings) -> KISBroker:
-    """Provide a mock KIS broker."""
-    broker = KISBroker(mock_settings)
-    broker.get_orderbook = AsyncMock()  # type: ignore[method-assign]
-    return broker
-
-
-@pytest.fixture
-def overseas_broker(mock_broker: KISBroker) -> OverseasBroker:
-    """Provide an OverseasBroker wrapping a mock KISBroker."""
-    return OverseasBroker(mock_broker)
-
-
-def _setup_broker_mocks(overseas_broker: OverseasBroker, mock_session: MagicMock) -> None:
-    """Wire up common broker mocks."""
-    overseas_broker._broker._rate_limiter.acquire = AsyncMock()
-    overseas_broker._broker._get_session = MagicMock(return_value=mock_session)
-    overseas_broker._broker._auth_headers = AsyncMock(return_value={})
-
-
-class TestRankingExchangeMap:
-    """Test exchange code mapping for ranking API."""
-
-    def test_nasd_maps_to_nas(self) -> None:
-        assert _RANKING_EXCHANGE_MAP["NASD"] == "NAS"
-
-    def test_nyse_maps_to_nys(self) -> None:
-        assert _RANKING_EXCHANGE_MAP["NYSE"] == "NYS"
-
-    def test_amex_maps_to_ams(self) -> None:
-        assert _RANKING_EXCHANGE_MAP["AMEX"] == "AMS"
-
-    def test_sehk_maps_to_hks(self) -> None:
-        assert _RANKING_EXCHANGE_MAP["SEHK"] == "HKS"
-
-    def test_unmapped_exchange_passes_through(self) -> None:
-        assert _RANKING_EXCHANGE_MAP.get("UNKNOWN", "UNKNOWN") == "UNKNOWN"
-
-    def test_tse_unchanged(self) -> None:
-        assert _RANKING_EXCHANGE_MAP["TSE"] == "TSE"
-
-
-class TestConfigDefaults:
-    """Test that config defaults match KIS official API specs."""
-
-    def test_fluct_tr_id(self, mock_settings: Settings) -> None:
-        assert mock_settings.OVERSEAS_RANKING_FLUCT_TR_ID == "HHDFS76290000"
-
-    def test_volume_tr_id(self, mock_settings: Settings) -> None:
-        assert mock_settings.OVERSEAS_RANKING_VOLUME_TR_ID == "HHDFS76270000"
-
-    def test_fluct_path(self, mock_settings: Settings) -> None:
-        assert mock_settings.OVERSEAS_RANKING_FLUCT_PATH == "/uapi/overseas-stock/v1/ranking/updown-rate"
-
-    def test_volume_path(self, mock_settings: Settings) -> None:
-        assert mock_settings.OVERSEAS_RANKING_VOLUME_PATH == "/uapi/overseas-stock/v1/ranking/volume-surge"
-
-
-class TestFetchOverseasRankings:
-    """Test fetch_overseas_rankings method."""
-
-    @pytest.mark.asyncio
-    async def test_fluctuation_uses_correct_params(
-        self, overseas_broker: OverseasBroker
-    ) -> None:
-        """Fluctuation ranking should use HHDFS76290000, updown-rate path, and correct params."""
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(
-            return_value={"output": [{"symb": "AAPL", "name": "Apple"}]}
-        )
-
-        mock_session = MagicMock()
-        mock_session.get = MagicMock(return_value=_make_async_cm(mock_resp))
-
-        _setup_broker_mocks(overseas_broker, mock_session)
-        overseas_broker._broker._auth_headers = AsyncMock(
-            return_value={"authorization": "Bearer test"}
-        )
-
-        result = await overseas_broker.fetch_overseas_rankings("NASD", "fluctuation")
-
-        assert len(result) == 1
-        assert result[0]["symb"] == "AAPL"
-
-        call_args = mock_session.get.call_args
-        url = call_args[0][0]
-        params = call_args[1]["params"]
-
-        assert "/uapi/overseas-stock/v1/ranking/updown-rate" in url
-        assert params["EXCD"] == "NAS"
-        assert params["NDAY"] == "0"
-        assert params["GUBN"] == "1"
-        assert params["VOL_RANG"] == "0"
-
-        overseas_broker._broker._auth_headers.assert_called_with("HHDFS76290000")
-
-    @pytest.mark.asyncio
-    async def test_volume_uses_correct_params(
-        self, overseas_broker: OverseasBroker
-    ) -> None:
-        """Volume ranking should use HHDFS76270000, volume-surge path, and correct params."""
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(
-            return_value={"output": [{"symb": "TSLA", "name": "Tesla"}]}
-        )
-
-        mock_session = MagicMock()
-        mock_session.get = MagicMock(return_value=_make_async_cm(mock_resp))
-
-        _setup_broker_mocks(overseas_broker, mock_session)
-        overseas_broker._broker._auth_headers = AsyncMock(
-            return_value={"authorization": "Bearer test"}
-        )
-
-        result = await overseas_broker.fetch_overseas_rankings("NYSE", "volume")
-
-        assert len(result) == 1
-
-        call_args = mock_session.get.call_args
-        url = call_args[0][0]
-        params = call_args[1]["params"]
-
-        assert "/uapi/overseas-stock/v1/ranking/volume-surge" in url
-        assert params["EXCD"] == "NYS"
-        assert params["MIXN"] == "0"
-        assert params["VOL_RANG"] == "0"
-        assert "NDAY" not in params
-        assert "GUBN" not in params
-
-        overseas_broker._broker._auth_headers.assert_called_with("HHDFS76270000")
-
-    @pytest.mark.asyncio
-    async def test_404_returns_empty_list(
-        self, overseas_broker: OverseasBroker
-    ) -> None:
-        """HTTP 404 should return empty list (fallback) instead of raising."""
-        mock_resp = AsyncMock()
-        mock_resp.status = 404
-        mock_resp.text = AsyncMock(return_value="Not Found")
-
-        mock_session = MagicMock()
-        mock_session.get = MagicMock(return_value=_make_async_cm(mock_resp))
-
-        _setup_broker_mocks(overseas_broker, mock_session)
-
-        result = await overseas_broker.fetch_overseas_rankings("AMEX", "fluctuation")
-        assert result == []
-
-    @pytest.mark.asyncio
-    async def test_non_404_error_raises(
-        self, overseas_broker: OverseasBroker
-    ) -> None:
-        """Non-404 HTTP errors should raise ConnectionError."""
-        mock_resp = AsyncMock()
-        mock_resp.status = 500
-        mock_resp.text = AsyncMock(return_value="Internal Server Error")
-
-        mock_session = MagicMock()
-        mock_session.get = MagicMock(return_value=_make_async_cm(mock_resp))
-
-        _setup_broker_mocks(overseas_broker, mock_session)
-
-        with pytest.raises(ConnectionError, match="500"):
-            await overseas_broker.fetch_overseas_rankings("NASD")
-
-    @pytest.mark.asyncio
-    async def test_empty_response_returns_empty(
-        self, overseas_broker: OverseasBroker
-    ) -> None:
-        """Empty output in response should return empty list."""
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(return_value={"output": []})
-
-        mock_session = MagicMock()
-        mock_session.get = MagicMock(return_value=_make_async_cm(mock_resp))
-
-        _setup_broker_mocks(overseas_broker, mock_session)
-
-        result = await overseas_broker.fetch_overseas_rankings("NASD")
-        assert result == []
-
-    @pytest.mark.asyncio
-    async def test_ranking_disabled_returns_empty(
-        self, overseas_broker: OverseasBroker
-    ) -> None:
-        """When OVERSEAS_RANKING_ENABLED=False, should return empty immediately."""
-        overseas_broker._broker._settings.OVERSEAS_RANKING_ENABLED = False
-        result = await overseas_broker.fetch_overseas_rankings("NASD")
-        assert result == []
-
-    @pytest.mark.asyncio
-    async def test_limit_truncates_results(
-        self, overseas_broker: OverseasBroker
-    ) -> None:
-        """Results should be truncated to the specified limit."""
-        rows = [{"symb": f"SYM{i}"} for i in range(20)]
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(return_value={"output": rows})
-
-        mock_session = MagicMock()
-        mock_session.get = MagicMock(return_value=_make_async_cm(mock_resp))
-
-        _setup_broker_mocks(overseas_broker, mock_session)
-
-        result = await overseas_broker.fetch_overseas_rankings("NASD", limit=5)
-        assert len(result) == 5
-
-    @pytest.mark.asyncio
-    async def test_network_error_raises(
-        self, overseas_broker: OverseasBroker
-    ) -> None:
-        """Network errors should raise ConnectionError."""
-        cm = MagicMock()
-        cm.__aenter__ = AsyncMock(side_effect=aiohttp.ClientError("timeout"))
-        cm.__aexit__ = AsyncMock(return_value=False)
-
-        mock_session = MagicMock()
-        mock_session.get = MagicMock(return_value=cm)
-
-        _setup_broker_mocks(overseas_broker, mock_session)
-
-        with pytest.raises(ConnectionError, match="Network error"):
-            await overseas_broker.fetch_overseas_rankings("NASD")
-
-    @pytest.mark.asyncio
-    async def test_exchange_code_mapping_applied(
-        self, overseas_broker: OverseasBroker
-    ) -> None:
-        """All major exchanges should use mapped codes in API params."""
-        for original, mapped in [("NASD", "NAS"), ("NYSE", "NYS"), ("AMEX", "AMS")]:
-            mock_resp = AsyncMock()
-            mock_resp.status = 200
-            mock_resp.json = AsyncMock(return_value={"output": [{"symb": "X"}]})
-
-            mock_session = MagicMock()
-            mock_session.get = MagicMock(return_value=_make_async_cm(mock_resp))
-
-            _setup_broker_mocks(overseas_broker, mock_session)
-
-            await overseas_broker.fetch_overseas_rankings(original)
-
-            call_params = mock_session.get.call_args[1]["params"]
-            assert call_params["EXCD"] == mapped, f"{original} should map to {mapped}"
-
-
-class TestGetOverseasPrice:
-    """Test get_overseas_price method."""
-
-    @pytest.mark.asyncio
-    async def test_success(self, overseas_broker: OverseasBroker) -> None:
-        """Successful price fetch returns JSON data."""
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(return_value={"output": {"last": "150.00"}})
-
-        mock_session = MagicMock()
-        mock_session.get = MagicMock(return_value=_make_async_cm(mock_resp))
-
-        _setup_broker_mocks(overseas_broker, mock_session)
-        overseas_broker._broker._auth_headers = AsyncMock(return_value={"authorization": "Bearer t"})
-
-        result = await overseas_broker.get_overseas_price("NASD", "AAPL")
-        assert result["output"]["last"] == "150.00"
-
-        call_args = mock_session.get.call_args
-        params = call_args[1]["params"]
-        assert params["EXCD"] == "NAS"  # NASD → NAS via _PRICE_EXCHANGE_MAP
-        assert params["SYMB"] == "AAPL"
-
-    @pytest.mark.asyncio
-    async def test_http_error_raises(self, overseas_broker: OverseasBroker) -> None:
-        """Non-200 response should raise ConnectionError."""
-        mock_resp = AsyncMock()
-        mock_resp.status = 400
-        mock_resp.text = AsyncMock(return_value="Bad Request")
-
-        mock_session = MagicMock()
-        mock_session.get = MagicMock(return_value=_make_async_cm(mock_resp))
-
-        _setup_broker_mocks(overseas_broker, mock_session)
-
-        with pytest.raises(ConnectionError, match="get_overseas_price failed"):
-            await overseas_broker.get_overseas_price("NASD", "AAPL")
-
-    @pytest.mark.asyncio
-    async def test_network_error_raises(self, overseas_broker: OverseasBroker) -> None:
-        """Network error should raise ConnectionError."""
-        cm = MagicMock()
-        cm.__aenter__ = AsyncMock(side_effect=aiohttp.ClientError("conn refused"))
-        cm.__aexit__ = AsyncMock(return_value=False)
-
-        mock_session = MagicMock()
-        mock_session.get = MagicMock(return_value=cm)
-
-        _setup_broker_mocks(overseas_broker, mock_session)
-
-        with pytest.raises(ConnectionError, match="Network error"):
-            await overseas_broker.get_overseas_price("NASD", "AAPL")
-
-
-class TestGetOverseasBalance:
-    """Test get_overseas_balance method."""
-
-    @pytest.mark.asyncio
-    async def test_success(self, overseas_broker: OverseasBroker) -> None:
-        """Successful balance fetch returns JSON data."""
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(return_value={"output1": [{"pdno": "AAPL"}]})
-
-        mock_session = MagicMock()
-        mock_session.get = MagicMock(return_value=_make_async_cm(mock_resp))
-
-        _setup_broker_mocks(overseas_broker, mock_session)
-
-        result = await overseas_broker.get_overseas_balance("NASD")
-        assert result["output1"][0]["pdno"] == "AAPL"
-
-    @pytest.mark.asyncio
-    async def test_http_error_raises(self, overseas_broker: OverseasBroker) -> None:
-        """Non-200 should raise ConnectionError."""
-        mock_resp = AsyncMock()
-        mock_resp.status = 500
-        mock_resp.text = AsyncMock(return_value="Server Error")
-
-        mock_session = MagicMock()
-        mock_session.get = MagicMock(return_value=_make_async_cm(mock_resp))
-
-        _setup_broker_mocks(overseas_broker, mock_session)
-
-        with pytest.raises(ConnectionError, match="get_overseas_balance failed"):
-            await overseas_broker.get_overseas_balance("NASD")
-
-    @pytest.mark.asyncio
-    async def test_network_error_raises(self, overseas_broker: OverseasBroker) -> None:
-        """Network error should raise ConnectionError."""
-        cm = MagicMock()
-        cm.__aenter__ = AsyncMock(side_effect=TimeoutError("timeout"))
-        cm.__aexit__ = AsyncMock(return_value=False)
-
-        mock_session = MagicMock()
-        mock_session.get = MagicMock(return_value=cm)
-
-        _setup_broker_mocks(overseas_broker, mock_session)
-
-        with pytest.raises(ConnectionError, match="Network error"):
-            await overseas_broker.get_overseas_balance("NYSE")
-
-
-class TestSendOverseasOrder:
-    """Test send_overseas_order method."""
-
-    @pytest.mark.asyncio
-    async def test_buy_market_order(self, overseas_broker: OverseasBroker) -> None:
-        """Market buy order should use VTTT1002U and ORD_DVSN=01."""
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(return_value={"rt_cd": "0"})
-
-        mock_session = MagicMock()
-        mock_session.post = MagicMock(return_value=_make_async_cm(mock_resp))
-
-        _setup_broker_mocks(overseas_broker, mock_session)
-        overseas_broker._broker._get_hash_key = AsyncMock(return_value="hashval")
-
-        result = await overseas_broker.send_overseas_order("NASD", "AAPL", "BUY", 10)
-        assert result["rt_cd"] == "0"
-
-        # Verify BUY TR_ID
-        overseas_broker._broker._auth_headers.assert_called_with("VTTT1002U")
-
-        call_args = mock_session.post.call_args
-        body = call_args[1]["json"]
-        assert body["ORD_DVSN"] == "01"  # market order
-        assert body["OVRS_ORD_UNPR"] == "0"
-
-    @pytest.mark.asyncio
-    async def test_sell_limit_order(self, overseas_broker: OverseasBroker) -> None:
-        """Limit sell order should use VTTT1001U and ORD_DVSN=00."""
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(return_value={"rt_cd": "0"})
-
-        mock_session = MagicMock()
-        mock_session.post = MagicMock(return_value=_make_async_cm(mock_resp))
-
-        _setup_broker_mocks(overseas_broker, mock_session)
-        overseas_broker._broker._get_hash_key = AsyncMock(return_value="hashval")
-
-        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")
-
-        call_args = mock_session.post.call_args
-        body = call_args[1]["json"]
-        assert body["ORD_DVSN"] == "00"  # limit order
-        assert body["OVRS_ORD_UNPR"] == "350.0"
-
-    @pytest.mark.asyncio
-    async def test_order_http_error_raises(self, overseas_broker: OverseasBroker) -> None:
-        """Non-200 should raise ConnectionError."""
-        mock_resp = AsyncMock()
-        mock_resp.status = 400
-        mock_resp.text = AsyncMock(return_value="Bad Request")
-
-        mock_session = MagicMock()
-        mock_session.post = MagicMock(return_value=_make_async_cm(mock_resp))
-
-        _setup_broker_mocks(overseas_broker, mock_session)
-        overseas_broker._broker._get_hash_key = AsyncMock(return_value="hashval")
-
-        with pytest.raises(ConnectionError, match="send_overseas_order failed"):
-            await overseas_broker.send_overseas_order("NASD", "AAPL", "BUY", 1)
-
-    @pytest.mark.asyncio
-    async def test_order_network_error_raises(self, overseas_broker: OverseasBroker) -> None:
-        """Network error should raise ConnectionError."""
-        cm = MagicMock()
-        cm.__aenter__ = AsyncMock(side_effect=aiohttp.ClientError("conn reset"))
-        cm.__aexit__ = AsyncMock(return_value=False)
-
-        mock_session = MagicMock()
-        mock_session.post = MagicMock(return_value=cm)
-
-        _setup_broker_mocks(overseas_broker, mock_session)
-        overseas_broker._broker._get_hash_key = AsyncMock(return_value="hashval")
-
-        with pytest.raises(ConnectionError, match="Network error"):
-            await overseas_broker.send_overseas_order("NASD", "TSLA", "SELL", 2)
-
-
-class TestGetCurrencyCode:
-    """Test _get_currency_code mapping."""
-
-    def test_us_exchanges(self, overseas_broker: OverseasBroker) -> None:
-        assert overseas_broker._get_currency_code("NASD") == "USD"
-        assert overseas_broker._get_currency_code("NYSE") == "USD"
-        assert overseas_broker._get_currency_code("AMEX") == "USD"
-
-    def test_japan(self, overseas_broker: OverseasBroker) -> None:
-        assert overseas_broker._get_currency_code("TSE") == "JPY"
-
-    def test_hong_kong(self, overseas_broker: OverseasBroker) -> None:
-        assert overseas_broker._get_currency_code("SEHK") == "HKD"
-
-    def test_china(self, overseas_broker: OverseasBroker) -> None:
-        assert overseas_broker._get_currency_code("SHAA") == "CNY"
-        assert overseas_broker._get_currency_code("SZAA") == "CNY"
-
-    def test_vietnam(self, overseas_broker: OverseasBroker) -> None:
-        assert overseas_broker._get_currency_code("HNX") == "VND"
-        assert overseas_broker._get_currency_code("HSX") == "VND"
-
-    def test_unknown_defaults_usd(self, overseas_broker: OverseasBroker) -> None:
-        assert overseas_broker._get_currency_code("UNKNOWN") == "USD"
-
-
-class TestExtractRankingRows:
-    """Test _extract_ranking_rows helper."""
-
-    def test_output_key(self, overseas_broker: OverseasBroker) -> None:
-        data = {"output": [{"a": 1}, {"b": 2}]}
-        assert overseas_broker._extract_ranking_rows(data) == [{"a": 1}, {"b": 2}]
-
-    def test_output1_key(self, overseas_broker: OverseasBroker) -> None:
-        data = {"output1": [{"c": 3}]}
-        assert overseas_broker._extract_ranking_rows(data) == [{"c": 3}]
-
-    def test_output2_key(self, overseas_broker: OverseasBroker) -> None:
-        data = {"output2": [{"d": 4}]}
-        assert overseas_broker._extract_ranking_rows(data) == [{"d": 4}]
-
-    def test_no_list_returns_empty(self, overseas_broker: OverseasBroker) -> None:
-        data = {"output": "not a list"}
-        assert overseas_broker._extract_ranking_rows(data) == []
-
-    def test_empty_data(self, overseas_broker: OverseasBroker) -> None:
-        assert overseas_broker._extract_ranking_rows({}) == []
-
-    def test_filters_non_dict_rows(self, overseas_broker: OverseasBroker) -> None:
-        data = {"output": [{"a": 1}, "invalid", {"b": 2}]}
-        assert overseas_broker._extract_ranking_rows(data) == [{"a": 1}, {"b": 2}]
-
-
-class TestPriceExchangeMap:
-    """Test _PRICE_EXCHANGE_MAP is applied in get_overseas_price (issue #151)."""
-
-    def test_price_map_equals_ranking_map(self) -> None:
-        assert _PRICE_EXCHANGE_MAP is _RANKING_EXCHANGE_MAP
-
-    @pytest.mark.parametrize("original,expected", [
-        ("NASD", "NAS"),
-        ("NYSE", "NYS"),
-        ("AMEX", "AMS"),
-    ])
-    def test_us_exchange_code_mapping(self, original: str, expected: str) -> None:
-        assert _PRICE_EXCHANGE_MAP[original] == expected
-
-    @pytest.mark.asyncio
-    async def test_get_overseas_price_sends_mapped_code(
-        self, overseas_broker: OverseasBroker
-    ) -> None:
-        """NASD → NAS must be sent to HHDFS00000300."""
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(return_value={"output": {"last": "200.00"}})
-
-        mock_session = MagicMock()
-        mock_session.get = MagicMock(return_value=_make_async_cm(mock_resp))
-        _setup_broker_mocks(overseas_broker, mock_session)
-
-        await overseas_broker.get_overseas_price("NASD", "AAPL")
-
-        params = mock_session.get.call_args[1]["params"]
-        assert params["EXCD"] == "NAS"
-
-
-class TestOrderRtCdCheck:
-    """Test that send_overseas_order checks rt_cd and logs accordingly (issue #151)."""
-
-    @pytest.fixture
-    def overseas_broker(self, mock_settings: Settings) -> OverseasBroker:
-        broker = MagicMock(spec=KISBroker)
-        broker._settings = mock_settings
-        broker._account_no = "12345678"
-        broker._product_cd = "01"
-        broker._base_url = "https://openapivts.koreainvestment.com:9443"
-        broker._rate_limiter = AsyncMock()
-        broker._rate_limiter.acquire = AsyncMock()
-        broker._auth_headers = AsyncMock(return_value={"authorization": "Bearer t"})
-        broker._get_hash_key = AsyncMock(return_value="hashval")
-        return OverseasBroker(broker)
-
-    @pytest.mark.asyncio
-    async def test_success_rt_cd_returns_data(
-        self, overseas_broker: OverseasBroker
-    ) -> None:
-        """rt_cd='0' → order accepted, data returned."""
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(return_value={"rt_cd": "0", "msg1": "완료"})
-
-        mock_session = MagicMock()
-        mock_session.post = MagicMock(return_value=_make_async_cm(mock_resp))
-        overseas_broker._broker._get_session = MagicMock(return_value=mock_session)
-
-        result = await overseas_broker.send_overseas_order("NASD", "AAPL", "BUY", 10, price=150.0)
-        assert result["rt_cd"] == "0"
-
-    @pytest.mark.asyncio
-    async def test_error_rt_cd_returns_data_with_msg(
-        self, overseas_broker: OverseasBroker
-    ) -> None:
-        """rt_cd != '0' → order rejected, data still returned (caller checks rt_cd)."""
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(
-            return_value={"rt_cd": "1", "msg1": "주문가능금액이 부족합니다."}
-        )
-
-        mock_session = MagicMock()
-        mock_session.post = MagicMock(return_value=_make_async_cm(mock_resp))
-        overseas_broker._broker._get_session = MagicMock(return_value=mock_session)
-
-        result = await overseas_broker.send_overseas_order("NASD", "AAPL", "BUY", 10, price=150.0)
-        assert result["rt_cd"] == "1"
-        assert "부족" in result["msg1"]
-
-
-class TestPaperOverseasCash:
-    """Test PAPER_OVERSEAS_CASH config setting (issue #151)."""
-
-    def test_default_value(self) -> None:
-        settings = Settings(
-            KIS_APP_KEY="k",
-            KIS_APP_SECRET="s",
-            KIS_ACCOUNT_NO="12345678-01",
-            GEMINI_API_KEY="g",
-        )
-        assert settings.PAPER_OVERSEAS_CASH == 50000.0
-
-    def test_env_override(self) -> None:
-        import os
-        os.environ["PAPER_OVERSEAS_CASH"] = "25000"
-        settings = Settings(
-            KIS_APP_KEY="k",
-            KIS_APP_SECRET="s",
-            KIS_ACCOUNT_NO="12345678-01",
-            GEMINI_API_KEY="g",
-        )
-        assert settings.PAPER_OVERSEAS_CASH == 25000.0
-        del os.environ["PAPER_OVERSEAS_CASH"]
-
-    def test_zero_disables_fallback(self) -> None:
-        import os
-        os.environ["PAPER_OVERSEAS_CASH"] = "0"
-        settings = Settings(
-            KIS_APP_KEY="k",
-            KIS_APP_SECRET="s",
-            KIS_ACCOUNT_NO="12345678-01",
-            GEMINI_API_KEY="g",
-        )
-        assert settings.PAPER_OVERSEAS_CASH == 0.0
-        del os.environ["PAPER_OVERSEAS_CASH"]

tests/test_pre_market_planner.py

@@ -164,23 +164,18 @@ class TestGeneratePlaybook:
         assert pb.market_outlook == MarketOutlook.NEUTRAL
 
     @pytest.mark.asyncio
-    async def test_gemini_failure_returns_smart_fallback(self) -> None:
+    async def test_gemini_failure_returns_defensive(self) -> None:
         planner = _make_planner()
         planner._gemini.decide = AsyncMock(side_effect=RuntimeError("API timeout"))
-        # oversold candidate (signal="oversold", rsi=28.5)
         candidates = [_candidate()]
 
         pb = await planner.generate_playbook("KR", candidates, today=date(2026, 2, 8))
 
         assert pb.default_action == ScenarioAction.HOLD
-        # Smart fallback uses NEUTRAL outlook (not NEUTRAL_TO_BEARISH)
-        assert pb.market_outlook == MarketOutlook.NEUTRAL
+        assert pb.market_outlook == MarketOutlook.NEUTRAL_TO_BEARISH
         assert pb.stock_count == 1
-        # Oversold candidate → first scenario is BUY, second is SELL stop-loss
-        scenarios = pb.stock_playbooks[0].scenarios
-        assert scenarios[0].action == ScenarioAction.BUY
-        assert scenarios[0].condition.rsi_below == 30
-        assert scenarios[1].action == ScenarioAction.SELL
+        # Defensive playbook has stop-loss scenarios
+        assert pb.stock_playbooks[0].scenarios[0].action == ScenarioAction.SELL
 
     @pytest.mark.asyncio
     async def test_gemini_failure_empty_when_defensive_disabled(self) -> None:
@@ -662,339 +657,3 @@ class TestDefensivePlaybook:
         assert pb.stock_count == 0
         assert pb.market == "US"
         assert pb.market_outlook == MarketOutlook.NEUTRAL
-
-
-# ---------------------------------------------------------------------------
-# Smart fallback playbook
-# ---------------------------------------------------------------------------
-
-
-class TestSmartFallbackPlaybook:
-    """Tests for _smart_fallback_playbook — rule-based BUY/SELL on Gemini failure."""
-
-    def _make_settings(self) -> Settings:
-        return Settings(
-            KIS_APP_KEY="test",
-            KIS_APP_SECRET="test",
-            KIS_ACCOUNT_NO="12345678-01",
-            GEMINI_API_KEY="test",
-            RSI_OVERSOLD_THRESHOLD=30,
-            VOL_MULTIPLIER=2.0,
-        )
-
-    def test_momentum_candidate_gets_buy_on_volume(self) -> None:
-        candidates = [
-            _candidate(code="CHOW", signal="momentum", volume_ratio=13.64, rsi=100.0)
-        ]
-        settings = self._make_settings()
-
-        pb = PreMarketPlanner._smart_fallback_playbook(
-            date(2026, 2, 17), "US_AMEX", candidates, settings
-        )
-
-        assert pb.stock_count == 1
-        sp = pb.stock_playbooks[0]
-        assert sp.stock_code == "CHOW"
-        # First scenario: BUY with volume_ratio_above
-        buy_sc = sp.scenarios[0]
-        assert buy_sc.action == ScenarioAction.BUY
-        assert buy_sc.condition.volume_ratio_above == 2.0
-        assert buy_sc.condition.rsi_below is None
-        assert buy_sc.confidence == 80
-        # Second scenario: stop-loss SELL
-        sell_sc = sp.scenarios[1]
-        assert sell_sc.action == ScenarioAction.SELL
-        assert sell_sc.condition.price_change_pct_below == -3.0
-
-    def test_oversold_candidate_gets_buy_on_rsi(self) -> None:
-        candidates = [
-            _candidate(code="005930", signal="oversold", rsi=22.0, volume_ratio=3.5)
-        ]
-        settings = self._make_settings()
-
-        pb = PreMarketPlanner._smart_fallback_playbook(
-            date(2026, 2, 17), "KR", candidates, settings
-        )
-
-        sp = pb.stock_playbooks[0]
-        buy_sc = sp.scenarios[0]
-        assert buy_sc.action == ScenarioAction.BUY
-        assert buy_sc.condition.rsi_below == 30
-        assert buy_sc.condition.volume_ratio_above is None
-
-    def test_all_candidates_have_stop_loss_sell(self) -> None:
-        candidates = [
-            _candidate(code="AAA", signal="momentum", volume_ratio=5.0),
-            _candidate(code="BBB", signal="oversold", rsi=25.0),
-        ]
-        settings = self._make_settings()
-
-        pb = PreMarketPlanner._smart_fallback_playbook(
-            date(2026, 2, 17), "US_NASDAQ", candidates, settings
-        )
-
-        assert pb.stock_count == 2
-        for sp in pb.stock_playbooks:
-            sell_scenarios = [s for s in sp.scenarios if s.action == ScenarioAction.SELL]
-            assert len(sell_scenarios) == 1
-            assert sell_scenarios[0].condition.price_change_pct_below == -3.0
-            assert sell_scenarios[0].condition.price_change_pct_below == -3.0
-
-    def test_market_outlook_is_neutral(self) -> None:
-        candidates = [_candidate(signal="momentum", volume_ratio=5.0)]
-        settings = self._make_settings()
-
-        pb = PreMarketPlanner._smart_fallback_playbook(
-            date(2026, 2, 17), "US_AMEX", candidates, settings
-        )
-
-        assert pb.market_outlook == MarketOutlook.NEUTRAL
-
-    def test_default_action_is_hold(self) -> None:
-        candidates = [_candidate(signal="momentum", volume_ratio=5.0)]
-        settings = self._make_settings()
-
-        pb = PreMarketPlanner._smart_fallback_playbook(
-            date(2026, 2, 17), "US_AMEX", candidates, settings
-        )
-
-        assert pb.default_action == ScenarioAction.HOLD
-
-    def test_has_global_reduce_all_rule(self) -> None:
-        candidates = [_candidate(signal="momentum", volume_ratio=5.0)]
-        settings = self._make_settings()
-
-        pb = PreMarketPlanner._smart_fallback_playbook(
-            date(2026, 2, 17), "US_AMEX", candidates, settings
-        )
-
-        assert len(pb.global_rules) == 1
-        rule = pb.global_rules[0]
-        assert rule.action == ScenarioAction.REDUCE_ALL
-        assert "portfolio_pnl_pct" in rule.condition
-
-    def test_empty_candidates_returns_empty_playbook(self) -> None:
-        settings = self._make_settings()
-
-        pb = PreMarketPlanner._smart_fallback_playbook(
-            date(2026, 2, 17), "US_AMEX", [], settings
-        )
-
-        assert pb.stock_count == 0
-
-    def test_vol_multiplier_applied_from_settings(self) -> None:
-        """VOL_MULTIPLIER=3.0 should set volume_ratio_above=3.0 for momentum."""
-        candidates = [_candidate(signal="momentum", volume_ratio=5.0)]
-        settings = self._make_settings()
-        settings = settings.model_copy(update={"VOL_MULTIPLIER": 3.0})
-
-        pb = PreMarketPlanner._smart_fallback_playbook(
-            date(2026, 2, 17), "US_AMEX", candidates, settings
-        )
-
-        buy_sc = pb.stock_playbooks[0].scenarios[0]
-        assert buy_sc.condition.volume_ratio_above == 3.0
-
-    def test_rsi_oversold_threshold_applied_from_settings(self) -> None:
-        """RSI_OVERSOLD_THRESHOLD=25 should set rsi_below=25 for oversold."""
-        candidates = [_candidate(signal="oversold", rsi=22.0)]
-        settings = self._make_settings()
-        settings = settings.model_copy(update={"RSI_OVERSOLD_THRESHOLD": 25})
-
-        pb = PreMarketPlanner._smart_fallback_playbook(
-            date(2026, 2, 17), "KR", candidates, settings
-        )
-
-        buy_sc = pb.stock_playbooks[0].scenarios[0]
-        assert buy_sc.condition.rsi_below == 25
-
-    @pytest.mark.asyncio
-    async def test_generate_playbook_uses_smart_fallback_on_gemini_error(self) -> None:
-        """generate_playbook() should use smart fallback (not defensive) on API failure."""
-        planner = _make_planner()
-        planner._gemini.decide = AsyncMock(side_effect=ConnectionError("429 quota exceeded"))
-        # momentum candidate
-        candidates = [
-            _candidate(code="CHOW", signal="momentum", volume_ratio=13.64, rsi=100.0)
-        ]
-
-        pb = await planner.generate_playbook(
-            "US_AMEX", candidates, today=date(2026, 2, 18)
-        )
-
-        # Should NOT be all-SELL defensive; should have BUY for momentum
-        assert pb.stock_count == 1
-        buy_scenarios = [
-            s for s in pb.stock_playbooks[0].scenarios
-            if s.action == ScenarioAction.BUY
-        ]
-        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

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

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."""
 

tests/test_telegram.py

@@ -5,7 +5,7 @@ from unittest.mock import AsyncMock, patch
 import aiohttp
 import pytest
 
-from src.notifications.telegram_client import NotificationFilter, NotificationPriority, TelegramClient
+from src.notifications.telegram_client import NotificationPriority, TelegramClient
 
 
 class TestTelegramClientInit:
@@ -481,187 +481,3 @@ class TestClientCleanup:
 
         # Should not raise exception
         await client.close()
-
-
-class TestNotificationFilter:
-    """Test granular notification filter behavior."""
-
-    def test_default_filter_allows_all(self) -> None:
-        """Default NotificationFilter has all flags enabled."""
-        f = NotificationFilter()
-        assert f.trades is True
-        assert f.market_open_close is True
-        assert f.fat_finger is True
-        assert f.system_events is True
-        assert f.playbook is True
-        assert f.scenario_match is True
-        assert f.errors is True
-
-    def test_client_uses_default_filter_when_none_given(self) -> None:
-        """TelegramClient creates a default NotificationFilter when none provided."""
-        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
-        assert isinstance(client._filter, NotificationFilter)
-        assert client._filter.scenario_match is True
-
-    def test_client_stores_provided_filter(self) -> None:
-        """TelegramClient stores a custom NotificationFilter."""
-        nf = NotificationFilter(scenario_match=False, trades=False)
-        client = TelegramClient(
-            bot_token="123:abc", chat_id="456", enabled=True, notification_filter=nf
-        )
-        assert client._filter.scenario_match is False
-        assert client._filter.trades is False
-        assert client._filter.market_open_close is True  # default still True
-
-    @pytest.mark.asyncio
-    async def test_scenario_match_filtered_does_not_send(self) -> None:
-        """notify_scenario_matched skips send when scenario_match=False."""
-        nf = NotificationFilter(scenario_match=False)
-        client = TelegramClient(
-            bot_token="123:abc", chat_id="456", enabled=True, notification_filter=nf
-        )
-        with patch("aiohttp.ClientSession.post") as mock_post:
-            await client.notify_scenario_matched(
-                stock_code="005930", action="BUY", condition_summary="rsi<30", confidence=85.0
-            )
-            mock_post.assert_not_called()
-
-    @pytest.mark.asyncio
-    async def test_trades_filtered_does_not_send(self) -> None:
-        """notify_trade_execution skips send when trades=False."""
-        nf = NotificationFilter(trades=False)
-        client = TelegramClient(
-            bot_token="123:abc", chat_id="456", enabled=True, notification_filter=nf
-        )
-        with patch("aiohttp.ClientSession.post") as mock_post:
-            await client.notify_trade_execution(
-                stock_code="005930", market="KR", action="BUY",
-                quantity=10, price=70000.0, confidence=85.0
-            )
-            mock_post.assert_not_called()
-
-    @pytest.mark.asyncio
-    async def test_market_open_close_filtered_does_not_send(self) -> None:
-        """notify_market_open/close skip send when market_open_close=False."""
-        nf = NotificationFilter(market_open_close=False)
-        client = TelegramClient(
-            bot_token="123:abc", chat_id="456", enabled=True, notification_filter=nf
-        )
-        with patch("aiohttp.ClientSession.post") as mock_post:
-            await client.notify_market_open("Korea")
-            await client.notify_market_close("Korea", pnl_pct=1.5)
-            mock_post.assert_not_called()
-
-    @pytest.mark.asyncio
-    async def test_circuit_breaker_always_sends_regardless_of_filter(self) -> None:
-        """notify_circuit_breaker always sends (no filter flag)."""
-        nf = NotificationFilter(
-            trades=False, market_open_close=False, fat_finger=False,
-            system_events=False, playbook=False, scenario_match=False, errors=False,
-        )
-        client = TelegramClient(
-            bot_token="123:abc", chat_id="456", enabled=True, notification_filter=nf
-        )
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
-        mock_resp.__aexit__ = AsyncMock(return_value=False)
-
-        with patch("aiohttp.ClientSession.post", return_value=mock_resp) as mock_post:
-            await client.notify_circuit_breaker(pnl_pct=-3.5, threshold=-3.0)
-            assert mock_post.call_count == 1
-
-    @pytest.mark.asyncio
-    async def test_errors_filtered_does_not_send(self) -> None:
-        """notify_error skips send when errors=False."""
-        nf = NotificationFilter(errors=False)
-        client = TelegramClient(
-            bot_token="123:abc", chat_id="456", enabled=True, notification_filter=nf
-        )
-        with patch("aiohttp.ClientSession.post") as mock_post:
-            await client.notify_error("TestError", "something went wrong", "KR")
-            mock_post.assert_not_called()
-
-    @pytest.mark.asyncio
-    async def test_playbook_filtered_does_not_send(self) -> None:
-        """notify_playbook_generated/failed skip send when playbook=False."""
-        nf = NotificationFilter(playbook=False)
-        client = TelegramClient(
-            bot_token="123:abc", chat_id="456", enabled=True, notification_filter=nf
-        )
-        with patch("aiohttp.ClientSession.post") as mock_post:
-            await client.notify_playbook_generated("KR", 3, 10, 1200)
-            await client.notify_playbook_failed("KR", "timeout")
-            mock_post.assert_not_called()
-
-    @pytest.mark.asyncio
-    async def test_system_events_filtered_does_not_send(self) -> None:
-        """notify_system_start/shutdown skip send when system_events=False."""
-        nf = NotificationFilter(system_events=False)
-        client = TelegramClient(
-            bot_token="123:abc", chat_id="456", enabled=True, notification_filter=nf
-        )
-        with patch("aiohttp.ClientSession.post") as mock_post:
-            await client.notify_system_start("paper", ["KR"])
-            await client.notify_system_shutdown("Normal shutdown")
-            mock_post.assert_not_called()
-
-    def test_set_flag_valid_key(self) -> None:
-        """set_flag returns True and updates field for a known key."""
-        nf = NotificationFilter()
-        assert nf.set_flag("scenario", False) is True
-        assert nf.scenario_match is False
-
-    def test_set_flag_invalid_key(self) -> None:
-        """set_flag returns False for an unknown key."""
-        nf = NotificationFilter()
-        assert nf.set_flag("unknown_key", False) is False
-
-    def test_as_dict_keys_match_KEYS(self) -> None:
-        """as_dict() returns every key defined in KEYS."""
-        nf = NotificationFilter()
-        d = nf.as_dict()
-        assert set(d.keys()) == set(NotificationFilter.KEYS.keys())
-
-    def test_set_notification_valid_key(self) -> None:
-        """TelegramClient.set_notification toggles filter at runtime."""
-        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
-        assert client._filter.scenario_match is True
-        assert client.set_notification("scenario", False) is True
-        assert client._filter.scenario_match is False
-
-    def test_set_notification_all_off(self) -> None:
-        """set_notification('all', False) disables every filter flag."""
-        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
-        assert client.set_notification("all", False) is True
-        for v in client.filter_status().values():
-            assert v is False
-
-    def test_set_notification_all_on(self) -> None:
-        """set_notification('all', True) enables every filter flag."""
-        client = TelegramClient(
-            bot_token="123:abc", chat_id="456", enabled=True,
-            notification_filter=NotificationFilter(
-                trades=False, market_open_close=False, scenario_match=False,
-                fat_finger=False, system_events=False, playbook=False, errors=False,
-            ),
-        )
-        assert client.set_notification("all", True) is True
-        for v in client.filter_status().values():
-            assert v is True
-
-    def test_set_notification_unknown_key(self) -> None:
-        """set_notification returns False for an unknown key."""
-        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
-        assert client.set_notification("unknown", False) is False
-
-    def test_filter_status_reflects_current_state(self) -> None:
-        """filter_status() matches the current NotificationFilter state."""
-        nf = NotificationFilter(trades=False, scenario_match=False)
-        client = TelegramClient(
-            bot_token="123:abc", chat_id="456", enabled=True, notification_filter=nf
-        )
-        status = client.filter_status()
-        assert status["trades"] is False
-        assert status["scenario"] is False
-        assert status["market"] is True

tests/test_telegram_commands.py

@@ -875,139 +875,3 @@ class TestGetUpdates:
             updates = await handler._get_updates()
 
             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."""
-
-    def test_register_command_with_args_stored(self) -> None:
-        """register_command_with_args stores handler in _commands_with_args."""
-        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
-        handler = TelegramCommandHandler(client)
-
-        async def my_handler(args: list[str]) -> None:
-            pass
-
-        handler.register_command_with_args("notify", my_handler)
-        assert "notify" in handler._commands_with_args
-        assert handler._commands_with_args["notify"] is my_handler
-
-    @pytest.mark.asyncio
-    async def test_args_handler_receives_arguments(self) -> None:
-        """Args handler is called with the trailing tokens."""
-        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
-        handler = TelegramCommandHandler(client)
-
-        received: list[list[str]] = []
-
-        async def capture(args: list[str]) -> None:
-            received.append(args)
-
-        handler.register_command_with_args("notify", capture)
-
-        update = {
-            "message": {
-                "chat": {"id": "456"},
-                "text": "/notify scenario off",
-            }
-        }
-        await handler._handle_update(update)
-        assert received == [["scenario", "off"]]
-
-    @pytest.mark.asyncio
-    async def test_args_handler_takes_priority_over_no_args_handler(self) -> None:
-        """When both handlers exist for same command, args handler wins."""
-        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
-        handler = TelegramCommandHandler(client)
-
-        no_args_called = []
-        args_called = []
-
-        async def no_args_handler() -> None:
-            no_args_called.append(True)
-
-        async def args_handler(args: list[str]) -> None:
-            args_called.append(args)
-
-        handler.register_command("notify", no_args_handler)
-        handler.register_command_with_args("notify", args_handler)
-
-        update = {
-            "message": {
-                "chat": {"id": "456"},
-                "text": "/notify all off",
-            }
-        }
-        await handler._handle_update(update)
-        assert args_called == [["all", "off"]]
-        assert no_args_called == []
-
-    @pytest.mark.asyncio
-    async def test_args_handler_with_no_trailing_args(self) -> None:
-        """/notify with no args still dispatches to args handler with empty list."""
-        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
-        handler = TelegramCommandHandler(client)
-
-        received: list[list[str]] = []
-
-        async def capture(args: list[str]) -> None:
-            received.append(args)
-
-        handler.register_command_with_args("notify", capture)
-
-        update = {
-            "message": {
-                "chat": {"id": "456"},
-                "text": "/notify",
-            }
-        }
-        await handler._handle_update(update)
-        assert received == [[]]