docs: add requirements log entry for overseas limit order fix (#149)

KIS VTS (paper trading) rejects overseas market orders with:
  "모의투자 주문처리가 안되었습니다(지정가만 가능한 상품입니다)"

Root cause: send_overseas_order() was called with price=0.0 (market order)
in both trading_cycle() and run_daily_session(), even though current_price
was already computed correctly by Fix #147 (exchange code mapping).

Fix: pass current_price as the limit order price in both call sites.
Domestic broker send_order() keeps price=0 (market orders are fine on KRX).

Adds regression test TestOverseasBalanceParsing::test_overseas_buy_order_uses_limit_price
verifying price=182.5 is passed, not 0.0.

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

docs/requirements-log.md

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

scripts/morning_report.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+# Morning summary for overnight run logs.
+
+set -euo pipefail
+
+LOG_DIR="${LOG_DIR:-data/overnight}"
+
+if [ ! -d "$LOG_DIR" ]; then
+    echo "로그 디렉터리가 없습니다: $LOG_DIR"
+    exit 1
+fi
+
+latest_run="$(ls -1t "$LOG_DIR"/run_*.log 2>/dev/null | head -n 1 || true)"
+latest_watchdog="$(ls -1t "$LOG_DIR"/watchdog_*.log 2>/dev/null | head -n 1 || true)"
+
+if [ -z "$latest_run" ]; then
+    echo "run 로그가 없습니다: $LOG_DIR/run_*.log"
+    exit 1
+fi
+
+echo "Overnight report"
+echo "- run log: $latest_run"
+if [ -n "$latest_watchdog" ]; then
+    echo "- watchdog log: $latest_watchdog"
+fi
+
+start_line="$(head -n 1 "$latest_run" || true)"
+end_line="$(tail -n 1 "$latest_run" || true)"
+
+info_count="$(rg -c '"level": "INFO"' "$latest_run" || true)"
+warn_count="$(rg -c '"level": "WARNING"' "$latest_run" || true)"
+error_count="$(rg -c '"level": "ERROR"' "$latest_run" || true)"
+critical_count="$(rg -c '"level": "CRITICAL"' "$latest_run" || true)"
+traceback_count="$(rg -c 'Traceback' "$latest_run" || true)"
+
+echo "- start: ${start_line:-N/A}"
+echo "- end:   ${end_line:-N/A}"
+echo "- INFO: ${info_count:-0}"
+echo "- WARNING: ${warn_count:-0}"
+echo "- ERROR: ${error_count:-0}"
+echo "- CRITICAL: ${critical_count:-0}"
+echo "- Traceback: ${traceback_count:-0}"
+
+if [ -n "$latest_watchdog" ]; then
+    watchdog_errors="$(rg -c '\[ERROR\]' "$latest_watchdog" || true)"
+    echo "- watchdog ERROR: ${watchdog_errors:-0}"
+    echo ""
+    echo "최근 watchdog 로그:"
+    tail -n 5 "$latest_watchdog" || true
+fi
+
+echo ""
+echo "최근 앱 로그:"
+tail -n 20 "$latest_run" || true

scripts/run_overnight.sh

@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+# Start The Ouroboros overnight with logs and watchdog.
+
+set -euo pipefail
+
+LOG_DIR="${LOG_DIR:-data/overnight}"
+CHECK_INTERVAL="${CHECK_INTERVAL:-30}"
+TMUX_AUTO="${TMUX_AUTO:-true}"
+TMUX_ATTACH="${TMUX_ATTACH:-true}"
+TMUX_SESSION_PREFIX="${TMUX_SESSION_PREFIX:-ouroboros_overnight}"
+
+if [ -z "${APP_CMD:-}" ]; then
+    if [ -x ".venv/bin/python" ]; then
+        PYTHON_BIN=".venv/bin/python"
+    elif command -v python3 >/dev/null 2>&1; then
+        PYTHON_BIN="python3"
+    elif command -v python >/dev/null 2>&1; then
+        PYTHON_BIN="python"
+    else
+        echo ".venv/bin/python 또는 python3/python 실행 파일을 찾을 수 없습니다."
+        exit 1
+    fi
+
+    dashboard_port="${DASHBOARD_PORT:-8080}"
+
+    APP_CMD="DASHBOARD_PORT=$dashboard_port $PYTHON_BIN -m src.main --mode=paper --dashboard"
+fi
+
+mkdir -p "$LOG_DIR"
+
+timestamp="$(date +"%Y%m%d_%H%M%S")"
+RUN_LOG="$LOG_DIR/run_${timestamp}.log"
+WATCHDOG_LOG="$LOG_DIR/watchdog_${timestamp}.log"
+PID_FILE="$LOG_DIR/app.pid"
+WATCHDOG_PID_FILE="$LOG_DIR/watchdog.pid"
+
+if [ -f "$PID_FILE" ]; then
+    old_pid="$(cat "$PID_FILE" || true)"
+    if [ -n "$old_pid" ] && kill -0 "$old_pid" 2>/dev/null; then
+        echo "앱이 이미 실행 중입니다. pid=$old_pid"
+        exit 1
+    fi
+fi
+
+echo "[$(date -u +"%Y-%m-%dT%H:%M:%SZ")] starting: $APP_CMD" | tee -a "$RUN_LOG"
+nohup bash -lc "$APP_CMD" >>"$RUN_LOG" 2>&1 &
+app_pid=$!
+echo "$app_pid" > "$PID_FILE"
+
+echo "[$(date -u +"%Y-%m-%dT%H:%M:%SZ")] app pid=$app_pid" | tee -a "$RUN_LOG"
+
+nohup env PID_FILE="$PID_FILE" LOG_FILE="$WATCHDOG_LOG" CHECK_INTERVAL="$CHECK_INTERVAL" \
+    bash scripts/watchdog.sh >/dev/null 2>&1 &
+watchdog_pid=$!
+echo "$watchdog_pid" > "$WATCHDOG_PID_FILE"
+
+cat <<EOF
+시작 완료
+- app pid: $app_pid
+- watchdog pid: $watchdog_pid
+- app log: $RUN_LOG
+- watchdog log: $WATCHDOG_LOG
+
+실시간 확인:
+tail -f "$RUN_LOG"
+tail -f "$WATCHDOG_LOG"
+EOF
+
+if [ "$TMUX_AUTO" = "true" ]; then
+    if ! command -v tmux >/dev/null 2>&1; then
+        echo "tmux를 찾지 못해 자동 세션 생성은 건너뜁니다."
+        exit 0
+    fi
+
+    session_name="${TMUX_SESSION_PREFIX}_${timestamp}"
+    window_name="overnight"
+    tmux new-session -d -s "$session_name" -n "$window_name" "tail -f '$RUN_LOG'"
+    tmux split-window -t "${session_name}:${window_name}" -v "tail -f '$WATCHDOG_LOG'"
+    tmux select-layout -t "${session_name}:${window_name}" even-vertical
+
+    echo "tmux session 생성: $session_name"
+    echo "수동 접속: tmux attach -t $session_name"
+
+    if [ -z "${TMUX:-}" ] && [ "$TMUX_ATTACH" = "true" ]; then
+        tmux attach -t "$session_name"
+    fi
+fi

scripts/stop_overnight.sh

@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+# Stop The Ouroboros overnight app/watchdog/tmux session.
+
+set -euo pipefail
+
+LOG_DIR="${LOG_DIR:-data/overnight}"
+PID_FILE="$LOG_DIR/app.pid"
+WATCHDOG_PID_FILE="$LOG_DIR/watchdog.pid"
+TMUX_SESSION_PREFIX="${TMUX_SESSION_PREFIX:-ouroboros_overnight}"
+KILL_TIMEOUT="${KILL_TIMEOUT:-5}"
+
+stop_pid() {
+    local name="$1"
+    local pid="$2"
+
+    if [ -z "$pid" ]; then
+        echo "$name PID가 비어 있습니다."
+        return 1
+    fi
+
+    if ! kill -0 "$pid" 2>/dev/null; then
+        echo "$name 프로세스가 이미 종료됨 (pid=$pid)"
+        return 0
+    fi
+
+    kill "$pid" 2>/dev/null || true
+    for _ in $(seq 1 "$KILL_TIMEOUT"); do
+        if ! kill -0 "$pid" 2>/dev/null; then
+            echo "$name 종료됨 (pid=$pid)"
+            return 0
+        fi
+        sleep 1
+    done
+
+    kill -9 "$pid" 2>/dev/null || true
+    if ! kill -0 "$pid" 2>/dev/null; then
+        echo "$name 강제 종료됨 (pid=$pid)"
+        return 0
+    fi
+
+    echo "$name 종료 실패 (pid=$pid)"
+    return 1
+}
+
+status=0
+
+if [ -f "$WATCHDOG_PID_FILE" ]; then
+    watchdog_pid="$(cat "$WATCHDOG_PID_FILE" || true)"
+    stop_pid "watchdog" "$watchdog_pid" || status=1
+    rm -f "$WATCHDOG_PID_FILE"
+else
+    echo "watchdog pid 파일 없음: $WATCHDOG_PID_FILE"
+fi
+
+if [ -f "$PID_FILE" ]; then
+    app_pid="$(cat "$PID_FILE" || true)"
+    stop_pid "app" "$app_pid" || status=1
+    rm -f "$PID_FILE"
+else
+    echo "app pid 파일 없음: $PID_FILE"
+fi
+
+if command -v tmux >/dev/null 2>&1; then
+    sessions="$(tmux ls 2>/dev/null | awk -F: -v p="$TMUX_SESSION_PREFIX" '$1 ~ "^" p "_" {print $1}')"
+    if [ -n "$sessions" ]; then
+        while IFS= read -r s; do
+            [ -z "$s" ] && continue
+            tmux kill-session -t "$s" 2>/dev/null || true
+            echo "tmux 세션 종료: $s"
+        done <<< "$sessions"
+    else
+        echo "종료할 tmux 세션 없음 (prefix=${TMUX_SESSION_PREFIX}_)"
+    fi
+fi
+
+exit "$status"

scripts/watchdog.sh

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+# Simple watchdog for The Ouroboros process.
+
+set -euo pipefail
+
+PID_FILE="${PID_FILE:-data/overnight/app.pid}"
+LOG_FILE="${LOG_FILE:-data/overnight/watchdog.log}"
+CHECK_INTERVAL="${CHECK_INTERVAL:-30}"
+STATUS_EVERY="${STATUS_EVERY:-10}"
+
+mkdir -p "$(dirname "$LOG_FILE")"
+
+log() {
+    printf '%s %s\n' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")" "$1" | tee -a "$LOG_FILE"
+}
+
+if [ ! -f "$PID_FILE" ]; then
+    log "[ERROR] pid file not found: $PID_FILE"
+    exit 1
+fi
+
+PID="$(cat "$PID_FILE")"
+if [ -z "$PID" ]; then
+    log "[ERROR] pid file is empty: $PID_FILE"
+    exit 1
+fi
+
+log "[INFO] watchdog started (pid=$PID, interval=${CHECK_INTERVAL}s)"
+
+count=0
+while true; do
+    if kill -0 "$PID" 2>/dev/null; then
+        count=$((count + 1))
+        if [ $((count % STATUS_EVERY)) -eq 0 ]; then
+            log "[INFO] process alive (pid=$PID)"
+        fi
+    else
+        log "[ERROR] process stopped (pid=$PID)"
+        exit 1
+    fi
+    sleep "$CHECK_INTERVAL"
+done

src/analysis/smart_scanner.py

@@ -315,6 +315,11 @@ class SmartVolatilityScanner:
             logger.info("Overseas scanner: no symbol universe for %s", market.name)
             return []
 
+        logger.info(
+            "Overseas scanner: scanning %d fallback symbols for %s",
+            len(symbols),
+            market.name,
+        )
         candidates: list[ScanCandidate] = []
         for stock_code in symbols:
             try:
@@ -350,6 +355,11 @@ class SmartVolatilityScanner:
                 logger.warning("Failed to analyze overseas %s: %s", stock_code, exc)
             except Exception as exc:
                 logger.error("Unexpected error analyzing overseas %s: %s", stock_code, exc)
+        logger.info(
+            "Overseas symbol fallback scan found %d candidates for %s",
+            len(candidates),
+            market.name,
+        )
         return candidates
 
     def get_stock_codes(self, candidates: list[ScanCandidate]) -> list[str]:

src/brain/gemini_client.py

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

src/broker/kis_api.py

@@ -104,12 +104,14 @@ class KISBroker:
             time_since_last_attempt = now - self._last_refresh_attempt
             if time_since_last_attempt < self._refresh_cooldown:
                 remaining = self._refresh_cooldown - time_since_last_attempt
-                error_msg = (
-                    f"Token refresh on cooldown. "
-                    f"Retry in {remaining:.1f}s (KIS allows 1/minute)"
+                # Do not fail fast here. If token is unavailable, upstream calls
+                # will all fail for up to a minute and scanning returns no trades.
+                logger.warning(
+                    "Token refresh on cooldown. Waiting %.1fs before retry (KIS allows 1/minute)",
+                    remaining,
                 )
-                logger.warning(error_msg)
-                raise ConnectionError(error_msg)
+                await asyncio.sleep(remaining)
+                now = asyncio.get_event_loop().time()
 
             logger.info("Refreshing KIS access token")
             self._last_refresh_attempt = now

src/broker/overseas.py

@@ -12,6 +12,24 @@ from src.broker.kis_api import KISBroker
 logger = logging.getLogger(__name__)
 
 
+# Ranking API uses different exchange codes than order/quote APIs.
+_RANKING_EXCHANGE_MAP: dict[str, str] = {
+    "NASD": "NAS",
+    "NYSE": "NYS",
+    "AMEX": "AMS",
+    "SEHK": "HKS",
+    "SHAA": "SHS",
+    "SZAA": "SZS",
+    "HSX": "HSX",
+    "HNX": "HNX",
+    "TSE": "TSE",
+}
+
+# Price inquiry API (HHDFS00000300) uses the same short exchange codes as rankings.
+# NASD → NAS, NYSE → NYS, AMEX → AMS (confirmed: AMEX returns empty, AMS returns price).
+_PRICE_EXCHANGE_MAP: dict[str, str] = _RANKING_EXCHANGE_MAP
+
+
 class OverseasBroker:
     """KIS Overseas Stock API wrapper that reuses KISBroker infrastructure."""
 
@@ -44,9 +62,11 @@ class OverseasBroker:
         session = self._broker._get_session()
 
         headers = await self._broker._auth_headers("HHDFS00000300")
+        # Map internal exchange codes to the short form expected by the price API.
+        price_excd = _PRICE_EXCHANGE_MAP.get(exchange_code, exchange_code)
         params = {
             "AUTH": "",
-            "EXCD": exchange_code,
+            "EXCD": price_excd,
             "SYMB": stock_code,
         }
         url = f"{self._broker._base_url}/uapi/overseas-price/v1/quotations/price"
@@ -70,7 +90,7 @@ class OverseasBroker:
         ranking_type: str = "fluctuation",
         limit: int = 30,
     ) -> list[dict[str, Any]]:
-        """Fetch overseas rankings (price change or volume amount).
+        """Fetch overseas rankings (price change or volume surge).
 
         Ranking API specs may differ by account/product. Endpoint paths and
         TR_IDs are configurable via settings and can be overridden in .env.
@@ -81,47 +101,63 @@ class OverseasBroker:
         await self._broker._rate_limiter.acquire()
         session = self._broker._get_session()
 
+        ranking_excd = _RANKING_EXCHANGE_MAP.get(exchange_code, exchange_code)
+
         if ranking_type == "volume":
             tr_id = self._broker._settings.OVERSEAS_RANKING_VOLUME_TR_ID
             path = self._broker._settings.OVERSEAS_RANKING_VOLUME_PATH
+            params: dict[str, str] = {
+                "AUTH": "",
+                "EXCD": ranking_excd,
+                "MIXN": "0",
+                "VOL_RANG": "0",
+            }
         else:
             tr_id = self._broker._settings.OVERSEAS_RANKING_FLUCT_TR_ID
             path = self._broker._settings.OVERSEAS_RANKING_FLUCT_PATH
+            params = {
+                "AUTH": "",
+                "EXCD": ranking_excd,
+                "NDAY": "0",
+                "GUBN": "1",
+                "VOL_RANG": "0",
+            }
 
         headers = await self._broker._auth_headers(tr_id)
         url = f"{self._broker._base_url}{path}"
 
-        # Try common param variants used by KIS overseas quotation APIs.
-        param_variants = [
-            {"AUTH": "", "EXCD": exchange_code, "NREC": str(max(limit, 30))},
-            {"AUTH": "", "OVRS_EXCG_CD": exchange_code, "NREC": str(max(limit, 30))},
-            {"AUTH": "", "EXCD": exchange_code},
-            {"AUTH": "", "OVRS_EXCG_CD": exchange_code},
-        ]
-
-        last_error: str | None = None
-        for params in param_variants:
-            try:
-                async with session.get(url, headers=headers, params=params) as resp:
+        try:
+            async with session.get(url, headers=headers, params=params) as resp:
+                if resp.status != 200:
                     text = await resp.text()
-                    if resp.status != 200:
-                        last_error = f"HTTP {resp.status}: {text}"
-                        continue
+                    if resp.status == 404:
+                        logger.warning(
+                            "Overseas ranking endpoint unavailable (404) for %s/%s; "
+                            "using symbol fallback scan",
+                            exchange_code,
+                            ranking_type,
+                        )
+                        return []
+                    raise ConnectionError(
+                        f"fetch_overseas_rankings failed ({resp.status}): {text}"
+                    )
 
-                    data = await resp.json()
-                    rows = self._extract_ranking_rows(data)
-                    if rows:
-                        return rows[:limit]
+                data = await resp.json()
+                rows = self._extract_ranking_rows(data)
+                if rows:
+                    return rows[:limit]
 
-                    # keep trying another param variant if response has no usable rows
-                    last_error = f"empty output (keys={list(data.keys())})"
-            except (TimeoutError, aiohttp.ClientError) as exc:
-                last_error = str(exc)
-                continue
-
-        raise ConnectionError(
-            f"fetch_overseas_rankings failed for {exchange_code}/{ranking_type}: {last_error}"
-        )
+                logger.debug(
+                    "Overseas ranking returned empty for %s/%s (keys=%s)",
+                    exchange_code,
+                    ranking_type,
+                    list(data.keys()),
+                )
+                return []
+        except (TimeoutError, aiohttp.ClientError) as exc:
+            raise ConnectionError(
+                f"Network error fetching overseas rankings: {exc}"
+            ) from exc
 
     async def get_overseas_balance(self, exchange_code: str) -> dict[str, Any]:
         """

src/config.py

@@ -55,6 +55,11 @@ class Settings(BaseSettings):
     # Trading mode
     MODE: str = Field(default="paper", pattern="^(paper|live)$")
 
+    # Simulated USD cash for VTS (paper) overseas trading.
+    # KIS VTS overseas balance API returns errors for most accounts.
+    # This value is used as a fallback when the balance API returns 0 in paper mode.
+    PAPER_OVERSEAS_CASH: float = Field(default=50000.0, ge=0.0)
+
     # Trading frequency mode (daily = batch API calls, realtime = per-stock calls)
     TRADE_MODE: str = Field(default="daily", pattern="^(daily|realtime)$")
     DAILY_SESSIONS: int = Field(default=4, ge=1, le=10)
@@ -91,13 +96,13 @@ class Settings(BaseSettings):
     # Overseas ranking API (KIS endpoint/TR_ID may vary by account/product)
     # Override these from .env if your account uses different specs.
     OVERSEAS_RANKING_ENABLED: bool = True
-    OVERSEAS_RANKING_FLUCT_TR_ID: str = "HHDFS76200100"
-    OVERSEAS_RANKING_VOLUME_TR_ID: str = "HHDFS76200200"
+    OVERSEAS_RANKING_FLUCT_TR_ID: str = "HHDFS76290000"
+    OVERSEAS_RANKING_VOLUME_TR_ID: str = "HHDFS76270000"
     OVERSEAS_RANKING_FLUCT_PATH: str = (
-        "/uapi/overseas-price/v1/quotations/inquire-updown-rank"
+        "/uapi/overseas-stock/v1/ranking/updown-rate"
     )
     OVERSEAS_RANKING_VOLUME_PATH: str = (
-        "/uapi/overseas-price/v1/quotations/inquire-volume-rank"
+        "/uapi/overseas-stock/v1/ranking/volume-surge"
     )
 
     # Dashboard (optional)

src/main.py

@@ -239,10 +239,33 @@ 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.
+        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,
+                settings.PAPER_OVERSEAS_CASH,
+            )
+            total_cash = settings.PAPER_OVERSEAS_CASH
+
         current_price = safe_float(price_data.get("output", {}).get("last", "0"))
         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)
@@ -487,7 +510,7 @@ async def trading_cycle(
                 stock_code=stock_code,
                 order_type=decision.action,
                 quantity=quantity,
-                price=0.0,  # market order
+                price=current_price,  # limit order — KIS VTS rejects market orders
             )
         logger.info("Order result: %s", result.get("msg1", "OK"))
 
@@ -692,6 +715,16 @@ async def run_daily_session(
                     price_change_pct = safe_float(
                         price_data.get("output", {}).get("rate", "0")
                     )
+                    # Fall back to scanner candidate price if API returns 0.
+                    if current_price <= 0:
+                        cand_lookup = candidate_map.get(stock_code)
+                        if cand_lookup and cand_lookup.price > 0:
+                            current_price = cand_lookup.price
+                            logger.debug(
+                                "Price API returned 0 for %s; using scanner price %.4f",
+                                stock_code,
+                                current_price,
+                            )
 
                 stock_data: dict[str, Any] = {
                     "stock_code": stock_code,
@@ -743,6 +776,10 @@ async def run_daily_session(
                 balance_info.get("frcr_buy_amt_smtl", "0") or "0"
             )
 
+            # VTS overseas balance API often returns 0; use paper fallback.
+            if total_cash <= 0 and settings.PAPER_OVERSEAS_CASH > 0:
+                total_cash = settings.PAPER_OVERSEAS_CASH
+
         # Calculate daily P&L %
         pnl_pct = (
             ((total_eval - purchase_total) / purchase_total * 100)
@@ -882,7 +919,7 @@ async def run_daily_session(
                             stock_code=stock_code,
                             order_type=decision.action,
                             quantity=quantity,
-                            price=0.0,  # market order
+                            price=stock_data["current_price"],  # limit order — KIS VTS rejects market orders
                         )
                     logger.info("Order result: %s", result.get("msg1", "OK"))
 

src/strategy/pre_market_planner.py

@@ -1,7 +1,8 @@
 """Pre-market planner — generates DayPlaybook via Gemini before market open.
 
 One Gemini API call per market per day. Candidates come from SmartVolatilityScanner.
-On failure, returns a defensive playbook (all HOLD, no trades).
+On failure, returns a smart rule-based fallback playbook that uses scanner signals
+(momentum/oversold) to generate BUY conditions, avoiding the all-HOLD problem.
 """
 
 from __future__ import annotations
@@ -134,7 +135,7 @@ class PreMarketPlanner:
         except Exception:
             logger.exception("Playbook generation failed for %s", market)
             if self._settings.DEFENSIVE_PLAYBOOK_ON_FAILURE:
-                return self._defensive_playbook(today, market, candidates)
+                return self._smart_fallback_playbook(today, market, candidates, self._settings)
             return self._empty_playbook(today, market)
 
     def build_cross_market_context(
@@ -470,3 +471,99 @@ class PreMarketPlanner:
                 ),
             ],
         )
+
+    @staticmethod
+    def _smart_fallback_playbook(
+        today: date,
+        market: str,
+        candidates: list[ScanCandidate],
+        settings: Settings,
+    ) -> DayPlaybook:
+        """Rule-based fallback playbook when Gemini is unavailable.
+
+        Uses scanner signals (RSI, volume_ratio) to generate meaningful BUY
+        conditions instead of the all-SELL defensive playbook.  Candidates are
+        already pre-qualified by SmartVolatilityScanner, so we trust their
+        signals and build actionable scenarios from them.
+
+        Scenario logic per candidate:
+        - momentum signal: BUY when volume_ratio exceeds scanner threshold
+        - oversold signal: BUY when RSI is below oversold threshold
+        - always: SELL stop-loss at -3.0% as guard
+        """
+        stock_playbooks = []
+        for c in candidates:
+            scenarios: list[StockScenario] = []
+
+            if c.signal == "momentum":
+                scenarios.append(
+                    StockScenario(
+                        condition=StockCondition(
+                            volume_ratio_above=settings.VOL_MULTIPLIER,
+                        ),
+                        action=ScenarioAction.BUY,
+                        confidence=80,
+                        allocation_pct=10.0,
+                        stop_loss_pct=-3.0,
+                        take_profit_pct=5.0,
+                        rationale=(
+                            f"Rule-based BUY: momentum signal, "
+                            f"volume={c.volume_ratio:.1f}x (fallback planner)"
+                        ),
+                    )
+                )
+            elif c.signal == "oversold":
+                scenarios.append(
+                    StockScenario(
+                        condition=StockCondition(
+                            rsi_below=settings.RSI_OVERSOLD_THRESHOLD,
+                        ),
+                        action=ScenarioAction.BUY,
+                        confidence=80,
+                        allocation_pct=10.0,
+                        stop_loss_pct=-3.0,
+                        take_profit_pct=5.0,
+                        rationale=(
+                            f"Rule-based BUY: oversold signal, "
+                            f"RSI={c.rsi:.0f} (fallback planner)"
+                        ),
+                    )
+                )
+
+            # Always add stop-loss guard
+            scenarios.append(
+                StockScenario(
+                    condition=StockCondition(price_change_pct_below=-3.0),
+                    action=ScenarioAction.SELL,
+                    confidence=90,
+                    stop_loss_pct=-3.0,
+                    rationale="Rule-based stop-loss (fallback planner)",
+                )
+            )
+
+            stock_playbooks.append(
+                StockPlaybook(
+                    stock_code=c.stock_code,
+                    scenarios=scenarios,
+                )
+            )
+
+        logger.info(
+            "Smart fallback playbook for %s: %d stocks with rule-based BUY/SELL conditions",
+            market,
+            len(stock_playbooks),
+        )
+        return DayPlaybook(
+            date=today,
+            market=market,
+            market_outlook=MarketOutlook.NEUTRAL,
+            default_action=ScenarioAction.HOLD,
+            stock_playbooks=stock_playbooks,
+            global_rules=[
+                GlobalRule(
+                    condition="portfolio_pnl_pct < -2.0",
+                    action=ScenarioAction.REDUCE_ALL,
+                    rationale="Defensive: reduce on loss threshold",
+                ),
+            ],
+        )

tests/test_brain.py

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

tests/test_broker.py

@@ -90,12 +90,12 @@ class TestTokenManagement:
         await broker.close()
 
     @pytest.mark.asyncio
-    async def test_token_refresh_cooldown_prevents_rapid_retries(self, settings):
-        """Token refresh should enforce cooldown after failure (issue #54)."""
+    async def test_token_refresh_cooldown_waits_then_retries(self, settings):
+        """Token refresh should wait out cooldown then retry (issue #54)."""
         broker = KISBroker(settings)
-        broker._refresh_cooldown = 2.0  # Short cooldown for testing
+        broker._refresh_cooldown = 0.1  # Short cooldown for testing
 
-        # First refresh attempt fails with 403 (EGW00133)
+        # All attempts fail with 403 (EGW00133)
         mock_resp_403 = AsyncMock()
         mock_resp_403.status = 403
         mock_resp_403.text = AsyncMock(
@@ -109,8 +109,8 @@ class TestTokenManagement:
             with pytest.raises(ConnectionError, match="Token refresh failed"):
                 await broker._ensure_token()
 
-            # Second attempt within cooldown should fail with cooldown error
-            with pytest.raises(ConnectionError, match="Token refresh on cooldown"):
+            # Second attempt within cooldown should wait then retry (and still get 403)
+            with pytest.raises(ConnectionError, match="Token refresh failed"):
                 await broker._ensure_token()
 
         await broker.close()

tests/test_main.py

@@ -738,6 +738,82 @@ class TestOverseasBalanceParsing:
         # Verify price API was called
         mock_overseas_broker_with_empty_price.get_overseas_price.assert_called_once()
 
+    @pytest.fixture
+    def mock_overseas_broker_with_buy_scenario(self) -> MagicMock:
+        """Create mock overseas broker that returns a valid price for BUY orders."""
+        broker = MagicMock()
+        broker.get_overseas_price = AsyncMock(
+            return_value={"output": {"last": "182.50"}}
+        )
+        broker.get_overseas_balance = AsyncMock(
+            return_value={
+                "output2": [
+                    {
+                        "frcr_evlu_tota": "100000.00",
+                        "frcr_dncl_amt_2": "50000.00",
+                        "frcr_buy_amt_smtl": "50000.00",
+                    }
+                ]
+            }
+        )
+        broker.send_overseas_order = AsyncMock(return_value={"msg1": "주문접수"})
+        return broker
+
+    @pytest.fixture
+    def mock_scenario_engine_buy(self) -> MagicMock:
+        """Create mock scenario engine that returns BUY."""
+        engine = MagicMock(spec=ScenarioEngine)
+        engine.evaluate = MagicMock(return_value=_make_buy_match("AAPL"))
+        return engine
+
+    @pytest.mark.asyncio
+    async def test_overseas_buy_order_uses_limit_price(
+        self,
+        mock_domestic_broker: MagicMock,
+        mock_overseas_broker_with_buy_scenario: MagicMock,
+        mock_scenario_engine_buy: 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:
+        """Overseas BUY order must use current_price (limit), not 0 (market).
+
+        KIS VTS rejects market orders for overseas paper trading.
+        Regression test for issue #149.
+        """
+        mock_telegram.notify_trade_execution = AsyncMock()
+
+        with patch("src.main.log_trade"):
+            await trading_cycle(
+                broker=mock_domestic_broker,
+                overseas_broker=mock_overseas_broker_with_buy_scenario,
+                scenario_engine=mock_scenario_engine_buy,
+                playbook=mock_playbook,
+                risk=mock_risk,
+                db_conn=mock_db,
+                decision_logger=mock_decision_logger,
+                context_store=mock_context_store,
+                criticality_assessor=mock_criticality_assessor,
+                telegram=mock_telegram,
+                market=mock_overseas_market,
+                stock_code="AAPL",
+                scan_candidates={},
+            )
+
+        # Verify limit order was sent with actual price, 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."
+        )
+
 
 class TestScenarioEngineIntegration:
     """Test scenario engine integration in trading_cycle."""

tests/test_overseas_broker.py

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

tests/test_pre_market_planner.py

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