fix: domestic current price fetching and KRX tick unit rounding (#157)

**Problem 1 — Current price always 0**
get_orderbook() used inquire-asking-price-exp-ccn which has no stck_prpr
in output1 (only askp/bidp data). This caused every domestic BUY to be
skipped with "no affordable quantity (cash=..., price=0.00)".

**Problem 2 — KRX tick unit error on limit orders**
Limit order prices were passed unrounded, triggering 호가단위 오류 in VTS.
Also ORD_DVSN was wrongly set to "01" (시장가) for limit orders.

**Fix**
- Add kr_tick_unit(price) and kr_round_down(price) module-level helpers
  implementing KRX 7-tier price tick rules (1/5/10/50/100/500/1000원).
- Add get_current_price(stock_code) → (price, change_pct, foreigner_net)
  using FHKST01010100 / inquire-price API (works in VTS, returns correct
  stck_prpr, prdy_ctrt, frgn_ntby_qty).
- Fix send_order() ORD_DVSN: "00"=지정가, "01"=시장가 (was "01"/"06").
- Apply kr_round_down() to limit order price inside send_order().
- Replace both get_orderbook() calls in main.py with get_current_price().
- Update all 4 test_main.py mock sites to use get_current_price AsyncMock.

**Tests added** (25 new tests, all 646 pass)
- TestKrTickUnit: 13 parametrized boundary cases + 7 round-down cases
- TestGetCurrentPrice: correct fields, correct API path/TR_ID, HTTP error
- TestSendOrderTickRounding: tick rounding, ORD_DVSN 00/01

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

src/broker/kis_api.py

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

src/broker/overseas.py

@@ -257,14 +257,27 @@ class OverseasBroker:
                         f"send_overseas_order failed ({resp.status}): {text}"
                     )
                 data = await resp.json()
-                logger.info(
-                    "Overseas order submitted",
-                    extra={
-                        "exchange": exchange_code,
-                        "stock_code": stock_code,
-                        "action": order_type,
-                    },
-                )
+                rt_cd = data.get("rt_cd", "")
+                msg1 = data.get("msg1", "")
+                if rt_cd == "0":
+                    logger.info(
+                        "Overseas order submitted",
+                        extra={
+                            "exchange": exchange_code,
+                            "stock_code": stock_code,
+                            "action": order_type,
+                        },
+                    )
+                else:
+                    logger.warning(
+                        "Overseas order rejected (rt_cd=%s): %s [%s %s %s qty=%d]",
+                        rt_cd,
+                        msg1,
+                        order_type,
+                        stock_code,
+                        exchange_code,
+                        quantity,
+                    )
                 return data
         except (TimeoutError, aiohttp.ClientError) as exc:
             raise ConnectionError(

src/main.py

@@ -204,7 +204,9 @@ async def trading_cycle(
 
     # 1. Fetch market data
     if market.is_domestic:
-        orderbook = await broker.get_orderbook(stock_code)
+        current_price, price_change_pct, foreigner_net = await broker.get_current_price(
+            stock_code
+        )
         balance_data = await broker.get_balance()
 
         output2 = balance_data.get("output2", [{}])
@@ -215,10 +217,6 @@ async def trading_cycle(
             else "0"
         )
         purchase_total = safe_float(output2[0].get("pchs_amt_smtl_amt", "0")) if output2 else 0
-
-        current_price = safe_float(orderbook.get("output1", {}).get("stck_prpr", "0"))
-        foreigner_net = safe_float(orderbook.get("output1", {}).get("frgn_ntby_qty", "0"))
-        price_change_pct = safe_float(orderbook.get("output1", {}).get("prdy_ctrt", "0"))
     else:
         # Overseas market
         price_data = await overseas_broker.get_overseas_price(
@@ -239,17 +237,27 @@ async def trading_cycle(
         total_cash = safe_float(balance_info.get("frcr_dncl_amt_2", "0") or "0")
         purchase_total = safe_float(balance_info.get("frcr_buy_amt_smtl", "0") or "0")
 
-        # VTS (paper trading) overseas balance API often returns 0 or errors.
-        # Fall back to configured paper cash so BUY orders can be sized.
+        # Paper mode fallback: VTS overseas balance API often fails for many accounts.
         if total_cash <= 0 and settings and settings.PAPER_OVERSEAS_CASH > 0:
             logger.debug(
-                "Overseas cash balance is 0 for %s; using paper fallback %.2f",
-                stock_code,
+                "Overseas cash balance is 0 for %s; using paper fallback %.2f USD",
+                market.exchange_code,
                 settings.PAPER_OVERSEAS_CASH,
             )
             total_cash = settings.PAPER_OVERSEAS_CASH
 
         current_price = safe_float(price_data.get("output", {}).get("last", "0"))
+        # Fallback: if price API returns 0, use scanner candidate price
+        if current_price <= 0:
+            market_candidates_lookup = scan_candidates.get(market.code, {})
+            cand_lookup = market_candidates_lookup.get(stock_code)
+            if cand_lookup and cand_lookup.price > 0:
+                logger.debug(
+                    "Price API returned 0 for %s; using scanner candidate price %.4f",
+                    stock_code,
+                    cand_lookup.price,
+                )
+                current_price = cand_lookup.price
         foreigner_net = 0.0  # Not available for overseas
         price_change_pct = safe_float(price_data.get("output", {}).get("rate", "0"))
 
@@ -497,6 +505,7 @@ async def trading_cycle(
             raise  # Re-raise to prevent trade
 
         # 5. Send order
+        order_succeeded = True
         if market.is_domestic:
             result = await broker.send_order(
                 stock_code=stock_code,
@@ -505,29 +514,48 @@ async def trading_cycle(
                 price=0,  # market order
             )
         else:
+            # For overseas orders:
+            # - KIS VTS only accepts limit orders (지정가만 가능)
+            # - BUY: use 0.5% premium over last price to improve fill probability
+            #   (ask price is typically slightly above last, and VTS won't fill below ask)
+            # - SELL: use last price as the limit
+            if decision.action == "BUY":
+                order_price = round(current_price * 1.005, 4)
+            else:
+                order_price = current_price
             result = await overseas_broker.send_overseas_order(
                 exchange_code=market.exchange_code,
                 stock_code=stock_code,
                 order_type=decision.action,
                 quantity=quantity,
-                price=current_price,  # limit order — KIS VTS rejects market orders
+                price=order_price,  # limit order — KIS VTS rejects market orders
             )
+            # Check if KIS rejected the order (rt_cd != "0")
+            if result.get("rt_cd", "") != "0":
+                order_succeeded = False
+                logger.warning(
+                    "Overseas order not accepted for %s: rt_cd=%s msg=%s",
+                    stock_code,
+                    result.get("rt_cd"),
+                    result.get("msg1"),
+                )
         logger.info("Order result: %s", result.get("msg1", "OK"))
 
-        # 5.5. Notify trade execution
-        try:
-            await telegram.notify_trade_execution(
-                stock_code=stock_code,
-                market=market.name,
-                action=decision.action,
-                quantity=quantity,
-                price=current_price,
-                confidence=decision.confidence,
-            )
-        except Exception as exc:
-            logger.warning("Telegram notification failed: %s", exc)
+        # 5.5. Notify trade execution (only on success)
+        if order_succeeded:
+            try:
+                await telegram.notify_trade_execution(
+                    stock_code=stock_code,
+                    market=market.name,
+                    action=decision.action,
+                    quantity=quantity,
+                    price=current_price,
+                    confidence=decision.confidence,
+                )
+            except Exception as exc:
+                logger.warning("Telegram notification failed: %s", exc)
 
-        if decision.action == "SELL":
+        if decision.action == "SELL" and order_succeeded:
             buy_trade = get_latest_buy_trade(db_conn, stock_code, market.code)
             if buy_trade and buy_trade.get("price") is not None:
                 buy_price = float(buy_trade["price"])
@@ -539,7 +567,9 @@ async def trading_cycle(
                     accuracy=1 if trade_pnl > 0 else 0,
                 )
 
-    # 6. Log trade with selection context
+    # 6. Log trade with selection context (skip if order was rejected)
+    if decision.action in ("BUY", "SELL") and not order_succeeded:
+        return
     selection_context = None
     if stock_code in market_candidates:
         candidate = market_candidates[stock_code]
@@ -694,15 +724,8 @@ async def run_daily_session(
         for stock_code in watchlist:
             try:
                 if market.is_domestic:
-                    orderbook = await broker.get_orderbook(stock_code)
-                    current_price = safe_float(
-                        orderbook.get("output1", {}).get("stck_prpr", "0")
-                    )
-                    foreigner_net = safe_float(
-                        orderbook.get("output1", {}).get("frgn_ntby_qty", "0")
-                    )
-                    price_change_pct = safe_float(
-                        orderbook.get("output1", {}).get("prdy_ctrt", "0")
+                    current_price, price_change_pct, foreigner_net = (
+                        await broker.get_current_price(stock_code)
                     )
                 else:
                     price_data = await overseas_broker.get_overseas_price(
@@ -711,6 +734,16 @@ async def run_daily_session(
                     current_price = safe_float(
                         price_data.get("output", {}).get("last", "0")
                     )
+                    # Fallback: if price API returns 0, use scanner candidate price
+                    if current_price <= 0:
+                        cand_lookup = candidate_map.get(stock_code)
+                        if cand_lookup and cand_lookup.price > 0:
+                            logger.debug(
+                                "Price API returned 0 for %s; using scanner candidate price %.4f",
+                                stock_code,
+                                cand_lookup.price,
+                            )
+                            current_price = cand_lookup.price
                     foreigner_net = 0.0
                     price_change_pct = safe_float(
                         price_data.get("output", {}).get("rate", "0")
@@ -775,6 +808,9 @@ async def run_daily_session(
             purchase_total = safe_float(
                 balance_info.get("frcr_buy_amt_smtl", "0") or "0"
             )
+            # Paper mode fallback: VTS overseas balance API often fails for many accounts.
+            if total_cash <= 0 and settings.PAPER_OVERSEAS_CASH > 0:
+                total_cash = settings.PAPER_OVERSEAS_CASH
 
             # VTS overseas balance API often returns 0; use paper fallback.
             if total_cash <= 0 and settings.PAPER_OVERSEAS_CASH > 0:
@@ -853,6 +889,7 @@ async def run_daily_session(
             quantity = 0
             trade_price = stock_data["current_price"]
             trade_pnl = 0.0
+            order_succeeded = True
             if decision.action in ("BUY", "SELL"):
                 quantity = _determine_order_quantity(
                     action=decision.action,
@@ -905,6 +942,7 @@ async def run_daily_session(
                     raise
 
                 # Send order
+                order_succeeded = True
                 try:
                     if market.is_domestic:
                         result = await broker.send_order(
@@ -914,34 +952,48 @@ async def run_daily_session(
                             price=0,  # market order
                         )
                     else:
+                        # KIS VTS only accepts limit orders; use 0.5% premium for BUY
+                        if decision.action == "BUY":
+                            order_price = round(stock_data["current_price"] * 1.005, 4)
+                        else:
+                            order_price = stock_data["current_price"]
                         result = await overseas_broker.send_overseas_order(
                             exchange_code=market.exchange_code,
                             stock_code=stock_code,
                             order_type=decision.action,
                             quantity=quantity,
-                            price=stock_data["current_price"],  # limit order — KIS VTS rejects market orders
+                            price=order_price,  # limit order
                         )
+                        if result.get("rt_cd", "") != "0":
+                            order_succeeded = False
+                            logger.warning(
+                                "Overseas order not accepted for %s: rt_cd=%s msg=%s",
+                                stock_code,
+                                result.get("rt_cd"),
+                                result.get("msg1"),
+                            )
                     logger.info("Order result: %s", result.get("msg1", "OK"))
 
-                    # Notify trade execution
-                    try:
-                        await telegram.notify_trade_execution(
-                            stock_code=stock_code,
-                            market=market.name,
-                            action=decision.action,
-                            quantity=quantity,
-                            price=stock_data["current_price"],
-                            confidence=decision.confidence,
-                        )
-                    except Exception as exc:
-                        logger.warning("Telegram notification failed: %s", exc)
+                    # Notify trade execution (only on success)
+                    if order_succeeded:
+                        try:
+                            await telegram.notify_trade_execution(
+                                stock_code=stock_code,
+                                market=market.name,
+                                action=decision.action,
+                                quantity=quantity,
+                                price=stock_data["current_price"],
+                                confidence=decision.confidence,
+                            )
+                        except Exception as exc:
+                            logger.warning("Telegram notification failed: %s", exc)
                 except Exception as exc:
                     logger.error(
                         "Order execution failed for %s: %s", stock_code, exc
                     )
                     continue
 
-                if decision.action == "SELL":
+                if decision.action == "SELL" and order_succeeded:
                     buy_trade = get_latest_buy_trade(db_conn, stock_code, market.code)
                     if buy_trade and buy_trade.get("price") is not None:
                         buy_price = float(buy_trade["price"])
@@ -953,7 +1005,9 @@ async def run_daily_session(
                             accuracy=1 if trade_pnl > 0 else 0,
                         )
 
-            # Log trade
+            # Log trade (skip if order was rejected by API)
+            if decision.action in ("BUY", "SELL") and not order_succeeded:
+                continue
             log_trade(
                 conn=db_conn,
                 stock_code=stock_code,

tests/test_broker.py

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

tests/test_main.py

@@ -111,15 +111,7 @@ class TestTradingCycleTelegramIntegration:
     def mock_broker(self) -> MagicMock:
         """Create mock broker."""
         broker = MagicMock()
-        broker.get_orderbook = AsyncMock(
-            return_value={
-                "output1": {
-                    "stck_prpr": "50000",
-                    "frgn_ntby_qty": "100",
-                    "prdy_ctrt": "1.23",
-                }
-            }
-        )
+        broker.get_current_price = AsyncMock(return_value=(50000.0, 1.23, 100.0))
         broker.get_balance = AsyncMock(
             return_value={
                 "output2": [
@@ -805,13 +797,14 @@ class TestOverseasBalanceParsing:
                 scan_candidates={},
             )
 
-        # Verify limit order was sent with actual price, not 0.0
+        # Verify limit order was sent with actual price + 0.5% premium (issue #151), not 0.0
         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]
-        assert sent_price == 182.5, (
-            f"Expected limit price 182.5 but got {sent_price}. "
-            "KIS VTS only accepts limit orders for overseas paper trading."
+        expected_price = round(182.5 * 1.005, 4)  # 0.5% premium for BUY limit orders
+        assert sent_price == expected_price, (
+            f"Expected limit price {expected_price} (182.5 * 1.005) but got {sent_price}. "
+            "KIS VTS only accepts limit orders; BUY uses 0.5% premium to improve fill rate."
         )
 
 
@@ -822,11 +815,7 @@ class TestScenarioEngineIntegration:
     def mock_broker(self) -> MagicMock:
         """Create mock broker with standard domestic data."""
         broker = MagicMock()
-        broker.get_orderbook = AsyncMock(
-            return_value={
-                "output1": {"stck_prpr": "50000", "frgn_ntby_qty": "100", "prdy_ctrt": "2.50"}
-            }
-        )
+        broker.get_current_price = AsyncMock(return_value=(50000.0, 2.50, 100.0))
         broker.get_balance = AsyncMock(
             return_value={
                 "output2": [
@@ -1248,9 +1237,7 @@ async def test_sell_updates_original_buy_decision_outcome() -> None:
     )
 
     broker = MagicMock()
-    broker.get_orderbook = AsyncMock(
-        return_value={"output1": {"stck_prpr": "120", "frgn_ntby_qty": "0"}}
-    )
+    broker.get_current_price = AsyncMock(return_value=(120.0, 0.0, 0.0))
     broker.get_balance = AsyncMock(
         return_value={
             "output2": [
@@ -1340,9 +1327,7 @@ async def test_hold_overridden_to_sell_when_stop_loss_triggered() -> None:
     )
 
     broker = MagicMock()
-    broker.get_orderbook = AsyncMock(
-        return_value={"output1": {"stck_prpr": "95", "frgn_ntby_qty": "0", "prdy_ctrt": "-5.0"}}
-    )
+    broker.get_current_price = AsyncMock(return_value=(95.0, -5.0, 0.0))
     broker.get_balance = AsyncMock(
         return_value={
             "output2": [

tests/test_overseas_broker.py

@@ -302,8 +302,7 @@ class TestGetOverseasPrice:
 
         call_args = mock_session.get.call_args
         params = call_args[1]["params"]
-        # NASD is mapped to NAS for the price inquiry API (same as ranking API).
-        assert params["EXCD"] == "NAS"
+        assert params["EXCD"] == "NAS"  # NASD → NAS via _PRICE_EXCHANGE_MAP
         assert params["SYMB"] == "AAPL"
 
     @pytest.mark.asyncio
@@ -522,58 +521,32 @@ class TestExtractRankingRows:
         assert overseas_broker._extract_ranking_rows(data) == [{"a": 1}, {"b": 2}]
 
 
-# ---------------------------------------------------------------------------
-# Price exchange code mapping
-# ---------------------------------------------------------------------------
-
-
 class TestPriceExchangeMap:
-    """Test that get_overseas_price uses the short exchange codes."""
+    """Test _PRICE_EXCHANGE_MAP is applied in get_overseas_price (issue #151)."""
 
     def test_price_map_equals_ranking_map(self) -> None:
         assert _PRICE_EXCHANGE_MAP is _RANKING_EXCHANGE_MAP
 
-    def test_nasd_maps_to_nas(self) -> None:
-        assert _PRICE_EXCHANGE_MAP["NASD"] == "NAS"
-
-    def test_amex_maps_to_ams(self) -> None:
-        assert _PRICE_EXCHANGE_MAP["AMEX"] == "AMS"
-
-    def test_nyse_maps_to_nys(self) -> None:
-        assert _PRICE_EXCHANGE_MAP["NYSE"] == "NYS"
+    @pytest.mark.parametrize("original,expected", [
+        ("NASD", "NAS"),
+        ("NYSE", "NYS"),
+        ("AMEX", "AMS"),
+    ])
+    def test_us_exchange_code_mapping(self, original: str, expected: str) -> None:
+        assert _PRICE_EXCHANGE_MAP[original] == expected
 
     @pytest.mark.asyncio
-    async def test_get_overseas_price_uses_mapped_excd(
+    async def test_get_overseas_price_sends_mapped_code(
         self, overseas_broker: OverseasBroker
     ) -> None:
-        """AMEX should be sent as AMS to the price API."""
+        """NASD → NAS must be sent to HHDFS00000300."""
         mock_resp = AsyncMock()
         mock_resp.status = 200
-        mock_resp.json = AsyncMock(return_value={"output": {"last": "44.30"}})
+        mock_resp.json = AsyncMock(return_value={"output": {"last": "200.00"}})
 
         mock_session = MagicMock()
         mock_session.get = MagicMock(return_value=_make_async_cm(mock_resp))
         _setup_broker_mocks(overseas_broker, mock_session)
-        overseas_broker._broker._auth_headers = AsyncMock(return_value={})
-
-        await overseas_broker.get_overseas_price("AMEX", "EWUS")
-
-        params = mock_session.get.call_args[1]["params"]
-        assert params["EXCD"] == "AMS"  # mapped, not raw "AMEX"
-        assert params["SYMB"] == "EWUS"
-
-    @pytest.mark.asyncio
-    async def test_get_overseas_price_nasd_uses_nas(
-        self, overseas_broker: OverseasBroker
-    ) -> None:
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(return_value={"output": {"last": "220.00"}})
-
-        mock_session = MagicMock()
-        mock_session.get = MagicMock(return_value=_make_async_cm(mock_resp))
-        _setup_broker_mocks(overseas_broker, mock_session)
-        overseas_broker._broker._auth_headers = AsyncMock(return_value={})
 
         await overseas_broker.get_overseas_price("NASD", "AAPL")
 
@@ -581,37 +554,90 @@ class TestPriceExchangeMap:
         assert params["EXCD"] == "NAS"
 
 
-# ---------------------------------------------------------------------------
-# PAPER_OVERSEAS_CASH config default
-# ---------------------------------------------------------------------------
+class TestOrderRtCdCheck:
+    """Test that send_overseas_order checks rt_cd and logs accordingly (issue #151)."""
+
+    @pytest.fixture
+    def overseas_broker(self, mock_settings: Settings) -> OverseasBroker:
+        broker = MagicMock(spec=KISBroker)
+        broker._settings = mock_settings
+        broker._account_no = "12345678"
+        broker._product_cd = "01"
+        broker._base_url = "https://openapivts.koreainvestment.com:9443"
+        broker._rate_limiter = AsyncMock()
+        broker._rate_limiter.acquire = AsyncMock()
+        broker._auth_headers = AsyncMock(return_value={"authorization": "Bearer t"})
+        broker._get_hash_key = AsyncMock(return_value="hashval")
+        return OverseasBroker(broker)
+
+    @pytest.mark.asyncio
+    async def test_success_rt_cd_returns_data(
+        self, overseas_broker: OverseasBroker
+    ) -> None:
+        """rt_cd='0' → order accepted, data returned."""
+        mock_resp = AsyncMock()
+        mock_resp.status = 200
+        mock_resp.json = AsyncMock(return_value={"rt_cd": "0", "msg1": "완료"})
+
+        mock_session = MagicMock()
+        mock_session.post = MagicMock(return_value=_make_async_cm(mock_resp))
+        overseas_broker._broker._get_session = MagicMock(return_value=mock_session)
+
+        result = await overseas_broker.send_overseas_order("NASD", "AAPL", "BUY", 10, price=150.0)
+        assert result["rt_cd"] == "0"
+
+    @pytest.mark.asyncio
+    async def test_error_rt_cd_returns_data_with_msg(
+        self, overseas_broker: OverseasBroker
+    ) -> None:
+        """rt_cd != '0' → order rejected, data still returned (caller checks rt_cd)."""
+        mock_resp = AsyncMock()
+        mock_resp.status = 200
+        mock_resp.json = AsyncMock(
+            return_value={"rt_cd": "1", "msg1": "주문가능금액이 부족합니다."}
+        )
+
+        mock_session = MagicMock()
+        mock_session.post = MagicMock(return_value=_make_async_cm(mock_resp))
+        overseas_broker._broker._get_session = MagicMock(return_value=mock_session)
+
+        result = await overseas_broker.send_overseas_order("NASD", "AAPL", "BUY", 10, price=150.0)
+        assert result["rt_cd"] == "1"
+        assert "부족" in result["msg1"]
 
 
 class TestPaperOverseasCash:
+    """Test PAPER_OVERSEAS_CASH config setting (issue #151)."""
+
     def test_default_value(self) -> None:
         settings = Settings(
-            KIS_APP_KEY="x",
-            KIS_APP_SECRET="x",
+            KIS_APP_KEY="k",
+            KIS_APP_SECRET="s",
             KIS_ACCOUNT_NO="12345678-01",
-            GEMINI_API_KEY="x",
+            GEMINI_API_KEY="g",
         )
         assert settings.PAPER_OVERSEAS_CASH == 50000.0
 
-    def test_can_be_set_via_env(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        monkeypatch.setenv("PAPER_OVERSEAS_CASH", "100000.0")
+    def test_env_override(self) -> None:
+        import os
+        os.environ["PAPER_OVERSEAS_CASH"] = "25000"
         settings = Settings(
-            KIS_APP_KEY="x",
-            KIS_APP_SECRET="x",
+            KIS_APP_KEY="k",
+            KIS_APP_SECRET="s",
             KIS_ACCOUNT_NO="12345678-01",
-            GEMINI_API_KEY="x",
+            GEMINI_API_KEY="g",
         )
-        assert settings.PAPER_OVERSEAS_CASH == 100000.0
+        assert settings.PAPER_OVERSEAS_CASH == 25000.0
+        del os.environ["PAPER_OVERSEAS_CASH"]
 
     def test_zero_disables_fallback(self) -> None:
+        import os
+        os.environ["PAPER_OVERSEAS_CASH"] = "0"
         settings = Settings(
-            KIS_APP_KEY="x",
-            KIS_APP_SECRET="x",
+            KIS_APP_KEY="k",
+            KIS_APP_SECRET="s",
             KIS_ACCOUNT_NO="12345678-01",
-            GEMINI_API_KEY="x",
-            PAPER_OVERSEAS_CASH=0.0,
+            GEMINI_API_KEY="g",
         )
         assert settings.PAPER_OVERSEAS_CASH == 0.0
+        del os.environ["PAPER_OVERSEAS_CASH"]