Merge pull request 'fix: 로그 WARNING 2종 수정 - scanner 오해 메시지 및 홀딩 종목 rsi 누락 (#267)' (#268) from feature/issue-267-fix-log-warnings into main

Reviewed-on: #268

scripts/run_overnight.sh

@@ -23,7 +23,7 @@ if [ -z "${APP_CMD:-}" ]; then
 
     dashboard_port="${DASHBOARD_PORT:-8080}"
 
-    APP_CMD="DASHBOARD_PORT=$dashboard_port $PYTHON_BIN -m src.main --mode=paper --dashboard"
+    APP_CMD="DASHBOARD_PORT=$dashboard_port $PYTHON_BIN -m src.main --mode=live --dashboard"
 fi
 
 mkdir -p "$LOG_DIR"

src/broker/overseas.py

@@ -121,6 +121,7 @@ class OverseasBroker:
             tr_id = self._broker._settings.OVERSEAS_RANKING_VOLUME_TR_ID
             path = self._broker._settings.OVERSEAS_RANKING_VOLUME_PATH
             params: dict[str, str] = {
+                "KEYB": "",  # NEXT KEY BUFF — Required, 공백
                 "AUTH": "",
                 "EXCD": ranking_excd,
                 "MIXN": "0",
@@ -130,10 +131,11 @@ class OverseasBroker:
             tr_id = self._broker._settings.OVERSEAS_RANKING_FLUCT_TR_ID
             path = self._broker._settings.OVERSEAS_RANKING_FLUCT_PATH
             params = {
+                "KEYB": "",  # NEXT KEY BUFF — Required, 공백
                 "AUTH": "",
                 "EXCD": ranking_excd,
                 "NDAY": "0",
-                "GUBN": "0",  # 0=전체(상승+하락), 1=상승만 — 변동성 스캐너는 전체 필요
+                "GUBN": "1",  # 0=하락율, 1=상승율 — 변동성 스캐너는 급등 종목 우선
                 "VOL_RANG": "0",
             }
 
@@ -220,6 +222,59 @@ class OverseasBroker:
                 f"Network error fetching overseas balance: {exc}"
             ) from exc
 
+    async def get_overseas_buying_power(
+        self,
+        exchange_code: str,
+        stock_code: str,
+        price: float,
+    ) -> dict[str, Any]:
+        """
+        Fetch overseas buying power for a specific stock and price.
+
+        Args:
+            exchange_code: Exchange code (e.g., "NASD", "NYSE")
+            stock_code: Stock ticker symbol
+            price: Current stock price (used for quantity calculation)
+
+        Returns:
+            API response; key field: output.ord_psbl_frcr_amt (주문가능외화금액)
+
+        Raises:
+            ConnectionError: On network or API errors
+        """
+        await self._broker._rate_limiter.acquire()
+        session = self._broker._get_session()
+
+        # TR_ID: 실전 TTTS3007R, 모의 VTTS3007R
+        # Source: 한국투자증권 오픈API 전체문서 (20260221) — '해외주식 매수가능금액조회' 시트
+        ps_tr_id = (
+            "TTTS3007R" if self._broker._settings.MODE == "live" else "VTTS3007R"
+        )
+        headers = await self._broker._auth_headers(ps_tr_id)
+        params = {
+            "CANO": self._broker._account_no,
+            "ACNT_PRDT_CD": self._broker._product_cd,
+            "OVRS_EXCG_CD": exchange_code,
+            "OVRS_ORD_UNPR": f"{price:.2f}",
+            "ITEM_CD": stock_code,
+        }
+        url = (
+            f"{self._broker._base_url}/uapi/overseas-stock/v1/trading/inquire-psamount"
+        )
+
+        try:
+            async with session.get(url, headers=headers, params=params) as resp:
+                if resp.status != 200:
+                    text = await resp.text()
+                    raise ConnectionError(
+                        f"get_overseas_buying_power failed ({resp.status}): {text}"
+                    )
+                return await resp.json()
+        except (TimeoutError, aiohttp.ClientError) as exc:
+            raise ConnectionError(
+                f"Network error fetching overseas buying power: {exc}"
+            ) from exc
+
     async def send_overseas_order(
         self,
         exchange_code: str,

src/db.py

@@ -254,10 +254,11 @@ def get_open_position(
     """Return open position if latest trade is BUY, else None."""
     cursor = conn.execute(
         """
-        SELECT action, decision_id, price, quantity
+        SELECT action, decision_id, price, quantity, timestamp
         FROM trades
         WHERE stock_code = ?
           AND market = ?
+          AND action IN ('BUY', 'SELL')
         ORDER BY timestamp DESC
         LIMIT 1
         """,
@@ -266,7 +267,7 @@ def get_open_position(
     row = cursor.fetchone()
     if not row or row[0] != "BUY":
         return None
-    return {"decision_id": row[1], "price": row[2], "quantity": row[3]}
+    return {"decision_id": row[1], "price": row[2], "quantity": row[3], "timestamp": row[4]}
 
 
 def get_recent_symbols(

src/main.py

@@ -182,6 +182,9 @@ async def sync_positions_from_broker(
             qty = _extract_held_qty_from_balance(
                 balance_data, stock_code, is_domestic=market.is_domestic
             )
+            avg_price = _extract_avg_price_from_balance(
+                balance_data, stock_code, is_domestic=market.is_domestic
+            )
             log_trade(
                 conn=db_conn,
                 stock_code=stock_code,
@@ -189,7 +192,7 @@ async def sync_positions_from_broker(
                 confidence=0,
                 rationale="[startup-sync] Position detected from broker at startup",
                 quantity=qty,
-                price=0.0,
+                price=avg_price,
                 market=log_market,
                 exchange_code=market.exchange_code,
                 mode=settings.MODE,
@@ -321,6 +324,37 @@ def _extract_held_qty_from_balance(
     return 0
 
 
+def _extract_avg_price_from_balance(
+    balance_data: dict[str, Any],
+    stock_code: str,
+    *,
+    is_domestic: bool,
+) -> float:
+    """Extract the broker-reported average purchase price for a stock.
+
+    Uses ``pchs_avg_pric`` (매입평균가격) from the balance response (output1).
+    Returns 0.0 when absent so callers can use ``if price > 0`` as sentinel.
+
+    Domestic fields (VTTC8434R output1):  pdno, pchs_avg_pric
+    Overseas fields (VTTS3012R output1):  ovrs_pdno, pchs_avg_pric
+    """
+    output1 = balance_data.get("output1", [])
+    if isinstance(output1, dict):
+        output1 = [output1]
+    if not isinstance(output1, list):
+        return 0.0
+
+    for holding in output1:
+        if not isinstance(holding, dict):
+            continue
+        code_key = "pdno" if is_domestic else "ovrs_pdno"
+        held_code = str(holding.get(code_key, "")).strip().upper()
+        if held_code != stock_code.strip().upper():
+            continue
+        return safe_float(holding.get("pchs_avg_pric"), 0.0)
+    return 0.0
+
+
 def _determine_order_quantity(
     *,
     action: str,
@@ -443,6 +477,7 @@ async def trading_cycle(
     cycle_start_time = asyncio.get_event_loop().time()
 
     # 1. Fetch market data
+    price_output: dict[str, Any] = {}  # Populated for overseas markets; used for fallback metrics
     if market.is_domestic:
         current_price, price_change_pct, foreigner_net = await broker.get_current_price(
             stock_code
@@ -474,9 +509,44 @@ async def trading_cycle(
             balance_info = {}
 
         total_eval = safe_float(balance_info.get("frcr_evlu_tota", "0") or "0")
-        total_cash = safe_float(balance_info.get("frcr_dncl_amt_2", "0") or "0")
         purchase_total = safe_float(balance_info.get("frcr_buy_amt_smtl", "0") or "0")
 
+        # Resolve current price first (needed for buying power API)
+        price_output = price_data.get("output", {})
+        current_price = safe_float(price_output.get("last", "0"))
+        if current_price <= 0:
+            market_candidates_lookup = scan_candidates.get(market.code, {})
+            cand_lookup = market_candidates_lookup.get(stock_code)
+            if cand_lookup and cand_lookup.price > 0:
+                logger.debug(
+                    "Price API returned 0 for %s; using scanner candidate price %.4f",
+                    stock_code,
+                    cand_lookup.price,
+                )
+                current_price = cand_lookup.price
+        foreigner_net = 0.0  # Not available for overseas
+        price_change_pct = safe_float(price_output.get("rate", "0"))
+
+        # Fetch available foreign currency cash via inquire-psamount (TTTS3007R/VTTS3007R).
+        # TTTS3012R output2 does not include a cash/deposit field — frcr_dncl_amt_2 does not exist.
+        # Source: 한국투자증권 오픈API 전체문서 (20260221) — '해외주식 매수가능금액조회' 시트
+        total_cash = 0.0
+        if current_price > 0:
+            try:
+                ps_data = await overseas_broker.get_overseas_buying_power(
+                    market.exchange_code, stock_code, current_price
+                )
+                total_cash = safe_float(
+                    ps_data.get("output", {}).get("ord_psbl_frcr_amt", "0") or "0"
+                )
+            except ConnectionError as exc:
+                logger.warning(
+                    "Could not fetch overseas buying power for %s/%s: %s",
+                    market.exchange_code,
+                    stock_code,
+                    exc,
+                )
+
         # Paper mode fallback: VTS overseas balance API often fails for many accounts.
         # Only activate in paper mode — live mode must use real balance from KIS.
         if (
@@ -492,34 +562,6 @@ async def trading_cycle(
             )
             total_cash = settings.PAPER_OVERSEAS_CASH
 
-        current_price = safe_float(price_data.get("output", {}).get("last", "0"))
-        # Fallback: if price API returns 0, use scanner candidate price
-        if current_price <= 0:
-            market_candidates_lookup = scan_candidates.get(market.code, {})
-            cand_lookup = market_candidates_lookup.get(stock_code)
-            if cand_lookup and cand_lookup.price > 0:
-                logger.debug(
-                    "Price API returned 0 for %s; using scanner candidate price %.4f",
-                    stock_code,
-                    cand_lookup.price,
-                )
-                current_price = cand_lookup.price
-        foreigner_net = 0.0  # Not available for overseas
-        price_change_pct = safe_float(price_data.get("output", {}).get("rate", "0"))
-
-        # Price API may return 0/empty for certain VTS exchange codes.
-        # Fall back to the scanner candidate's price so order sizing still works.
-        if current_price <= 0:
-            market_candidates_lookup = scan_candidates.get(market.code, {})
-            cand_lookup = market_candidates_lookup.get(stock_code)
-            if cand_lookup and cand_lookup.price > 0:
-                current_price = cand_lookup.price
-                logger.debug(
-                    "Price API returned 0 for %s; using scanner price %.4f",
-                    stock_code,
-                    current_price,
-                )
-
     # Calculate daily P&L %
     pnl_pct = (
         ((total_eval - purchase_total) / purchase_total * 100)
@@ -541,6 +583,44 @@ async def trading_cycle(
     if candidate:
         market_data["rsi"] = candidate.rsi
         market_data["volume_ratio"] = candidate.volume_ratio
+    else:
+        # Holding stocks not in scanner: derive metrics from price API data already fetched.
+        # For overseas stocks, price_output contains high/low/rate from get_overseas_price.
+        # For domestic stocks, only price_change_pct is available from get_current_price.
+        market_data["rsi"] = max(0.0, min(100.0, 50.0 + price_change_pct * 2.0))
+        if price_output and current_price > 0:
+            pr_high = safe_float(
+                price_output.get("high") or price_output.get("ovrs_hgpr")
+                or price_output.get("stck_hgpr")
+            )
+            pr_low = safe_float(
+                price_output.get("low") or price_output.get("ovrs_lwpr")
+                or price_output.get("stck_lwpr")
+            )
+            if pr_high > 0 and pr_low > 0 and pr_high >= pr_low:
+                intraday_range_pct = (pr_high - pr_low) / current_price * 100.0
+                volatility_pct = max(abs(price_change_pct), intraday_range_pct)
+                market_data["volume_ratio"] = max(1.0, volatility_pct / 2.0)
+            else:
+                market_data["volume_ratio"] = 1.0
+        else:
+            market_data["volume_ratio"] = 1.0
+
+    # Enrich market_data with holding info for SELL/HOLD scenario conditions
+    open_pos = get_open_position(db_conn, stock_code, market.code)
+    if open_pos and current_price > 0:
+        entry_price = safe_float(open_pos.get("price"), 0.0)
+        if entry_price > 0:
+            market_data["unrealized_pnl_pct"] = (
+                (current_price - entry_price) / entry_price * 100
+            )
+        entry_ts = open_pos.get("timestamp")
+        if entry_ts:
+            try:
+                entry_date = datetime.fromisoformat(entry_ts).date()
+                market_data["holding_days"] = (datetime.now(UTC).date() - entry_date).days
+            except (ValueError, TypeError):
+                pass
 
     # 1.3. Record L7 real-time context (market-scoped keys)
     timeframe = datetime.now(UTC).isoformat()
@@ -696,7 +776,7 @@ async def trading_cycle(
         open_position = get_open_position(db_conn, stock_code, market.code)
         if open_position:
             entry_price = safe_float(open_position.get("price"), 0.0)
-            if entry_price > 0:
+            if entry_price > 0 and current_price > 0:
                 loss_pct = (current_price - entry_price) / entry_price * 100
                 stop_loss_threshold = -2.0
                 take_profit_threshold = 3.0
@@ -891,10 +971,13 @@ async def trading_cycle(
             # - SELL: -0.2% below last price — ensures fill even when price dips slightly
             #   (placing at exact last price risks no-fill if the bid is just below).
             overseas_price: float
+            # KIS requires at most 2 decimal places for prices >= $1 (≥1달러 소수점 2자리 제한).
+            # Penny stocks (< $1) keep 4 decimal places to preserve price precision.
+            _price_decimals = 2 if current_price >= 1.0 else 4
             if decision.action == "BUY":
-                overseas_price = round(current_price * 1.002, 4)
+                overseas_price = round(current_price * 1.002, _price_decimals)
             else:
-                overseas_price = round(current_price * 0.998, 4)
+                overseas_price = round(current_price * 0.998, _price_decimals)
             result = await overseas_broker.send_overseas_order(
                 exchange_code=market.exchange_code,
                 stock_code=stock_code,
@@ -1440,8 +1523,9 @@ async def run_daily_session(
                 active_stocks={},
             )
             if not fallback_stocks:
-                logger.warning(
-                    "No dynamic overseas symbol universe for %s; scanner cannot run",
+                logger.debug(
+                    "No dynamic overseas symbol universe for %s;"
+                    " scanner will use overseas ranking API",
                     market.code,
                 )
         try:
@@ -1606,10 +1690,35 @@ async def run_daily_session(
                 balance_info = {}
 
             total_eval = safe_float(balance_info.get("frcr_evlu_tota", "0") or "0")
-            total_cash = safe_float(balance_info.get("frcr_dncl_amt_2", "0") or "0")
             purchase_total = safe_float(
                 balance_info.get("frcr_buy_amt_smtl", "0") or "0"
             )
+
+            # Fetch available foreign currency cash via inquire-psamount (TTTS3007R/VTTS3007R).
+            # TTTS3012R output2 does not include a cash/deposit field — frcr_dncl_amt_2 does not exist.
+            # Use the first stock with a valid price as the reference for the buying power query.
+            # Source: 한국투자증권 오픈API 전체문서 (20260221) — '해외주식 매수가능금액조회' 시트
+            total_cash = 0.0
+            ref_stock = next(
+                (s for s in stocks_data if s.get("current_price", 0) > 0), None
+            )
+            if ref_stock:
+                try:
+                    ps_data = await overseas_broker.get_overseas_buying_power(
+                        market.exchange_code,
+                        ref_stock["stock_code"],
+                        ref_stock["current_price"],
+                    )
+                    total_cash = safe_float(
+                        ps_data.get("output", {}).get("ord_psbl_frcr_amt", "0") or "0"
+                    )
+                except ConnectionError as exc:
+                    logger.warning(
+                        "Could not fetch overseas buying power for %s: %s",
+                        market.exchange_code,
+                        exc,
+                    )
+
             # Paper mode fallback: VTS overseas balance API often fails for many accounts.
             # Only activate in paper mode — live mode must use real balance from KIS.
             if (
@@ -2728,9 +2837,9 @@ async def run(settings: Settings) -> None:
                                     active_stocks=active_stocks,
                                 )
                                 if not fallback_stocks:
-                                    logger.warning(
+                                    logger.debug(
                                         "No dynamic overseas symbol universe for %s;"
-                                        " scanner cannot run",
+                                        " scanner will use overseas ranking API",
                                         market.code,
                                     )
 

src/strategies/v20260220_210124_evolved.py

@@ -1,114 +0,0 @@
-"""Auto-generated strategy: v20260220_210124
-
-Generated at: 2026-02-20T21:01:24.706847+00:00
-Rationale: Auto-evolved from 6 failures. Primary failure markets: ['US_AMEX', 'US_NYSE', 'US_NASDAQ']. Average loss: -194.69
-"""
-
-from __future__ import annotations
-from typing import Any
-from src.strategies.base import BaseStrategy
-
-
-class Strategy_v20260220_210124(BaseStrategy):
-    """Strategy: v20260220_210124"""
-
-    def evaluate(self, market_data: dict[str, Any]) -> dict[str, Any]:
-        import datetime
-
-        # --- Strategy Constants ---
-        # Minimum price for a stock to be considered for trading (avoids penny stocks)
-        MIN_PRICE = 5.0
-
-        # Momentum signal thresholds (stricter than previous failures)
-        MOMENTUM_PRICE_CHANGE_THRESHOLD = 7.0  # % price change
-        MOMENTUM_VOLUME_RATIO_THRESHOLD = 4.0  # X times average volume
-
-        # Oversold signal thresholds (more conservative)
-        OVERSOLD_RSI_THRESHOLD = 25.0  # RSI value (lower means more oversold)
-
-        # Confidence levels
-        CONFIDENCE_HOLD = 30
-        CONFIDENCE_BUY_OVERSOLD = 65
-        CONFIDENCE_BUY_MOMENTUM = 85
-        CONFIDENCE_BUY_STRONG_MOMENTUM = 90  # For higher-priced stocks with strong momentum
-
-        # Market hours in UTC (9:30 AM ET to 4:00 PM ET)
-        MARKET_OPEN_UTC = datetime.time(14, 30)
-        MARKET_CLOSE_UTC = datetime.time(21, 0)
-
-        # Volatile periods within market hours (UTC) to avoid
-        # First hour after open (14:30 UTC - 15:30 UTC)
-        VOLATILE_OPEN_END_UTC = datetime.time(15, 30)
-        # Last 30 minutes before close (20:30 UTC - 21:00 UTC)
-        VOLATILE_CLOSE_START_UTC = datetime.time(20, 30)
-
-        current_price = market_data.get('current_price')
-        price_change_pct = market_data.get('price_change_pct')
-        volume_ratio = market_data.get('volume_ratio')  # Assumed pre-computed indicator
-        rsi = market_data.get('rsi')                    # Assumed pre-computed indicator
-        timestamp_str = market_data.get('timestamp')
-
-        action = "HOLD"
-        confidence = CONFIDENCE_HOLD
-        rationale = "Initial HOLD: No clear signal or conditions not met."
-
-        # --- 1. Basic Data Validation ---
-        if current_price is None or price_change_pct is None:
-            return {"action": "HOLD", "confidence": CONFIDENCE_HOLD,
-                    "rationale": "Insufficient core data (price or price change) to evaluate."}
-
-        # --- 2. Price Filter: Avoid low-priced/penny stocks ---
-        if current_price < MIN_PRICE:
-            return {"action": "HOLD", "confidence": CONFIDENCE_HOLD,
-                    "rationale": f"Avoiding low-priced stock (${current_price:.2f} < ${MIN_PRICE:.2f})."}
-
-        # --- 3. Time Filter: Only trade during core market hours ---
-        if timestamp_str:
-            try:
-                dt_object = datetime.datetime.fromisoformat(timestamp_str)
-                current_time_utc = dt_object.time()
-
-                if not (MARKET_OPEN_UTC <= current_time_utc < MARKET_CLOSE_UTC):
-                    return {"action": "HOLD", "confidence": CONFIDENCE_HOLD,
-                            "rationale": f"Avoiding trade outside core market hours ({current_time_utc} UTC)."}
-
-                if (MARKET_OPEN_UTC <= current_time_utc < VOLATILE_OPEN_END_UTC) or \
-                   (VOLATILE_CLOSE_START_UTC <= current_time_utc < MARKET_CLOSE_UTC):
-                    return {"action": "HOLD", "confidence": CONFIDENCE_HOLD,
-                            "rationale": f"Avoiding trade during volatile market open/close periods ({current_time_utc} UTC)."}
-
-            except ValueError:
-                rationale += " (Warning: Malformed timestamp, time filters skipped)"
-
-        # --- Initialize signal states ---
-        has_momentum_buy_signal = False
-        has_oversold_buy_signal = False
-
-        # --- 4. Evaluate Enhanced Buy Signals ---
-
-        # Momentum Buy Signal
-        if volume_ratio is not None and \
-           price_change_pct > MOMENTUM_PRICE_CHANGE_THRESHOLD and \
-           volume_ratio > MOMENTUM_VOLUME_RATIO_THRESHOLD:
-            has_momentum_buy_signal = True
-            rationale = f"Momentum BUY: Price change {price_change_pct:.2f}%, Volume {volume_ratio:.2f}x."
-            confidence = CONFIDENCE_BUY_MOMENTUM
-            if current_price >= 10.0:
-                confidence = CONFIDENCE_BUY_STRONG_MOMENTUM
-
-        # Oversold Buy Signal
-        if rsi is not None and rsi < OVERSOLD_RSI_THRESHOLD:
-            has_oversold_buy_signal = True
-            if not has_momentum_buy_signal:
-                rationale = f"Oversold BUY: RSI {rsi:.2f}."
-                confidence = CONFIDENCE_BUY_OVERSOLD
-                if current_price >= 10.0:
-                    confidence = min(CONFIDENCE_BUY_OVERSOLD + 5, 80)
-
-        # --- 5. Decision Logic ---
-        if has_momentum_buy_signal:
-            action = "BUY"
-        elif has_oversold_buy_signal:
-            action = "BUY"
-
-        return {"action": action, "confidence": confidence, "rationale": rationale}

src/strategies/v20260220_210159_evolved.py

@@ -1,97 +0,0 @@
-"""Auto-generated strategy: v20260220_210159
-
-Generated at: 2026-02-20T21:01:59.391523+00:00
-Rationale: Auto-evolved from 6 failures. Primary failure markets: ['US_AMEX', 'US_NYSE', 'US_NASDAQ']. Average loss: -194.69
-"""
-
-from __future__ import annotations
-from typing import Any
-from src.strategies.base import BaseStrategy
-
-
-class Strategy_v20260220_210159(BaseStrategy):
-    """Strategy: v20260220_210159"""
-
-    def evaluate(self, market_data: dict[str, Any]) -> dict[str, Any]:
-        import datetime
-
-        current_price = market_data.get('current_price')
-        price_change_pct = market_data.get('price_change_pct')
-        volume_ratio = market_data.get('volume_ratio')
-        rsi = market_data.get('rsi')
-        timestamp_str = market_data.get('timestamp')
-        market_name = market_data.get('market')
-
-        # Default action
-        action = "HOLD"
-        confidence = 0
-        rationale = "No strong signal or conditions not met."
-
-        # --- FAILURE PATTERN AVOIDANCE ---
-
-        # 1. Avoid low-priced/penny stocks
-        MIN_PRICE_THRESHOLD = 5.0  # USD
-        if current_price is not None and current_price < MIN_PRICE_THRESHOLD:
-            rationale = (
-                f"HOLD: Stock price (${current_price:.2f}) is below minimum threshold "
-                f"(${MIN_PRICE_THRESHOLD:.2f}). Past failures consistently involved low-priced stocks."
-            )
-            return {"action": action, "confidence": confidence, "rationale": rationale}
-
-        # 2. Avoid early market hour volatility
-        if timestamp_str:
-            try:
-                dt_obj = datetime.datetime.fromisoformat(timestamp_str)
-                utc_hour = dt_obj.hour
-                utc_minute = dt_obj.minute
-
-                if (utc_hour == 14 and utc_minute < 45) or (utc_hour == 13 and utc_minute >= 30):
-                    rationale = (
-                        f"HOLD: Trading during early market hours (UTC {utc_hour}:{utc_minute}), "
-                        f"a period identified with past failures due to high volatility."
-                    )
-                    return {"action": action, "confidence": confidence, "rationale": rationale}
-            except ValueError:
-                pass
-
-        # --- IMPROVED BUY STRATEGY ---
-
-        # Momentum BUY signal
-        if volume_ratio is not None and price_change_pct is not None:
-            if price_change_pct > 7.0 and volume_ratio > 3.0:
-                action = "BUY"
-                confidence = 70
-                rationale = "Improved BUY: Momentum signal with high volume and above price threshold."
-
-                if market_name == 'US_AMEX':
-                    confidence = max(55, confidence - 5)
-                    rationale += " (Adjusted lower for AMEX market's higher risk profile)."
-                elif market_name == 'US_NASDAQ' and price_change_pct > 20:
-                    confidence = max(50, confidence - 10)
-                    rationale += " (Adjusted lower for aggressive NASDAQ momentum volatility)."
-
-                if price_change_pct > 15.0:
-                    confidence = max(50, confidence - 5)
-                    rationale += " (Caution: Very high daily price change, potential for reversal)."
-
-                return {"action": action, "confidence": confidence, "rationale": rationale}
-
-        # Oversold BUY signal
-        if rsi is not None and price_change_pct is not None:
-            if rsi < 30 and price_change_pct < -3.0:
-                action = "BUY"
-                confidence = 65
-                rationale = "Improved BUY: Oversold signal with recent decline and above price threshold."
-
-                if market_name == 'US_AMEX':
-                    confidence = max(50, confidence - 5)
-                    rationale += " (Adjusted lower for AMEX market's higher risk on oversold assets)."
-
-                if price_change_pct < -10.0:
-                    confidence = max(45, confidence - 10)
-                    rationale += " (Caution: Very steep decline, potential falling knife)."
-
-                return {"action": action, "confidence": confidence, "rationale": rationale}
-
-        # If no specific BUY signal, default to HOLD
-        return {"action": action, "confidence": confidence, "rationale": rationale}

src/strategies/v20260220_210244_evolved.py

@@ -1,88 +0,0 @@
-"""Auto-generated strategy: v20260220_210244
-
-Generated at: 2026-02-20T21:02:44.387355+00:00
-Rationale: Auto-evolved from 6 failures. Primary failure markets: ['US_AMEX', 'US_NYSE', 'US_NASDAQ']. Average loss: -194.69
-"""
-
-from __future__ import annotations
-from typing import Any
-from src.strategies.base import BaseStrategy
-
-
-class Strategy_v20260220_210244(BaseStrategy):
-    """Strategy: v20260220_210244"""
-
-    def evaluate(self, market_data: dict[str, Any]) -> dict[str, Any]:
-        from datetime import datetime
-
-        # Extract required data points safely
-        current_price = market_data.get("current_price")
-        price_change_pct = market_data.get("price_change_pct")
-        volume_ratio = market_data.get("volume_ratio")
-        rsi = market_data.get("rsi")
-        timestamp_str = market_data.get("timestamp")
-        market_name = market_data.get("market")
-        stock_code = market_data.get("stock_code", "UNKNOWN")
-
-        # Default action is HOLD with conservative confidence and rationale
-        action = "HOLD"
-        confidence = 50
-        rationale = f"No strong BUY signal for {stock_code} or awaiting more favorable conditions after avoiding known failure patterns."
-
-        # --- 1. Failure Pattern Avoidance Filters ---
-
-        # A. Avoid low-priced (penny) stocks
-        if current_price is not None and current_price < 5.0:
-            return {
-                "action": "HOLD",
-                "confidence": 50,
-                "rationale": f"AVOID {stock_code}: Stock price (${current_price:.2f}) is below minimum threshold ($5.00) for BUY action. Identified past failures on highly volatile, low-priced stocks."
-            }
-
-        # B. Avoid initiating BUY trades during identified high-volatility hours
-        if timestamp_str:
-            try:
-                trade_hour = datetime.fromisoformat(timestamp_str).hour
-                if trade_hour in [14, 20]:
-                    return {
-                        "action": "HOLD",
-                        "confidence": 50,
-                        "rationale": f"AVOID {stock_code}: Trading during historically volatile hour ({trade_hour} UTC) where previous BUYs resulted in losses. Prefer to observe market stability."
-                    }
-            except ValueError:
-                pass
-
-        # C. Be cautious with extreme momentum spikes
-        if volume_ratio is not None and price_change_pct is not None:
-            if volume_ratio >= 9.0 and price_change_pct >= 15.0:
-                return {
-                    "action": "HOLD",
-                    "confidence": 50,
-                    "rationale": f"AVOID {stock_code}: Extreme short-term momentum detected (price change: +{price_change_pct:.2f}%, volume ratio: {volume_ratio:.1f}x). Historical failures indicate buying into such rapid spikes often leads to reversals."
-                }
-
-        # D. Be cautious with "oversold" signals without further confirmation
-        if rsi is not None and rsi < 30:
-            return {
-                "action": "HOLD",
-                "confidence": 50,
-                "rationale": f"AVOID {stock_code}: Oversold signal (RSI={rsi:.1f}) detected. While often a BUY signal, historical failures on similar 'oversold' trades suggest waiting for stronger confirmation."
-            }
-
-        # --- 2. Improved BUY Signal Generation ---
-        if volume_ratio is not None and 2.0 <= volume_ratio < 9.0 and \
-           price_change_pct is not None and 2.0 <= price_change_pct < 15.0:
-
-            action = "BUY"
-            confidence = 70
-            rationale = f"BUY {stock_code}: Moderate momentum detected (price change: +{price_change_pct:.2f}%, volume ratio: {volume_ratio:.1f}x). Passed filters for price and extreme momentum, avoiding past failure patterns."
-
-            if market_name in ["US_AMEX", "US_NASDAQ"]:
-                confidence = max(60, confidence - 5)
-                rationale += f" Adjusted confidence for {market_name} market characteristics."
-            elif market_name == "US_NYSE":
-                confidence = max(65, confidence)
-
-            confidence = max(50, min(85, confidence))
-
-        return {"action": action, "confidence": confidence, "rationale": rationale}

tests/test_main.py

@@ -15,6 +15,7 @@ from src.logging.decision_logger import DecisionLogger
 from src.main import (
     _apply_dashboard_flag,
     _determine_order_quantity,
+    _extract_avg_price_from_balance,
     _extract_held_codes_from_balance,
     _extract_held_qty_from_balance,
     _handle_market_close,
@@ -76,6 +77,81 @@ def _make_sell_match(stock_code: str = "005930") -> ScenarioMatch:
     )
 
 
+class TestExtractAvgPriceFromBalance:
+    """Tests for _extract_avg_price_from_balance() (issue #249)."""
+
+    def test_domestic_returns_pchs_avg_pric(self) -> None:
+        """Domestic balance with pchs_avg_pric returns the correct float."""
+        balance = {"output1": [{"pdno": "005930", "pchs_avg_pric": "68000.00"}]}
+        result = _extract_avg_price_from_balance(balance, "005930", is_domestic=True)
+        assert result == 68000.0
+
+    def test_overseas_returns_pchs_avg_pric(self) -> None:
+        """Overseas balance with pchs_avg_pric returns the correct float."""
+        balance = {"output1": [{"ovrs_pdno": "AAPL", "pchs_avg_pric": "170.50"}]}
+        result = _extract_avg_price_from_balance(balance, "AAPL", is_domestic=False)
+        assert result == 170.5
+
+    def test_returns_zero_when_field_absent(self) -> None:
+        """Returns 0.0 when pchs_avg_pric key is missing entirely."""
+        balance = {"output1": [{"pdno": "005930", "ord_psbl_qty": "5"}]}
+        result = _extract_avg_price_from_balance(balance, "005930", is_domestic=True)
+        assert result == 0.0
+
+    def test_returns_zero_when_field_empty_string(self) -> None:
+        """Returns 0.0 when pchs_avg_pric is an empty string."""
+        balance = {"output1": [{"pdno": "005930", "pchs_avg_pric": ""}]}
+        result = _extract_avg_price_from_balance(balance, "005930", is_domestic=True)
+        assert result == 0.0
+
+    def test_returns_zero_when_stock_not_found(self) -> None:
+        """Returns 0.0 when the requested stock_code is not in output1."""
+        balance = {"output1": [{"pdno": "000660", "pchs_avg_pric": "100000.0"}]}
+        result = _extract_avg_price_from_balance(balance, "005930", is_domestic=True)
+        assert result == 0.0
+
+    def test_returns_zero_when_output1_empty(self) -> None:
+        """Returns 0.0 when output1 is an empty list."""
+        balance = {"output1": []}
+        result = _extract_avg_price_from_balance(balance, "005930", is_domestic=True)
+        assert result == 0.0
+
+    def test_returns_zero_when_output1_key_absent(self) -> None:
+        """Returns 0.0 when output1 key is missing from balance_data."""
+        balance: dict = {}
+        result = _extract_avg_price_from_balance(balance, "005930", is_domestic=True)
+        assert result == 0.0
+
+    def test_handles_output1_as_dict(self) -> None:
+        """Handles the edge case where output1 is a dict instead of a list."""
+        balance = {"output1": {"pdno": "005930", "pchs_avg_pric": "55000.0"}}
+        result = _extract_avg_price_from_balance(balance, "005930", is_domestic=True)
+        assert result == 55000.0
+
+    def test_case_insensitive_code_matching(self) -> None:
+        """Stock code comparison is case-insensitive."""
+        balance = {"output1": [{"ovrs_pdno": "aapl", "pchs_avg_pric": "170.0"}]}
+        result = _extract_avg_price_from_balance(balance, "AAPL", is_domestic=False)
+        assert result == 170.0
+
+    def test_returns_zero_for_non_numeric_string(self) -> None:
+        """Returns 0.0 when pchs_avg_pric contains a non-numeric value."""
+        balance = {"output1": [{"pdno": "005930", "pchs_avg_pric": "N/A"}]}
+        result = _extract_avg_price_from_balance(balance, "005930", is_domestic=True)
+        assert result == 0.0
+
+    def test_returns_correct_stock_among_multiple(self) -> None:
+        """Returns only the avg price of the requested stock when output1 has multiple holdings."""
+        balance = {
+            "output1": [
+                {"pdno": "000660", "pchs_avg_pric": "150000.0"},
+                {"pdno": "005930", "pchs_avg_pric": "68000.0"},
+            ]
+        }
+        result = _extract_avg_price_from_balance(balance, "005930", is_domestic=True)
+        assert result == 68000.0
+
+
 class TestExtractHeldQtyFromBalance:
     """Tests for _extract_held_qty_from_balance()."""
 
@@ -827,12 +903,14 @@ class TestOverseasBalanceParsing:
                 "output2": [
                     {
                         "frcr_evlu_tota": "10000.00",
-                        "frcr_dncl_amt_2": "5000.00",
                         "frcr_buy_amt_smtl": "4500.00",
                     }
                 ]
             }
         )
+        broker.get_overseas_buying_power = AsyncMock(
+            return_value={"output": {"ord_psbl_frcr_amt": "5000.00"}}
+        )
         return broker
 
     @pytest.fixture
@@ -846,11 +924,13 @@ class TestOverseasBalanceParsing:
             return_value={
                 "output2": {
                     "frcr_evlu_tota": "10000.00",
-                    "frcr_dncl_amt_2": "5000.00",
                     "frcr_buy_amt_smtl": "4500.00",
                 }
             }
         )
+        broker.get_overseas_buying_power = AsyncMock(
+            return_value={"output": {"ord_psbl_frcr_amt": "5000.00"}}
+        )
         return broker
 
     @pytest.fixture
@@ -861,6 +941,9 @@ class TestOverseasBalanceParsing:
             return_value={"output": {"last": "150.50"}}
         )
         broker.get_overseas_balance = AsyncMock(return_value={"output2": []})
+        broker.get_overseas_buying_power = AsyncMock(
+            return_value={"output": {"ord_psbl_frcr_amt": "0.00"}}
+        )
         return broker
 
     @pytest.fixture
@@ -875,12 +958,15 @@ class TestOverseasBalanceParsing:
                 "output2": [
                     {
                         "frcr_evlu_tota": "10000.00",
-                        "frcr_dncl_amt_2": "5000.00",
                         "frcr_buy_amt_smtl": "4500.00",
                     }
                 ]
             }
         )
+        # get_overseas_buying_power not called when price=0, but mock for safety
+        broker.get_overseas_buying_power = AsyncMock(
+            return_value={"output": {"ord_psbl_frcr_amt": "5000.00"}}
+        )
         return broker
 
     @pytest.fixture
@@ -1110,12 +1196,14 @@ class TestOverseasBalanceParsing:
                 "output2": [
                     {
                         "frcr_evlu_tota": "100000.00",
-                        "frcr_dncl_amt_2": "50000.00",
                         "frcr_buy_amt_smtl": "50000.00",
                     }
                 ]
             }
         )
+        broker.get_overseas_buying_power = AsyncMock(
+            return_value={"output": {"ord_psbl_frcr_amt": "50000.00"}}
+        )
         broker.send_overseas_order = AsyncMock(return_value={"msg1": "주문접수"})
         return broker
 
@@ -1170,7 +1258,8 @@ class TestOverseasBalanceParsing:
         mock_overseas_broker_with_buy_scenario.send_overseas_order.assert_called_once()
         call_kwargs = mock_overseas_broker_with_buy_scenario.send_overseas_order.call_args
         sent_price = call_kwargs[1].get("price") or call_kwargs[0][4]
-        expected_price = round(182.5 * 1.002, 4)  # 0.2% premium for BUY limit orders
+        # KIS requires max 2 decimal places for prices >= $1 (#252)
+        expected_price = round(182.5 * 1.002, 2)  # 0.2% premium for BUY limit orders
         assert sent_price == expected_price, (
             f"Expected limit price {expected_price} (182.5 * 1.002) but got {sent_price}. "
             "BUY uses +0.2% to improve fill rate while minimising overpayment (#211)."
@@ -1214,12 +1303,14 @@ class TestOverseasBalanceParsing:
                 "output2": [
                     {
                         "frcr_evlu_tota": "100000.00",
-                        "frcr_dncl_amt_2": "50000.00",
                         "frcr_buy_amt_smtl": "50000.00",
                     }
                 ],
             }
         )
+        overseas_broker.get_overseas_buying_power = AsyncMock(
+            return_value={"output": {"ord_psbl_frcr_amt": "50000.00"}}
+        )
         overseas_broker.send_overseas_order = AsyncMock(
             return_value={"rt_cd": "0", "msg1": "OK"}
         )
@@ -1249,12 +1340,139 @@ class TestOverseasBalanceParsing:
         overseas_broker.send_overseas_order.assert_called_once()
         call_kwargs = overseas_broker.send_overseas_order.call_args
         sent_price = call_kwargs[1].get("price") or call_kwargs[0][4]
-        expected_price = round(sell_price * 0.998, 4)  # -0.2% for SELL limit orders
+        # KIS requires max 2 decimal places for prices >= $1 (#252)
+        expected_price = round(sell_price * 0.998, 2)  # -0.2% for SELL limit orders
         assert sent_price == expected_price, (
             f"Expected SELL limit price {expected_price} (182.5 * 0.998) but got {sent_price}. "
             "SELL uses -0.2% to ensure fill even when price dips slightly (#211)."
         )
 
+    @pytest.mark.asyncio
+    async def test_overseas_buy_price_rounded_to_2_decimals_for_dollar_plus_stock(
+        self,
+        mock_domestic_broker: MagicMock,
+        mock_playbook: DayPlaybook,
+        mock_risk: MagicMock,
+        mock_db: MagicMock,
+        mock_decision_logger: MagicMock,
+        mock_context_store: MagicMock,
+        mock_criticality_assessor: MagicMock,
+        mock_telegram: MagicMock,
+        mock_overseas_market: MagicMock,
+    ) -> None:
+        """BUY price for $1+ stocks is rounded to 2 decimal places (issue #252).
+
+        KIS rejects prices with more than 2 decimal places for stocks priced >= $1.
+        current_price=50.1234 * 1.002 = 50.22... should be sent as 50.22, not 50.2236.
+        """
+        overseas_broker = MagicMock()
+        overseas_broker.get_overseas_balance = AsyncMock(
+            return_value={
+                "output1": [],
+                "output2": [{"frcr_evlu_tota": "0", "frcr_buy_amt_smtl": "0"}],
+            }
+        )
+        overseas_broker.get_overseas_buying_power = AsyncMock(
+            return_value={"output": {"ord_psbl_frcr_amt": "10000"}}
+        )
+        overseas_broker.get_overseas_price = AsyncMock(
+            return_value={"output": {"last": "50.1234", "rate": "0"}}
+        )
+        overseas_broker.send_overseas_order = AsyncMock(
+            return_value={"rt_cd": None, "msg1": "주문접수"}
+        )
+
+        db_conn = init_db(":memory:")
+        decision_logger = DecisionLogger(db_conn)
+
+        engine = MagicMock(spec=ScenarioEngine)
+        engine.evaluate = MagicMock(return_value=_make_buy_match())
+
+        await trading_cycle(
+            broker=mock_domestic_broker,
+            overseas_broker=overseas_broker,
+            scenario_engine=engine,
+            playbook=mock_playbook,
+            risk=mock_risk,
+            db_conn=db_conn,
+            decision_logger=decision_logger,
+            context_store=mock_context_store,
+            criticality_assessor=mock_criticality_assessor,
+            telegram=mock_telegram,
+            market=mock_overseas_market,
+            stock_code="TQQQ",
+            scan_candidates={},
+        )
+
+        overseas_broker.send_overseas_order.assert_called_once()
+        sent_price = overseas_broker.send_overseas_order.call_args[1].get("price") or \
+            overseas_broker.send_overseas_order.call_args[0][4]
+        # 50.1234 * 1.002 = 50.2235... rounded to 2 decimals = 50.22
+        assert sent_price == round(50.1234 * 1.002, 2), (
+            f"Expected 2-decimal price {round(50.1234 * 1.002, 2)} but got {sent_price} (#252)"
+        )
+
+    @pytest.mark.asyncio
+    async def test_overseas_penny_stock_price_keeps_4_decimals(
+        self,
+        mock_domestic_broker: MagicMock,
+        mock_playbook: DayPlaybook,
+        mock_risk: MagicMock,
+        mock_db: MagicMock,
+        mock_decision_logger: MagicMock,
+        mock_context_store: MagicMock,
+        mock_criticality_assessor: MagicMock,
+        mock_telegram: MagicMock,
+        mock_overseas_market: MagicMock,
+    ) -> None:
+        """BUY price for penny stocks (< $1) uses 4 decimal places (issue #252)."""
+        overseas_broker = MagicMock()
+        overseas_broker.get_overseas_balance = AsyncMock(
+            return_value={
+                "output1": [],
+                "output2": [{"frcr_evlu_tota": "0", "frcr_buy_amt_smtl": "0"}],
+            }
+        )
+        overseas_broker.get_overseas_buying_power = AsyncMock(
+            return_value={"output": {"ord_psbl_frcr_amt": "10000"}}
+        )
+        overseas_broker.get_overseas_price = AsyncMock(
+            return_value={"output": {"last": "0.5678", "rate": "0"}}
+        )
+        overseas_broker.send_overseas_order = AsyncMock(
+            return_value={"rt_cd": None, "msg1": "주문접수"}
+        )
+
+        db_conn = init_db(":memory:")
+        decision_logger = DecisionLogger(db_conn)
+
+        engine = MagicMock(spec=ScenarioEngine)
+        engine.evaluate = MagicMock(return_value=_make_buy_match())
+
+        await trading_cycle(
+            broker=mock_domestic_broker,
+            overseas_broker=overseas_broker,
+            scenario_engine=engine,
+            playbook=mock_playbook,
+            risk=mock_risk,
+            db_conn=db_conn,
+            decision_logger=decision_logger,
+            context_store=mock_context_store,
+            criticality_assessor=mock_criticality_assessor,
+            telegram=mock_telegram,
+            market=mock_overseas_market,
+            stock_code="PENNYX",
+            scan_candidates={},
+        )
+
+        overseas_broker.send_overseas_order.assert_called_once()
+        sent_price = overseas_broker.send_overseas_order.call_args[1].get("price") or \
+            overseas_broker.send_overseas_order.call_args[0][4]
+        # 0.5678 * 1.002 = 0.56893... rounded to 4 decimals = 0.5689
+        assert sent_price == round(0.5678 * 1.002, 4), (
+            f"Expected 4-decimal price {round(0.5678 * 1.002, 4)} but got {sent_price} (#252)"
+        )
+
 
 class TestScenarioEngineIntegration:
     """Test scenario engine integration in trading_cycle."""
@@ -1450,10 +1668,10 @@ class TestScenarioEngineIntegration:
                 scan_candidates={"US": {"005930": us_candidate}},  # Wrong market
             )
 
-        # Should NOT have rsi/volume_ratio because candidate is under US, not KR
+        # Should NOT use US candidate's rsi (=15.0); fallback implied_rsi used instead
         market_data = engine.evaluate.call_args[0][2]
-        assert "rsi" not in market_data
-        assert "volume_ratio" not in market_data
+        assert market_data["rsi"] != 15.0  # US candidate's rsi must be ignored
+        assert market_data["volume_ratio"] == 1.0  # Fallback default
 
     @pytest.mark.asyncio
     async def test_scenario_engine_called_without_scanner_data(
@@ -1484,13 +1702,70 @@ class TestScenarioEngineIntegration:
                 scan_candidates={},  # No scanner data
             )
 
-        # Should still work, just without rsi/volume_ratio
+        # Holding stocks without scanner data use implied_rsi (from price_change_pct)
+        # and volume_ratio=1.0 as fallback, so rsi/volume_ratio are always present.
         engine.evaluate.assert_called_once()
         market_data = engine.evaluate.call_args[0][2]
-        assert "rsi" not in market_data
-        assert "volume_ratio" not in market_data
+        assert "rsi" in market_data  # Implied RSI from price_change_pct=2.5 → 55.0
+        assert market_data["rsi"] == pytest.approx(55.0)
+        assert market_data["volume_ratio"] == 1.0
         assert market_data["current_price"] == 50000.0
 
+    @pytest.mark.asyncio
+    async def test_holding_overseas_stock_derives_volume_ratio_from_price_api(
+        self, mock_broker: MagicMock, mock_telegram: MagicMock,
+    ) -> None:
+        """Test overseas holding stocks derive volume_ratio from get_overseas_price high/low."""
+        engine = MagicMock(spec=ScenarioEngine)
+        engine.evaluate = MagicMock(return_value=_make_hold_match())
+
+        os_market = MagicMock()
+        os_market.name = "NASDAQ"
+        os_market.code = "US_NASDAQ"
+        os_market.exchange_code = "NAS"
+        os_market.is_domestic = False
+        os_market.timezone = UTC
+
+        os_broker = MagicMock()
+        # price_change_pct=5.0, high=106, low=94 → intraday_range=12% → volume_ratio=max(1,6)=6
+        os_broker.get_overseas_price = AsyncMock(return_value={
+            "output": {"last": "100.0", "rate": "5.0", "high": "106.0", "low": "94.0"}
+        })
+        os_broker.get_overseas_balance = AsyncMock(return_value={
+            "output2": [{"frcr_evlu_tota": "10000", "frcr_buy_amt_smtl": "9000"}]
+        })
+        os_broker.get_overseas_buying_power = AsyncMock(return_value={
+            "output": {"ord_psbl_frcr_amt": "500"}
+        })
+
+        with patch("src.main.log_trade"):
+            await trading_cycle(
+                broker=mock_broker,
+                overseas_broker=os_broker,
+                scenario_engine=engine,
+                playbook=_make_playbook(),
+                risk=MagicMock(),
+                db_conn=MagicMock(),
+                decision_logger=MagicMock(),
+                context_store=MagicMock(get_latest_timeframe=MagicMock(return_value=None)),
+                criticality_assessor=MagicMock(
+                    assess_market_conditions=MagicMock(return_value=MagicMock(value="NORMAL")),
+                    get_timeout=MagicMock(return_value=5.0),
+                ),
+                telegram=mock_telegram,
+                market=os_market,
+                stock_code="NVDA",
+                scan_candidates={},  # Not in scanner — holding stock
+            )
+
+        market_data = engine.evaluate.call_args[0][2]
+        # rsi: 50.0 + 5.0 * 2.0 = 60.0
+        assert market_data["rsi"] == pytest.approx(60.0)
+        # intraday_range = (106-94)/100 * 100 = 12.0%
+        # volatility_pct = max(abs(5.0), 12.0) = 12.0
+        # volume_ratio = max(1.0, 12.0 / 2.0) = 6.0
+        assert market_data["volume_ratio"] == pytest.approx(6.0)
+
     @pytest.mark.asyncio
     async def test_scenario_matched_notification_sent(
         self, mock_broker: MagicMock, mock_market: MagicMock, mock_telegram: MagicMock,
@@ -2048,6 +2323,92 @@ async def test_hold_not_overridden_when_between_stop_loss_and_take_profit() -> N
     broker.send_order.assert_not_called()
 
 
+@pytest.mark.asyncio
+async def test_stop_loss_not_triggered_when_current_price_is_zero() -> None:
+    """HOLD must stay HOLD when current_price=0 even if entry_price is set (issue #251).
+
+    A price API failure that returns 0.0 must not cause a false -100% stop-loss.
+    """
+    db_conn = init_db(":memory:")
+    decision_logger = DecisionLogger(db_conn)
+
+    buy_decision_id = decision_logger.log_decision(
+        stock_code="005930",
+        market="KR",
+        exchange_code="KRX",
+        action="BUY",
+        confidence=90,
+        rationale="entry",
+        context_snapshot={},
+        input_data={},
+    )
+    log_trade(
+        conn=db_conn,
+        stock_code="005930",
+        action="BUY",
+        confidence=90,
+        rationale="entry",
+        quantity=1,
+        price=100.0,  # valid entry price
+        market="KR",
+        exchange_code="KRX",
+        decision_id=buy_decision_id,
+    )
+
+    broker = MagicMock()
+    # Price API returns 0.0 — simulates API failure or pre-market unavailability
+    broker.get_current_price = AsyncMock(return_value=(0.0, 0.0, 0.0))
+    broker.get_balance = AsyncMock(
+        return_value={
+            "output2": [
+                {
+                    "tot_evlu_amt": "100000",
+                    "dnca_tot_amt": "10000",
+                    "pchs_amt_smtl_amt": "90000",
+                }
+            ]
+        }
+    )
+    broker.send_order = AsyncMock(return_value={"msg1": "OK"})
+
+    market = MagicMock()
+    market.name = "Korea"
+    market.code = "KR"
+    market.exchange_code = "KRX"
+    market.is_domestic = True
+
+    telegram = MagicMock()
+    telegram.notify_trade_execution = AsyncMock()
+    telegram.notify_fat_finger = AsyncMock()
+    telegram.notify_circuit_breaker = AsyncMock()
+    telegram.notify_scenario_matched = AsyncMock()
+
+    await trading_cycle(
+        broker=broker,
+        overseas_broker=MagicMock(),
+        scenario_engine=MagicMock(evaluate=MagicMock(return_value=_make_hold_match())),
+        playbook=_make_playbook("KR"),
+        risk=MagicMock(),
+        db_conn=db_conn,
+        decision_logger=decision_logger,
+        context_store=MagicMock(
+            get_latest_timeframe=MagicMock(return_value=None),
+            set_context=MagicMock(),
+        ),
+        criticality_assessor=MagicMock(
+            assess_market_conditions=MagicMock(return_value=MagicMock(value="NORMAL")),
+            get_timeout=MagicMock(return_value=5.0),
+        ),
+        telegram=telegram,
+        market=market,
+        stock_code="005930",
+        scan_candidates={},
+    )
+
+    # No SELL order must be placed — current_price=0 must suppress stop-loss
+    broker.send_order.assert_not_called()
+
+
 @pytest.mark.asyncio
 async def test_sell_order_uses_broker_balance_qty_not_db() -> None:
     """SELL quantity must come from broker balance output1, not DB.
@@ -2497,9 +2858,11 @@ class TestBuyCooldown:
         )
         broker.get_overseas_balance = AsyncMock(return_value={
             "output1": [],
-            "output2": [{"frcr_dncl_amt_2": "50000", "frcr_evlu_tota": "50000",
-                         "frcr_buy_amt_smtl": "0"}],
+            "output2": [{"frcr_evlu_tota": "50000", "frcr_buy_amt_smtl": "0"}],
         })
+        broker.get_overseas_buying_power = AsyncMock(
+            return_value={"output": {"ord_psbl_frcr_amt": "50000"}}
+        )
         broker.send_overseas_order = AsyncMock(
             return_value={"rt_cd": "1", "msg1": "모의투자 주문가능금액이 부족합니다."}
         )
@@ -2612,9 +2975,11 @@ class TestBuyCooldown:
         )
         overseas_broker.get_overseas_balance = AsyncMock(return_value={
             "output1": [],
-            "output2": [{"frcr_dncl_amt_2": "50000", "frcr_evlu_tota": "50000",
-                         "frcr_buy_amt_smtl": "0"}],
+            "output2": [{"frcr_evlu_tota": "50000", "frcr_buy_amt_smtl": "0"}],
         })
+        overseas_broker.get_overseas_buying_power = AsyncMock(
+            return_value={"output": {"ord_psbl_frcr_amt": "50000"}}
+        )
         overseas_broker.send_overseas_order = AsyncMock(
             return_value={"rt_cd": "1", "msg1": "기타 오류 메시지"}
         )
@@ -3009,9 +3374,12 @@ async def test_buy_suppressed_when_open_position_exists() -> None:
     overseas_broker.get_overseas_balance = AsyncMock(
         return_value={
             "output1": [],
-            "output2": [{"frcr_dncl_amt_2": "10000", "frcr_evlu_tota": "10000", "frcr_buy_amt_smtl": "0"}],
+            "output2": [{"frcr_evlu_tota": "10000", "frcr_buy_amt_smtl": "0"}],
         }
     )
+    overseas_broker.get_overseas_buying_power = AsyncMock(
+        return_value={"output": {"ord_psbl_frcr_amt": "10000"}}
+    )
     overseas_broker.send_overseas_order = AsyncMock(return_value={"msg1": "OK"})
 
     engine = MagicMock(spec=ScenarioEngine)
@@ -3073,9 +3441,12 @@ async def test_buy_proceeds_when_no_open_position() -> None:
     overseas_broker.get_overseas_balance = AsyncMock(
         return_value={
             "output1": [],
-            "output2": [{"frcr_dncl_amt_2": "50000", "frcr_evlu_tota": "50000", "frcr_buy_amt_smtl": "0"}],
+            "output2": [{"frcr_evlu_tota": "50000", "frcr_buy_amt_smtl": "0"}],
         }
     )
+    overseas_broker.get_overseas_buying_power = AsyncMock(
+        return_value={"output": {"ord_psbl_frcr_amt": "50000"}}
+    )
     overseas_broker.send_overseas_order = AsyncMock(return_value={"msg1": "OK"})
 
     engine = MagicMock(spec=ScenarioEngine)
@@ -3176,13 +3547,15 @@ class TestOverseasBrokerIntegration:
                 "output1": [{"ovrs_pdno": "AAPL", "ovrs_cblc_qty": "10"}],
                 "output2": [
                     {
-                        "frcr_dncl_amt_2": "50000.00",
                         "frcr_evlu_tota": "60000.00",
                         "frcr_buy_amt_smtl": "50000.00",
                     }
                 ],
             }
         )
+        overseas_broker.get_overseas_buying_power = AsyncMock(
+            return_value={"output": {"ord_psbl_frcr_amt": "50000.00"}}
+        )
         overseas_broker.send_overseas_order = AsyncMock(return_value={"msg1": "주문접수"})
 
         engine = MagicMock(spec=ScenarioEngine)
@@ -3250,13 +3623,15 @@ class TestOverseasBrokerIntegration:
                 "output1": [],
                 "output2": [
                     {
-                        "frcr_dncl_amt_2": "50000.00",
                         "frcr_evlu_tota": "50000.00",
                         "frcr_buy_amt_smtl": "0.00",
                     }
                 ],
             }
         )
+        overseas_broker.get_overseas_buying_power = AsyncMock(
+            return_value={"output": {"ord_psbl_frcr_amt": "50000.00"}}
+        )
         overseas_broker.send_overseas_order = AsyncMock(return_value={"msg1": "주문접수"})
 
         engine = MagicMock(spec=ScenarioEngine)
@@ -3679,7 +4054,6 @@ class TestSyncPositionsFromBroker:
             "output2": [
                 {
                     "frcr_evlu_tota": "50000",
-                    "frcr_dncl_amt_2": "10000",
                     "frcr_buy_amt_smtl": "40000",
                 }
             ],
@@ -3818,6 +4192,70 @@ class TestSyncPositionsFromBroker:
         # Two distinct exchange codes (NASD, NYSE) → 2 calls
         assert overseas_broker.get_overseas_balance.call_count == 2
 
+    @pytest.mark.asyncio
+    async def test_syncs_domestic_position_with_correct_avg_price(self) -> None:
+        """Domestic position is stored with pchs_avg_pric as price (issue #249)."""
+        settings = self._make_settings("KR")
+        db_conn = init_db(":memory:")
+
+        balance = {
+            "output1": [{"pdno": "005930", "ord_psbl_qty": "5", "pchs_avg_pric": "68000.0"}],
+            "output2": [{"tot_evlu_amt": "1000000", "dnca_tot_amt": "500000", "pchs_amt_smtl_amt": "500000"}],
+        }
+        broker = MagicMock()
+        broker.get_balance = AsyncMock(return_value=balance)
+        overseas_broker = MagicMock()
+
+        await sync_positions_from_broker(broker, overseas_broker, db_conn, settings)
+
+        from src.db import get_open_position
+        pos = get_open_position(db_conn, "005930", "KR")
+        assert pos is not None
+        assert pos["price"] == 68000.0
+
+    @pytest.mark.asyncio
+    async def test_syncs_overseas_position_with_correct_avg_price(self) -> None:
+        """Overseas position is stored with pchs_avg_pric as price (issue #249)."""
+        settings = self._make_settings("US_NASDAQ")
+        db_conn = init_db(":memory:")
+
+        balance = {
+            "output1": [{"ovrs_pdno": "AAPL", "ovrs_cblc_qty": "10", "pchs_avg_pric": "170.0"}],
+            "output2": [{"frcr_evlu_tota": "50000", "frcr_buy_amt_smtl": "40000"}],
+        }
+        broker = MagicMock()
+        overseas_broker = MagicMock()
+        overseas_broker.get_overseas_balance = AsyncMock(return_value=balance)
+
+        await sync_positions_from_broker(broker, overseas_broker, db_conn, settings)
+
+        from src.db import get_open_position
+        pos = get_open_position(db_conn, "AAPL", "US_NASDAQ")
+        assert pos is not None
+        assert pos["price"] == 170.0
+
+    @pytest.mark.asyncio
+    async def test_syncs_position_with_zero_price_when_pchs_avg_pric_absent(self) -> None:
+        """Fallback to price=0.0 when pchs_avg_pric is absent (issue #249)."""
+        settings = self._make_settings("KR")
+        db_conn = init_db(":memory:")
+
+        # No pchs_avg_pric in output1
+        balance = {
+            "output1": [{"pdno": "005930", "ord_psbl_qty": "5"}],
+            "output2": [{"tot_evlu_amt": "1000000", "dnca_tot_amt": "500000", "pchs_amt_smtl_amt": "500000"}],
+        }
+        broker = MagicMock()
+        broker.get_balance = AsyncMock(return_value=balance)
+        overseas_broker = MagicMock()
+
+        await sync_positions_from_broker(broker, overseas_broker, db_conn, settings)
+
+        from src.db import get_open_position
+        pos = get_open_position(db_conn, "005930", "KR")
+        assert pos is not None
+        assert pos["price"] == 0.0
+
 
 # ---------------------------------------------------------------------------
 # Domestic BUY double-prevention (issue #206) — trading_cycle integration
@@ -4441,6 +4879,9 @@ class TestOverseasGhostPositionClose:
             return_value={"output": {"last": str(current_price), "rate": "0.0"}}
         )
         ob.get_overseas_balance = AsyncMock(return_value=balance_data)
+        ob.get_overseas_buying_power = AsyncMock(
+            return_value={"output": {"ord_psbl_frcr_amt": "0.00"}}
+        )
         ob.send_overseas_order = AsyncMock(return_value=sell_result)
         return ob
 
@@ -4463,7 +4904,7 @@ class TestOverseasGhostPositionClose:
             "output1": [
                 {"ovrs_pdno": stock_code, "ord_psbl_qty": "5", "ovrs_cblc_qty": "5"}
             ],
-            "output2": [{"tot_evlu_amt": "10000", "frcr_dncl_amt_2": "10000"}],
+            "output2": [{"tot_evlu_amt": "10000"}],
         }
         sell_result = {"rt_cd": "1", "msg1": "모의투자 잔고내역이 없습니다"}
 
@@ -4539,7 +4980,7 @@ class TestOverseasGhostPositionClose:
         current_price = 250.0
         balance_data = {
             "output1": [{"ovrs_pdno": stock_code, "ord_psbl_qty": "5", "ovrs_cblc_qty": "5"}],
-            "output2": [{"tot_evlu_amt": "100000", "frcr_dncl_amt_2": "100000"}],
+            "output2": [{"tot_evlu_amt": "100000"}],
         }
         sell_result = {"rt_cd": "1", "msg1": "일시적 오류가 발생했습니다"}
 

tests/test_overseas_broker.py

@@ -28,6 +28,7 @@ def mock_settings() -> Settings:
         KIS_APP_SECRET="test_secret",
         KIS_ACCOUNT_NO="12345678-01",
         GEMINI_API_KEY="test_gemini_key",
+        MODE="paper",  # Explicitly set to avoid .env MODE=live override
     )
 
 
@@ -122,9 +123,10 @@ class TestFetchOverseasRankings:
         params = call_args[1]["params"]
 
         assert "/uapi/overseas-stock/v1/ranking/updown-rate" in url
+        assert params["KEYB"] == ""  # Required by KIS API spec
         assert params["EXCD"] == "NAS"
         assert params["NDAY"] == "0"
-        assert params["GUBN"] == "0"  # 0=전체(상승+하락), 변동성 스캐너에 필요
+        assert params["GUBN"] == "1"  # 1=상승율 — 변동성 스캐너는 급등 종목 우선
         assert params["VOL_RANG"] == "0"
 
         overseas_broker._broker._auth_headers.assert_called_with("HHDFS76290000")
@@ -157,6 +159,7 @@ class TestFetchOverseasRankings:
         params = call_args[1]["params"]
 
         assert "/uapi/overseas-stock/v1/ranking/volume-surge" in url
+        assert params["KEYB"] == ""  # Required by KIS API spec
         assert params["EXCD"] == "NYS"
         assert params["MIXN"] == "0"
         assert params["VOL_RANG"] == "0"