Merge pull request 'feat: implement Volatility Hunter for real-time market scanning' (#25) from feature/issue-20-volatility-hunter into main

Reviewed-on: #25

src/analysis/__init__.py

@@ -0,0 +1,8 @@
+"""Technical analysis and market scanning modules."""
+
+from __future__ import annotations
+
+from src.analysis.scanner import MarketScanner
+from src.analysis.volatility import VolatilityAnalyzer
+
+__all__ = ["VolatilityAnalyzer", "MarketScanner"]

src/analysis/scanner.py

@@ -0,0 +1,237 @@
+"""Real-time market scanner for detecting high-momentum stocks.
+
+Scans all available stocks in a market and ranks by volatility/momentum score.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass
+from typing import Any
+
+from src.analysis.volatility import VolatilityAnalyzer, VolatilityMetrics
+from src.broker.kis_api import KISBroker
+from src.broker.overseas import OverseasBroker
+from src.context.layer import ContextLayer
+from src.context.store import ContextStore
+from src.markets.schedule import MarketInfo
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ScanResult:
+    """Result from a market scan."""
+
+    market_code: str
+    timestamp: str
+    total_scanned: int
+    top_movers: list[VolatilityMetrics]
+    breakouts: list[str]  # Stock codes with breakout patterns
+    breakdowns: list[str]  # Stock codes with breakdown patterns
+
+
+class MarketScanner:
+    """Scans markets for high-volatility, high-momentum stocks."""
+
+    def __init__(
+        self,
+        broker: KISBroker,
+        overseas_broker: OverseasBroker,
+        volatility_analyzer: VolatilityAnalyzer,
+        context_store: ContextStore,
+        top_n: int = 5,
+    ) -> None:
+        """Initialize the market scanner.
+
+        Args:
+            broker: KIS broker instance for domestic market
+            overseas_broker: Overseas broker instance
+            volatility_analyzer: Volatility analyzer instance
+            context_store: Context store for L7 real-time data
+            top_n: Number of top movers to return per market (default 5)
+        """
+        self.broker = broker
+        self.overseas_broker = overseas_broker
+        self.analyzer = volatility_analyzer
+        self.context_store = context_store
+        self.top_n = top_n
+
+    async def scan_stock(
+        self,
+        stock_code: str,
+        market: MarketInfo,
+    ) -> VolatilityMetrics | None:
+        """Scan a single stock for volatility metrics.
+
+        Args:
+            stock_code: Stock code to scan
+            market: Market information
+
+        Returns:
+            VolatilityMetrics if successful, None on error
+        """
+        try:
+            if market.is_domestic:
+                orderbook = await self.broker.get_orderbook(stock_code)
+            else:
+                # For overseas, we need to adapt the price data structure
+                price_data = await self.overseas_broker.get_overseas_price(
+                    market.exchange_code, stock_code
+                )
+                # Convert to orderbook-like structure
+                orderbook = {
+                    "output1": {
+                        "stck_prpr": price_data.get("output", {}).get("last", "0"),
+                        "acml_vol": price_data.get("output", {}).get("tvol", "0"),
+                    }
+                }
+
+            # For now, use empty price history (would need real historical data)
+            # In production, this would fetch from a time-series database or API
+            price_history: dict[str, Any] = {
+                "high": [],
+                "low": [],
+                "close": [],
+                "volume": [],
+            }
+
+            metrics = self.analyzer.analyze(stock_code, orderbook, price_history)
+
+            # Store in L7 real-time layer
+            from datetime import UTC, datetime
+            timeframe = datetime.now(UTC).isoformat()
+            self.context_store.set_context(
+                ContextLayer.L7_REALTIME,
+                timeframe,
+                f"{market.code}_{stock_code}_volatility",
+                {
+                    "price": metrics.current_price,
+                    "atr": metrics.atr,
+                    "price_change_1m": metrics.price_change_1m,
+                    "volume_surge": metrics.volume_surge,
+                    "momentum_score": metrics.momentum_score,
+                },
+            )
+
+            return metrics
+
+        except Exception as exc:
+            logger.warning("Failed to scan %s (%s): %s", stock_code, market.code, exc)
+            return None
+
+    async def scan_market(
+        self,
+        market: MarketInfo,
+        stock_codes: list[str],
+    ) -> ScanResult:
+        """Scan all stocks in a market and rank by momentum.
+
+        Args:
+            market: Market to scan
+            stock_codes: List of stock codes to scan
+
+        Returns:
+            ScanResult with ranked stocks
+        """
+        from datetime import UTC, datetime
+
+        logger.info("Scanning %s market (%d stocks)", market.name, len(stock_codes))
+
+        # Scan all stocks concurrently (with rate limiting handled by broker)
+        tasks = [self.scan_stock(code, market) for code in stock_codes]
+        results = await asyncio.gather(*tasks)
+
+        # Filter out failures and sort by momentum score
+        valid_metrics = [m for m in results if m is not None]
+        valid_metrics.sort(key=lambda m: m.momentum_score, reverse=True)
+
+        # Get top N movers
+        top_movers = valid_metrics[: self.top_n]
+
+        # Detect breakouts and breakdowns
+        breakouts = [
+            m.stock_code for m in valid_metrics if self.analyzer.is_breakout(m)
+        ]
+        breakdowns = [
+            m.stock_code for m in valid_metrics if self.analyzer.is_breakdown(m)
+        ]
+
+        logger.info(
+            "%s scan complete: %d scanned, top momentum=%.1f, %d breakouts, %d breakdowns",
+            market.name,
+            len(valid_metrics),
+            top_movers[0].momentum_score if top_movers else 0.0,
+            len(breakouts),
+            len(breakdowns),
+        )
+
+        # Store scan results in L7
+        timeframe = datetime.now(UTC).isoformat()
+        self.context_store.set_context(
+            ContextLayer.L7_REALTIME,
+            timeframe,
+            f"{market.code}_scan_result",
+            {
+                "total_scanned": len(valid_metrics),
+                "top_movers": [m.stock_code for m in top_movers],
+                "breakouts": breakouts,
+                "breakdowns": breakdowns,
+            },
+        )
+
+        return ScanResult(
+            market_code=market.code,
+            timestamp=timeframe,
+            total_scanned=len(valid_metrics),
+            top_movers=top_movers,
+            breakouts=breakouts,
+            breakdowns=breakdowns,
+        )
+
+    def get_updated_watchlist(
+        self,
+        current_watchlist: list[str],
+        scan_result: ScanResult,
+        max_replacements: int = 2,
+    ) -> list[str]:
+        """Update watchlist by replacing laggards with leaders.
+
+        Args:
+            current_watchlist: Current watchlist
+            scan_result: Recent scan result
+            max_replacements: Maximum stocks to replace per scan
+
+        Returns:
+            Updated watchlist with leaders
+        """
+        # Keep stocks that are in top movers
+        top_codes = [m.stock_code for m in scan_result.top_movers]
+        keepers = [code for code in current_watchlist if code in top_codes]
+
+        # Add new leaders not in current watchlist
+        new_leaders = [code for code in top_codes if code not in current_watchlist]
+
+        # Limit replacements
+        new_leaders = new_leaders[:max_replacements]
+
+        # Create updated watchlist
+        updated = keepers + new_leaders
+
+        # If we removed too many, backfill from current watchlist
+        if len(updated) < len(current_watchlist):
+            backfill = [
+                code for code in current_watchlist
+                if code not in updated
+            ][: len(current_watchlist) - len(updated)]
+            updated.extend(backfill)
+
+        logger.info(
+            "Watchlist updated: %d kept, %d new leaders, %d total",
+            len(keepers),
+            len(new_leaders),
+            len(updated),
+        )
+
+        return updated

src/analysis/volatility.py

@@ -0,0 +1,325 @@
+"""Volatility and momentum analysis for stock selection.
+
+Calculates ATR, price change percentages, volume surges, and price-volume divergence.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class VolatilityMetrics:
+    """Volatility and momentum metrics for a stock."""
+
+    stock_code: str
+    current_price: float
+    atr: float  # Average True Range (14 periods)
+    price_change_1m: float  # 1-minute price change %
+    price_change_5m: float  # 5-minute price change %
+    price_change_15m: float  # 15-minute price change %
+    volume_surge: float  # Volume vs average (ratio)
+    pv_divergence: float  # Price-volume divergence score
+    momentum_score: float  # Combined momentum score (0-100)
+
+    def __repr__(self) -> str:
+        return (
+            f"VolatilityMetrics({self.stock_code}: "
+            f"price={self.current_price:.2f}, "
+            f"atr={self.atr:.2f}, "
+            f"1m={self.price_change_1m:.2f}%, "
+            f"vol_surge={self.volume_surge:.2f}x, "
+            f"momentum={self.momentum_score:.1f})"
+        )
+
+
+class VolatilityAnalyzer:
+    """Analyzes stock volatility and momentum for leader detection."""
+
+    def __init__(self, min_volume_surge: float = 2.0, min_price_change: float = 1.0) -> None:
+        """Initialize the volatility analyzer.
+
+        Args:
+            min_volume_surge: Minimum volume surge ratio (default 2x average)
+            min_price_change: Minimum price change % for breakout (default 1%)
+        """
+        self.min_volume_surge = min_volume_surge
+        self.min_price_change = min_price_change
+
+    def calculate_atr(
+        self,
+        high_prices: list[float],
+        low_prices: list[float],
+        close_prices: list[float],
+        period: int = 14,
+    ) -> float:
+        """Calculate Average True Range (ATR).
+
+        Args:
+            high_prices: List of high prices (most recent last)
+            low_prices: List of low prices (most recent last)
+            close_prices: List of close prices (most recent last)
+            period: ATR period (default 14)
+
+        Returns:
+            ATR value
+        """
+        if (
+            len(high_prices) < period + 1
+            or len(low_prices) < period + 1
+            or len(close_prices) < period + 1
+        ):
+            return 0.0
+
+        true_ranges: list[float] = []
+        for i in range(1, len(high_prices)):
+            high = high_prices[i]
+            low = low_prices[i]
+            prev_close = close_prices[i - 1]
+
+            tr = max(
+                high - low,
+                abs(high - prev_close),
+                abs(low - prev_close),
+            )
+            true_ranges.append(tr)
+
+        if len(true_ranges) < period:
+            return 0.0
+
+        # Simple Moving Average of True Range
+        recent_tr = true_ranges[-period:]
+        return sum(recent_tr) / len(recent_tr)
+
+    def calculate_price_change(
+        self, current_price: float, past_price: float
+    ) -> float:
+        """Calculate price change percentage.
+
+        Args:
+            current_price: Current price
+            past_price: Past price to compare against
+
+        Returns:
+            Price change percentage
+        """
+        if past_price == 0:
+            return 0.0
+        return ((current_price - past_price) / past_price) * 100
+
+    def calculate_volume_surge(
+        self, current_volume: float, avg_volume: float
+    ) -> float:
+        """Calculate volume surge ratio.
+
+        Args:
+            current_volume: Current volume
+            avg_volume: Average volume
+
+        Returns:
+            Volume surge ratio (current / average)
+        """
+        if avg_volume == 0:
+            return 1.0
+        return current_volume / avg_volume
+
+    def calculate_pv_divergence(
+        self,
+        price_change: float,
+        volume_surge: float,
+    ) -> float:
+        """Calculate price-volume divergence score.
+
+        Positive divergence: Price up + Volume up = bullish
+        Negative divergence: Price up + Volume down = bearish
+        Neutral: Price/volume move together moderately
+
+        Args:
+            price_change: Price change percentage
+            volume_surge: Volume surge ratio
+
+        Returns:
+            Divergence score (-100 to +100)
+        """
+        # Normalize volume surge to -1 to +1 scale (1.0 = neutral)
+        volume_signal = (volume_surge - 1.0) * 10  # Scale for sensitivity
+
+        # Calculate divergence
+        # Positive: price and volume move in same direction
+        # Negative: price and volume move in opposite directions
+        if price_change > 0 and volume_surge > 1.0:
+            # Bullish: price up, volume up
+            return min(100.0, price_change * volume_signal)
+        elif price_change < 0 and volume_surge < 1.0:
+            # Bearish confirmation: price down, volume down
+            return max(-100.0, price_change * volume_signal)
+        elif price_change > 0 and volume_surge < 1.0:
+            # Bearish divergence: price up but volume low (weak rally)
+            return -abs(price_change) * 0.5
+        elif price_change < 0 and volume_surge > 1.0:
+            # Selling pressure: price down, volume up
+            return price_change * volume_signal
+        else:
+            return 0.0
+
+    def calculate_momentum_score(
+        self,
+        price_change_1m: float,
+        price_change_5m: float,
+        price_change_15m: float,
+        volume_surge: float,
+        atr: float,
+        current_price: float,
+    ) -> float:
+        """Calculate combined momentum score (0-100).
+
+        Weights:
+        - 1m change: 40%
+        - 5m change: 30%
+        - 15m change: 20%
+        - Volume surge: 10%
+
+        Args:
+            price_change_1m: 1-minute price change %
+            price_change_5m: 5-minute price change %
+            price_change_15m: 15-minute price change %
+            volume_surge: Volume surge ratio
+            atr: Average True Range
+            current_price: Current price
+
+        Returns:
+            Momentum score (0-100)
+        """
+        # Weight recent changes more heavily
+        weighted_change = (
+            price_change_1m * 0.4 +
+            price_change_5m * 0.3 +
+            price_change_15m * 0.2
+        )
+
+        # Volume contribution (normalized to 0-10 scale)
+        volume_contribution = min(10.0, (volume_surge - 1.0) * 5.0)
+
+        # Volatility bonus: higher ATR = higher potential (normalized)
+        volatility_bonus = 0.0
+        if current_price > 0:
+            atr_pct = (atr / current_price) * 100
+            volatility_bonus = min(10.0, atr_pct)
+
+        # Combine scores
+        raw_score = weighted_change + volume_contribution + volatility_bonus
+
+        # Normalize to 0-100 scale
+        # Assume typical momentum range is -10 to +30
+        normalized = ((raw_score + 10) / 40) * 100
+
+        return max(0.0, min(100.0, normalized))
+
+    def analyze(
+        self,
+        stock_code: str,
+        orderbook_data: dict[str, Any],
+        price_history: dict[str, Any],
+    ) -> VolatilityMetrics:
+        """Analyze volatility and momentum for a stock.
+
+        Args:
+            stock_code: Stock code
+            orderbook_data: Current orderbook/quote data
+            price_history: Historical price and volume data
+
+        Returns:
+            VolatilityMetrics with calculated indicators
+        """
+        # Extract current data from orderbook
+        output1 = orderbook_data.get("output1", {})
+        current_price = float(output1.get("stck_prpr", 0))
+        current_volume = float(output1.get("acml_vol", 0))
+
+        # Extract historical data
+        high_prices = price_history.get("high", [])
+        low_prices = price_history.get("low", [])
+        close_prices = price_history.get("close", [])
+        volumes = price_history.get("volume", [])
+
+        # Calculate ATR
+        atr = self.calculate_atr(high_prices, low_prices, close_prices)
+
+        # Calculate price changes (use historical data if available)
+        price_change_1m = 0.0
+        price_change_5m = 0.0
+        price_change_15m = 0.0
+
+        if len(close_prices) > 0:
+            if len(close_prices) >= 1:
+                price_change_1m = self.calculate_price_change(
+                    current_price, close_prices[-1]
+                )
+            if len(close_prices) >= 5:
+                price_change_5m = self.calculate_price_change(
+                    current_price, close_prices[-5]
+                )
+            if len(close_prices) >= 15:
+                price_change_15m = self.calculate_price_change(
+                    current_price, close_prices[-15]
+                )
+
+        # Calculate volume surge
+        avg_volume = sum(volumes) / len(volumes) if volumes else current_volume
+        volume_surge = self.calculate_volume_surge(current_volume, avg_volume)
+
+        # Calculate price-volume divergence
+        pv_divergence = self.calculate_pv_divergence(price_change_1m, volume_surge)
+
+        # Calculate momentum score
+        momentum_score = self.calculate_momentum_score(
+            price_change_1m,
+            price_change_5m,
+            price_change_15m,
+            volume_surge,
+            atr,
+            current_price,
+        )
+
+        return VolatilityMetrics(
+            stock_code=stock_code,
+            current_price=current_price,
+            atr=atr,
+            price_change_1m=price_change_1m,
+            price_change_5m=price_change_5m,
+            price_change_15m=price_change_15m,
+            volume_surge=volume_surge,
+            pv_divergence=pv_divergence,
+            momentum_score=momentum_score,
+        )
+
+    def is_breakout(self, metrics: VolatilityMetrics) -> bool:
+        """Determine if a stock is experiencing a breakout.
+
+        Args:
+            metrics: Volatility metrics for the stock
+
+        Returns:
+            True if breakout conditions are met
+        """
+        return (
+            metrics.price_change_1m >= self.min_price_change
+            and metrics.volume_surge >= self.min_volume_surge
+            and metrics.pv_divergence > 0  # Bullish divergence
+        )
+
+    def is_breakdown(self, metrics: VolatilityMetrics) -> bool:
+        """Determine if a stock is experiencing a breakdown.
+
+        Args:
+            metrics: Volatility metrics for the stock
+
+        Returns:
+            True if breakdown conditions are met
+        """
+        return (
+            metrics.price_change_1m <= -self.min_price_change
+            and metrics.volume_surge >= self.min_volume_surge
+            and metrics.pv_divergence < 0  # Bearish divergence
+        )

src/main.py

@@ -13,10 +13,13 @@ import signal
 from datetime import UTC, datetime
 from typing import Any
 
+from src.analysis.scanner import MarketScanner
+from src.analysis.volatility import VolatilityAnalyzer
 from src.brain.gemini_client import GeminiClient
 from src.broker.kis_api import KISBroker
 from src.broker.overseas import OverseasBroker
 from src.config import Settings
+from src.context.store import ContextStore
 from src.core.risk_manager import CircuitBreakerTripped, RiskManager
 from src.db import init_db, log_trade
 from src.logging.decision_logger import DecisionLogger
@@ -34,8 +37,18 @@ WATCHLISTS = {
 }
 
 TRADE_INTERVAL_SECONDS = 60
+SCAN_INTERVAL_SECONDS = 60  # Scan markets every 60 seconds
 MAX_CONNECTION_RETRIES = 3
 
+# Full stock universe per market (for scanning)
+# In production, this would be loaded from a database or API
+STOCK_UNIVERSE = {
+    "KR": ["005930", "000660", "035420", "051910", "005380", "005490"],
+    "US_NASDAQ": ["AAPL", "MSFT", "GOOGL", "AMZN", "NVDA", "TSLA"],
+    "US_NYSE": ["JPM", "BAC", "XOM", "JNJ", "V"],
+    "JP": ["7203", "6758", "9984", "6861"],
+}
+
 
 async def trading_cycle(
     broker: KISBroker,
@@ -187,6 +200,20 @@ async def run(settings: Settings) -> None:
     risk = RiskManager(settings)
     db_conn = init_db(settings.DB_PATH)
     decision_logger = DecisionLogger(db_conn)
+    context_store = ContextStore(db_conn)
+
+    # Initialize volatility hunter
+    volatility_analyzer = VolatilityAnalyzer(min_volume_surge=2.0, min_price_change=1.0)
+    market_scanner = MarketScanner(
+        broker=broker,
+        overseas_broker=overseas_broker,
+        volatility_analyzer=volatility_analyzer,
+        context_store=context_store,
+        top_n=5,
+    )
+
+    # Track last scan time for each market
+    last_scan_time: dict[str, float] = {}
 
     shutdown = asyncio.Event()
 
@@ -232,6 +259,39 @@ async def run(settings: Settings) -> None:
                 if shutdown.is_set():
                     break
 
+                # Volatility Hunter: Scan market periodically to update watchlist
+                now_timestamp = asyncio.get_event_loop().time()
+                last_scan = last_scan_time.get(market.code, 0.0)
+                if now_timestamp - last_scan >= SCAN_INTERVAL_SECONDS:
+                    try:
+                        # Scan all stocks in the universe
+                        stock_universe = STOCK_UNIVERSE.get(market.code, [])
+                        if stock_universe:
+                            logger.info("Volatility Hunter: Scanning %s market", market.name)
+                            scan_result = await market_scanner.scan_market(
+                                market, stock_universe
+                            )
+
+                            # Update watchlist with top movers
+                            current_watchlist = WATCHLISTS.get(market.code, [])
+                            updated_watchlist = market_scanner.get_updated_watchlist(
+                                current_watchlist,
+                                scan_result,
+                                max_replacements=2,
+                            )
+                            WATCHLISTS[market.code] = updated_watchlist
+
+                            logger.info(
+                                "Volatility Hunter: Watchlist updated for %s (%d top movers, %d breakouts)",
+                                market.name,
+                                len(scan_result.top_movers),
+                                len(scan_result.breakouts),
+                            )
+
+                        last_scan_time[market.code] = now_timestamp
+                    except Exception as exc:
+                        logger.error("Volatility Hunter scan failed for %s: %s", market.name, exc)
+
                 # Get watchlist for this market
                 watchlist = WATCHLISTS.get(market.code, [])
                 if not watchlist:

tests/test_volatility.py

@@ -0,0 +1,511 @@
+"""Tests for volatility analysis and market scanning."""
+
+from __future__ import annotations
+
+import sqlite3
+from typing import Any
+from unittest.mock import AsyncMock
+
+import pytest
+
+from src.analysis.scanner import MarketScanner, ScanResult
+from src.analysis.volatility import VolatilityAnalyzer, VolatilityMetrics
+from src.broker.kis_api import KISBroker
+from src.broker.overseas import OverseasBroker
+from src.config import Settings
+from src.context.layer import ContextLayer
+from src.context.store import ContextStore
+from src.db import init_db
+from src.markets.schedule import MARKETS
+
+
+@pytest.fixture
+def db_conn() -> sqlite3.Connection:
+    """Provide an in-memory database connection."""
+    return init_db(":memory:")
+
+
+@pytest.fixture
+def context_store(db_conn: sqlite3.Connection) -> ContextStore:
+    """Provide a ContextStore instance."""
+    return ContextStore(db_conn)
+
+
+@pytest.fixture
+def volatility_analyzer() -> VolatilityAnalyzer:
+    """Provide a VolatilityAnalyzer instance."""
+    return VolatilityAnalyzer(min_volume_surge=2.0, min_price_change=1.0)
+
+
+@pytest.fixture
+def mock_settings() -> Settings:
+    """Provide mock settings for broker initialization."""
+    return Settings(
+        KIS_APP_KEY="test_key",
+        KIS_APP_SECRET="test_secret",
+        KIS_ACCOUNT_NO="12345678-01",
+        GEMINI_API_KEY="test_gemini_key",
+    )
+
+
+@pytest.fixture
+def mock_broker(mock_settings: Settings) -> KISBroker:
+    """Provide a mock KIS broker."""
+    broker = KISBroker(mock_settings)
+    broker.get_orderbook = AsyncMock()  # type: ignore[method-assign]
+    return broker
+
+
+@pytest.fixture
+def mock_overseas_broker(mock_broker: KISBroker) -> OverseasBroker:
+    """Provide a mock overseas broker."""
+    overseas = OverseasBroker(mock_broker)
+    overseas.get_overseas_price = AsyncMock()  # type: ignore[method-assign]
+    return overseas
+
+
+class TestVolatilityAnalyzer:
+    """Test suite for VolatilityAnalyzer."""
+
+    def test_calculate_atr(self, volatility_analyzer: VolatilityAnalyzer) -> None:
+        """Test ATR calculation."""
+        high_prices = [110.0, 112.0, 115.0, 113.0, 116.0] + [120.0] * 10
+        low_prices = [105.0, 107.0, 110.0, 108.0, 111.0] + [115.0] * 10
+        close_prices = [108.0, 110.0, 112.0, 111.0, 114.0] + [118.0] * 10
+
+        atr = volatility_analyzer.calculate_atr(high_prices, low_prices, close_prices, period=14)
+
+        assert atr > 0.0
+        # ATR should be roughly the average true range
+        assert 3.0 <= atr <= 6.0
+
+    def test_calculate_atr_insufficient_data(
+        self, volatility_analyzer: VolatilityAnalyzer
+    ) -> None:
+        """Test ATR with insufficient data returns 0."""
+        high_prices = [110.0, 112.0]
+        low_prices = [105.0, 107.0]
+        close_prices = [108.0, 110.0]
+
+        atr = volatility_analyzer.calculate_atr(high_prices, low_prices, close_prices, period=14)
+
+        assert atr == 0.0
+
+    def test_calculate_price_change(self, volatility_analyzer: VolatilityAnalyzer) -> None:
+        """Test price change percentage calculation."""
+        # 10% increase
+        change = volatility_analyzer.calculate_price_change(110.0, 100.0)
+        assert change == pytest.approx(10.0)
+
+        # 5% decrease
+        change = volatility_analyzer.calculate_price_change(95.0, 100.0)
+        assert change == pytest.approx(-5.0)
+
+        # Zero past price
+        change = volatility_analyzer.calculate_price_change(100.0, 0.0)
+        assert change == 0.0
+
+    def test_calculate_volume_surge(self, volatility_analyzer: VolatilityAnalyzer) -> None:
+        """Test volume surge ratio calculation."""
+        # 2x surge
+        surge = volatility_analyzer.calculate_volume_surge(2000.0, 1000.0)
+        assert surge == pytest.approx(2.0)
+
+        # Below average
+        surge = volatility_analyzer.calculate_volume_surge(500.0, 1000.0)
+        assert surge == pytest.approx(0.5)
+
+        # Zero average
+        surge = volatility_analyzer.calculate_volume_surge(1000.0, 0.0)
+        assert surge == 1.0
+
+    def test_calculate_pv_divergence_bullish(
+        self, volatility_analyzer: VolatilityAnalyzer
+    ) -> None:
+        """Test bullish price-volume divergence."""
+        # Price up + Volume up = bullish
+        divergence = volatility_analyzer.calculate_pv_divergence(5.0, 2.0)
+        assert divergence > 0.0
+
+    def test_calculate_pv_divergence_bearish(
+        self, volatility_analyzer: VolatilityAnalyzer
+    ) -> None:
+        """Test bearish price-volume divergence."""
+        # Price up + Volume down = bearish divergence
+        divergence = volatility_analyzer.calculate_pv_divergence(5.0, 0.5)
+        assert divergence < 0.0
+
+    def test_calculate_pv_divergence_selling_pressure(
+        self, volatility_analyzer: VolatilityAnalyzer
+    ) -> None:
+        """Test selling pressure detection."""
+        # Price down + Volume up = selling pressure
+        divergence = volatility_analyzer.calculate_pv_divergence(-5.0, 2.0)
+        assert divergence < 0.0
+
+    def test_calculate_momentum_score(
+        self, volatility_analyzer: VolatilityAnalyzer
+    ) -> None:
+        """Test momentum score calculation."""
+        score = volatility_analyzer.calculate_momentum_score(
+            price_change_1m=5.0,
+            price_change_5m=3.0,
+            price_change_15m=2.0,
+            volume_surge=2.5,
+            atr=1.5,
+            current_price=100.0,
+        )
+
+        assert 0.0 <= score <= 100.0
+        assert score > 50.0  # Should be high for strong positive momentum
+
+    def test_calculate_momentum_score_negative(
+        self, volatility_analyzer: VolatilityAnalyzer
+    ) -> None:
+        """Test momentum score with negative price changes."""
+        score = volatility_analyzer.calculate_momentum_score(
+            price_change_1m=-5.0,
+            price_change_5m=-3.0,
+            price_change_15m=-2.0,
+            volume_surge=1.0,
+            atr=1.0,
+            current_price=100.0,
+        )
+
+        assert 0.0 <= score <= 100.0
+        assert score < 50.0  # Should be low for negative momentum
+
+    def test_analyze(self, volatility_analyzer: VolatilityAnalyzer) -> None:
+        """Test full analysis of a stock."""
+        orderbook_data = {
+            "output1": {
+                "stck_prpr": "50000",
+                "acml_vol": "1000000",
+            }
+        }
+
+        price_history = {
+            "high": [51000.0] * 20,
+            "low": [49000.0] * 20,
+            "close": [48000.0] + [50000.0] * 19,
+            "volume": [500000.0] * 20,
+        }
+
+        metrics = volatility_analyzer.analyze("005930", orderbook_data, price_history)
+
+        assert metrics.stock_code == "005930"
+        assert metrics.current_price == 50000.0
+        assert metrics.atr > 0.0
+        assert metrics.volume_surge == pytest.approx(2.0)  # 1M / 500K
+        assert 0.0 <= metrics.momentum_score <= 100.0
+
+    def test_is_breakout(self, volatility_analyzer: VolatilityAnalyzer) -> None:
+        """Test breakout detection."""
+        # Strong breakout
+        metrics = VolatilityMetrics(
+            stock_code="005930",
+            current_price=50000.0,
+            atr=500.0,
+            price_change_1m=2.5,
+            price_change_5m=3.0,
+            price_change_15m=4.0,
+            volume_surge=3.0,
+            pv_divergence=50.0,
+            momentum_score=85.0,
+        )
+
+        assert volatility_analyzer.is_breakout(metrics) is True
+
+    def test_is_breakout_no_volume(self, volatility_analyzer: VolatilityAnalyzer) -> None:
+        """Test that breakout requires volume confirmation."""
+        # Price up but no volume = not a real breakout
+        metrics = VolatilityMetrics(
+            stock_code="005930",
+            current_price=50000.0,
+            atr=500.0,
+            price_change_1m=2.5,
+            price_change_5m=3.0,
+            price_change_15m=4.0,
+            volume_surge=1.2,  # Below threshold
+            pv_divergence=10.0,
+            momentum_score=70.0,
+        )
+
+        assert volatility_analyzer.is_breakout(metrics) is False
+
+    def test_is_breakdown(self, volatility_analyzer: VolatilityAnalyzer) -> None:
+        """Test breakdown detection."""
+        # Strong breakdown
+        metrics = VolatilityMetrics(
+            stock_code="005930",
+            current_price=50000.0,
+            atr=500.0,
+            price_change_1m=-2.5,
+            price_change_5m=-3.0,
+            price_change_15m=-4.0,
+            volume_surge=3.0,
+            pv_divergence=-50.0,
+            momentum_score=15.0,
+        )
+
+        assert volatility_analyzer.is_breakdown(metrics) is True
+
+    def test_volatility_metrics_repr(self) -> None:
+        """Test VolatilityMetrics string representation."""
+        metrics = VolatilityMetrics(
+            stock_code="005930",
+            current_price=50000.0,
+            atr=500.0,
+            price_change_1m=2.5,
+            price_change_5m=3.0,
+            price_change_15m=4.0,
+            volume_surge=3.0,
+            pv_divergence=50.0,
+            momentum_score=85.0,
+        )
+
+        repr_str = repr(metrics)
+        assert "005930" in repr_str
+        assert "50000.00" in repr_str
+        assert "2.50%" in repr_str
+
+
+class TestMarketScanner:
+    """Test suite for MarketScanner."""
+
+    @pytest.fixture
+    def scanner(
+        self,
+        mock_broker: KISBroker,
+        mock_overseas_broker: OverseasBroker,
+        volatility_analyzer: VolatilityAnalyzer,
+        context_store: ContextStore,
+    ) -> MarketScanner:
+        """Provide a MarketScanner instance."""
+        return MarketScanner(
+            broker=mock_broker,
+            overseas_broker=mock_overseas_broker,
+            volatility_analyzer=volatility_analyzer,
+            context_store=context_store,
+            top_n=5,
+        )
+
+    @pytest.mark.asyncio
+    async def test_scan_stock_domestic(
+        self,
+        scanner: MarketScanner,
+        mock_broker: KISBroker,
+        context_store: ContextStore,
+    ) -> None:
+        """Test scanning a domestic stock."""
+        mock_broker.get_orderbook.return_value = {
+            "output1": {
+                "stck_prpr": "50000",
+                "acml_vol": "1000000",
+            }
+        }
+
+        market = MARKETS["KR"]
+        metrics = await scanner.scan_stock("005930", market)
+
+        assert metrics is not None
+        assert metrics.stock_code == "005930"
+        assert metrics.current_price == 50000.0
+
+        # Verify L7 context was stored
+        latest_timeframe = context_store.get_latest_timeframe(ContextLayer.L7_REALTIME)
+        assert latest_timeframe is not None
+
+    @pytest.mark.asyncio
+    async def test_scan_stock_overseas(
+        self,
+        scanner: MarketScanner,
+        mock_overseas_broker: OverseasBroker,
+        context_store: ContextStore,
+    ) -> None:
+        """Test scanning an overseas stock."""
+        mock_overseas_broker.get_overseas_price.return_value = {
+            "output": {
+                "last": "150.50",
+                "tvol": "5000000",
+            }
+        }
+
+        market = MARKETS["US_NASDAQ"]
+        metrics = await scanner.scan_stock("AAPL", market)
+
+        assert metrics is not None
+        assert metrics.stock_code == "AAPL"
+        assert metrics.current_price == 150.50
+
+    @pytest.mark.asyncio
+    async def test_scan_stock_error_handling(
+        self,
+        scanner: MarketScanner,
+        mock_broker: KISBroker,
+    ) -> None:
+        """Test that scan_stock handles errors gracefully."""
+        mock_broker.get_orderbook.side_effect = Exception("Network error")
+
+        market = MARKETS["KR"]
+        metrics = await scanner.scan_stock("005930", market)
+
+        assert metrics is None  # Should return None on error, not crash
+
+    @pytest.mark.asyncio
+    async def test_scan_market(
+        self,
+        scanner: MarketScanner,
+        mock_broker: KISBroker,
+        context_store: ContextStore,
+    ) -> None:
+        """Test scanning a full market."""
+
+        def mock_orderbook(stock_code: str) -> dict[str, Any]:
+            """Generate mock orderbook with varying prices."""
+            base_price = int(stock_code) if stock_code.isdigit() else 50000
+            return {
+                "output1": {
+                    "stck_prpr": str(base_price),
+                    "acml_vol": str(base_price * 20),  # Volume proportional to price
+                }
+            }
+
+        mock_broker.get_orderbook.side_effect = mock_orderbook
+
+        market = MARKETS["KR"]
+        stock_codes = ["005930", "000660", "035420"]
+
+        result = await scanner.scan_market(market, stock_codes)
+
+        assert result.market_code == "KR"
+        assert result.total_scanned == 3
+        assert len(result.top_movers) <= 5
+        assert all(isinstance(m, VolatilityMetrics) for m in result.top_movers)
+
+        # Verify scan result was stored in L7
+        latest_timeframe = context_store.get_latest_timeframe(ContextLayer.L7_REALTIME)
+        assert latest_timeframe is not None
+        scan_result = context_store.get_context(
+            ContextLayer.L7_REALTIME,
+            latest_timeframe,
+            "KR_scan_result",
+        )
+        assert scan_result is not None
+        assert scan_result["total_scanned"] == 3
+
+    @pytest.mark.asyncio
+    async def test_scan_market_with_breakouts(
+        self,
+        scanner: MarketScanner,
+        mock_broker: KISBroker,
+    ) -> None:
+        """Test that scan detects breakouts."""
+        # Mock strong price increase with volume
+        mock_broker.get_orderbook.return_value = {
+            "output1": {
+                "stck_prpr": "55000",  # High price
+                "acml_vol": "5000000",  # High volume
+            }
+        }
+
+        market = MARKETS["KR"]
+        stock_codes = ["005930"]
+
+        result = await scanner.scan_market(market, stock_codes)
+
+        # With high volume and price, might detect breakouts
+        # (depends on price history which is empty in this test)
+        assert isinstance(result.breakouts, list)
+        assert isinstance(result.breakdowns, list)
+
+    def test_get_updated_watchlist(self, scanner: MarketScanner) -> None:
+        """Test watchlist update logic."""
+        current_watchlist = ["005930", "000660", "035420"]
+
+        # Create scan result with new leaders
+        top_movers = [
+            VolatilityMetrics("005930", 50000, 500, 2.0, 3.0, 4.0, 3.0, 50.0, 90.0),
+            VolatilityMetrics("005380", 48000, 480, 1.8, 2.5, 3.0, 2.8, 45.0, 85.0),
+            VolatilityMetrics("005490", 46000, 460, 1.5, 2.0, 2.5, 2.5, 40.0, 80.0),
+        ]
+
+        scan_result = ScanResult(
+            market_code="KR",
+            timestamp="2026-02-04T10:00:00",
+            total_scanned=10,
+            top_movers=top_movers,
+            breakouts=["005380"],
+            breakdowns=[],
+        )
+
+        updated = scanner.get_updated_watchlist(
+            current_watchlist,
+            scan_result,
+            max_replacements=2,
+        )
+
+        assert "005930" in updated  # Should keep existing top mover
+        assert "005380" in updated  # Should add new leader
+        assert len(updated) == len(current_watchlist)  # Should maintain size
+
+    def test_get_updated_watchlist_all_keepers(self, scanner: MarketScanner) -> None:
+        """Test watchlist when all current stocks are still top movers."""
+        current_watchlist = ["005930", "000660", "035420"]
+
+        top_movers = [
+            VolatilityMetrics("005930", 50000, 500, 2.0, 3.0, 4.0, 3.0, 50.0, 90.0),
+            VolatilityMetrics("000660", 48000, 480, 1.8, 2.5, 3.0, 2.8, 45.0, 85.0),
+            VolatilityMetrics("035420", 46000, 460, 1.5, 2.0, 2.5, 2.5, 40.0, 80.0),
+        ]
+
+        scan_result = ScanResult(
+            market_code="KR",
+            timestamp="2026-02-04T10:00:00",
+            total_scanned=10,
+            top_movers=top_movers,
+            breakouts=[],
+            breakdowns=[],
+        )
+
+        updated = scanner.get_updated_watchlist(
+            current_watchlist,
+            scan_result,
+            max_replacements=2,
+        )
+
+        # Should keep all current stocks since they're all in top movers
+        assert set(updated) == set(current_watchlist)
+
+    def test_get_updated_watchlist_max_replacements(
+        self, scanner: MarketScanner
+    ) -> None:
+        """Test that max_replacements limit is respected."""
+        current_watchlist = ["000660", "035420", "005490"]
+
+        # All new leaders (none in current watchlist)
+        top_movers = [
+            VolatilityMetrics("005930", 50000, 500, 2.0, 3.0, 4.0, 3.0, 50.0, 90.0),
+            VolatilityMetrics("005380", 48000, 480, 1.8, 2.5, 3.0, 2.8, 45.0, 85.0),
+            VolatilityMetrics("035720", 46000, 460, 1.5, 2.0, 2.5, 2.5, 40.0, 80.0),
+        ]
+
+        scan_result = ScanResult(
+            market_code="KR",
+            timestamp="2026-02-04T10:00:00",
+            total_scanned=10,
+            top_movers=top_movers,
+            breakouts=[],
+            breakdowns=[],
+        )
+
+        updated = scanner.get_updated_watchlist(
+            current_watchlist,
+            scan_result,
+            max_replacements=1,  # Only allow 1 replacement
+        )
+
+        # Should add at most 1 new leader
+        new_additions = [code for code in updated if code not in current_watchlist]
+        assert len(new_additions) <= 1
+        assert len(updated) == len(current_watchlist)