feat: unify domestic scanner and sizing; update docs

Reviewed-on: #135

docs/architecture.md

@@ -68,6 +68,10 @@ High-frequency trading with individual stock analysis:
 - `fetch_market_rankings()` — Fetch volume surge rankings from KIS API
 - `get_daily_prices()` — Fetch OHLCV history for technical analysis
 
+**Overseas Ranking API Methods** (added in v0.10.x):
+- `fetch_overseas_rankings()` — Fetch overseas ranking universe (fluctuation / volume)
+- Ranking endpoint paths and TR_IDs are configurable via environment variables
+
 ### 2. Analysis (`src/analysis/`)
 
 **VolatilityAnalyzer** (`volatility.py`) — Technical indicator calculations
@@ -81,20 +85,24 @@ High-frequency trading with individual stock analysis:
 
 **SmartVolatilityScanner** (`smart_scanner.py`) — Python-first filtering pipeline
 
-- **Step 1**: Fetch volume rankings from KIS API (top 30 stocks)
-- **Step 2**: Calculate RSI and volume ratio for each stock
-- **Step 3**: Apply filters:
-  - Volume ratio >= `VOL_MULTIPLIER` (default 2.0x previous day)
-  - RSI < `RSI_OVERSOLD_THRESHOLD` (30) OR RSI > `RSI_MOMENTUM_THRESHOLD` (70)
-- **Step 4**: Score candidates by RSI extremity (60%) + volume surge (40%)
-- **Step 5**: Return top N candidates (default 3) for AI analysis
-- **Fallback**: Uses static watchlist if ranking API unavailable
+- **Domestic (KR)**:
+  - **Step 1**: Fetch domestic fluctuation ranking as primary universe
+  - **Step 2**: Fetch domestic volume ranking for liquidity bonus
+  - **Step 3**: Compute volatility-first score (max of daily change% and intraday range%)
+  - **Step 4**: Apply liquidity bonus and return top N candidates
+- **Overseas (US/JP/HK/CN/VN)**:
+  - **Step 1**: Fetch overseas ranking universe (fluctuation rank + volume rank bonus)
+  - **Step 2**: Compute volatility-first score (max of daily change% and intraday range%)
+  - **Step 3**: Apply liquidity bonus from volume ranking
+  - **Step 4**: Return top N candidates (default 3)
+- **Fallback (overseas only)**: If ranking API is unavailable, uses dynamic universe
+  from runtime active symbols + recent traded symbols + current holdings (no static watchlist)
 - **Realtime mode only**: Daily mode uses batch processing for API efficiency
 
 **Benefits:**
 - Reduces Gemini API calls from 20-30 stocks to 1-3 qualified candidates
 - Fast Python-based filtering before expensive AI judgment
-- Logs selection context (RSI, volume_ratio, signal, score) for Evolution system
+- Logs selection context (RSI-compatible proxy, volume_ratio, signal, score) for Evolution system
 
 ### 3. Brain (`src/brain/gemini_client.py`)
 
@@ -167,10 +175,12 @@ High-frequency trading with individual stock analysis:
                            ▼
         ┌──────────────────────────────────┐
         │ Smart Scanner (Python-first)      │
-        │ - Fetch volume rankings (KIS)    │
-        │ - Get 20d price history per stock│
-        │ - Calculate RSI(14) + vol ratio  │
-        │ - Filter: vol>2x AND RSI extreme │
+        │ - Domestic: fluctuation rank     │
+        │   + volume rank bonus            │
+        │   + volatility-first scoring     │
+        │ - Overseas: ranking universe     │
+        │   + volatility-first scoring     │
+        │ - Fallback: dynamic universe     │
         │ - Return top 3 qualified stocks  │
         └──────────────────┬────────────────┘
                            │
@@ -303,10 +313,23 @@ TELEGRAM_CHAT_ID=123456789
 TELEGRAM_ENABLED=true
 
 # Smart Scanner (optional, realtime mode only)
-RSI_OVERSOLD_THRESHOLD=30    # 0-50, oversold threshold
-RSI_MOMENTUM_THRESHOLD=70    # 50-100, momentum threshold
-VOL_MULTIPLIER=2.0           # Minimum volume ratio (2.0 = 200%)
 SCANNER_TOP_N=3              # Max qualified candidates per scan
+POSITION_SIZING_ENABLED=true
+POSITION_BASE_ALLOCATION_PCT=5.0
+POSITION_MIN_ALLOCATION_PCT=1.0
+POSITION_MAX_ALLOCATION_PCT=10.0
+POSITION_VOLATILITY_TARGET_SCORE=50.0
+# Legacy/compat scanner thresholds (kept for backward compatibility)
+RSI_OVERSOLD_THRESHOLD=30
+RSI_MOMENTUM_THRESHOLD=70
+VOL_MULTIPLIER=2.0
+
+# Overseas Ranking API (optional override; account-dependent)
+OVERSEAS_RANKING_ENABLED=true
+OVERSEAS_RANKING_FLUCT_TR_ID=HHDFS76200100
+OVERSEAS_RANKING_VOLUME_TR_ID=HHDFS76200200
+OVERSEAS_RANKING_FLUCT_PATH=/uapi/overseas-price/v1/quotations/inquire-updown-rank
+OVERSEAS_RANKING_VOLUME_PATH=/uapi/overseas-price/v1/quotations/inquire-volume-rank
 ```
 
 Tests use in-memory SQLite (`DB_PATH=":memory:"`) and dummy credentials via `tests/conftest.py`.

docs/requirements-log.md

@@ -64,3 +64,83 @@
 **참고:** Realtime 모드 전용. Daily 모드는 배치 효율성을 위해 정적 watchlist 사용.
 
 **이슈/PR:** #76, #77
+
+---
+
+## 2026-02-10
+
+### 코드 리뷰 시 플랜-구현 일치 검증 규칙
+
+**배경:**
+- 코드 리뷰 시 플랜(EnterPlanMode에서 승인된 계획)과 실제 구현이 일치하는지 확인하는 절차가 없었음
+- 플랜과 다른 구현이 리뷰 없이 통과될 위험
+
+**요구사항:**
+1. 모든 PR 리뷰에서 플랜-구현 일치 여부를 필수 체크
+2. 플랜에 없는 변경은 정당한 사유 필요
+3. 플랜 항목이 누락되면 PR 설명에 사유 기록
+4. 스코프가 플랜과 일치하는지 확인
+
+**구현 결과:**
+- `docs/workflow.md`에 Code Review Checklist 섹션 추가
+  - Plan Consistency (필수), Safety & Constraints, Quality, Workflow 4개 카테고리
+
+**이슈/PR:** #114
+
+---
+
+## 2026-02-16
+
+### 해외 스캐너 개선: 랭킹 연동 + 변동성 우선 선별
+
+**배경:**
+- `run_overnight` 실운영에서 미국장 동안 거래가 0건 지속
+- 원인: 해외 시장에서도 국내 랭킹/일봉 API 경로를 사용하던 구조적 불일치
+
+**요구사항:**
+1. 해외 시장도 랭킹 API 기반 유니버스 탐색 지원
+2. 단순 상승률/거래대금 상위가 아니라, **변동성이 큰 종목**을 우선 선별
+3. 고정 티커 fallback 금지
+
+**구현 결과:**
+- `src/broker/overseas.py`
+  - `fetch_overseas_rankings()` 추가 (fluctuation / volume)
+  - 해외 랭킹 API 경로/TR_ID를 설정값으로 오버라이드 가능하게 구현
+- `src/analysis/smart_scanner.py`
+  - market-aware 스캔(국내/해외 분리)
+  - 해외: 랭킹 API 유니버스 + 변동성 우선 점수(일변동률 vs 장중 고저폭)
+  - 거래대금/거래량 랭킹은 유동성 보정 점수로 활용
+  - 랭킹 실패 시에는 동적 유니버스(active/recent/holdings)만 사용
+- `src/config.py`
+  - `OVERSEAS_RANKING_*` 설정 추가
+
+**효과:**
+- 해외 시장에서 스캐너 후보 0개로 정지되는 상황 완화
+- 종목 선정 기준이 단순 상승률 중심에서 변동성 중심으로 개선
+- 고정 티커 없이도 시장 주도 변동 종목 탐지 가능
+
+### 국내 스캐너/주문수량 정렬: 변동성 우선 + 리스크 타기팅
+
+**배경:**
+- 해외만 변동성 우선으로 동작하고, 국내는 RSI/거래량 필터 중심으로 동작해 시장 간 전략 일관성이 낮았음
+- 매수 수량이 고정 1주라서 변동성 구간별 익스포저 관리가 어려웠음
+
+**요구사항:**
+1. 국내 스캐너도 변동성 우선 선별로 해외와 통일
+2. 고변동 종목일수록 포지션 크기를 줄이는 수량 산식 적용
+
+**구현 결과:**
+- `src/analysis/smart_scanner.py`
+  - 국내: `fluctuation ranking + volume ranking bonus` 기반 점수화로 전환
+  - 점수는 `max(abs(change_rate), intraday_range_pct)` 중심으로 계산
+  - 국내 랭킹 응답 스키마 키(`price`, `change_rate`, `volume`) 파싱 보강
+- `src/main.py`
+  - `_determine_order_quantity()` 추가
+  - BUY 시 변동성 점수 기반 동적 수량 산정 적용
+  - `trading_cycle`, `run_daily_session` 경로 모두 동일 수량 로직 사용
+- `src/config.py`
+  - `POSITION_SIZING_*` 설정 추가
+
+**효과:**
+- 국내/해외 스캐너 기준이 변동성 중심으로 일관화
+- 고변동 구간에서 자동 익스포저 축소, 저변동 구간에서 과소진입 완화

docs/workflow.md

@@ -74,3 +74,37 @@ task_tool(
 ```
 
 Use `run_in_background=True` for independent tasks that don't block subsequent work.
+
+## Code Review Checklist
+
+**CRITICAL: Every PR review MUST verify plan-implementation consistency.**
+
+Before approving any PR, the reviewer (human or agent) must check ALL of the following:
+
+### 1. Plan Consistency (MANDATORY)
+
+- [ ] **Implementation matches the approved plan** — Compare the actual code changes against the plan created during `EnterPlanMode`. Every item in the plan must be addressed.
+- [ ] **No unplanned changes** — If the implementation includes changes not in the plan, they must be explicitly justified.
+- [ ] **No plan items omitted** — If any planned item was skipped, the reason must be documented in the PR description.
+- [ ] **Scope matches** — The PR does not exceed or fall short of the planned scope.
+
+### 2. Safety & Constraints
+
+- [ ] `src/core/risk_manager.py` is unchanged (READ-ONLY)
+- [ ] Circuit breaker threshold not weakened (only stricter allowed)
+- [ ] Fat-finger protection (30% max order) still enforced
+- [ ] Confidence < 80 still forces HOLD
+- [ ] No hardcoded API keys or secrets
+
+### 3. Quality
+
+- [ ] All new/modified code has corresponding tests
+- [ ] Test coverage >= 80%
+- [ ] `ruff check src/ tests/` passes (no lint errors)
+- [ ] No `assert` statements removed from tests
+
+### 4. Workflow
+
+- [ ] PR references the Gitea issue number
+- [ ] Feature branch follows naming convention (`feature/issue-N-description`)
+- [ ] Commit messages are clear and descriptive

pyproject.toml

@@ -9,6 +9,8 @@ dependencies = [
     "pydantic-settings>=2.1,<3",
     "google-genai>=1.0,<2",
     "scipy>=1.11,<2",
+    "fastapi>=0.110,<1",
+    "uvicorn>=0.29,<1",
 ]
 
 [project.optional-dependencies]

src/analysis/scanner.py

@@ -108,7 +108,7 @@ class MarketScanner:
             self.context_store.set_context(
                 ContextLayer.L7_REALTIME,
                 timeframe,
-                f"{market.code}_{stock_code}_volatility",
+                f"volatility_{market.code}_{stock_code}",
                 {
                     "price": metrics.current_price,
                     "atr": metrics.atr,
@@ -179,7 +179,7 @@ class MarketScanner:
         self.context_store.set_context(
             ContextLayer.L7_REALTIME,
             timeframe,
-            f"{market.code}_scan_result",
+            f"scan_result_{market.code}",
             {
                 "total_scanned": len(valid_metrics),
                 "top_movers": [m.stock_code for m in top_movers],

src/analysis/smart_scanner.py

@@ -1,8 +1,4 @@
-"""Smart Volatility Scanner with RSI and volume filters.
-
-Fetches market rankings from KIS API and applies technical filters
-to identify high-probability trading candidates.
-"""
+"""Smart Volatility Scanner with volatility-first market ranking logic."""
 
 from __future__ import annotations
 
@@ -12,7 +8,9 @@ from typing import Any
 
 from src.analysis.volatility import VolatilityAnalyzer
 from src.broker.kis_api import KISBroker
+from src.broker.overseas import OverseasBroker
 from src.config import Settings
+from src.markets.schedule import MarketInfo
 
 logger = logging.getLogger(__name__)
 
@@ -32,19 +30,19 @@ class ScanCandidate:
 
 
 class SmartVolatilityScanner:
-    """Scans market rankings and applies RSI/volume filters.
+    """Scans market rankings and applies volatility-first filters.
 
     Flow:
-    1. Fetch volume rankings from KIS API
-    2. For each ranked stock, fetch daily prices
-    3. Calculate RSI and volume ratio
-    4. Apply filters: volume > VOL_MULTIPLIER AND (RSI < 30 OR RSI > 70)
-    5. Return top N qualified candidates
+    1. Fetch fluctuation rankings as primary universe
+    2. Fetch volume rankings for liquidity bonus
+    3. Score by volatility first, liquidity second
+    4. Return top N qualified candidates
     """
 
     def __init__(
         self,
         broker: KISBroker,
+        overseas_broker: OverseasBroker | None,
         volatility_analyzer: VolatilityAnalyzer,
         settings: Settings,
     ) -> None:
@@ -56,6 +54,7 @@ class SmartVolatilityScanner:
             settings: Application settings
         """
         self.broker = broker
+        self.overseas_broker = overseas_broker
         self.analyzer = volatility_analyzer
         self.settings = settings
 
@@ -67,107 +66,129 @@ class SmartVolatilityScanner:
 
     async def scan(
         self,
+        market: MarketInfo | None = None,
         fallback_stocks: list[str] | None = None,
     ) -> list[ScanCandidate]:
         """Execute smart scan and return qualified candidates.
 
         Args:
+            market: Target market info (domestic vs overseas behavior)
             fallback_stocks: Stock codes to use if ranking API fails
 
         Returns:
             List of ScanCandidate, sorted by score, up to top_n items
         """
-        # Step 1: Fetch rankings
+        if market and not market.is_domestic:
+            return await self._scan_overseas(market, fallback_stocks)
+
+        return await self._scan_domestic(fallback_stocks)
+
+    async def _scan_domestic(
+        self,
+        fallback_stocks: list[str] | None = None,
+    ) -> list[ScanCandidate]:
+        """Scan domestic market using volatility-first ranking + liquidity bonus."""
+        # 1) Primary universe from fluctuation ranking.
         try:
-            rankings = await self.broker.fetch_market_rankings(
-                ranking_type="volume",
-                limit=30,  # Fetch more than needed for filtering
+            fluct_rows = await self.broker.fetch_market_rankings(
+                ranking_type="fluctuation",
+                limit=50,
             )
-            logger.info("Fetched %d stocks from volume rankings", len(rankings))
         except ConnectionError as exc:
-            logger.warning("Ranking API failed, using fallback: %s", exc)
-            if fallback_stocks:
-                # Create minimal ranking data for fallback
-                rankings = [
-                    {
-                        "stock_code": code,
-                        "name": code,
-                        "price": 0,
-                        "volume": 0,
-                        "change_rate": 0,
-                        "volume_increase_rate": 0,
-                    }
-                    for code in fallback_stocks
-                ]
-            else:
-                return []
+            logger.warning("Domestic fluctuation ranking failed: %s", exc)
+            fluct_rows = []
+
+        # 2) Liquidity bonus from volume ranking.
+        try:
+            volume_rows = await self.broker.fetch_market_rankings(
+                ranking_type="volume",
+                limit=50,
+            )
+        except ConnectionError as exc:
+            logger.warning("Domestic volume ranking failed: %s", exc)
+            volume_rows = []
+
+        if not fluct_rows and fallback_stocks:
+            logger.info(
+                "Domestic ranking unavailable; using fallback symbols (%d)",
+                len(fallback_stocks),
+            )
+            fluct_rows = [
+                {
+                    "stock_code": code,
+                    "name": code,
+                    "price": 0.0,
+                    "volume": 0.0,
+                    "change_rate": 0.0,
+                    "volume_increase_rate": 0.0,
+                }
+                for code in fallback_stocks
+            ]
+
+        if not fluct_rows:
+            return []
+
+        volume_rank_bonus: dict[str, float] = {}
+        for idx, row in enumerate(volume_rows):
+            code = _extract_stock_code(row)
+            if not code:
+                continue
+            volume_rank_bonus[code] = max(0.0, 15.0 - idx * 0.3)
 
-        # Step 2: Analyze each stock
         candidates: list[ScanCandidate] = []
-
-        for stock in rankings:
-            stock_code = stock["stock_code"]
+        for stock in fluct_rows:
+            stock_code = _extract_stock_code(stock)
             if not stock_code:
                 continue
 
             try:
-                # Fetch daily prices for RSI calculation
-                daily_prices = await self.broker.get_daily_prices(stock_code, days=20)
+                price = _extract_last_price(stock)
+                change_rate = _extract_change_rate_pct(stock)
+                volume = _extract_volume(stock)
 
-                if len(daily_prices) < 15:  # Need at least 14+1 for RSI
-                    logger.debug("Insufficient price history for %s", stock_code)
+                intraday_range_pct = 0.0
+                volume_ratio = _safe_float(stock.get("volume_increase_rate"), 0.0) / 100.0 + 1.0
+
+                # Use daily chart to refine range/volume when available.
+                daily_prices = await self.broker.get_daily_prices(stock_code, days=2)
+                if daily_prices:
+                    latest = daily_prices[-1]
+                    latest_close = _safe_float(latest.get("close"), default=price)
+                    if price <= 0:
+                        price = latest_close
+                    latest_high = _safe_float(latest.get("high"))
+                    latest_low = _safe_float(latest.get("low"))
+                    if latest_close > 0 and latest_high > 0 and latest_low > 0 and latest_high >= latest_low:
+                        intraday_range_pct = (latest_high - latest_low) / latest_close * 100.0
+                    if volume <= 0:
+                        volume = _safe_float(latest.get("volume"))
+                    if len(daily_prices) >= 2:
+                        prev_day_volume = _safe_float(daily_prices[-2].get("volume"))
+                        if prev_day_volume > 0:
+                            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:
                     continue
 
-                # Calculate RSI
-                close_prices = [p["close"] for p in daily_prices]
-                rsi = self.analyzer.calculate_rsi(close_prices, period=14)
+                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 * 4.0)))
 
-                # Calculate volume ratio (today vs previous day avg)
-                if len(daily_prices) >= 2:
-                    prev_day_volume = daily_prices[-2]["volume"]
-                    current_volume = stock.get("volume", 0) or daily_prices[-1]["volume"]
-                    volume_ratio = (
-                        current_volume / prev_day_volume if prev_day_volume > 0 else 1.0
-                    )
-                else:
-                    volume_ratio = stock.get("volume_increase_rate", 0) / 100 + 1  # Fallback
-
-                # Apply filters
-                volume_qualified = volume_ratio >= self.vol_multiplier
-                rsi_oversold = rsi < self.rsi_oversold
-                rsi_momentum = rsi > self.rsi_momentum
-
-                if volume_qualified and (rsi_oversold or rsi_momentum):
-                    signal = "oversold" if rsi_oversold else "momentum"
-
-                    # Calculate composite score
-                    # Higher score for: extreme RSI + high volume
-                    rsi_extremity = abs(rsi - 50) / 50  # 0-1 scale
-                    volume_score = min(volume_ratio / 5, 1.0)  # Cap at 5x
-                    score = (rsi_extremity * 0.6 + volume_score * 0.4) * 100
-
-                    candidates.append(
-                        ScanCandidate(
-                            stock_code=stock_code,
-                            name=stock.get("name", stock_code),
-                            price=stock.get("price", daily_prices[-1]["close"]),
-                            volume=current_volume,
-                            volume_ratio=volume_ratio,
-                            rsi=rsi,
-                            signal=signal,
-                            score=score,
-                        )
-                    )
-
-                    logger.info(
-                        "Qualified: %s (%s) RSI=%.1f vol=%.1fx signal=%s score=%.1f",
-                        stock_code,
-                        stock.get("name", ""),
-                        rsi,
-                        volume_ratio,
-                        signal,
-                        score,
+                candidates.append(
+                    ScanCandidate(
+                        stock_code=stock_code,
+                        name=stock.get("name", stock_code),
+                        price=price,
+                        volume=volume,
+                        volume_ratio=max(1.0, volume_ratio, volatility_pct / 2.0),
+                        rsi=implied_rsi,
+                        signal=signal,
+                        score=score,
                     )
+                )
 
             except ConnectionError as exc:
                 logger.warning("Failed to analyze %s: %s", stock_code, exc)
@@ -176,10 +197,161 @@ class SmartVolatilityScanner:
                 logger.error("Unexpected error analyzing %s: %s", stock_code, exc)
                 continue
 
-        # Sort by score and return 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]
 
+    async def _scan_overseas(
+        self,
+        market: MarketInfo,
+        fallback_stocks: list[str] | None = None,
+    ) -> list[ScanCandidate]:
+        """Scan overseas symbols using ranking API first, then fallback universe."""
+        if self.overseas_broker is None:
+            logger.warning(
+                "Overseas scanner unavailable for %s: overseas broker not configured",
+                market.name,
+            )
+            return []
+
+        candidates = await self._scan_overseas_from_rankings(market)
+        if not candidates:
+            candidates = await self._scan_overseas_from_symbols(market, fallback_stocks)
+
+        candidates.sort(key=lambda c: c.score, reverse=True)
+        return candidates[: self.top_n]
+
+    async def _scan_overseas_from_rankings(
+        self,
+        market: MarketInfo,
+    ) -> list[ScanCandidate]:
+        """Build overseas candidates from ranking APIs using volatility-first scoring."""
+        assert self.overseas_broker is not None
+        try:
+            fluct_rows = await self.overseas_broker.fetch_overseas_rankings(
+                exchange_code=market.exchange_code,
+                ranking_type="fluctuation",
+                limit=50,
+            )
+        except Exception as exc:
+            logger.warning(
+                "Overseas fluctuation ranking failed for %s: %s", market.code, exc
+            )
+            fluct_rows = []
+
+        if not fluct_rows:
+            return []
+
+        volume_rank_bonus: dict[str, float] = {}
+        try:
+            volume_rows = await self.overseas_broker.fetch_overseas_rankings(
+                exchange_code=market.exchange_code,
+                ranking_type="volume",
+                limit=50,
+            )
+        except Exception as exc:
+            logger.warning(
+                "Overseas volume ranking failed for %s: %s", market.code, exc
+            )
+            volume_rows = []
+
+        for idx, row in enumerate(volume_rows):
+            code = _extract_stock_code(row)
+            if not code:
+                continue
+            # Top-ranked by traded value/volume gets higher liquidity bonus.
+            volume_rank_bonus[code] = max(0.0, 15.0 - idx * 0.3)
+
+        candidates: list[ScanCandidate] = []
+        for row in fluct_rows:
+            stock_code = _extract_stock_code(row)
+            if not stock_code:
+                continue
+
+            price = _extract_last_price(row)
+            change_rate = _extract_change_rate_pct(row)
+            volume = _extract_volume(row)
+            intraday_range_pct = _extract_intraday_range_pct(row, price)
+            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:
+                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 * 4.0)))
+            candidates.append(
+                ScanCandidate(
+                    stock_code=stock_code,
+                    name=str(row.get("name") or row.get("ovrs_item_name") or stock_code),
+                    price=price,
+                    volume=volume,
+                    volume_ratio=max(1.0, volatility_pct / 2.0),
+                    rsi=implied_rsi,
+                    signal=signal,
+                    score=score,
+                )
+            )
+
+        if candidates:
+            logger.info(
+                "Overseas ranking scan found %d candidates for %s",
+                len(candidates),
+                market.name,
+            )
+        return candidates
+
+    async def _scan_overseas_from_symbols(
+        self,
+        market: MarketInfo,
+        symbols: list[str] | None,
+    ) -> list[ScanCandidate]:
+        """Fallback overseas scan from dynamic symbol universe."""
+        assert self.overseas_broker is not None
+        if not symbols:
+            logger.info("Overseas scanner: no symbol universe for %s", market.name)
+            return []
+
+        candidates: list[ScanCandidate] = []
+        for stock_code in symbols:
+            try:
+                price_data = await self.overseas_broker.get_overseas_price(
+                    market.exchange_code, stock_code
+                )
+                output = price_data.get("output", {})
+                price = _extract_last_price(output)
+                change_rate = _extract_change_rate_pct(output)
+                volume = _extract_volume(output)
+                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:
+                    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 * 4.0)))
+                candidates.append(
+                    ScanCandidate(
+                        stock_code=stock_code,
+                        name=stock_code,
+                        price=price,
+                        volume=volume,
+                        volume_ratio=max(1.0, volatility_pct / 2.0),
+                        rsi=implied_rsi,
+                        signal=signal,
+                        score=score,
+                    )
+                )
+            except ConnectionError as exc:
+                logger.warning("Failed to analyze overseas %s: %s", stock_code, exc)
+            except Exception as exc:
+                logger.error("Unexpected error analyzing overseas %s: %s", stock_code, exc)
+        return candidates
+
     def get_stock_codes(self, candidates: list[ScanCandidate]) -> list[str]:
         """Extract stock codes from candidates for watchlist update.
 
@@ -190,3 +362,78 @@ class SmartVolatilityScanner:
             List of stock codes
         """
         return [c.stock_code for c in candidates]
+
+
+def _safe_float(value: Any, default: float = 0.0) -> float:
+    """Convert arbitrary values to float safely."""
+    if value in (None, ""):
+        return default
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def _extract_stock_code(row: dict[str, Any]) -> str:
+    """Extract normalized stock code from various API schemas."""
+    return (
+        str(
+            row.get("symb")
+            or row.get("ovrs_pdno")
+            or row.get("stock_code")
+            or row.get("pdno")
+            or ""
+        )
+        .strip()
+        .upper()
+    )
+
+
+def _extract_last_price(row: dict[str, Any]) -> float:
+    """Extract last/close-like price from API schema variants."""
+    return _safe_float(
+        row.get("last")
+        or row.get("ovrs_nmix_prpr")
+        or row.get("stck_prpr")
+        or row.get("price")
+        or row.get("close")
+    )
+
+
+def _extract_change_rate_pct(row: dict[str, Any]) -> float:
+    """Extract daily change rate (%) from API schema variants."""
+    return _safe_float(
+        row.get("rate")
+        or row.get("change_rate")
+        or row.get("prdy_ctrt")
+        or row.get("evlu_pfls_rt")
+        or row.get("chg_rt")
+    )
+
+
+def _extract_volume(row: dict[str, Any]) -> float:
+    """Extract volume/traded-amount proxy from schema variants."""
+    return _safe_float(
+        row.get("tvol") or row.get("acml_vol") or row.get("vol") or row.get("volume")
+    )
+
+
+def _extract_intraday_range_pct(row: dict[str, Any], price: float) -> float:
+    """Estimate intraday range percentage from high/low fields."""
+    if price <= 0:
+        return 0.0
+    high = _safe_float(
+        row.get("high")
+        or row.get("ovrs_hgpr")
+        or row.get("stck_hgpr")
+        or row.get("day_hgpr")
+    )
+    low = _safe_float(
+        row.get("low")
+        or row.get("ovrs_lwpr")
+        or row.get("stck_lwpr")
+        or row.get("day_lwpr")
+    )
+    if high <= 0 or low <= 0 or high < low:
+        return 0.0
+    return (high - low) / price * 100.0

src/broker/overseas.py

@@ -64,6 +64,65 @@ class OverseasBroker:
                 f"Network error fetching overseas price: {exc}"
             ) from exc
 
+    async def fetch_overseas_rankings(
+        self,
+        exchange_code: str,
+        ranking_type: str = "fluctuation",
+        limit: int = 30,
+    ) -> list[dict[str, Any]]:
+        """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.
+        """
+        if not self._broker._settings.OVERSEAS_RANKING_ENABLED:
+            return []
+
+        await self._broker._rate_limiter.acquire()
+        session = self._broker._get_session()
+
+        if ranking_type == "volume":
+            tr_id = self._broker._settings.OVERSEAS_RANKING_VOLUME_TR_ID
+            path = self._broker._settings.OVERSEAS_RANKING_VOLUME_PATH
+        else:
+            tr_id = self._broker._settings.OVERSEAS_RANKING_FLUCT_TR_ID
+            path = self._broker._settings.OVERSEAS_RANKING_FLUCT_PATH
+
+        headers = await self._broker._auth_headers(tr_id)
+        url = f"{self._broker._base_url}{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
+        for params in param_variants:
+            try:
+                async with session.get(url, headers=headers, params=params) as resp:
+                    text = await resp.text()
+                    if resp.status != 200:
+                        last_error = f"HTTP {resp.status}: {text}"
+                        continue
+
+                    data = await resp.json()
+                    rows = self._extract_ranking_rows(data)
+                    if rows:
+                        return rows[:limit]
+
+                    # 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
+
+        raise ConnectionError(
+            f"fetch_overseas_rankings failed for {exchange_code}/{ranking_type}: {last_error}"
+        )
+
     async def get_overseas_balance(self, exchange_code: str) -> dict[str, Any]:
         """
         Fetch overseas account balance.
@@ -198,3 +257,11 @@ class OverseasBroker:
             "HSX": "VND",
         }
         return currency_map.get(exchange_code, "USD")
+
+    def _extract_ranking_rows(self, data: dict[str, Any]) -> list[dict[str, Any]]:
+        """Extract list rows from ranking response across schema variants."""
+        candidates = [data.get("output"), data.get("output1"), data.get("output2")]
+        for value in candidates:
+            if isinstance(value, list):
+                return [row for row in value if isinstance(row, dict)]
+        return []

src/config.py

@@ -38,6 +38,11 @@ class Settings(BaseSettings):
     RSI_MOMENTUM_THRESHOLD: int = Field(default=70, ge=50, le=100)
     VOL_MULTIPLIER: float = Field(default=2.0, gt=1.0, le=10.0)
     SCANNER_TOP_N: int = Field(default=3, ge=1, le=10)
+    POSITION_SIZING_ENABLED: bool = True
+    POSITION_BASE_ALLOCATION_PCT: float = Field(default=5.0, gt=0.0, le=30.0)
+    POSITION_MIN_ALLOCATION_PCT: float = Field(default=1.0, gt=0.0, le=20.0)
+    POSITION_MAX_ALLOCATION_PCT: float = Field(default=10.0, gt=0.0, le=50.0)
+    POSITION_VOLATILITY_TARGET_SCORE: float = Field(default=50.0, gt=0.0, le=100.0)
 
     # Database
     DB_PATH: str = "data/trade_logs.db"
@@ -83,6 +88,23 @@ class Settings(BaseSettings):
     TELEGRAM_COMMANDS_ENABLED: bool = True
     TELEGRAM_POLLING_INTERVAL: float = 1.0  # seconds
 
+    # 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 = "HHDFS76200100"
+    OVERSEAS_RANKING_VOLUME_TR_ID: str = "HHDFS76200200"
+    OVERSEAS_RANKING_FLUCT_PATH: str = (
+        "/uapi/overseas-price/v1/quotations/inquire-updown-rank"
+    )
+    OVERSEAS_RANKING_VOLUME_PATH: str = (
+        "/uapi/overseas-price/v1/quotations/inquire-volume-rank"
+    )
+
+    # Dashboard (optional)
+    DASHBOARD_ENABLED: bool = False
+    DASHBOARD_HOST: str = "127.0.0.1"
+    DASHBOARD_PORT: int = Field(default=8080, ge=1, le=65535)
+
     model_config = {"env_file": ".env", "env_file_encoding": "utf-8"}
 
     @property
@@ -96,4 +118,7 @@ class Settings(BaseSettings):
     @property
     def enabled_market_list(self) -> list[str]:
         """Parse ENABLED_MARKETS into list of market codes."""
-        return [m.strip() for m in self.ENABLED_MARKETS.split(",") if m.strip()]
+        from src.markets.schedule import expand_market_codes
+
+        raw = [m.strip() for m in self.ENABLED_MARKETS.split(",") if m.strip()]
+        return expand_market_codes(raw)

src/context/__init__.py

@@ -5,6 +5,7 @@ The context tree implements Pillar 2: hierarchical memory management across
 """
 
 from src.context.layer import ContextLayer
+from src.context.scheduler import ContextScheduler
 from src.context.store import ContextStore
 
-__all__ = ["ContextLayer", "ContextStore"]
+__all__ = ["ContextLayer", "ContextScheduler", "ContextStore"]

src/context/aggregator.py

@@ -18,52 +18,83 @@ class ContextAggregator:
         self.conn = conn
         self.store = ContextStore(conn)
 
-    def aggregate_daily_from_trades(self, date: str | None = None) -> None:
+    def aggregate_daily_from_trades(
+        self, date: str | None = None, market: str | None = None
+    ) -> None:
         """Aggregate L6 (daily) context from trades table.
 
         Args:
             date: Date in YYYY-MM-DD format. If None, uses today.
+            market: Market code filter (e.g., "KR", "US"). If None, aggregates all markets.
         """
         if date is None:
             date = datetime.now(UTC).date().isoformat()
 
-        # Calculate daily metrics from trades
-        cursor = self.conn.execute(
-            """
-            SELECT
-                COUNT(*) as trade_count,
-                SUM(CASE WHEN action = 'BUY' THEN 1 ELSE 0 END) as buys,
-                SUM(CASE WHEN action = 'SELL' THEN 1 ELSE 0 END) as sells,
-                SUM(CASE WHEN action = 'HOLD' THEN 1 ELSE 0 END) as holds,
-                AVG(confidence) as avg_confidence,
-                SUM(pnl) as total_pnl,
-                COUNT(DISTINCT stock_code) as unique_stocks,
-                SUM(CASE WHEN pnl > 0 THEN 1 ELSE 0 END) as wins,
-                SUM(CASE WHEN pnl < 0 THEN 1 ELSE 0 END) as losses
-            FROM trades
-            WHERE DATE(timestamp) = ?
-            """,
-            (date,),
-        )
-        row = cursor.fetchone()
-
-        if row and row[0] > 0:  # At least one trade
-            trade_count, buys, sells, holds, avg_conf, total_pnl, stocks, wins, losses = row
-
-            # Store daily metrics in L6
-            self.store.set_context(ContextLayer.L6_DAILY, date, "trade_count", trade_count)
-            self.store.set_context(ContextLayer.L6_DAILY, date, "buys", buys)
-            self.store.set_context(ContextLayer.L6_DAILY, date, "sells", sells)
-            self.store.set_context(ContextLayer.L6_DAILY, date, "holds", holds)
-            self.store.set_context(
-                ContextLayer.L6_DAILY, date, "avg_confidence", round(avg_conf, 2)
+        if market is None:
+            cursor = self.conn.execute(
+                """
+                SELECT DISTINCT market
+                FROM trades
+                WHERE DATE(timestamp) = ?
+                """,
+                (date,),
             )
-            self.store.set_context(
-                ContextLayer.L6_DAILY, date, "total_pnl", round(total_pnl, 2)
+            markets = [row[0] for row in cursor.fetchall() if row[0]]
+        else:
+            markets = [market]
+
+        for market_code in markets:
+            # Calculate daily metrics from trades for the market
+            cursor = self.conn.execute(
+                """
+                SELECT
+                    COUNT(*) as trade_count,
+                    SUM(CASE WHEN action = 'BUY' THEN 1 ELSE 0 END) as buys,
+                    SUM(CASE WHEN action = 'SELL' THEN 1 ELSE 0 END) as sells,
+                    SUM(CASE WHEN action = 'HOLD' THEN 1 ELSE 0 END) as holds,
+                    AVG(confidence) as avg_confidence,
+                    SUM(pnl) as total_pnl,
+                    COUNT(DISTINCT stock_code) as unique_stocks,
+                    SUM(CASE WHEN pnl > 0 THEN 1 ELSE 0 END) as wins,
+                    SUM(CASE WHEN pnl < 0 THEN 1 ELSE 0 END) as losses
+                FROM trades
+                WHERE DATE(timestamp) = ? AND market = ?
+                """,
+                (date, market_code),
             )
-            self.store.set_context(ContextLayer.L6_DAILY, date, "unique_stocks", stocks)
-            win_rate = round(wins / max(wins + losses, 1) * 100, 2)
-            self.store.set_context(ContextLayer.L6_DAILY, date, "win_rate", win_rate)
+            row = cursor.fetchone()
+
+            if row and row[0] > 0:  # At least one trade
+                trade_count, buys, sells, holds, avg_conf, total_pnl, stocks, wins, losses = row
+
+                key_suffix = f"_{market_code}"
+
+                # Store daily metrics in L6 with market suffix
+                self.store.set_context(
+                    ContextLayer.L6_DAILY, date, f"trade_count{key_suffix}", trade_count
+                )
+                self.store.set_context(ContextLayer.L6_DAILY, date, f"buys{key_suffix}", buys)
+                self.store.set_context(ContextLayer.L6_DAILY, date, f"sells{key_suffix}", sells)
+                self.store.set_context(ContextLayer.L6_DAILY, date, f"holds{key_suffix}", holds)
+                self.store.set_context(
+                    ContextLayer.L6_DAILY,
+                    date,
+                    f"avg_confidence{key_suffix}",
+                    round(avg_conf, 2),
+                )
+                self.store.set_context(
+                    ContextLayer.L6_DAILY,
+                    date,
+                    f"total_pnl{key_suffix}",
+                    round(total_pnl, 2),
+                )
+                self.store.set_context(
+                    ContextLayer.L6_DAILY, date, f"unique_stocks{key_suffix}", stocks
+                )
+                win_rate = round(wins / max(wins + losses, 1) * 100, 2)
+                self.store.set_context(
+                    ContextLayer.L6_DAILY, date, f"win_rate{key_suffix}", win_rate
+                )
 
     def aggregate_weekly_from_daily(self, week: str | None = None) -> None:
         """Aggregate L5 (weekly) context from L6 (daily).
@@ -92,14 +123,25 @@ class ContextAggregator:
             daily_data[row[0]].append(json.loads(row[1]))
 
         if daily_data:
-            # Sum all PnL values
+            # Sum all PnL values (market-specific if suffixed)
             if "total_pnl" in daily_data:
                 total_pnl = sum(daily_data["total_pnl"])
                 self.store.set_context(
                     ContextLayer.L5_WEEKLY, week, "weekly_pnl", round(total_pnl, 2)
                 )
 
-            # Average all confidence values
+            for key, values in daily_data.items():
+                if key.startswith("total_pnl_"):
+                    market_code = key.split("total_pnl_", 1)[1]
+                    total_pnl = sum(values)
+                    self.store.set_context(
+                        ContextLayer.L5_WEEKLY,
+                        week,
+                        f"weekly_pnl_{market_code}",
+                        round(total_pnl, 2),
+                    )
+
+            # Average all confidence values (market-specific if suffixed)
             if "avg_confidence" in daily_data:
                 conf_values = daily_data["avg_confidence"]
                 avg_conf = sum(conf_values) / len(conf_values)
@@ -107,6 +149,17 @@ class ContextAggregator:
                     ContextLayer.L5_WEEKLY, week, "avg_confidence", round(avg_conf, 2)
                 )
 
+            for key, values in daily_data.items():
+                if key.startswith("avg_confidence_"):
+                    market_code = key.split("avg_confidence_", 1)[1]
+                    avg_conf = sum(values) / len(values)
+                    self.store.set_context(
+                        ContextLayer.L5_WEEKLY,
+                        week,
+                        f"avg_confidence_{market_code}",
+                        round(avg_conf, 2),
+                    )
+
     def aggregate_monthly_from_weekly(self, month: str | None = None) -> None:
         """Aggregate L4 (monthly) context from L5 (weekly).
 
@@ -135,8 +188,16 @@ class ContextAggregator:
 
         if weekly_data:
             # Sum all weekly PnL values
+            total_pnl_values: list[float] = []
             if "weekly_pnl" in weekly_data:
-                total_pnl = sum(weekly_data["weekly_pnl"])
+                total_pnl_values.extend(weekly_data["weekly_pnl"])
+
+            for key, values in weekly_data.items():
+                if key.startswith("weekly_pnl_"):
+                    total_pnl_values.extend(values)
+
+            if total_pnl_values:
+                total_pnl = sum(total_pnl_values)
                 self.store.set_context(
                     ContextLayer.L4_MONTHLY, month, "monthly_pnl", round(total_pnl, 2)
                 )
@@ -230,21 +291,44 @@ class ContextAggregator:
             )
 
     def run_all_aggregations(self) -> None:
-        """Run all aggregations from L7 to L1 (bottom-up)."""
+        """Run all aggregations from L7 to L1 (bottom-up).
+
+        All timeframes are derived from the latest trade timestamp so that
+        past data re-aggregation produces consistent results across layers.
+        """
+        cursor = self.conn.execute("SELECT MAX(timestamp) FROM trades")
+        row = cursor.fetchone()
+        if not row or row[0] is None:
+            return
+
+        ts_raw = row[0]
+        if ts_raw.endswith("Z"):
+            ts_raw = ts_raw.replace("Z", "+00:00")
+        latest_ts = datetime.fromisoformat(ts_raw)
+        trade_date = latest_ts.date()
+        date_str = trade_date.isoformat()
+
+        iso_year, iso_week, _ = trade_date.isocalendar()
+        week_str = f"{iso_year}-W{iso_week:02d}"
+        month_str = f"{trade_date.year}-{trade_date.month:02d}"
+        quarter = (trade_date.month - 1) // 3 + 1
+        quarter_str = f"{trade_date.year}-Q{quarter}"
+        year_str = str(trade_date.year)
+
         # L7 (trades) → L6 (daily)
-        self.aggregate_daily_from_trades()
+        self.aggregate_daily_from_trades(date_str)
 
         # L6 (daily) → L5 (weekly)
-        self.aggregate_weekly_from_daily()
+        self.aggregate_weekly_from_daily(week_str)
 
         # L5 (weekly) → L4 (monthly)
-        self.aggregate_monthly_from_weekly()
+        self.aggregate_monthly_from_weekly(month_str)
 
         # L4 (monthly) → L3 (quarterly)
-        self.aggregate_quarterly_from_monthly()
+        self.aggregate_quarterly_from_monthly(quarter_str)
 
         # L3 (quarterly) → L2 (annual)
-        self.aggregate_annual_from_quarterly()
+        self.aggregate_annual_from_quarterly(year_str)
 
         # L2 (annual) → L1 (legacy)
         self.aggregate_legacy_from_annual()

src/context/scheduler.py

@@ -0,0 +1,135 @@
+"""Context aggregation scheduler for periodic rollups and cleanup."""
+
+from __future__ import annotations
+
+import sqlite3
+from calendar import monthrange
+from dataclasses import dataclass
+from datetime import UTC, datetime
+
+from src.context.aggregator import ContextAggregator
+from src.context.store import ContextStore
+
+
+@dataclass(frozen=True)
+class ScheduleResult:
+    """Represents which scheduled tasks ran."""
+
+    weekly: bool = False
+    monthly: bool = False
+    quarterly: bool = False
+    annual: bool = False
+    legacy: bool = False
+    cleanup: bool = False
+
+
+class ContextScheduler:
+    """Run periodic context aggregations and cleanup when due."""
+
+    def __init__(
+        self,
+        conn: sqlite3.Connection | None = None,
+        aggregator: ContextAggregator | None = None,
+        store: ContextStore | None = None,
+    ) -> None:
+        if aggregator is None:
+            if conn is None:
+                raise ValueError("conn is required when aggregator is not provided")
+            aggregator = ContextAggregator(conn)
+        self.aggregator = aggregator
+
+        if store is None:
+            store = getattr(aggregator, "store", None)
+        if store is None:
+            if conn is None:
+                raise ValueError("conn is required when store is not provided")
+            store = ContextStore(conn)
+        self.store = store
+
+        self._last_run: dict[str, str] = {}
+
+    def run_if_due(self, now: datetime | None = None) -> ScheduleResult:
+        """Run scheduled aggregations if their schedule is due.
+
+        Args:
+            now: Current datetime (UTC). If None, uses current time.
+
+        Returns:
+            ScheduleResult indicating which tasks ran.
+        """
+        if now is None:
+            now = datetime.now(UTC)
+
+        today = now.date().isoformat()
+        result = ScheduleResult()
+
+        if self._should_run("cleanup", today):
+            self.store.cleanup_expired_contexts()
+            result = self._with(result, cleanup=True)
+
+        if self._is_sunday(now) and self._should_run("weekly", today):
+            week = now.strftime("%Y-W%V")
+            self.aggregator.aggregate_weekly_from_daily(week)
+            result = self._with(result, weekly=True)
+
+        if self._is_last_day_of_month(now) and self._should_run("monthly", today):
+            month = now.strftime("%Y-%m")
+            self.aggregator.aggregate_monthly_from_weekly(month)
+            result = self._with(result, monthly=True)
+
+        if self._is_last_day_of_quarter(now) and self._should_run("quarterly", today):
+            quarter = self._current_quarter(now)
+            self.aggregator.aggregate_quarterly_from_monthly(quarter)
+            result = self._with(result, quarterly=True)
+
+        if self._is_last_day_of_year(now) and self._should_run("annual", today):
+            year = str(now.year)
+            self.aggregator.aggregate_annual_from_quarterly(year)
+            result = self._with(result, annual=True)
+
+            # Legacy rollup runs after annual aggregation.
+            self.aggregator.aggregate_legacy_from_annual()
+            result = self._with(result, legacy=True)
+
+        return result
+
+    def _should_run(self, key: str, date_str: str) -> bool:
+        if self._last_run.get(key) == date_str:
+            return False
+        self._last_run[key] = date_str
+        return True
+
+    @staticmethod
+    def _is_sunday(now: datetime) -> bool:
+        return now.weekday() == 6
+
+    @staticmethod
+    def _is_last_day_of_month(now: datetime) -> bool:
+        last_day = monthrange(now.year, now.month)[1]
+        return now.day == last_day
+
+    @classmethod
+    def _is_last_day_of_quarter(cls, now: datetime) -> bool:
+        if now.month not in (3, 6, 9, 12):
+            return False
+        return cls._is_last_day_of_month(now)
+
+    @staticmethod
+    def _is_last_day_of_year(now: datetime) -> bool:
+        return now.month == 12 and now.day == 31
+
+    @staticmethod
+    def _current_quarter(now: datetime) -> str:
+        quarter = (now.month - 1) // 3 + 1
+        return f"{now.year}-Q{quarter}"
+
+    @staticmethod
+    def _with(result: ScheduleResult, **kwargs: bool) -> ScheduleResult:
+        return ScheduleResult(
+            weekly=kwargs.get("weekly", result.weekly),
+            monthly=kwargs.get("monthly", result.monthly),
+            quarterly=kwargs.get("quarterly", result.quarterly),
+            annual=kwargs.get("annual", result.annual),
+            legacy=kwargs.get("legacy", result.legacy),
+            cleanup=kwargs.get("cleanup", result.cleanup),
+        )

src/dashboard/__init__.py

@@ -0,0 +1,5 @@
+"""FastAPI dashboard package for observability APIs."""
+
+from src.dashboard.app import create_dashboard_app
+
+__all__ = ["create_dashboard_app"]

src/dashboard/app.py

@@ -0,0 +1,361 @@
+"""FastAPI application for observability dashboard endpoints."""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.responses import FileResponse
+
+
+def create_dashboard_app(db_path: str) -> FastAPI:
+    """Create dashboard FastAPI app bound to a SQLite database path."""
+    app = FastAPI(title="The Ouroboros Dashboard", version="1.0.0")
+    app.state.db_path = db_path
+
+    @app.get("/")
+    def index() -> FileResponse:
+        index_path = Path(__file__).parent / "static" / "index.html"
+        return FileResponse(index_path)
+
+    @app.get("/api/status")
+    def get_status() -> dict[str, Any]:
+        today = datetime.now(UTC).date().isoformat()
+        with _connect(db_path) as conn:
+            market_rows = conn.execute(
+                """
+                SELECT DISTINCT market FROM (
+                    SELECT market FROM trades WHERE DATE(timestamp) = ?
+                    UNION
+                    SELECT market FROM decision_logs WHERE DATE(timestamp) = ?
+                    UNION
+                    SELECT market FROM playbooks WHERE date = ?
+                ) ORDER BY market
+                """,
+                (today, today, today),
+            ).fetchall()
+            markets = [row[0] for row in market_rows] if market_rows else []
+            market_status: dict[str, Any] = {}
+            total_trades = 0
+            total_pnl = 0.0
+            total_decisions = 0
+            for market in markets:
+                trade_row = conn.execute(
+                    """
+                    SELECT COUNT(*) AS c, COALESCE(SUM(pnl), 0.0) AS p
+                    FROM trades
+                    WHERE DATE(timestamp) = ? AND market = ?
+                    """,
+                    (today, market),
+                ).fetchone()
+                decision_row = conn.execute(
+                    """
+                    SELECT COUNT(*) AS c
+                    FROM decision_logs
+                    WHERE DATE(timestamp) = ? AND market = ?
+                    """,
+                    (today, market),
+                ).fetchone()
+                playbook_row = conn.execute(
+                    """
+                    SELECT status
+                    FROM playbooks
+                    WHERE date = ? AND market = ?
+                    LIMIT 1
+                    """,
+                    (today, market),
+                ).fetchone()
+                market_status[market] = {
+                    "trade_count": int(trade_row["c"] if trade_row else 0),
+                    "total_pnl": float(trade_row["p"] if trade_row else 0.0),
+                    "decision_count": int(decision_row["c"] if decision_row else 0),
+                    "playbook_status": playbook_row["status"] if playbook_row else None,
+                }
+                total_trades += market_status[market]["trade_count"]
+                total_pnl += market_status[market]["total_pnl"]
+                total_decisions += market_status[market]["decision_count"]
+
+            return {
+                "date": today,
+                "markets": market_status,
+                "totals": {
+                    "trade_count": total_trades,
+                    "total_pnl": round(total_pnl, 2),
+                    "decision_count": total_decisions,
+                },
+            }
+
+    @app.get("/api/playbook/{date_str}")
+    def get_playbook(date_str: str, market: str = Query("KR")) -> dict[str, Any]:
+        with _connect(db_path) as conn:
+            row = conn.execute(
+                """
+                SELECT date, market, status, playbook_json, generated_at,
+                       token_count, scenario_count, match_count
+                FROM playbooks
+                WHERE date = ? AND market = ?
+                """,
+                (date_str, market),
+            ).fetchone()
+            if row is None:
+                raise HTTPException(status_code=404, detail="playbook not found")
+            return {
+                "date": row["date"],
+                "market": row["market"],
+                "status": row["status"],
+                "playbook": json.loads(row["playbook_json"]),
+                "generated_at": row["generated_at"],
+                "token_count": row["token_count"],
+                "scenario_count": row["scenario_count"],
+                "match_count": row["match_count"],
+            }
+
+    @app.get("/api/scorecard/{date_str}")
+    def get_scorecard(date_str: str, market: str = Query("KR")) -> dict[str, Any]:
+        key = f"scorecard_{market}"
+        with _connect(db_path) as conn:
+            row = conn.execute(
+                """
+                SELECT value
+                FROM contexts
+                WHERE layer = 'L6_DAILY' AND timeframe = ? AND key = ?
+                """,
+                (date_str, key),
+            ).fetchone()
+            if row is None:
+                raise HTTPException(status_code=404, detail="scorecard not found")
+            return {"date": date_str, "market": market, "scorecard": json.loads(row["value"])}
+
+    @app.get("/api/performance")
+    def get_performance(market: str = Query("all")) -> dict[str, Any]:
+        with _connect(db_path) as conn:
+            if market == "all":
+                by_market_rows = conn.execute(
+                    """
+                    SELECT market,
+                           COUNT(*) AS total_trades,
+                           SUM(CASE WHEN pnl > 0 THEN 1 ELSE 0 END) AS wins,
+                           SUM(CASE WHEN pnl < 0 THEN 1 ELSE 0 END) AS losses,
+                           COALESCE(SUM(pnl), 0.0) AS total_pnl,
+                           COALESCE(AVG(confidence), 0.0) AS avg_confidence
+                    FROM trades
+                    GROUP BY market
+                    ORDER BY market
+                    """
+                ).fetchall()
+                combined = _performance_from_rows(by_market_rows)
+                return {
+                    "market": "all",
+                    "combined": combined,
+                    "by_market": [
+                        _row_to_performance(row)
+                        for row in by_market_rows
+                    ],
+                }
+
+            row = conn.execute(
+                """
+                SELECT market,
+                       COUNT(*) AS total_trades,
+                       SUM(CASE WHEN pnl > 0 THEN 1 ELSE 0 END) AS wins,
+                       SUM(CASE WHEN pnl < 0 THEN 1 ELSE 0 END) AS losses,
+                       COALESCE(SUM(pnl), 0.0) AS total_pnl,
+                       COALESCE(AVG(confidence), 0.0) AS avg_confidence
+                FROM trades
+                WHERE market = ?
+                GROUP BY market
+                """,
+                (market,),
+            ).fetchone()
+            if row is None:
+                return {"market": market, "metrics": _empty_performance(market)}
+            return {"market": market, "metrics": _row_to_performance(row)}
+
+    @app.get("/api/context/{layer}")
+    def get_context_layer(
+        layer: str,
+        timeframe: str | None = Query(default=None),
+        limit: int = Query(default=100, ge=1, le=1000),
+    ) -> dict[str, Any]:
+        with _connect(db_path) as conn:
+            if timeframe is None:
+                rows = conn.execute(
+                    """
+                    SELECT timeframe, key, value, updated_at
+                    FROM contexts
+                    WHERE layer = ?
+                    ORDER BY updated_at DESC
+                    LIMIT ?
+                    """,
+                    (layer, limit),
+                ).fetchall()
+            else:
+                rows = conn.execute(
+                    """
+                    SELECT timeframe, key, value, updated_at
+                    FROM contexts
+                    WHERE layer = ? AND timeframe = ?
+                    ORDER BY key
+                    LIMIT ?
+                    """,
+                    (layer, timeframe, limit),
+                ).fetchall()
+
+            entries = [
+                {
+                    "timeframe": row["timeframe"],
+                    "key": row["key"],
+                    "value": json.loads(row["value"]),
+                    "updated_at": row["updated_at"],
+                }
+                for row in rows
+            ]
+            return {
+                "layer": layer,
+                "timeframe": timeframe,
+                "count": len(entries),
+                "entries": entries,
+            }
+
+    @app.get("/api/decisions")
+    def get_decisions(
+        market: str = Query("KR"),
+        limit: int = Query(default=50, ge=1, le=500),
+    ) -> dict[str, Any]:
+        with _connect(db_path) as conn:
+            rows = conn.execute(
+                """
+                SELECT decision_id, timestamp, stock_code, market, exchange_code,
+                       action, confidence, rationale, context_snapshot, input_data,
+                       outcome_pnl, outcome_accuracy
+                FROM decision_logs
+                WHERE market = ?
+                ORDER BY timestamp DESC
+                LIMIT ?
+                """,
+                (market, limit),
+            ).fetchall()
+            decisions = []
+            for row in rows:
+                decisions.append(
+                    {
+                        "decision_id": row["decision_id"],
+                        "timestamp": row["timestamp"],
+                        "stock_code": row["stock_code"],
+                        "market": row["market"],
+                        "exchange_code": row["exchange_code"],
+                        "action": row["action"],
+                        "confidence": row["confidence"],
+                        "rationale": row["rationale"],
+                        "context_snapshot": json.loads(row["context_snapshot"]),
+                        "input_data": json.loads(row["input_data"]),
+                        "outcome_pnl": row["outcome_pnl"],
+                        "outcome_accuracy": row["outcome_accuracy"],
+                    }
+                )
+            return {"market": market, "count": len(decisions), "decisions": decisions}
+
+    @app.get("/api/scenarios/active")
+    def get_active_scenarios(
+        market: str = Query("US"),
+        date_str: str | None = Query(default=None),
+        limit: int = Query(default=50, ge=1, le=500),
+    ) -> dict[str, Any]:
+        if date_str is None:
+            date_str = datetime.now(UTC).date().isoformat()
+
+        with _connect(db_path) as conn:
+            rows = conn.execute(
+                """
+                SELECT timestamp, stock_code, action, confidence, rationale, context_snapshot
+                FROM decision_logs
+                WHERE market = ? AND DATE(timestamp) = ?
+                ORDER BY timestamp DESC
+                LIMIT ?
+                """,
+                (market, date_str, limit),
+            ).fetchall()
+            matches: list[dict[str, Any]] = []
+            for row in rows:
+                snapshot = json.loads(row["context_snapshot"])
+                scenario_match = snapshot.get("scenario_match", {})
+                if not isinstance(scenario_match, dict) or not scenario_match:
+                    continue
+                matches.append(
+                    {
+                        "timestamp": row["timestamp"],
+                        "stock_code": row["stock_code"],
+                        "action": row["action"],
+                        "confidence": row["confidence"],
+                        "rationale": row["rationale"],
+                        "scenario_match": scenario_match,
+                    }
+                )
+            return {"market": market, "date": date_str, "count": len(matches), "matches": matches}
+
+    return app
+
+
+def _connect(db_path: str) -> sqlite3.Connection:
+    conn = sqlite3.connect(db_path)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def _row_to_performance(row: sqlite3.Row) -> dict[str, Any]:
+    wins = int(row["wins"] or 0)
+    losses = int(row["losses"] or 0)
+    total = int(row["total_trades"] or 0)
+    win_rate = round((wins / (wins + losses) * 100), 2) if (wins + losses) > 0 else 0.0
+    return {
+        "market": row["market"],
+        "total_trades": total,
+        "wins": wins,
+        "losses": losses,
+        "win_rate": win_rate,
+        "total_pnl": round(float(row["total_pnl"] or 0.0), 2),
+        "avg_confidence": round(float(row["avg_confidence"] or 0.0), 2),
+    }
+
+
+def _performance_from_rows(rows: list[sqlite3.Row]) -> dict[str, Any]:
+    total_trades = 0
+    wins = 0
+    losses = 0
+    total_pnl = 0.0
+    confidence_weighted = 0.0
+    for row in rows:
+        market_total = int(row["total_trades"] or 0)
+        market_conf = float(row["avg_confidence"] or 0.0)
+        total_trades += market_total
+        wins += int(row["wins"] or 0)
+        losses += int(row["losses"] or 0)
+        total_pnl += float(row["total_pnl"] or 0.0)
+        confidence_weighted += market_total * market_conf
+    win_rate = round((wins / (wins + losses) * 100), 2) if (wins + losses) > 0 else 0.0
+    avg_confidence = round(confidence_weighted / total_trades, 2) if total_trades > 0 else 0.0
+    return {
+        "market": "all",
+        "total_trades": total_trades,
+        "wins": wins,
+        "losses": losses,
+        "win_rate": win_rate,
+        "total_pnl": round(total_pnl, 2),
+        "avg_confidence": avg_confidence,
+    }
+
+
+def _empty_performance(market: str) -> dict[str, Any]:
+    return {
+        "market": market,
+        "total_trades": 0,
+        "wins": 0,
+        "losses": 0,
+        "win_rate": 0.0,
+        "total_pnl": 0.0,
+        "avg_confidence": 0.0,
+    }

src/dashboard/static/index.html

@@ -0,0 +1,61 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>The Ouroboros Dashboard</title>
+    <style>
+      :root {
+        --bg: #0b1724;
+        --panel: #12263a;
+        --fg: #e6eef7;
+        --muted: #9fb3c8;
+        --accent: #3cb371;
+      }
+      body {
+        margin: 0;
+        font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+        background: radial-gradient(circle at top left, #173b58, var(--bg));
+        color: var(--fg);
+      }
+      .wrap {
+        max-width: 900px;
+        margin: 48px auto;
+        padding: 0 16px;
+      }
+      .card {
+        background: color-mix(in oklab, var(--panel), black 12%);
+        border: 1px solid #28455f;
+        border-radius: 12px;
+        padding: 20px;
+      }
+      h1 {
+        margin-top: 0;
+      }
+      code {
+        color: var(--accent);
+      }
+      li {
+        margin: 6px 0;
+        color: var(--muted);
+      }
+    </style>
+  </head>
+  <body>
+    <div class="wrap">
+      <div class="card">
+        <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>
+  </body>
+</html>

src/db.py

@@ -6,6 +6,7 @@ import json
 import sqlite3
 from datetime import UTC, datetime
 from pathlib import Path
+from typing import Any
 
 
 def init_db(db_path: str) -> sqlite3.Connection:
@@ -26,7 +27,8 @@ def init_db(db_path: str) -> sqlite3.Connection:
             price REAL,
             pnl REAL DEFAULT 0.0,
             market TEXT DEFAULT 'KR',
-            exchange_code TEXT DEFAULT 'KRX'
+            exchange_code TEXT DEFAULT 'KRX',
+            decision_id TEXT
         )
         """
     )
@@ -41,6 +43,8 @@ def init_db(db_path: str) -> sqlite3.Connection:
         conn.execute("ALTER TABLE trades ADD COLUMN exchange_code TEXT DEFAULT 'KRX'")
     if "selection_context" not in columns:
         conn.execute("ALTER TABLE trades ADD COLUMN selection_context TEXT")
+    if "decision_id" not in columns:
+        conn.execute("ALTER TABLE trades ADD COLUMN decision_id TEXT")
 
     # Context tree tables for multi-layered memory management
     conn.execute(
@@ -143,6 +147,7 @@ def log_trade(
     market: str = "KR",
     exchange_code: str = "KRX",
     selection_context: dict[str, any] | None = None,
+    decision_id: str | None = None,
 ) -> None:
     """Insert a trade record into the database.
 
@@ -166,9 +171,9 @@ def log_trade(
         """
         INSERT INTO trades (
             timestamp, stock_code, action, confidence, rationale,
-            quantity, price, pnl, market, exchange_code, selection_context
+            quantity, price, pnl, market, exchange_code, selection_context, decision_id
         )
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         """,
         (
             datetime.now(UTC).isoformat(),
@@ -182,6 +187,69 @@ def log_trade(
             market,
             exchange_code,
             context_json,
+            decision_id,
         ),
     )
     conn.commit()
+
+
+def get_latest_buy_trade(
+    conn: sqlite3.Connection, stock_code: str, market: str
+) -> dict[str, Any] | None:
+    """Fetch the most recent BUY trade for a stock and market."""
+    cursor = conn.execute(
+        """
+        SELECT decision_id, price, quantity
+        FROM trades
+        WHERE stock_code = ?
+          AND market = ?
+          AND action = 'BUY'
+          AND decision_id IS NOT NULL
+        ORDER BY timestamp DESC
+        LIMIT 1
+        """,
+        (stock_code, market),
+    )
+    row = cursor.fetchone()
+    if not row:
+        return None
+    return {"decision_id": row[0], "price": row[1], "quantity": row[2]}
+
+
+def get_open_position(
+    conn: sqlite3.Connection, stock_code: str, market: str
+) -> dict[str, Any] | None:
+    """Return open position if latest trade is BUY, else None."""
+    cursor = conn.execute(
+        """
+        SELECT action, decision_id, price, quantity
+        FROM trades
+        WHERE stock_code = ?
+          AND market = ?
+        ORDER BY timestamp DESC
+        LIMIT 1
+        """,
+        (stock_code, market),
+    )
+    row = cursor.fetchone()
+    if not row or row[0] != "BUY":
+        return None
+    return {"decision_id": row[1], "price": row[2], "quantity": row[3]}
+
+
+def get_recent_symbols(
+    conn: sqlite3.Connection, market: str, limit: int = 30
+) -> list[str]:
+    """Return recent unique symbols for a market, newest first."""
+    cursor = conn.execute(
+        """
+        SELECT stock_code, MAX(timestamp) AS last_ts
+        FROM trades
+        WHERE market = ?
+        GROUP BY stock_code
+        ORDER BY last_ts DESC
+        LIMIT ?
+        """,
+        (market, limit),
+    )
+    return [row[0] for row in cursor.fetchall() if row and row[0]]

src/evolution/__init__.py

@@ -1,12 +1,14 @@
 """Evolution engine for self-improving trading strategies."""
 
 from src.evolution.ab_test import ABTester, ABTestResult, StrategyPerformance
+from src.evolution.daily_review import DailyReviewer
 from src.evolution.optimizer import EvolutionOptimizer
 from src.evolution.performance_tracker import (
     PerformanceDashboard,
     PerformanceTracker,
     StrategyMetrics,
 )
+from src.evolution.scorecard import DailyScorecard
 
 __all__ = [
     "EvolutionOptimizer",
@@ -16,4 +18,6 @@ __all__ = [
     "PerformanceTracker",
     "PerformanceDashboard",
     "StrategyMetrics",
+    "DailyScorecard",
+    "DailyReviewer",
 ]

src/evolution/daily_review.py

@@ -0,0 +1,196 @@
+"""Daily review generator for market-scoped end-of-day scorecards."""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import sqlite3
+from dataclasses import asdict
+
+from src.brain.gemini_client import GeminiClient
+from src.context.layer import ContextLayer
+from src.context.store import ContextStore
+from src.evolution.scorecard import DailyScorecard
+
+logger = logging.getLogger(__name__)
+
+
+class DailyReviewer:
+    """Builds daily scorecards and optional AI-generated lessons."""
+
+    def __init__(
+        self,
+        conn: sqlite3.Connection,
+        context_store: ContextStore,
+        gemini_client: GeminiClient | None = None,
+    ) -> None:
+        self._conn = conn
+        self._context_store = context_store
+        self._gemini = gemini_client
+
+    def generate_scorecard(self, date: str, market: str) -> DailyScorecard:
+        """Generate a market-scoped scorecard from decision logs and trades."""
+        decision_rows = self._conn.execute(
+            """
+            SELECT action, confidence, context_snapshot
+            FROM decision_logs
+            WHERE DATE(timestamp) = ? AND market = ?
+            """,
+            (date, market),
+        ).fetchall()
+
+        total_decisions = len(decision_rows)
+        buys = sum(1 for row in decision_rows if row[0] == "BUY")
+        sells = sum(1 for row in decision_rows if row[0] == "SELL")
+        holds = sum(1 for row in decision_rows if row[0] == "HOLD")
+        avg_confidence = (
+            round(sum(int(row[1]) for row in decision_rows) / total_decisions, 2)
+            if total_decisions > 0
+            else 0.0
+        )
+
+        matched = 0
+        for row in decision_rows:
+            try:
+                snapshot = json.loads(row[2]) if row[2] else {}
+            except json.JSONDecodeError:
+                snapshot = {}
+            scenario_match = snapshot.get("scenario_match", {})
+            if isinstance(scenario_match, dict) and scenario_match:
+                matched += 1
+        scenario_match_rate = (
+            round((matched / total_decisions) * 100, 2)
+            if total_decisions
+            else 0.0
+        )
+
+        trade_stats = self._conn.execute(
+            """
+            SELECT
+                COALESCE(SUM(pnl), 0.0),
+                SUM(CASE WHEN pnl > 0 THEN 1 ELSE 0 END),
+                SUM(CASE WHEN pnl < 0 THEN 1 ELSE 0 END)
+            FROM trades
+            WHERE DATE(timestamp) = ? AND market = ?
+            """,
+            (date, market),
+        ).fetchone()
+        total_pnl = round(float(trade_stats[0] or 0.0), 2) if trade_stats else 0.0
+        wins = int(trade_stats[1] or 0) if trade_stats else 0
+        losses = int(trade_stats[2] or 0) if trade_stats else 0
+        win_rate = round((wins / (wins + losses)) * 100, 2) if (wins + losses) > 0 else 0.0
+
+        top_winners = [
+            row[0]
+            for row in self._conn.execute(
+                """
+                SELECT stock_code, SUM(pnl) AS stock_pnl
+                FROM trades
+                WHERE DATE(timestamp) = ? AND market = ?
+                GROUP BY stock_code
+                HAVING stock_pnl > 0
+                ORDER BY stock_pnl DESC
+                LIMIT 3
+                """,
+                (date, market),
+            ).fetchall()
+        ]
+
+        top_losers = [
+            row[0]
+            for row in self._conn.execute(
+                """
+                SELECT stock_code, SUM(pnl) AS stock_pnl
+                FROM trades
+                WHERE DATE(timestamp) = ? AND market = ?
+                GROUP BY stock_code
+                HAVING stock_pnl < 0
+                ORDER BY stock_pnl ASC
+                LIMIT 3
+                """,
+                (date, market),
+            ).fetchall()
+        ]
+
+        return DailyScorecard(
+            date=date,
+            market=market,
+            total_decisions=total_decisions,
+            buys=buys,
+            sells=sells,
+            holds=holds,
+            total_pnl=total_pnl,
+            win_rate=win_rate,
+            avg_confidence=avg_confidence,
+            scenario_match_rate=scenario_match_rate,
+            top_winners=top_winners,
+            top_losers=top_losers,
+            lessons=[],
+            cross_market_note="",
+        )
+
+    async def generate_lessons(self, scorecard: DailyScorecard) -> list[str]:
+        """Generate concise lessons from scorecard metrics using Gemini."""
+        if self._gemini is None:
+            return []
+
+        prompt = (
+            "You are a trading performance reviewer.\n"
+            "Return ONLY a JSON array of 1-3 short lessons in English.\n"
+            f"Market: {scorecard.market}\n"
+            f"Date: {scorecard.date}\n"
+            f"Total decisions: {scorecard.total_decisions}\n"
+            f"Buys/Sells/Holds: {scorecard.buys}/{scorecard.sells}/{scorecard.holds}\n"
+            f"Total PnL: {scorecard.total_pnl}\n"
+            f"Win rate: {scorecard.win_rate}%\n"
+            f"Average confidence: {scorecard.avg_confidence}\n"
+            f"Scenario match rate: {scorecard.scenario_match_rate}%\n"
+            f"Top winners: {', '.join(scorecard.top_winners) or 'N/A'}\n"
+            f"Top losers: {', '.join(scorecard.top_losers) or 'N/A'}\n"
+        )
+
+        try:
+            decision = await self._gemini.decide(
+                {
+                    "stock_code": "REVIEW",
+                    "market_name": scorecard.market,
+                    "current_price": 0,
+                    "prompt_override": prompt,
+                }
+            )
+            return self._parse_lessons(decision.rationale)
+        except Exception as exc:
+            logger.warning("Failed to generate daily lessons: %s", exc)
+            return []
+
+    def store_scorecard_in_context(self, scorecard: DailyScorecard) -> None:
+        """Store scorecard in L6 using market-scoped key."""
+        self._context_store.set_context(
+            ContextLayer.L6_DAILY,
+            scorecard.date,
+            f"scorecard_{scorecard.market}",
+            asdict(scorecard),
+        )
+
+    def _parse_lessons(self, raw_text: str) -> list[str]:
+        """Parse lessons from JSON array response or fallback text."""
+        raw_text = raw_text.strip()
+        try:
+            parsed = json.loads(raw_text)
+            if isinstance(parsed, list):
+                return [str(item).strip() for item in parsed if str(item).strip()][:3]
+        except json.JSONDecodeError:
+            pass
+
+        match = re.search(r"\[.*\]", raw_text, re.DOTALL)
+        if match:
+            try:
+                parsed = json.loads(match.group(0))
+                if isinstance(parsed, list):
+                    return [str(item).strip() for item in parsed if str(item).strip()][:3]
+            except json.JSONDecodeError:
+                pass
+
+        lines = [line.strip("-* \t") for line in raw_text.splitlines() if line.strip()]
+        return lines[:3]

src/evolution/scorecard.py

@@ -0,0 +1,25 @@
+"""Daily scorecard model for end-of-day performance review."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class DailyScorecard:
+    """Structured daily performance snapshot for a single market."""
+
+    date: str
+    market: str
+    total_decisions: int
+    buys: int
+    sells: int
+    holds: int
+    total_pnl: float
+    win_rate: float
+    avg_confidence: float
+    scenario_match_rate: float
+    top_winners: list[str] = field(default_factory=list)
+    top_losers: list[str] = field(default_factory=list)
+    lessons: list[str] = field(default_factory=list)
+    cross_market_note: str = ""

src/markets/schedule.py

@@ -123,6 +123,23 @@ MARKETS: dict[str, MarketInfo] = {
     ),
 }
 
+MARKET_SHORTHAND: dict[str, list[str]] = {
+    "US": ["US_NASDAQ", "US_NYSE", "US_AMEX"],
+    "CN": ["CN_SHA", "CN_SZA"],
+    "VN": ["VN_HAN", "VN_HCM"],
+}
+
+
+def expand_market_codes(codes: list[str]) -> list[str]:
+    """Expand shorthand market codes into concrete exchange market codes."""
+    expanded: list[str] = []
+    for code in codes:
+        if code in MARKET_SHORTHAND:
+            expanded.extend(MARKET_SHORTHAND[code])
+        else:
+            expanded.append(code)
+    return expanded
+
 
 def is_market_open(market: MarketInfo, now: datetime | None = None) -> bool:
     """

src/strategy/pre_market_planner.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 
 import json
 import logging
-from datetime import date
+from datetime import date, timedelta
 from typing import Any
 
 from src.analysis.smart_scanner import ScanCandidate
@@ -95,10 +95,17 @@ class PreMarketPlanner:
         try:
             # 1. Gather context
             context_data = self._gather_context()
+            self_market_scorecard = self.build_self_market_scorecard(market, today)
             cross_market = self.build_cross_market_context(market, today)
 
             # 2. Build prompt
-            prompt = self._build_prompt(market, candidates, context_data, cross_market)
+            prompt = self._build_prompt(
+                market,
+                candidates,
+                context_data,
+                self_market_scorecard,
+                cross_market,
+            )
 
             # 3. Call Gemini
             market_data = {
@@ -145,7 +152,8 @@ class PreMarketPlanner:
         other_market = "US" if target_market == "KR" else "KR"
         if today is None:
             today = date.today()
-        timeframe = today.isoformat()
+        timeframe_date = today - timedelta(days=1) if target_market == "KR" else today
+        timeframe = timeframe_date.isoformat()
 
         scorecard_key = f"scorecard_{other_market}"
         scorecard_data = self._context_store.get_context(
@@ -175,6 +183,37 @@ class PreMarketPlanner:
             lessons=scorecard_data.get("lessons", []),
         )
 
+    def build_self_market_scorecard(
+        self, market: str, today: date | None = None,
+    ) -> dict[str, Any] | None:
+        """Build previous-day scorecard for the same market."""
+        if today is None:
+            today = date.today()
+        timeframe = (today - timedelta(days=1)).isoformat()
+        scorecard_key = f"scorecard_{market}"
+        scorecard_data = self._context_store.get_context(
+            ContextLayer.L6_DAILY, timeframe, scorecard_key
+        )
+
+        if scorecard_data is None:
+            return None
+
+        if isinstance(scorecard_data, str):
+            try:
+                scorecard_data = json.loads(scorecard_data)
+            except (json.JSONDecodeError, TypeError):
+                return None
+
+        if not isinstance(scorecard_data, dict):
+            return None
+
+        return {
+            "date": timeframe,
+            "total_pnl": float(scorecard_data.get("total_pnl", 0.0)),
+            "win_rate": float(scorecard_data.get("win_rate", 0.0)),
+            "lessons": scorecard_data.get("lessons", []),
+        }
+
     def _gather_context(self) -> dict[str, Any]:
         """Gather strategic context using ContextSelector."""
         layers = self._context_selector.select_layers(
@@ -188,6 +227,7 @@ class PreMarketPlanner:
         market: str,
         candidates: list[ScanCandidate],
         context_data: dict[str, Any],
+        self_market_scorecard: dict[str, Any] | None,
         cross_market: CrossMarketContext | None,
     ) -> str:
         """Build a structured prompt for Gemini to generate scenario JSON."""
@@ -211,6 +251,18 @@ class PreMarketPlanner:
             if cross_market.lessons:
                 cross_market_text += f"- Lessons: {'; '.join(cross_market.lessons[:3])}\n"
 
+        self_market_text = ""
+        if self_market_scorecard:
+            self_market_text = (
+                f"\n## My Market Previous Day ({market})\n"
+                f"- Date: {self_market_scorecard['date']}\n"
+                f"- P&L: {self_market_scorecard['total_pnl']:+.2f}%\n"
+                f"- Win Rate: {self_market_scorecard['win_rate']:.0f}%\n"
+            )
+            lessons = self_market_scorecard.get("lessons", [])
+            if lessons:
+                self_market_text += f"- Lessons: {'; '.join(lessons[:3])}\n"
+
         context_text = ""
         if context_data:
             context_text = "\n## Strategic Context\n"
@@ -224,6 +276,7 @@ class PreMarketPlanner:
             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"{self_market_text}"
             f"{cross_market_text}"
             f"{context_text}\n"
             f"## Instructions\n"

tests/test_context.py

@@ -161,7 +161,7 @@ class TestContextAggregator:
         self, aggregator: ContextAggregator, db_conn: sqlite3.Connection
     ) -> None:
         """Test aggregating daily metrics from trades."""
-        date = "2026-02-04"
+        date = datetime.now(UTC).date().isoformat()
 
         # Create sample trades
         log_trade(db_conn, "005930", "BUY", 85, "Good signal", quantity=10, price=70000, pnl=500)
@@ -175,36 +175,44 @@ class TestContextAggregator:
         db_conn.commit()
 
         # Aggregate
-        aggregator.aggregate_daily_from_trades(date)
+        aggregator.aggregate_daily_from_trades(date, market="KR")
 
         # Verify L6 contexts
         store = aggregator.store
-        assert store.get_context(ContextLayer.L6_DAILY, date, "trade_count") == 3
-        assert store.get_context(ContextLayer.L6_DAILY, date, "buys") == 1
-        assert store.get_context(ContextLayer.L6_DAILY, date, "sells") == 1
-        assert store.get_context(ContextLayer.L6_DAILY, date, "holds") == 1
-        assert store.get_context(ContextLayer.L6_DAILY, date, "total_pnl") == 2000.0
-        assert store.get_context(ContextLayer.L6_DAILY, date, "unique_stocks") == 3
+        assert store.get_context(ContextLayer.L6_DAILY, date, "trade_count_KR") == 3
+        assert store.get_context(ContextLayer.L6_DAILY, date, "buys_KR") == 1
+        assert store.get_context(ContextLayer.L6_DAILY, date, "sells_KR") == 1
+        assert store.get_context(ContextLayer.L6_DAILY, date, "holds_KR") == 1
+        assert store.get_context(ContextLayer.L6_DAILY, date, "total_pnl_KR") == 2000.0
+        assert store.get_context(ContextLayer.L6_DAILY, date, "unique_stocks_KR") == 3
         # 2 wins, 0 losses
-        assert store.get_context(ContextLayer.L6_DAILY, date, "win_rate") == 100.0
+        assert store.get_context(ContextLayer.L6_DAILY, date, "win_rate_KR") == 100.0
 
     def test_aggregate_weekly_from_daily(self, aggregator: ContextAggregator) -> None:
         """Test aggregating weekly metrics from daily."""
         week = "2026-W06"
 
         # Set daily contexts
-        aggregator.store.set_context(ContextLayer.L6_DAILY, "2026-02-02", "total_pnl", 100.0)
-        aggregator.store.set_context(ContextLayer.L6_DAILY, "2026-02-03", "total_pnl", 200.0)
-        aggregator.store.set_context(ContextLayer.L6_DAILY, "2026-02-02", "avg_confidence", 80.0)
-        aggregator.store.set_context(ContextLayer.L6_DAILY, "2026-02-03", "avg_confidence", 85.0)
+        aggregator.store.set_context(
+            ContextLayer.L6_DAILY, "2026-02-02", "total_pnl_KR", 100.0
+        )
+        aggregator.store.set_context(
+            ContextLayer.L6_DAILY, "2026-02-03", "total_pnl_KR", 200.0
+        )
+        aggregator.store.set_context(
+            ContextLayer.L6_DAILY, "2026-02-02", "avg_confidence_KR", 80.0
+        )
+        aggregator.store.set_context(
+            ContextLayer.L6_DAILY, "2026-02-03", "avg_confidence_KR", 85.0
+        )
 
         # Aggregate
         aggregator.aggregate_weekly_from_daily(week)
 
         # Verify L5 contexts
         store = aggregator.store
-        weekly_pnl = store.get_context(ContextLayer.L5_WEEKLY, week, "weekly_pnl")
-        avg_conf = store.get_context(ContextLayer.L5_WEEKLY, week, "avg_confidence")
+        weekly_pnl = store.get_context(ContextLayer.L5_WEEKLY, week, "weekly_pnl_KR")
+        avg_conf = store.get_context(ContextLayer.L5_WEEKLY, week, "avg_confidence_KR")
 
         assert weekly_pnl == 300.0
         assert avg_conf == 82.5
@@ -214,9 +222,15 @@ class TestContextAggregator:
         month = "2026-02"
 
         # Set weekly contexts
-        aggregator.store.set_context(ContextLayer.L5_WEEKLY, "2026-W05", "weekly_pnl", 100.0)
-        aggregator.store.set_context(ContextLayer.L5_WEEKLY, "2026-W06", "weekly_pnl", 200.0)
-        aggregator.store.set_context(ContextLayer.L5_WEEKLY, "2026-W07", "weekly_pnl", 150.0)
+        aggregator.store.set_context(
+            ContextLayer.L5_WEEKLY, "2026-W05", "weekly_pnl_KR", 100.0
+        )
+        aggregator.store.set_context(
+            ContextLayer.L5_WEEKLY, "2026-W06", "weekly_pnl_KR", 200.0
+        )
+        aggregator.store.set_context(
+            ContextLayer.L5_WEEKLY, "2026-W07", "weekly_pnl_KR", 150.0
+        )
 
         # Aggregate
         aggregator.aggregate_monthly_from_weekly(month)
@@ -285,7 +299,7 @@ class TestContextAggregator:
         self, aggregator: ContextAggregator, db_conn: sqlite3.Connection
     ) -> None:
         """Test running all aggregations from L7 to L1."""
-        date = "2026-02-04"
+        date = datetime.now(UTC).date().isoformat()
 
         # Create sample trades
         log_trade(db_conn, "005930", "BUY", 85, "Good signal", quantity=10, price=70000, pnl=1000)
@@ -299,10 +313,18 @@ class TestContextAggregator:
 
         # Verify data exists in each layer
         store = aggregator.store
-        assert store.get_context(ContextLayer.L6_DAILY, date, "total_pnl") == 1000.0
-        current_week = datetime.now(UTC).strftime("%Y-W%V")
-        assert store.get_context(ContextLayer.L5_WEEKLY, current_week, "weekly_pnl") is not None
-        # Further layers depend on time alignment, just verify no crashes
+        assert store.get_context(ContextLayer.L6_DAILY, date, "total_pnl_KR") == 1000.0
+        from datetime import date as date_cls
+        trade_date = date_cls.fromisoformat(date)
+        iso_year, iso_week, _ = trade_date.isocalendar()
+        trade_week = f"{iso_year}-W{iso_week:02d}"
+        assert store.get_context(ContextLayer.L5_WEEKLY, trade_week, "weekly_pnl_KR") is not None
+        trade_month = f"{trade_date.year}-{trade_date.month:02d}"
+        trade_quarter = f"{trade_date.year}-Q{(trade_date.month - 1) // 3 + 1}"
+        trade_year = str(trade_date.year)
+        assert store.get_context(ContextLayer.L4_MONTHLY, trade_month, "monthly_pnl") == 1000.0
+        assert store.get_context(ContextLayer.L3_QUARTERLY, trade_quarter, "quarterly_pnl") == 1000.0
+        assert store.get_context(ContextLayer.L2_ANNUAL, trade_year, "annual_pnl") == 1000.0
 
 
 class TestLayerMetadata:

tests/test_context_scheduler.py

@@ -0,0 +1,104 @@
+"""Tests for ContextScheduler."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import UTC, datetime
+
+from src.context.scheduler import ContextScheduler
+
+
+@dataclass
+class StubAggregator:
+    """Stub aggregator that records calls."""
+
+    weekly_calls: list[str]
+    monthly_calls: list[str]
+    quarterly_calls: list[str]
+    annual_calls: list[str]
+    legacy_calls: int
+
+    def aggregate_weekly_from_daily(self, week: str) -> None:
+        self.weekly_calls.append(week)
+
+    def aggregate_monthly_from_weekly(self, month: str) -> None:
+        self.monthly_calls.append(month)
+
+    def aggregate_quarterly_from_monthly(self, quarter: str) -> None:
+        self.quarterly_calls.append(quarter)
+
+    def aggregate_annual_from_quarterly(self, year: str) -> None:
+        self.annual_calls.append(year)
+
+    def aggregate_legacy_from_annual(self) -> None:
+        self.legacy_calls += 1
+
+
+@dataclass
+class StubStore:
+    """Stub store that records cleanup calls."""
+
+    cleanup_calls: int = 0
+
+    def cleanup_expired_contexts(self) -> None:
+        self.cleanup_calls += 1
+
+
+def make_scheduler() -> tuple[ContextScheduler, StubAggregator, StubStore]:
+    aggregator = StubAggregator([], [], [], [], 0)
+    store = StubStore()
+    scheduler = ContextScheduler(aggregator=aggregator, store=store)
+    return scheduler, aggregator, store
+
+
+def test_run_if_due_weekly() -> None:
+    scheduler, aggregator, store = make_scheduler()
+    now = datetime(2026, 2, 8, 10, 0, tzinfo=UTC)  # Sunday
+
+    result = scheduler.run_if_due(now)
+
+    assert result.weekly is True
+    assert aggregator.weekly_calls == ["2026-W06"]
+    assert store.cleanup_calls == 1
+
+
+def test_run_if_due_monthly() -> None:
+    scheduler, aggregator, _store = make_scheduler()
+    now = datetime(2026, 2, 28, 12, 0, tzinfo=UTC)  # Last day of month
+
+    result = scheduler.run_if_due(now)
+
+    assert result.monthly is True
+    assert aggregator.monthly_calls == ["2026-02"]
+
+
+def test_run_if_due_quarterly() -> None:
+    scheduler, aggregator, _store = make_scheduler()
+    now = datetime(2026, 3, 31, 12, 0, tzinfo=UTC)  # Last day of Q1
+
+    result = scheduler.run_if_due(now)
+
+    assert result.quarterly is True
+    assert aggregator.quarterly_calls == ["2026-Q1"]
+
+
+def test_run_if_due_annual_and_legacy() -> None:
+    scheduler, aggregator, _store = make_scheduler()
+    now = datetime(2026, 12, 31, 12, 0, tzinfo=UTC)
+
+    result = scheduler.run_if_due(now)
+
+    assert result.annual is True
+    assert result.legacy is True
+    assert aggregator.annual_calls == ["2026"]
+    assert aggregator.legacy_calls == 1
+
+
+def test_cleanup_runs_once_per_day() -> None:
+    scheduler, _aggregator, store = make_scheduler()
+    now = datetime(2026, 2, 9, 9, 0, tzinfo=UTC)
+
+    scheduler.run_if_due(now)
+    scheduler.run_if_due(now)
+
+    assert store.cleanup_calls == 1

tests/test_daily_review.py

@@ -0,0 +1,387 @@
+"""Tests for DailyReviewer."""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from src.context.layer import ContextLayer
+from src.context.store import ContextStore
+from src.db import init_db, log_trade
+from src.evolution.daily_review import DailyReviewer
+from src.evolution.scorecard import DailyScorecard
+from src.logging.decision_logger import DecisionLogger
+
+from datetime import UTC, datetime
+
+TODAY = datetime.now(UTC).strftime("%Y-%m-%d")
+
+
+@pytest.fixture
+def db_conn() -> sqlite3.Connection:
+    return init_db(":memory:")
+
+
+@pytest.fixture
+def context_store(db_conn: sqlite3.Connection) -> ContextStore:
+    return ContextStore(db_conn)
+
+
+def _log_decision(
+    logger: DecisionLogger,
+    *,
+    stock_code: str,
+    market: str,
+    action: str,
+    confidence: int,
+    scenario_match: dict[str, float] | None = None,
+) -> str:
+    return logger.log_decision(
+        stock_code=stock_code,
+        market=market,
+        exchange_code="KRX" if market == "KR" else "NASDAQ",
+        action=action,
+        confidence=confidence,
+        rationale="test",
+        context_snapshot={"scenario_match": scenario_match or {}},
+        input_data={"stock_code": stock_code},
+    )
+
+
+def test_generate_scorecard_market_scoped(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    reviewer = DailyReviewer(db_conn, context_store)
+    logger = DecisionLogger(db_conn)
+
+    buy_id = _log_decision(
+        logger,
+        stock_code="005930",
+        market="KR",
+        action="BUY",
+        confidence=90,
+        scenario_match={"rsi": 29.0},
+    )
+    _log_decision(
+        logger,
+        stock_code="000660",
+        market="KR",
+        action="HOLD",
+        confidence=60,
+    )
+    _log_decision(
+        logger,
+        stock_code="AAPL",
+        market="US",
+        action="SELL",
+        confidence=80,
+        scenario_match={"volume_ratio": 2.1},
+    )
+
+    log_trade(
+        db_conn,
+        "005930",
+        "BUY",
+        90,
+        "buy",
+        quantity=1,
+        price=100.0,
+        pnl=10.0,
+        market="KR",
+        exchange_code="KRX",
+        decision_id=buy_id,
+    )
+    log_trade(
+        db_conn,
+        "000660",
+        "HOLD",
+        60,
+        "hold",
+        quantity=0,
+        price=0.0,
+        pnl=0.0,
+        market="KR",
+        exchange_code="KRX",
+    )
+    log_trade(
+        db_conn,
+        "AAPL",
+        "SELL",
+        80,
+        "sell",
+        quantity=1,
+        price=200.0,
+        pnl=-5.0,
+        market="US",
+        exchange_code="NASDAQ",
+    )
+
+    scorecard = reviewer.generate_scorecard(TODAY, "KR")
+
+    assert scorecard.market == "KR"
+    assert scorecard.total_decisions == 2
+    assert scorecard.buys == 1
+    assert scorecard.sells == 0
+    assert scorecard.holds == 1
+    assert scorecard.total_pnl == 10.0
+    assert scorecard.win_rate == 100.0
+    assert scorecard.avg_confidence == 75.0
+    assert scorecard.scenario_match_rate == 50.0
+
+
+def test_generate_scorecard_top_winners_and_losers(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    reviewer = DailyReviewer(db_conn, context_store)
+    logger = DecisionLogger(db_conn)
+
+    for code, pnl in [("005930", 30.0), ("000660", 10.0), ("035420", -15.0), ("051910", -5.0)]:
+        decision_id = _log_decision(
+            logger,
+            stock_code=code,
+            market="KR",
+            action="BUY" if pnl >= 0 else "SELL",
+            confidence=80,
+            scenario_match={"rsi": 30.0},
+        )
+        log_trade(
+            db_conn,
+            code,
+            "BUY" if pnl >= 0 else "SELL",
+            80,
+            "test",
+            quantity=1,
+            price=100.0,
+            pnl=pnl,
+            market="KR",
+            exchange_code="KRX",
+            decision_id=decision_id,
+        )
+
+    scorecard = reviewer.generate_scorecard(TODAY, "KR")
+    assert scorecard.top_winners == ["005930", "000660"]
+    assert scorecard.top_losers == ["035420", "051910"]
+
+
+def test_generate_scorecard_empty_day(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    reviewer = DailyReviewer(db_conn, context_store)
+    scorecard = reviewer.generate_scorecard(TODAY, "KR")
+
+    assert scorecard.total_decisions == 0
+    assert scorecard.total_pnl == 0.0
+    assert scorecard.win_rate == 0.0
+    assert scorecard.avg_confidence == 0.0
+    assert scorecard.scenario_match_rate == 0.0
+    assert scorecard.top_winners == []
+    assert scorecard.top_losers == []
+
+
+@pytest.mark.asyncio
+async def test_generate_lessons_without_gemini_returns_empty(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    reviewer = DailyReviewer(db_conn, context_store, gemini_client=None)
+    lessons = await reviewer.generate_lessons(
+        DailyScorecard(
+            date="2026-02-14",
+            market="KR",
+            total_decisions=1,
+            buys=1,
+            sells=0,
+            holds=0,
+            total_pnl=5.0,
+            win_rate=100.0,
+            avg_confidence=90.0,
+            scenario_match_rate=100.0,
+        )
+    )
+    assert lessons == []
+
+
+@pytest.mark.asyncio
+async def test_generate_lessons_parses_json_array(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    mock_gemini = MagicMock()
+    mock_gemini.decide = AsyncMock(
+        return_value=SimpleNamespace(rationale='["Cut losers earlier", "Reduce midday churn"]')
+    )
+    reviewer = DailyReviewer(db_conn, context_store, gemini_client=mock_gemini)
+
+    lessons = await reviewer.generate_lessons(
+        DailyScorecard(
+            date="2026-02-14",
+            market="KR",
+            total_decisions=3,
+            buys=1,
+            sells=1,
+            holds=1,
+            total_pnl=-2.5,
+            win_rate=50.0,
+            avg_confidence=70.0,
+            scenario_match_rate=66.7,
+        )
+    )
+    assert lessons == ["Cut losers earlier", "Reduce midday churn"]
+
+
+@pytest.mark.asyncio
+async def test_generate_lessons_fallback_to_lines(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    mock_gemini = MagicMock()
+    mock_gemini.decide = AsyncMock(
+        return_value=SimpleNamespace(rationale="- Keep risk tighter\n- Increase selectivity")
+    )
+    reviewer = DailyReviewer(db_conn, context_store, gemini_client=mock_gemini)
+
+    lessons = await reviewer.generate_lessons(
+        DailyScorecard(
+            date="2026-02-14",
+            market="US",
+            total_decisions=2,
+            buys=1,
+            sells=1,
+            holds=0,
+            total_pnl=1.0,
+            win_rate=50.0,
+            avg_confidence=75.0,
+            scenario_match_rate=100.0,
+        )
+    )
+    assert lessons == ["Keep risk tighter", "Increase selectivity"]
+
+
+@pytest.mark.asyncio
+async def test_generate_lessons_handles_gemini_error(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    mock_gemini = MagicMock()
+    mock_gemini.decide = AsyncMock(side_effect=RuntimeError("boom"))
+    reviewer = DailyReviewer(db_conn, context_store, gemini_client=mock_gemini)
+
+    lessons = await reviewer.generate_lessons(
+        DailyScorecard(
+            date="2026-02-14",
+            market="US",
+            total_decisions=0,
+            buys=0,
+            sells=0,
+            holds=0,
+            total_pnl=0.0,
+            win_rate=0.0,
+            avg_confidence=0.0,
+            scenario_match_rate=0.0,
+        )
+    )
+    assert lessons == []
+
+
+def test_store_scorecard_in_context(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    reviewer = DailyReviewer(db_conn, context_store)
+    scorecard = DailyScorecard(
+        date="2026-02-14",
+        market="KR",
+        total_decisions=5,
+        buys=2,
+        sells=1,
+        holds=2,
+        total_pnl=15.0,
+        win_rate=66.67,
+        avg_confidence=82.0,
+        scenario_match_rate=80.0,
+        lessons=["Keep position sizing stable"],
+        cross_market_note="US risk-off",
+    )
+
+    reviewer.store_scorecard_in_context(scorecard)
+
+    stored = context_store.get_context(
+        ContextLayer.L6_DAILY,
+        "2026-02-14",
+        "scorecard_KR",
+    )
+    assert stored is not None
+    assert stored["market"] == "KR"
+    assert stored["total_pnl"] == 15.0
+    assert stored["lessons"] == ["Keep position sizing stable"]
+
+
+def test_store_scorecard_key_is_market_scoped(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    reviewer = DailyReviewer(db_conn, context_store)
+    kr = DailyScorecard(
+        date="2026-02-14",
+        market="KR",
+        total_decisions=1,
+        buys=1,
+        sells=0,
+        holds=0,
+        total_pnl=1.0,
+        win_rate=100.0,
+        avg_confidence=90.0,
+        scenario_match_rate=100.0,
+    )
+    us = DailyScorecard(
+        date="2026-02-14",
+        market="US",
+        total_decisions=1,
+        buys=0,
+        sells=1,
+        holds=0,
+        total_pnl=-1.0,
+        win_rate=0.0,
+        avg_confidence=70.0,
+        scenario_match_rate=100.0,
+    )
+
+    reviewer.store_scorecard_in_context(kr)
+    reviewer.store_scorecard_in_context(us)
+
+    kr_ctx = context_store.get_context(ContextLayer.L6_DAILY, "2026-02-14", "scorecard_KR")
+    us_ctx = context_store.get_context(ContextLayer.L6_DAILY, "2026-02-14", "scorecard_US")
+
+    assert kr_ctx["market"] == "KR"
+    assert us_ctx["market"] == "US"
+    assert kr_ctx["total_pnl"] == 1.0
+    assert us_ctx["total_pnl"] == -1.0
+
+
+def test_generate_scorecard_handles_invalid_context_snapshot(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    reviewer = DailyReviewer(db_conn, context_store)
+    db_conn.execute(
+        """
+        INSERT INTO decision_logs (
+            decision_id, timestamp, stock_code, market, exchange_code,
+            action, confidence, rationale, context_snapshot, input_data
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            "d1",
+            "2026-02-14T09:00:00+00:00",
+            "005930",
+            "KR",
+            "KRX",
+            "HOLD",
+            50,
+            "test",
+            "{invalid_json",
+            json.dumps({}),
+        ),
+    )
+    db_conn.commit()
+
+    scorecard = reviewer.generate_scorecard("2026-02-14", "KR")
+    assert scorecard.total_decisions == 1
+    assert scorecard.scenario_match_rate == 0.0

tests/test_dashboard.py

@@ -0,0 +1,298 @@
+"""Tests for dashboard endpoint handlers."""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from collections.abc import Callable
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+import pytest
+from fastapi import HTTPException
+from fastapi.responses import FileResponse
+
+from src.dashboard.app import create_dashboard_app
+from src.db import init_db
+
+
+def _seed_db(conn: sqlite3.Connection) -> None:
+    today = datetime.now(UTC).date().isoformat()
+
+    conn.execute(
+        """
+        INSERT INTO playbooks (
+            date, market, status, playbook_json, generated_at,
+            token_count, scenario_count, match_count
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            "2026-02-14",
+            "KR",
+            "ready",
+            json.dumps({"market": "KR", "stock_playbooks": []}),
+            "2026-02-14T08:30:00+00:00",
+            123,
+            2,
+            1,
+        ),
+    )
+    conn.execute(
+        """
+        INSERT INTO playbooks (
+            date, market, status, playbook_json, generated_at,
+            token_count, scenario_count, match_count
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            today,
+            "US_NASDAQ",
+            "ready",
+            json.dumps({"market": "US_NASDAQ", "stock_playbooks": []}),
+            f"{today}T08:30:00+00:00",
+            100,
+            1,
+            0,
+        ),
+    )
+    conn.execute(
+        """
+        INSERT INTO contexts (layer, timeframe, key, value, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?)
+        """,
+        (
+            "L6_DAILY",
+            "2026-02-14",
+            "scorecard_KR",
+            json.dumps({"market": "KR", "total_pnl": 1.5, "win_rate": 60.0}),
+            "2026-02-14T15:30:00+00:00",
+            "2026-02-14T15:30:00+00:00",
+        ),
+    )
+    conn.execute(
+        """
+        INSERT INTO contexts (layer, timeframe, key, value, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?)
+        """,
+        (
+            "L7_REALTIME",
+            "2026-02-14T10:00:00+00:00",
+            "volatility_KR_005930",
+            json.dumps({"momentum_score": 70.0}),
+            "2026-02-14T10:00:00+00:00",
+            "2026-02-14T10:00:00+00:00",
+        ),
+    )
+    conn.execute(
+        """
+        INSERT INTO decision_logs (
+            decision_id, timestamp, stock_code, market, exchange_code,
+            action, confidence, rationale, context_snapshot, input_data
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            "d-kr-1",
+            f"{today}T09:10:00+00:00",
+            "005930",
+            "KR",
+            "KRX",
+            "BUY",
+            85,
+            "signal matched",
+            json.dumps({"scenario_match": {"rsi": 28.0}}),
+            json.dumps({"current_price": 70000}),
+        ),
+    )
+    conn.execute(
+        """
+        INSERT INTO decision_logs (
+            decision_id, timestamp, stock_code, market, exchange_code,
+            action, confidence, rationale, context_snapshot, input_data
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            "d-us-1",
+            f"{today}T21:10:00+00:00",
+            "AAPL",
+            "US_NASDAQ",
+            "NASDAQ",
+            "SELL",
+            80,
+            "no match",
+            json.dumps({"scenario_match": {}}),
+            json.dumps({"current_price": 200}),
+        ),
+    )
+    conn.execute(
+        """
+        INSERT INTO trades (
+            timestamp, stock_code, action, confidence, rationale,
+            quantity, price, pnl, market, exchange_code, selection_context, decision_id
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            f"{today}T09:11:00+00:00",
+            "005930",
+            "BUY",
+            85,
+            "buy",
+            1,
+            70000,
+            2.0,
+            "KR",
+            "KRX",
+            None,
+            "d-kr-1",
+        ),
+    )
+    conn.execute(
+        """
+        INSERT INTO trades (
+            timestamp, stock_code, action, confidence, rationale,
+            quantity, price, pnl, market, exchange_code, selection_context, decision_id
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            f"{today}T21:11:00+00:00",
+            "AAPL",
+            "SELL",
+            80,
+            "sell",
+            1,
+            200,
+            -1.0,
+            "US_NASDAQ",
+            "NASDAQ",
+            None,
+            "d-us-1",
+        ),
+    )
+    conn.commit()
+
+
+def _app(tmp_path: Path) -> Any:
+    db_path = tmp_path / "dashboard_test.db"
+    conn = init_db(str(db_path))
+    _seed_db(conn)
+    conn.close()
+    return create_dashboard_app(str(db_path))
+
+
+def _endpoint(app: Any, path: str) -> Callable[..., Any]:
+    for route in app.routes:
+        if getattr(route, "path", None) == path:
+            return route.endpoint
+    raise AssertionError(f"route not found: {path}")
+
+
+def test_index_serves_html(tmp_path: Path) -> None:
+    app = _app(tmp_path)
+    index = _endpoint(app, "/")
+    resp = index()
+    assert isinstance(resp, FileResponse)
+    assert "index.html" in str(resp.path)
+
+
+def test_status_endpoint(tmp_path: Path) -> None:
+    app = _app(tmp_path)
+    get_status = _endpoint(app, "/api/status")
+    body = get_status()
+    assert "KR" in body["markets"]
+    assert "US_NASDAQ" in body["markets"]
+    assert "totals" in body
+
+
+def test_playbook_found(tmp_path: Path) -> None:
+    app = _app(tmp_path)
+    get_playbook = _endpoint(app, "/api/playbook/{date_str}")
+    body = get_playbook("2026-02-14", market="KR")
+    assert body["market"] == "KR"
+
+
+def test_playbook_not_found(tmp_path: Path) -> None:
+    app = _app(tmp_path)
+    get_playbook = _endpoint(app, "/api/playbook/{date_str}")
+    with pytest.raises(HTTPException, match="playbook not found"):
+        get_playbook("2026-02-15", market="KR")
+
+
+def test_scorecard_found(tmp_path: Path) -> None:
+    app = _app(tmp_path)
+    get_scorecard = _endpoint(app, "/api/scorecard/{date_str}")
+    body = get_scorecard("2026-02-14", market="KR")
+    assert body["scorecard"]["total_pnl"] == 1.5
+
+
+def test_scorecard_not_found(tmp_path: Path) -> None:
+    app = _app(tmp_path)
+    get_scorecard = _endpoint(app, "/api/scorecard/{date_str}")
+    with pytest.raises(HTTPException, match="scorecard not found"):
+        get_scorecard("2026-02-15", market="KR")
+
+
+def test_performance_all(tmp_path: Path) -> None:
+    app = _app(tmp_path)
+    get_performance = _endpoint(app, "/api/performance")
+    body = get_performance(market="all")
+    assert body["market"] == "all"
+    assert body["combined"]["total_trades"] == 2
+    assert len(body["by_market"]) == 2
+
+
+def test_performance_market_filter(tmp_path: Path) -> None:
+    app = _app(tmp_path)
+    get_performance = _endpoint(app, "/api/performance")
+    body = get_performance(market="KR")
+    assert body["market"] == "KR"
+    assert body["metrics"]["total_trades"] == 1
+
+
+def test_performance_empty_market(tmp_path: Path) -> None:
+    app = _app(tmp_path)
+    get_performance = _endpoint(app, "/api/performance")
+    body = get_performance(market="JP")
+    assert body["metrics"]["total_trades"] == 0
+
+
+def test_context_layer_all(tmp_path: Path) -> None:
+    app = _app(tmp_path)
+    get_context_layer = _endpoint(app, "/api/context/{layer}")
+    body = get_context_layer("L7_REALTIME", timeframe=None, limit=100)
+    assert body["layer"] == "L7_REALTIME"
+    assert body["count"] == 1
+
+
+def test_context_layer_timeframe_filter(tmp_path: Path) -> None:
+    app = _app(tmp_path)
+    get_context_layer = _endpoint(app, "/api/context/{layer}")
+    body = get_context_layer("L6_DAILY", timeframe="2026-02-14", limit=100)
+    assert body["count"] == 1
+    assert body["entries"][0]["key"] == "scorecard_KR"
+
+
+def test_decisions_endpoint(tmp_path: Path) -> None:
+    app = _app(tmp_path)
+    get_decisions = _endpoint(app, "/api/decisions")
+    body = get_decisions(market="KR", limit=50)
+    assert body["count"] == 1
+    assert body["decisions"][0]["decision_id"] == "d-kr-1"
+
+
+def test_scenarios_active_filters_non_matched(tmp_path: Path) -> None:
+    app = _app(tmp_path)
+    get_active_scenarios = _endpoint(app, "/api/scenarios/active")
+    body = get_active_scenarios(
+        market="KR",
+        date_str=datetime.now(UTC).date().isoformat(),
+        limit=50,
+    )
+    assert body["count"] == 1
+    assert body["matches"][0]["stock_code"] == "005930"
+
+
+def test_scenarios_active_empty_when_no_matches(tmp_path: Path) -> None:
+    app = _app(tmp_path)
+    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

tests/test_db.py

@@ -0,0 +1,60 @@
+"""Tests for database helper functions."""
+
+from src.db import get_open_position, init_db, log_trade
+
+
+def test_get_open_position_returns_latest_buy() -> None:
+    conn = init_db(":memory:")
+    log_trade(
+        conn=conn,
+        stock_code="005930",
+        action="BUY",
+        confidence=90,
+        rationale="entry",
+        quantity=2,
+        price=70000.0,
+        market="KR",
+        exchange_code="KRX",
+        decision_id="d-buy-1",
+    )
+
+    position = get_open_position(conn, "005930", "KR")
+    assert position is not None
+    assert position["decision_id"] == "d-buy-1"
+    assert position["price"] == 70000.0
+    assert position["quantity"] == 2
+
+
+def test_get_open_position_returns_none_when_latest_is_sell() -> None:
+    conn = init_db(":memory:")
+    log_trade(
+        conn=conn,
+        stock_code="005930",
+        action="BUY",
+        confidence=90,
+        rationale="entry",
+        quantity=1,
+        price=70000.0,
+        market="KR",
+        exchange_code="KRX",
+        decision_id="d-buy-1",
+    )
+    log_trade(
+        conn=conn,
+        stock_code="005930",
+        action="SELL",
+        confidence=95,
+        rationale="exit",
+        quantity=1,
+        price=71000.0,
+        market="KR",
+        exchange_code="KRX",
+        decision_id="d-sell-1",
+    )
+
+    assert get_open_position(conn, "005930", "KR") is None
+
+
+def test_get_open_position_returns_none_when_no_trades() -> None:
+    conn = init_db(":memory:")
+    assert get_open_position(conn, "AAPL", "US_NASDAQ") is None

tests/test_market_schedule.py

@@ -7,6 +7,7 @@ import pytest
 
 from src.markets.schedule import (
     MARKETS,
+    expand_market_codes,
     get_next_market_open,
     get_open_markets,
     is_market_open,
@@ -199,3 +200,28 @@ class TestGetNextMarketOpen:
             enabled_markets=["INVALID", "KR"], now=test_time
         )
         assert market.code == "KR"
+
+
+class TestExpandMarketCodes:
+    """Test shorthand market expansion."""
+
+    def test_expand_us_shorthand(self) -> None:
+        assert expand_market_codes(["US"]) == ["US_NASDAQ", "US_NYSE", "US_AMEX"]
+
+    def test_expand_cn_shorthand(self) -> None:
+        assert expand_market_codes(["CN"]) == ["CN_SHA", "CN_SZA"]
+
+    def test_expand_vn_shorthand(self) -> None:
+        assert expand_market_codes(["VN"]) == ["VN_HAN", "VN_HCM"]
+
+    def test_expand_mixed_codes(self) -> None:
+        assert expand_market_codes(["KR", "US", "JP"]) == [
+            "KR",
+            "US_NASDAQ",
+            "US_NYSE",
+            "US_AMEX",
+            "JP",
+        ]
+
+    def test_expand_preserves_unknown_code(self) -> None:
+        assert expand_market_codes(["KR", "UNKNOWN"]) == ["KR", "UNKNOWN"]

tests/test_pre_market_planner.py

@@ -9,6 +9,7 @@ from unittest.mock import AsyncMock, MagicMock
 import pytest
 
 from src.analysis.smart_scanner import ScanCandidate
+from src.brain.context_selector import DecisionType
 from src.brain.gemini_client import TradeDecision
 from src.config import Settings
 from src.context.store import ContextLayer
@@ -16,12 +17,10 @@ from src.strategy.models import (
     CrossMarketContext,
     DayPlaybook,
     MarketOutlook,
-    PlaybookStatus,
     ScenarioAction,
 )
 from src.strategy.pre_market_planner import PreMarketPlanner
 
-
 # ---------------------------------------------------------------------------
 # Fixtures
 # ---------------------------------------------------------------------------
@@ -89,6 +88,7 @@ def _make_planner(
     token_count: int = 200,
     context_data: dict | None = None,
     scorecard_data: dict | None = None,
+    scorecard_map: dict[tuple[str, str, str], dict | None] | None = None,
 ) -> PreMarketPlanner:
     """Create a PreMarketPlanner with mocked dependencies."""
     if not gemini_response:
@@ -107,11 +107,20 @@ def _make_planner(
 
     # Mock ContextStore
     store = MagicMock()
-    store.get_context = MagicMock(return_value=scorecard_data)
+    if scorecard_map is not None:
+        store.get_context = MagicMock(
+            side_effect=lambda layer, timeframe, key: scorecard_map.get(
+                (layer.value if hasattr(layer, "value") else layer, timeframe, key)
+            )
+        )
+    else:
+        store.get_context = MagicMock(return_value=scorecard_data)
 
     # Mock ContextSelector
     selector = MagicMock()
-    selector.select_layers = MagicMock(return_value=[ContextLayer.L7_REALTIME, ContextLayer.L6_DAILY])
+    selector.select_layers = MagicMock(
+        return_value=[ContextLayer.L7_REALTIME, ContextLayer.L6_DAILY]
+    )
     selector.get_context_data = MagicMock(return_value=context_data or {})
 
     settings = Settings(
@@ -220,11 +229,25 @@ class TestGeneratePlaybook:
         stocks = [
             {
                 "stock_code": "005930",
-                "scenarios": [{"condition": {"rsi_below": 30}, "action": "BUY", "confidence": 85, "rationale": "ok"}],
+                "scenarios": [
+                    {
+                        "condition": {"rsi_below": 30},
+                        "action": "BUY",
+                        "confidence": 85,
+                        "rationale": "ok",
+                    }
+                ],
             },
             {
                 "stock_code": "UNKNOWN",
-                "scenarios": [{"condition": {"rsi_below": 20}, "action": "BUY", "confidence": 90, "rationale": "bad"}],
+                "scenarios": [
+                    {
+                        "condition": {"rsi_below": 20},
+                        "action": "BUY",
+                        "confidence": 90,
+                        "rationale": "bad",
+                    }
+                ],
             },
         ]
         planner = _make_planner(gemini_response=_gemini_response_json(stocks=stocks))
@@ -254,6 +277,43 @@ class TestGeneratePlaybook:
 
         assert pb.token_count == 450
 
+    @pytest.mark.asyncio
+    async def test_generate_playbook_uses_strategic_context_selector(self) -> None:
+        planner = _make_planner()
+        candidates = [_candidate()]
+
+        await planner.generate_playbook("KR", candidates, today=date(2026, 2, 8))
+
+        planner._context_selector.select_layers.assert_called_once_with(
+            decision_type=DecisionType.STRATEGIC,
+            include_realtime=True,
+        )
+        planner._context_selector.get_context_data.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_generate_playbook_injects_self_and_cross_scorecards(self) -> None:
+        scorecard_map = {
+            (ContextLayer.L6_DAILY.value, "2026-02-07", "scorecard_KR"): {
+                "total_pnl": -1.0,
+                "win_rate": 40,
+                "lessons": ["Tighten entries"],
+            },
+            (ContextLayer.L6_DAILY.value, "2026-02-07", "scorecard_US"): {
+                "total_pnl": 1.5,
+                "win_rate": 62,
+                "index_change_pct": 0.9,
+                "lessons": ["Follow momentum"],
+            },
+        }
+        planner = _make_planner(scorecard_map=scorecard_map)
+
+        await planner.generate_playbook("KR", [_candidate()], today=date(2026, 2, 8))
+
+        call_market_data = planner._gemini.decide.call_args.args[0]
+        prompt = call_market_data["prompt_override"]
+        assert "My Market Previous Day (KR)" in prompt
+        assert "Other Market (US)" in prompt
+
 
 # ---------------------------------------------------------------------------
 # _parse_response
@@ -402,7 +462,12 @@ class TestParseResponse:
 
 class TestBuildCrossMarketContext:
     def test_kr_reads_us_scorecard(self) -> None:
-        scorecard = {"total_pnl": 2.5, "win_rate": 65, "index_change_pct": 0.8, "lessons": ["Stay patient"]}
+        scorecard = {
+            "total_pnl": 2.5,
+            "win_rate": 65,
+            "index_change_pct": 0.8,
+            "lessons": ["Stay patient"],
+        }
         planner = _make_planner(scorecard_data=scorecard)
 
         ctx = planner.build_cross_market_context("KR", today=date(2026, 2, 8))
@@ -415,8 +480,9 @@ class TestBuildCrossMarketContext:
 
         # Verify it queried scorecard_US
         planner._context_store.get_context.assert_called_once_with(
-            ContextLayer.L6_DAILY, "2026-02-08", "scorecard_US"
+            ContextLayer.L6_DAILY, "2026-02-07", "scorecard_US"
         )
+        assert ctx.date == "2026-02-07"
 
     def test_us_reads_kr_scorecard(self) -> None:
         scorecard = {"total_pnl": -1.0, "win_rate": 40, "index_change_pct": -0.5}
@@ -447,6 +513,32 @@ class TestBuildCrossMarketContext:
         assert ctx is None
 
 
+# ---------------------------------------------------------------------------
+# build_self_market_scorecard
+# ---------------------------------------------------------------------------
+
+
+class TestBuildSelfMarketScorecard:
+    def test_reads_previous_day_scorecard(self) -> None:
+        scorecard = {"total_pnl": -1.2, "win_rate": 45, "lessons": ["Reduce overtrading"]}
+        planner = _make_planner(scorecard_data=scorecard)
+
+        data = planner.build_self_market_scorecard("KR", today=date(2026, 2, 8))
+
+        assert data is not None
+        assert data["date"] == "2026-02-07"
+        assert data["total_pnl"] == -1.2
+        assert data["win_rate"] == 45
+        assert "Reduce overtrading" in data["lessons"]
+        planner._context_store.get_context.assert_called_once_with(
+            ContextLayer.L6_DAILY, "2026-02-07", "scorecard_KR"
+        )
+
+    def test_missing_scorecard_returns_none(self) -> None:
+        planner = _make_planner(scorecard_data=None)
+        assert planner.build_self_market_scorecard("US", today=date(2026, 2, 8)) is None
+
+
 # ---------------------------------------------------------------------------
 # _build_prompt
 # ---------------------------------------------------------------------------
@@ -457,7 +549,7 @@ class TestBuildPrompt:
         planner = _make_planner()
         candidates = [_candidate(code="005930", name="Samsung")]
 
-        prompt = planner._build_prompt("KR", candidates, {}, None)
+        prompt = planner._build_prompt("KR", candidates, {}, None, None)
 
         assert "005930" in prompt
         assert "Samsung" in prompt
@@ -471,7 +563,7 @@ class TestBuildPrompt:
             win_rate=60, index_change_pct=0.8, lessons=["Cut losses early"],
         )
 
-        prompt = planner._build_prompt("KR", [_candidate()], {}, cross)
+        prompt = planner._build_prompt("KR", [_candidate()], {}, None, cross)
 
         assert "Other Market (US)" in prompt
         assert "+1.50%" in prompt
@@ -481,7 +573,7 @@ class TestBuildPrompt:
         planner = _make_planner()
         context = {"L6_DAILY": {"win_rate": 0.65, "total_pnl": 2.5}}
 
-        prompt = planner._build_prompt("KR", [_candidate()], context, None)
+        prompt = planner._build_prompt("KR", [_candidate()], context, None, None)
 
         assert "Strategic Context" in prompt
         assert "L6_DAILY" in prompt
@@ -489,15 +581,30 @@ class TestBuildPrompt:
 
     def test_prompt_contains_max_scenarios(self) -> None:
         planner = _make_planner()
-        prompt = planner._build_prompt("KR", [_candidate()], {}, None)
+        prompt = planner._build_prompt("KR", [_candidate()], {}, None, None)
 
         assert f"Max {planner._settings.MAX_SCENARIOS_PER_STOCK} scenarios" in prompt
 
     def test_prompt_market_name(self) -> None:
         planner = _make_planner()
-        prompt = planner._build_prompt("US", [_candidate()], {}, None)
+        prompt = planner._build_prompt("US", [_candidate()], {}, None, None)
         assert "US market" in prompt
 
+    def test_prompt_contains_self_market_scorecard(self) -> None:
+        planner = _make_planner()
+        self_scorecard = {
+            "date": "2026-02-07",
+            "total_pnl": -0.8,
+            "win_rate": 45.0,
+            "lessons": ["Avoid midday entries"],
+        }
+        prompt = planner._build_prompt("KR", [_candidate()], {}, self_scorecard, None)
+
+        assert "My Market Previous Day (KR)" in prompt
+        assert "2026-02-07" in prompt
+        assert "-0.80%" in prompt
+        assert "Avoid midday entries" in prompt
+
 
 # ---------------------------------------------------------------------------
 # _extract_json

tests/test_scorecard.py

@@ -0,0 +1,81 @@
+"""Tests for DailyScorecard model."""
+
+from __future__ import annotations
+
+from src.evolution.scorecard import DailyScorecard
+
+
+def test_scorecard_initialization() -> None:
+    scorecard = DailyScorecard(
+        date="2026-02-08",
+        market="KR",
+        total_decisions=10,
+        buys=3,
+        sells=2,
+        holds=5,
+        total_pnl=1234.5,
+        win_rate=60.0,
+        avg_confidence=78.5,
+        scenario_match_rate=70.0,
+        top_winners=["005930", "000660"],
+        top_losers=["035420"],
+        lessons=["Avoid chasing breakouts"],
+        cross_market_note="US volatility spillover",
+    )
+
+    assert scorecard.market == "KR"
+    assert scorecard.total_decisions == 10
+    assert scorecard.total_pnl == 1234.5
+    assert scorecard.top_winners == ["005930", "000660"]
+    assert scorecard.lessons == ["Avoid chasing breakouts"]
+    assert scorecard.cross_market_note == "US volatility spillover"
+
+
+def test_scorecard_defaults() -> None:
+    scorecard = DailyScorecard(
+        date="2026-02-08",
+        market="US",
+        total_decisions=0,
+        buys=0,
+        sells=0,
+        holds=0,
+        total_pnl=0.0,
+        win_rate=0.0,
+        avg_confidence=0.0,
+        scenario_match_rate=0.0,
+    )
+
+    assert scorecard.top_winners == []
+    assert scorecard.top_losers == []
+    assert scorecard.lessons == []
+    assert scorecard.cross_market_note == ""
+
+
+def test_scorecard_list_isolation() -> None:
+    a = DailyScorecard(
+        date="2026-02-08",
+        market="KR",
+        total_decisions=1,
+        buys=1,
+        sells=0,
+        holds=0,
+        total_pnl=10.0,
+        win_rate=100.0,
+        avg_confidence=90.0,
+        scenario_match_rate=100.0,
+    )
+    b = DailyScorecard(
+        date="2026-02-08",
+        market="US",
+        total_decisions=1,
+        buys=0,
+        sells=1,
+        holds=0,
+        total_pnl=-5.0,
+        win_rate=0.0,
+        avg_confidence=60.0,
+        scenario_match_rate=50.0,
+    )
+
+    a.top_winners.append("005930")
+    assert b.top_winners == []

tests/test_smart_scanner.py

@@ -8,6 +8,7 @@ from unittest.mock import AsyncMock, MagicMock
 from src.analysis.smart_scanner import ScanCandidate, SmartVolatilityScanner
 from src.analysis.volatility import VolatilityAnalyzer
 from src.broker.kis_api import KISBroker
+from src.broker.overseas import OverseasBroker
 from src.config import Settings
 
 
@@ -43,61 +44,70 @@ def scanner(mock_broker: MagicMock, mock_settings: Settings) -> SmartVolatilityS
     analyzer = VolatilityAnalyzer()
     return SmartVolatilityScanner(
         broker=mock_broker,
+        overseas_broker=None,
         volatility_analyzer=analyzer,
         settings=mock_settings,
     )
 
 
+@pytest.fixture
+def mock_overseas_broker() -> MagicMock:
+    """Create mock overseas broker."""
+    broker = MagicMock(spec=OverseasBroker)
+    broker.get_overseas_price = AsyncMock()
+    broker.fetch_overseas_rankings = AsyncMock(return_value=[])
+    return broker
+
+
 class TestSmartVolatilityScanner:
     """Test suite for SmartVolatilityScanner."""
 
     @pytest.mark.asyncio
-    async def test_scan_finds_oversold_candidates(
+    async def test_scan_domestic_prefers_volatility_with_liquidity_bonus(
         self, scanner: SmartVolatilityScanner, mock_broker: MagicMock
     ) -> None:
-        """Test that scanner identifies oversold stocks with high volume."""
-        # Mock rankings
-        mock_broker.fetch_market_rankings.return_value = [
+        """Domestic scan should score by volatility first and volume rank second."""
+        fluctuation_rows = [
             {
                 "stock_code": "005930",
                 "name": "Samsung",
                 "price": 70000,
                 "volume": 5000000,
-                "change_rate": -3.5,
+                "change_rate": -5.0,
                 "volume_increase_rate": 250,
             },
+            {
+                "stock_code": "035420",
+                "name": "NAVER",
+                "price": 250000,
+                "volume": 3000000,
+                "change_rate": 3.0,
+                "volume_increase_rate": 200,
+            },
+        ]
+        volume_rows = [
+            {"stock_code": "035420", "name": "NAVER", "price": 250000, "volume": 3000000},
+            {"stock_code": "005930", "name": "Samsung", "price": 70000, "volume": 5000000},
+        ]
+        mock_broker.fetch_market_rankings.side_effect = [fluctuation_rows, volume_rows]
+        mock_broker.get_daily_prices.return_value = [
+            {"open": 1, "high": 1, "low": 1, "close": 1, "volume": 1000000},
+            {"open": 1, "high": 1, "low": 1, "close": 1, "volume": 1000000},
         ]
-
-        # Mock daily prices - trending down (oversold)
-        prices = []
-        for i in range(20):
-            prices.append({
-                "date": f"2026020{i:02d}",
-                "open": 75000 - i * 200,
-                "high": 75500 - i * 200,
-                "low": 74500 - i * 200,
-                "close": 75000 - i * 250,  # Steady decline
-                "volume": 2000000,
-            })
-        mock_broker.get_daily_prices.return_value = prices
 
         candidates = await scanner.scan()
 
-        # Should find at least one candidate (depending on exact RSI calculation)
-        mock_broker.fetch_market_rankings.assert_called_once()
-        mock_broker.get_daily_prices.assert_called_once_with("005930", days=20)
-
-        # If qualified, should have oversold signal
-        if candidates:
-            assert candidates[0].signal in ["oversold", "momentum"]
-            assert candidates[0].volume_ratio >= scanner.vol_multiplier
+        assert len(candidates) >= 1
+        # Samsung has higher absolute move, so it should lead despite lower volume rank bonus.
+        assert candidates[0].stock_code == "005930"
+        assert candidates[0].signal == "oversold"
 
     @pytest.mark.asyncio
-    async def test_scan_finds_momentum_candidates(
+    async def test_scan_domestic_finds_momentum_candidate(
         self, scanner: SmartVolatilityScanner, mock_broker: MagicMock
     ) -> None:
-        """Test that scanner identifies momentum stocks with high volume."""
-        mock_broker.fetch_market_rankings.return_value = [
+        """Positive change should be represented as momentum signal."""
+        fluctuation_rows = [
             {
                 "stock_code": "035420",
                 "name": "NAVER",
@@ -107,124 +117,67 @@ class TestSmartVolatilityScanner:
                 "volume_increase_rate": 300,
             },
         ]
-
-        # Mock daily prices - trending up (momentum)
-        prices = []
-        for i in range(20):
-            prices.append({
-                "date": f"2026020{i:02d}",
-                "open": 230000 + i * 500,
-                "high": 231000 + i * 500,
-                "low": 229000 + i * 500,
-                "close": 230500 + i * 500,  # Steady rise
-                "volume": 1000000,
-            })
-        mock_broker.get_daily_prices.return_value = prices
+        mock_broker.fetch_market_rankings.side_effect = [fluctuation_rows, fluctuation_rows]
+        mock_broker.get_daily_prices.return_value = [
+            {"open": 1, "high": 1, "low": 1, "close": 1, "volume": 1000000},
+            {"open": 1, "high": 1, "low": 1, "close": 1, "volume": 1000000},
+        ]
 
         candidates = await scanner.scan()
 
-        mock_broker.fetch_market_rankings.assert_called_once()
+        assert [c.stock_code for c in candidates] == ["035420"]
+        assert candidates[0].signal == "momentum"
 
     @pytest.mark.asyncio
-    async def test_scan_filters_low_volume(
+    async def test_scan_domestic_filters_low_volatility(
         self, scanner: SmartVolatilityScanner, mock_broker: MagicMock
     ) -> None:
-        """Test that stocks with low volume ratio are filtered out."""
-        mock_broker.fetch_market_rankings.return_value = [
+        """Domestic scan should drop symbols below volatility threshold."""
+        fluctuation_rows = [
             {
                 "stock_code": "000660",
                 "name": "SK Hynix",
                 "price": 150000,
                 "volume": 500000,
-                "change_rate": -5.0,
-                "volume_increase_rate": 50,  # Only 50% increase (< 200%)
+                "change_rate": 0.2,
+                "volume_increase_rate": 50,
             },
         ]
-
-        # Low volume
-        prices = []
-        for i in range(20):
-            prices.append({
-                "date": f"2026020{i:02d}",
-                "open": 150000 - i * 100,
-                "high": 151000 - i * 100,
-                "low": 149000 - i * 100,
-                "close": 150000 - i * 150,  # Declining (would be oversold)
-                "volume": 1000000,  # Current 500k < 2x prev day 1M
-            })
-        mock_broker.get_daily_prices.return_value = prices
+        mock_broker.fetch_market_rankings.side_effect = [fluctuation_rows, fluctuation_rows]
+        mock_broker.get_daily_prices.return_value = [
+            {"open": 1, "high": 150100, "low": 149900, "close": 150000, "volume": 1000000},
+            {"open": 1, "high": 150100, "low": 149900, "close": 150000, "volume": 1000000},
+        ]
 
         candidates = await scanner.scan()
 
-        # Should be filtered out due to low volume ratio
-        assert len(candidates) == 0
-
-    @pytest.mark.asyncio
-    async def test_scan_filters_neutral_rsi(
-        self, scanner: SmartVolatilityScanner, mock_broker: MagicMock
-    ) -> None:
-        """Test that stocks with neutral RSI are filtered out."""
-        mock_broker.fetch_market_rankings.return_value = [
-            {
-                "stock_code": "051910",
-                "name": "LG Chem",
-                "price": 500000,
-                "volume": 3000000,
-                "change_rate": 0.5,
-                "volume_increase_rate": 300,  # High volume
-            },
-        ]
-
-        # Flat prices (neutral RSI ~50)
-        prices = []
-        for i in range(20):
-            prices.append({
-                "date": f"2026020{i:02d}",
-                "open": 500000 + (i % 2) * 100,  # Small oscillation
-                "high": 500500,
-                "low": 499500,
-                "close": 500000 + (i % 2) * 50,
-                "volume": 1000000,
-            })
-        mock_broker.get_daily_prices.return_value = prices
-
-        candidates = await scanner.scan()
-
-        # Should be filtered out (RSI ~50, not < 30 or > 70)
         assert len(candidates) == 0
 
     @pytest.mark.asyncio
     async def test_scan_uses_fallback_on_api_error(
         self, scanner: SmartVolatilityScanner, mock_broker: MagicMock
     ) -> None:
-        """Test fallback to static list when ranking API fails."""
-        mock_broker.fetch_market_rankings.side_effect = ConnectionError("API unavailable")
-
-        # Fallback stocks should still be analyzed
-        prices = []
-        for i in range(20):
-            prices.append({
-                "date": f"2026020{i:02d}",
-                "open": 50000 - i * 50,
-                "high": 51000 - i * 50,
-                "low": 49000 - i * 50,
-                "close": 50000 - i * 75,  # Declining
-                "volume": 1000000,
-            })
-        mock_broker.get_daily_prices.return_value = prices
+        """Domestic scan should remain operational using fallback symbols."""
+        mock_broker.fetch_market_rankings.side_effect = [
+            ConnectionError("API unavailable"),
+            ConnectionError("API unavailable"),
+        ]
+        mock_broker.get_daily_prices.return_value = [
+            {"open": 1, "high": 103, "low": 97, "close": 100, "volume": 1000000},
+            {"open": 1, "high": 103, "low": 97, "close": 100, "volume": 800000},
+        ]
 
         candidates = await scanner.scan(fallback_stocks=["005930", "000660"])
 
-        # Should not crash
         assert isinstance(candidates, list)
+        assert len(candidates) >= 1
 
     @pytest.mark.asyncio
     async def test_scan_returns_top_n_only(
         self, scanner: SmartVolatilityScanner, mock_broker: MagicMock
     ) -> None:
         """Test that scan returns at most top_n candidates."""
-        # Return many stocks
-        mock_broker.fetch_market_rankings.return_value = [
+        fluctuation_rows = [
             {
                 "stock_code": f"00{i}000",
                 "name": f"Stock{i}",
@@ -235,62 +188,17 @@ class TestSmartVolatilityScanner:
             }
             for i in range(1, 10)
         ]
-
-        # All oversold with high volume
-        def make_prices(code: str) -> list[dict]:
-            prices = []
-            for i in range(20):
-                prices.append({
-                    "date": f"2026020{i:02d}",
-                    "open": 10000 - i * 100,
-                    "high": 10500 - i * 100,
-                    "low": 9500 - i * 100,
-                    "close": 10000 - i * 150,
-                    "volume": 1000000,
-                })
-            return prices
-
-        mock_broker.get_daily_prices.side_effect = make_prices
+        mock_broker.fetch_market_rankings.side_effect = [fluctuation_rows, fluctuation_rows]
+        mock_broker.get_daily_prices.return_value = [
+            {"open": 1, "high": 105, "low": 95, "close": 100, "volume": 1000000},
+            {"open": 1, "high": 105, "low": 95, "close": 100, "volume": 900000},
+        ]
 
         candidates = await scanner.scan()
 
         # Should respect top_n limit (3)
         assert len(candidates) <= scanner.top_n
 
-    @pytest.mark.asyncio
-    async def test_scan_skips_insufficient_price_history(
-        self, scanner: SmartVolatilityScanner, mock_broker: MagicMock
-    ) -> None:
-        """Test that stocks with insufficient history are skipped."""
-        mock_broker.fetch_market_rankings.return_value = [
-            {
-                "stock_code": "005930",
-                "name": "Samsung",
-                "price": 70000,
-                "volume": 5000000,
-                "change_rate": -5.0,
-                "volume_increase_rate": 300,
-            },
-        ]
-
-        # Only 5 days of data (need 15+ for RSI)
-        mock_broker.get_daily_prices.return_value = [
-            {
-                "date": f"2026020{i:02d}",
-                "open": 70000,
-                "high": 71000,
-                "low": 69000,
-                "close": 70000,
-                "volume": 2000000,
-            }
-            for i in range(5)
-        ]
-
-        candidates = await scanner.scan()
-
-        # Should skip due to insufficient data
-        assert len(candidates) == 0
-
     @pytest.mark.asyncio
     async def test_get_stock_codes(
         self, scanner: SmartVolatilityScanner
@@ -323,6 +231,124 @@ class TestSmartVolatilityScanner:
 
         assert codes == ["005930", "035420"]
 
+    @pytest.mark.asyncio
+    async def test_scan_overseas_uses_dynamic_symbols(
+        self, mock_broker: MagicMock, mock_overseas_broker: MagicMock, mock_settings: Settings
+    ) -> None:
+        """Overseas scan should use provided dynamic universe symbols."""
+        analyzer = VolatilityAnalyzer()
+        scanner = SmartVolatilityScanner(
+            broker=mock_broker,
+            overseas_broker=mock_overseas_broker,
+            volatility_analyzer=analyzer,
+            settings=mock_settings,
+        )
+
+        market = MagicMock()
+        market.name = "NASDAQ"
+        market.code = "US_NASDAQ"
+        market.exchange_code = "NASD"
+        market.is_domestic = False
+
+        mock_overseas_broker.get_overseas_price.side_effect = [
+            {"output": {"last": "210.5", "rate": "1.6", "tvol": "1500000"}},
+            {"output": {"last": "330.1", "rate": "0.2", "tvol": "900000"}},
+        ]
+
+        candidates = await scanner.scan(
+            market=market,
+            fallback_stocks=["AAPL", "MSFT"],
+        )
+
+        assert [c.stock_code for c in candidates] == ["AAPL"]
+        assert candidates[0].signal == "momentum"
+        assert candidates[0].price == 210.5
+
+    @pytest.mark.asyncio
+    async def test_scan_overseas_uses_ranking_api_first(
+        self, mock_broker: MagicMock, mock_overseas_broker: MagicMock, mock_settings: Settings
+    ) -> None:
+        """Overseas scan should prioritize ranking API when available."""
+        analyzer = VolatilityAnalyzer()
+        scanner = SmartVolatilityScanner(
+            broker=mock_broker,
+            overseas_broker=mock_overseas_broker,
+            volatility_analyzer=analyzer,
+            settings=mock_settings,
+        )
+        market = MagicMock()
+        market.name = "NASDAQ"
+        market.code = "US_NASDAQ"
+        market.exchange_code = "NASD"
+        market.is_domestic = False
+
+        mock_overseas_broker.fetch_overseas_rankings.return_value = [
+            {"symb": "NVDA", "last": "780.2", "rate": "2.4", "tvol": "1200000"},
+            {"symb": "MSFT", "last": "420.0", "rate": "0.3", "tvol": "900000"},
+        ]
+
+        candidates = await scanner.scan(market=market, fallback_stocks=["AAPL", "TSLA"])
+
+        assert mock_overseas_broker.fetch_overseas_rankings.call_count >= 1
+        mock_overseas_broker.get_overseas_price.assert_not_called()
+        assert [c.stock_code for c in candidates] == ["NVDA"]
+
+    @pytest.mark.asyncio
+    async def test_scan_overseas_without_symbols_returns_empty(
+        self, mock_broker: MagicMock, mock_overseas_broker: MagicMock, mock_settings: Settings
+    ) -> None:
+        """Overseas scan should return empty list when no symbol universe exists."""
+        analyzer = VolatilityAnalyzer()
+        scanner = SmartVolatilityScanner(
+            broker=mock_broker,
+            overseas_broker=mock_overseas_broker,
+            volatility_analyzer=analyzer,
+            settings=mock_settings,
+        )
+        market = MagicMock()
+        market.name = "NASDAQ"
+        market.code = "US_NASDAQ"
+        market.exchange_code = "NASD"
+        market.is_domestic = False
+
+        candidates = await scanner.scan(market=market, fallback_stocks=[])
+
+        assert candidates == []
+
+    @pytest.mark.asyncio
+    async def test_scan_overseas_picks_high_intraday_range_even_with_low_change(
+        self, mock_broker: MagicMock, mock_overseas_broker: MagicMock, mock_settings: Settings
+    ) -> None:
+        """Volatility selection should consider intraday range, not only change rate."""
+        analyzer = VolatilityAnalyzer()
+        scanner = SmartVolatilityScanner(
+            broker=mock_broker,
+            overseas_broker=mock_overseas_broker,
+            volatility_analyzer=analyzer,
+            settings=mock_settings,
+        )
+        market = MagicMock()
+        market.name = "NASDAQ"
+        market.code = "US_NASDAQ"
+        market.exchange_code = "NASD"
+        market.is_domestic = False
+
+        # change rate is tiny, but high-low range is large (15%).
+        mock_overseas_broker.fetch_overseas_rankings.return_value = [
+            {
+                "symb": "ABCD",
+                "last": "100",
+                "rate": "0.2",
+                "high": "110",
+                "low": "95",
+                "tvol": "800000",
+            }
+        ]
+
+        candidates = await scanner.scan(market=market, fallback_stocks=[])
+
+        assert [c.stock_code for c in candidates] == ["ABCD"]
+
 
 class TestRSICalculation:
     """Test RSI calculation in VolatilityAnalyzer."""

tests/test_telegram_commands.py

@@ -682,6 +682,10 @@ class TestBasicCommands:
                 "/help - Show available commands\n"
                 "/status - Trading status (mode, markets, P&L)\n"
                 "/positions - Current holdings\n"
+                "/report - Daily summary report\n"
+                "/scenarios - Today's playbook scenarios\n"
+                "/review - Recent scorecards\n"
+                "/dashboard - Dashboard URL/status\n"
                 "/stop - Pause trading\n"
                 "/resume - Resume trading"
             )
@@ -707,10 +711,106 @@ class TestBasicCommands:
             assert "/help" in payload["text"]
             assert "/status" in payload["text"]
             assert "/positions" in payload["text"]
+            assert "/report" in payload["text"]
+            assert "/scenarios" in payload["text"]
+            assert "/review" in payload["text"]
+            assert "/dashboard" in payload["text"]
             assert "/stop" in payload["text"]
             assert "/resume" in payload["text"]
 
 
+class TestExtendedCommands:
+    """Test additional bot commands."""
+
+    @pytest.mark.asyncio
+    async def test_report_command(self) -> None:
+        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
+        handler = TelegramCommandHandler(client)
+
+        mock_resp = AsyncMock()
+        mock_resp.status = 200
+        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
+        mock_resp.__aexit__ = AsyncMock(return_value=False)
+
+        async def mock_report() -> None:
+            await client.send_message("<b>📈 Daily Report</b>\n\nTrades: 1")
+
+        handler.register_command("report", mock_report)
+
+        with patch("aiohttp.ClientSession.post", return_value=mock_resp) as mock_post:
+            await handler._handle_update(
+                {"update_id": 1, "message": {"chat": {"id": 456}, "text": "/report"}}
+            )
+            payload = mock_post.call_args.kwargs["json"]
+            assert "Daily Report" in payload["text"]
+
+    @pytest.mark.asyncio
+    async def test_scenarios_command(self) -> None:
+        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
+        handler = TelegramCommandHandler(client)
+
+        mock_resp = AsyncMock()
+        mock_resp.status = 200
+        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
+        mock_resp.__aexit__ = AsyncMock(return_value=False)
+
+        async def mock_scenarios() -> None:
+            await client.send_message("<b>🧠 Today's Scenarios</b>\n\n- AAPL: BUY (85)")
+
+        handler.register_command("scenarios", mock_scenarios)
+
+        with patch("aiohttp.ClientSession.post", return_value=mock_resp) as mock_post:
+            await handler._handle_update(
+                {"update_id": 1, "message": {"chat": {"id": 456}, "text": "/scenarios"}}
+            )
+            payload = mock_post.call_args.kwargs["json"]
+            assert "Today's Scenarios" in payload["text"]
+
+    @pytest.mark.asyncio
+    async def test_review_command(self) -> None:
+        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
+        handler = TelegramCommandHandler(client)
+
+        mock_resp = AsyncMock()
+        mock_resp.status = 200
+        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
+        mock_resp.__aexit__ = AsyncMock(return_value=False)
+
+        async def mock_review() -> None:
+            await client.send_message("<b>📝 Recent Reviews</b>\n\n- 2026-02-14 KR")
+
+        handler.register_command("review", mock_review)
+
+        with patch("aiohttp.ClientSession.post", return_value=mock_resp) as mock_post:
+            await handler._handle_update(
+                {"update_id": 1, "message": {"chat": {"id": 456}, "text": "/review"}}
+            )
+            payload = mock_post.call_args.kwargs["json"]
+            assert "Recent Reviews" in payload["text"]
+
+    @pytest.mark.asyncio
+    async def test_dashboard_command(self) -> None:
+        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
+        handler = TelegramCommandHandler(client)
+
+        mock_resp = AsyncMock()
+        mock_resp.status = 200
+        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
+        mock_resp.__aexit__ = AsyncMock(return_value=False)
+
+        async def mock_dashboard() -> None:
+            await client.send_message("<b>🖥️ Dashboard</b>\n\nURL: http://127.0.0.1:8080")
+
+        handler.register_command("dashboard", mock_dashboard)
+
+        with patch("aiohttp.ClientSession.post", return_value=mock_resp) as mock_post:
+            await handler._handle_update(
+                {"update_id": 1, "message": {"chat": {"id": 456}, "text": "/dashboard"}}
+            )
+            payload = mock_post.call_args.kwargs["json"]
+            assert "Dashboard" in payload["text"]
+
+
 class TestGetUpdates:
     """Test getUpdates API interaction."""
 

tests/test_volatility.py

@@ -412,7 +412,7 @@ class TestMarketScanner:
         scan_result = context_store.get_context(
             ContextLayer.L7_REALTIME,
             latest_timeframe,
-            "KR_scan_result",
+            "scan_result_KR",
         )
         assert scan_result is not None
         assert scan_result["total_scanned"] == 3