feat: include current holdings in realtime trading loop for exit evaluation (#165)

스캐너 후보 종목뿐 아니라 현재 보유 종목도 매 사이클마다 평가해
stop-loss / take-profit이 실제로 동작하도록 개선.

- db.py: get_open_positions_by_market() 추가
  - net BUY - SELL 집계 쿼리로 실제 보유 종목 코드 목록 반환
  - 단순 "최신 레코드 = BUY" 방식보다 안전 (이중 매도 방지)
- main.py: 실시간 루프에서 스캐너 후보 + 보유 종목을 union으로 구성
  - dict.fromkeys로 순서 유지하며 중복 제거
  - 스캐너에 없는 보유 종목은 로그로 명시
  - 보유 종목은 Playbook 없으면 HOLD → stop-loss/take-profit 체크
- tests/test_db.py: get_open_positions_by_market 테스트 5개 추가
  - net 양수 종목 포함, 전량 매도 제외, 부분 매도 포함
  - 마켓 범위 격리, 거래 없을 때 빈 리스트

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

.env.example

@@ -1,82 +1,36 @@
-# ============================================================
-# The Ouroboros — Environment Configuration
-# ============================================================
-# Copy this file to .env and fill in your values.
-# Lines starting with # are comments.
-
-# ============================================================
 # Korea Investment Securities API
-# ============================================================
 KIS_APP_KEY=your_app_key_here
 KIS_APP_SECRET=your_app_secret_here
 KIS_ACCOUNT_NO=12345678-01
+KIS_BASE_URL=https://openapivts.koreainvestment.com:9443
 
-# Paper trading (VTS): https://openapivts.koreainvestment.com:29443
-# Live trading:        https://openapi.koreainvestment.com:9443
-KIS_BASE_URL=https://openapivts.koreainvestment.com:29443
-
-# ============================================================
-# Trading Mode
-# ============================================================
-# paper = 모의투자 (safe for testing), live = 실전투자 (real money)
-MODE=paper
-
-# daily = batch per session, realtime = per-stock continuous scan
-TRADE_MODE=daily
-
-# Comma-separated market codes: KR, US, JP, HK, CN, VN
-ENABLED_MARKETS=KR,US
-
-# Simulated USD cash for paper (VTS) overseas trading.
-# VTS overseas balance API often returns 0; this value is used as fallback.
-# Set to 0 to disable fallback (not used in live mode).
-PAPER_OVERSEAS_CASH=50000.0
-
-# ============================================================
 # Google Gemini
-# ============================================================
 GEMINI_API_KEY=your_gemini_api_key_here
-# Recommended: gemini-2.0-flash-exp or gemini-1.5-pro
-GEMINI_MODEL=gemini-2.0-flash-exp
+GEMINI_MODEL=gemini-pro
 
-# ============================================================
 # Risk Management
-# ============================================================
 CIRCUIT_BREAKER_PCT=-3.0
 FAT_FINGER_PCT=30.0
 CONFIDENCE_THRESHOLD=80
 
-# ============================================================
 # Database
-# ============================================================
 DB_PATH=data/trade_logs.db
 
-# ============================================================
-# Rate Limiting
-# ============================================================
-# KIS API real limit is ~2 RPS. Keep at 2.0 for maximum safety.
-# Increasing this risks EGW00201 "초당 거래건수 초과" errors.
-RATE_LIMIT_RPS=2.0
+# Rate Limiting (requests per second for KIS API)
+# Reduced to 5.0 to avoid "초당 거래건수 초과" errors (EGW00201)
+RATE_LIMIT_RPS=5.0
 
-# ============================================================
-# External Data APIs (optional)
-# ============================================================
+# Trading Mode (paper / live)
+MODE=paper
+
+# External Data APIs (optional — for enhanced decision-making)
 # NEWS_API_KEY=your_news_api_key_here
 # NEWS_API_PROVIDER=alphavantage
 # MARKET_DATA_API_KEY=your_market_data_key_here
 
-# ============================================================
 # Telegram Notifications (optional)
-# ============================================================
 # Get bot token from @BotFather on Telegram
 # Get chat ID from @userinfobot or your chat
 # TELEGRAM_BOT_TOKEN=1234567890:ABCdefGHIjklMNOpqrsTUVwxyz
 # TELEGRAM_CHAT_ID=123456789
 # TELEGRAM_ENABLED=true
-
-# ============================================================
-# Dashboard (optional)
-# ============================================================
-# DASHBOARD_ENABLED=false
-# DASHBOARD_HOST=127.0.0.1
-# DASHBOARD_PORT=8080

CLAUDE.md

@@ -170,7 +170,7 @@ Markets auto-detected based on timezone and enabled in `ENABLED_MARKETS` env var
 - `src/core/risk_manager.py` is **READ-ONLY** — changes require human approval
 - Circuit breaker at -3.0% P&L — may only be made **stricter**
 - Fat-finger protection: max 30% of cash per order — always enforced
-- Confidence 임계값 (market_outlook별, 낮출 수 없음): BEARISH ≥ 90, NEUTRAL/기본 ≥ 80, BULLISH ≥ 75
+- Confidence < 80 → force HOLD — cannot be weakened
 - All code changes → corresponding tests → coverage ≥ 80%
 
 ## Contributing

docs/commands.md

@@ -192,27 +192,6 @@ When `TELEGRAM_COMMANDS_ENABLED=true` (default), the bot accepts these interacti
 
 Commands are only processed from the authorized `TELEGRAM_CHAT_ID`.
 
-## KIS API TR_ID 참조 문서
-
-**TR_ID를 추가하거나 수정할 때 반드시 공식 문서를 먼저 확인할 것.**
-
-공식 문서: `docs/한국투자증권_오픈API_전체문서_20260221_030000.xlsx`
-
-> ⚠️ 커뮤니티 블로그, GitHub 예제 등 비공식 자료의 TR_ID는 오래되거나 틀릴 수 있음.
-> 실제로 `VTTT1006U`(미국 매도 — 잘못됨)가 오랫동안 코드에 남아있던 사례가 있음 (Issue #189).
-
-### 주요 TR_ID 목록
-
-| 구분 | 모의투자 TR_ID | 실전투자 TR_ID | 시트명 |
-|------|---------------|---------------|--------|
-| 해외주식 매수 (미국) | `VTTT1002U` | `TTTT1002U` | 해외주식 주문 |
-| 해외주식 매도 (미국) | `VTTT1001U` | `TTTT1006U` | 해외주식 주문 |
-
-새로운 TR_ID가 필요할 때:
-1. 위 xlsx 파일에서 해당 거래 유형의 시트를 찾는다.
-2. 모의투자(`VTTT`) / 실전투자(`TTTT`) 컬럼을 구분하여 정확한 값을 사용한다.
-3. 코드에 출처 주석을 남긴다: `# Source: 한국투자증권_오픈API_전체문서 — '<시트명>' 시트`
-
 ## Environment Setup
 
 ```bash

docs/requirements-log.md

@@ -7,32 +7,6 @@
 
 ---
 
-## 2026-02-21
-
-### 거래 상태 확인 중 발견된 버그 (#187)
-
-- 거래 상태 점검 요청 → SELL 주문(손절/익절)이 Fat Finger에 막혀 전혀 실행 안 됨 발견
-- **#187 (Critical)**: SELL 주문에서 Fat Finger 오탐 — `order_amount/total_cash > 30%`가 SELL에도 적용되어 대형 포지션 매도 불가
-  - JELD stop-loss -6.20% → 차단, RXT take-profit +46.13% → 차단
-  - 수정: SELL은 `check_circuit_breaker`만 호출, `validate_order`(Fat Finger 포함) 미호출
-
----
-
-## 2026-02-20
-
-### 지속적 모니터링 및 개선점 도출 (이슈 #178~#182)
-
-- Dashboard 포함해서 실행하며 간헐적 문제 모니터링 및 개선점 자동 도출 요청
-- 모니터링 결과 발견된 이슈 목록:
-  - **#178**: uvicorn 미설치 → dashboard 미작동 + 오해의 소지 있는 시작 로그 → uvicorn 설치 완료
-  - **#179 (Critical)**: 잔액 부족 주문 실패 후 매 사이클마다 무한 재시도 (MLECW 20분 이상 반복)
-  - **#180**: 다중 인스턴스 실행 시 Telegram 409 충돌
-  - **#181**: implied_rsi 공식 포화 문제 (change_rate≥12.5% → RSI=100)
-  - **#182 (Critical)**: 보유 종목이 SmartScanner 변동성 필터에 걸려 SELL 신호 미생성 → SELL 체결 0건, 잔고 소진
-- 요구사항: 모니터링 자동화 및 주기적 개선점 리포트 도출
-
----
-
 ## 2026-02-05
 
 ### API 효율화

src/analysis/smart_scanner.py

@@ -175,7 +175,7 @@ class SmartVolatilityScanner:
                 liquidity_score = volume_rank_bonus.get(stock_code, 0.0)
                 score = min(100.0, volatility_score + liquidity_score)
                 signal = "momentum" if change_rate >= 0 else "oversold"
-                implied_rsi = max(0.0, min(100.0, 50.0 + (change_rate * 2.0)))
+                implied_rsi = max(0.0, min(100.0, 50.0 + (change_rate * 4.0)))
 
                 candidates.append(
                     ScanCandidate(
@@ -282,7 +282,7 @@ class SmartVolatilityScanner:
             liquidity_score = volume_rank_bonus.get(stock_code, 0.0)
             score = min(100.0, volatility_score + liquidity_score)
             signal = "momentum" if change_rate >= 0 else "oversold"
-            implied_rsi = max(0.0, min(100.0, 50.0 + (change_rate * 2.0)))
+            implied_rsi = max(0.0, min(100.0, 50.0 + (change_rate * 4.0)))
             candidates.append(
                 ScanCandidate(
                     stock_code=stock_code,
@@ -338,7 +338,7 @@ class SmartVolatilityScanner:
 
                 score = min(volatility_pct / 10.0, 1.0) * 100.0
                 signal = "momentum" if change_rate >= 0 else "oversold"
-                implied_rsi = max(0.0, min(100.0, 50.0 + (change_rate * 2.0)))
+                implied_rsi = max(0.0, min(100.0, 50.0 + (change_rate * 4.0)))
                 candidates.append(
                     ScanCandidate(
                         stock_code=stock_code,

src/broker/kis_api.py

@@ -285,10 +285,7 @@ class KISBroker:
         await self._rate_limiter.acquire()
         session = self._get_session()
 
-        # TR_ID: 실전 TTTC8434R, 모의 VTTC8434R
-        # Source: 한국투자증권 오픈API 전체문서 (20260221) — '국내주식 잔고조회' 시트
-        tr_id = "TTTC8434R" if self._settings.MODE == "live" else "VTTC8434R"
-        headers = await self._auth_headers(tr_id)
+        headers = await self._auth_headers("VTTC8434R")  # 모의투자 잔고조회
         params = {
             "CANO": self._account_no,
             "ACNT_PRDT_CD": self._product_cd,
@@ -333,13 +330,7 @@ class KISBroker:
         await self._rate_limiter.acquire()
         session = self._get_session()
 
-        # TR_ID: 실전 BUY=TTTC0012U SELL=TTTC0011U, 모의 BUY=VTTC0012U SELL=VTTC0011U
-        # Source: 한국투자증권 오픈API 전체문서 (20260221) — '주식주문(현금)' 시트
-        # ※ TTTC0802U/VTTC0802U는 미수매수(증거금40% 계좌 전용) — 현금주문에 사용 금지
-        if self._settings.MODE == "live":
-            tr_id = "TTTC0012U" if order_type == "BUY" else "TTTC0011U"
-        else:
-            tr_id = "VTTC0012U" if order_type == "BUY" else "VTTC0011U"
+        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"=시장가

src/broker/overseas.py

@@ -175,12 +175,8 @@ class OverseasBroker:
         await self._broker._rate_limiter.acquire()
         session = self._broker._get_session()
 
-        # TR_ID: 실전 TTTS3012R, 모의 VTTS3012R
-        # Source: 한국투자증권 오픈API 전체문서 (20260221) — '해외주식 잔고조회' 시트
-        balance_tr_id = (
-            "TTTS3012R" if self._broker._settings.MODE == "live" else "VTTS3012R"
-        )
-        headers = await self._broker._auth_headers(balance_tr_id)
+        # Virtual trading TR_ID for overseas balance inquiry
+        headers = await self._broker._auth_headers("VTTS3012R")
         params = {
             "CANO": self._broker._account_no,
             "ACNT_PRDT_CD": self._broker._product_cd,
@@ -233,12 +229,8 @@ class OverseasBroker:
         await self._broker._rate_limiter.acquire()
         session = self._broker._get_session()
 
-        # TR_ID: 실전 BUY=TTTT1002U SELL=TTTT1006U, 모의 BUY=VTTT1002U SELL=VTTT1001U
-        # Source: 한국투자증권 오픈API 전체문서 (20260221) — '해외주식 주문' 시트
-        if self._broker._settings.MODE == "live":
-            tr_id = "TTTT1002U" if order_type == "BUY" else "TTTT1006U"
-        else:
-            tr_id = "VTTT1002U" if order_type == "BUY" else "VTTT1001U"
+        # Virtual trading TR_IDs for overseas orders
+        tr_id = "VTTT1002U" if order_type == "BUY" else "VTTT1006U"
 
         body = {
             "CANO": self._broker._account_no,

src/config.py

@@ -13,7 +13,7 @@ class Settings(BaseSettings):
     KIS_APP_KEY: str
     KIS_APP_SECRET: str
     KIS_ACCOUNT_NO: str  # format: "XXXXXXXX-XX"
-    KIS_BASE_URL: str = "https://openapivts.koreainvestment.com:29443"
+    KIS_BASE_URL: str = "https://openapivts.koreainvestment.com:9443"
 
     # Google Gemini
     GEMINI_API_KEY: str

src/dashboard/app.py

@@ -3,9 +3,8 @@
 from __future__ import annotations
 
 import json
-import os
 import sqlite3
-from datetime import UTC, datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
 
@@ -80,35 +79,6 @@ def create_dashboard_app(db_path: str) -> FastAPI:
                 total_pnl += market_status[market]["total_pnl"]
                 total_decisions += market_status[market]["decision_count"]
 
-            cb_threshold = float(os.getenv("CIRCUIT_BREAKER_PCT", "-3.0"))
-            pnl_pct_rows = conn.execute(
-                """
-                SELECT key, value
-                FROM system_metrics
-                WHERE key LIKE 'portfolio_pnl_pct_%'
-                ORDER BY updated_at DESC
-                LIMIT 20
-                """
-            ).fetchall()
-            current_pnl_pct: float | None = None
-            if pnl_pct_rows:
-                values = [
-                    json.loads(row["value"]).get("pnl_pct")
-                    for row in pnl_pct_rows
-                    if json.loads(row["value"]).get("pnl_pct") is not None
-                ]
-                if values:
-                    current_pnl_pct = round(min(values), 4)
-
-            if current_pnl_pct is None:
-                cb_status = "unknown"
-            elif current_pnl_pct <= cb_threshold:
-                cb_status = "tripped"
-            elif current_pnl_pct <= cb_threshold + 1.0:
-                cb_status = "warning"
-            else:
-                cb_status = "ok"
-
             return {
                 "date": today,
                 "markets": market_status,
@@ -117,11 +87,6 @@ def create_dashboard_app(db_path: str) -> FastAPI:
                     "total_pnl": round(total_pnl, 2),
                     "decision_count": total_decisions,
                 },
-                "circuit_breaker": {
-                    "threshold_pct": cb_threshold,
-                    "current_pnl_pct": current_pnl_pct,
-                    "status": cb_status,
-                },
             }
 
     @app.get("/api/playbook/{date_str}")
@@ -376,68 +341,12 @@ def create_dashboard_app(db_path: str) -> FastAPI:
                 )
             return {"market": market, "date": date_str, "count": len(matches), "matches": matches}
 
-    @app.get("/api/positions")
-    def get_positions() -> dict[str, Any]:
-        """Return all currently open positions (last trade per symbol is BUY)."""
-        with _connect(db_path) as conn:
-            rows = conn.execute(
-                """
-                SELECT stock_code, market, exchange_code,
-                       price AS entry_price, quantity, timestamp AS entry_time,
-                       decision_id
-                FROM (
-                    SELECT stock_code, market, exchange_code, price, quantity,
-                           timestamp, decision_id, action,
-                           ROW_NUMBER() OVER (
-                               PARTITION BY stock_code, market
-                               ORDER BY timestamp DESC
-                           ) AS rn
-                    FROM trades
-                )
-                WHERE rn = 1 AND action = 'BUY'
-                ORDER BY entry_time DESC
-                """
-            ).fetchall()
-
-            now = datetime.now(timezone.utc)
-            positions = []
-            for row in rows:
-                entry_time_str = row["entry_time"]
-                try:
-                    entry_dt = datetime.fromisoformat(entry_time_str.replace("Z", "+00:00"))
-                    held_seconds = int((now - entry_dt).total_seconds())
-                    held_hours = held_seconds // 3600
-                    held_minutes = (held_seconds % 3600) // 60
-                    if held_hours >= 1:
-                        held_display = f"{held_hours}h {held_minutes}m"
-                    else:
-                        held_display = f"{held_minutes}m"
-                except (ValueError, TypeError):
-                    held_display = "--"
-
-                positions.append(
-                    {
-                        "stock_code": row["stock_code"],
-                        "market": row["market"],
-                        "exchange_code": row["exchange_code"],
-                        "entry_price": row["entry_price"],
-                        "quantity": row["quantity"],
-                        "entry_time": entry_time_str,
-                        "held": held_display,
-                        "decision_id": row["decision_id"],
-                    }
-                )
-
-            return {"count": len(positions), "positions": positions}
-
     return app
 
 
 def _connect(db_path: str) -> sqlite3.Connection:
     conn = sqlite3.connect(db_path)
     conn.row_factory = sqlite3.Row
-    conn.execute("PRAGMA journal_mode=WAL")
-    conn.execute("PRAGMA busy_timeout=8000")
     return conn
 
 

src/dashboard/static/index.html

@@ -13,7 +13,6 @@
         --muted: #9fb3c8;
         --accent: #3cb371;
         --red: #e05555;
-        --warn: #e8a040;
         --border: #28455f;
       }
       * { box-sizing: border-box; margin: 0; padding: 0; }
@@ -44,25 +43,6 @@
       }
       .refresh-btn:hover { border-color: var(--accent); color: var(--accent); }
 
-      /* CB Gauge */
-      .cb-gauge-wrap {
-        display: flex; align-items: center; gap: 8px;
-        font-size: 11px; color: var(--muted);
-      }
-      .cb-dot {
-        width: 8px; height: 8px; border-radius: 50%; flex-shrink: 0;
-      }
-      .cb-dot.ok      { background: var(--accent); }
-      .cb-dot.warning { background: var(--warn); animation: pulse-warn 1.2s ease-in-out infinite; }
-      .cb-dot.tripped { background: var(--red);  animation: pulse-warn 0.6s ease-in-out infinite; }
-      .cb-dot.unknown { background: var(--border); }
-      @keyframes pulse-warn {
-        0%, 100% { opacity: 1; }
-        50%       { opacity: 0.35; }
-      }
-      .cb-bar-wrap { width: 64px; height: 5px; background: rgba(255,255,255,0.08); border-radius: 3px; overflow: hidden; }
-      .cb-bar-fill { height: 100%; border-radius: 3px; transition: width 0.4s, background 0.4s; }
-
       /* Summary cards */
       .cards { display: grid; grid-template-columns: repeat(4, 1fr); gap: 12px; margin-bottom: 20px; }
       @media (max-width: 700px) { .cards { grid-template-columns: repeat(2, 1fr); } }
@@ -143,80 +123,9 @@
       .rationale-cell { max-width: 200px; overflow: hidden; text-overflow: ellipsis; color: var(--muted); }
       .empty-row td { text-align: center; color: var(--muted); padding: 24px; }
 
-      /* Positions panel */
-      .positions-panel {
-        background: var(--panel);
-        border: 1px solid var(--border);
-        border-radius: 10px;
-        padding: 16px;
-        margin-bottom: 20px;
-      }
-      .positions-table { width: 100%; border-collapse: collapse; margin-top: 14px; }
-      .positions-table th {
-        text-align: left; color: var(--muted); font-size: 11px; font-weight: 600;
-        padding: 6px 8px; border-bottom: 1px solid var(--border); white-space: nowrap;
-      }
-      .positions-table td {
-        padding: 8px 8px; border-bottom: 1px solid rgba(40, 69, 95, 0.5);
-        vertical-align: middle; white-space: nowrap;
-      }
-      .positions-table tr:last-child td { border-bottom: none; }
-      .positions-table tr:hover td { background: rgba(255,255,255,0.02); }
-      .pos-empty { color: var(--muted); text-align: center; padding: 20px 0; font-size: 12px; }
-      .pos-count {
-        display: inline-block; background: rgba(60, 179, 113, 0.12);
-        color: var(--accent); font-size: 11px; font-weight: 700;
-        padding: 2px 8px; border-radius: 10px; margin-left: 8px;
-      }
-
       /* Spinner */
       .spinner { display: inline-block; width: 12px; height: 12px; border: 2px solid var(--border); border-top-color: var(--accent); border-radius: 50%; animation: spin 0.8s linear infinite; }
       @keyframes spin { to { transform: rotate(360deg); } }
-
-      /* Generic panel */
-      .panel {
-        background: var(--panel);
-        border: 1px solid var(--border);
-        border-radius: 10px;
-        padding: 16px;
-        margin-top: 20px;
-      }
-
-      /* Playbook panel - details/summary accordion */
-      .playbook-panel details { border: 1px solid var(--border); border-radius: 4px; margin-bottom: 6px; }
-      .playbook-panel summary { padding: 8px 12px; cursor: pointer; font-weight: 600; background: var(--bg); color: var(--fg); }
-      .playbook-panel summary:hover { color: var(--accent); }
-      .playbook-panel pre { margin: 0; padding: 12px; background: var(--bg); overflow-x: auto;
-                            font-size: 11px; color: #a0c4ff; white-space: pre-wrap; }
-
-      /* Scorecard KPI card grid */
-      .scorecard-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(140px, 1fr)); gap: 10px; }
-      .kpi-card { background: var(--bg); border: 1px solid var(--border); border-radius: 6px; padding: 12px; text-align: center; }
-      .kpi-card .kpi-label { font-size: 11px; color: var(--muted); margin-bottom: 4px; }
-      .kpi-card .kpi-value { font-size: 20px; font-weight: 700; color: var(--fg); }
-
-      /* Scenarios table */
-      .scenarios-table { width: 100%; border-collapse: collapse; font-size: 13px; }
-      .scenarios-table th { background: var(--bg); padding: 8px; text-align: left; border-bottom: 1px solid var(--border);
-                            color: var(--muted); font-size: 11px; font-weight: 600; white-space: nowrap; }
-      .scenarios-table td { padding: 7px 8px; border-bottom: 1px solid rgba(40,69,95,0.5); }
-      .scenarios-table tr:hover td { background: rgba(255,255,255,0.02); }
-
-      /* Context table */
-      .context-table { width: 100%; border-collapse: collapse; font-size: 12px; }
-      .context-table th { background: var(--bg); padding: 8px; text-align: left; border-bottom: 1px solid var(--border);
-                          color: var(--muted); font-size: 11px; font-weight: 600; white-space: nowrap; }
-      .context-table td { padding: 6px 8px; border-bottom: 1px solid rgba(40,69,95,0.5); vertical-align: top; }
-      .context-value { max-height: 60px; overflow-y: auto; color: #a0c4ff; word-break: break-all; }
-
-      /* Common panel select controls */
-      .panel-controls { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
-      .panel-controls select, .panel-controls input[type="number"] {
-        background: var(--bg); color: var(--fg); border: 1px solid var(--border);
-        border-radius: 4px; padding: 4px 8px; font-size: 13px; font-family: inherit;
-      }
-      .panel-date { color: var(--muted); font-size: 12px; }
-      .empty-msg { color: var(--muted); text-align: center; padding: 20px 0; font-size: 12px; }
     </style>
   </head>
   <body>
@@ -225,13 +134,6 @@
       <header>
         <h1>&#x1F40D; The Ouroboros</h1>
         <div class="header-right">
-          <div class="cb-gauge-wrap" id="cb-gauge" title="Circuit Breaker">
-            <span class="cb-dot unknown" id="cb-dot"></span>
-            <span id="cb-label">CB --</span>
-            <div class="cb-bar-wrap">
-              <div class="cb-bar-fill" id="cb-bar" style="width:0%;background:var(--accent)"></div>
-            </div>
-          </div>
           <span id="last-updated">--</span>
           <button class="refresh-btn" onclick="refreshAll()">&#x21BA; 새로고침</button>
         </div>
@@ -261,30 +163,6 @@
         </div>
       </div>
 
-      <!-- Open Positions -->
-      <div class="positions-panel">
-        <div class="panel-header">
-          <span class="panel-title">
-            현재 보유 포지션
-            <span class="pos-count" id="positions-count">0</span>
-          </span>
-        </div>
-        <table class="positions-table">
-          <thead>
-            <tr>
-              <th>종목</th>
-              <th>시장</th>
-              <th>수량</th>
-              <th>진입가</th>
-              <th>보유 시간</th>
-            </tr>
-          </thead>
-          <tbody id="positions-body">
-            <tr><td colspan="5" class="pos-empty"><span class="spinner"></span></td></tr>
-          </tbody>
-        </table>
-      </div>
-
       <!-- P&L Chart -->
       <div class="chart-panel">
         <div class="panel-header">
@@ -328,72 +206,6 @@
           </tbody>
         </table>
       </div>
-
-      <!-- playbook panel -->
-      <div class="panel playbook-panel">
-        <div class="panel-header">
-          <span class="panel-title">&#x1F4CB; 프리마켓 플레이북</span>
-          <div class="panel-controls">
-            <select id="pb-market-select" onchange="fetchPlaybook()">
-              <option value="KR">KR</option>
-              <option value="US_NASDAQ">US_NASDAQ</option>
-              <option value="US_NYSE">US_NYSE</option>
-            </select>
-            <span id="pb-date" class="panel-date"></span>
-          </div>
-        </div>
-        <div id="playbook-content"><p class="empty-msg">데이터 없음</p></div>
-      </div>
-
-      <!-- scorecard panel -->
-      <div class="panel">
-        <div class="panel-header">
-          <span class="panel-title">&#x1F4CA; 일간 스코어카드</span>
-          <div class="panel-controls">
-            <select id="sc-market-select" onchange="fetchScorecard()">
-              <option value="KR">KR</option>
-              <option value="US_NASDAQ">US_NASDAQ</option>
-            </select>
-            <span id="sc-date" class="panel-date"></span>
-          </div>
-        </div>
-        <div id="scorecard-grid" class="scorecard-grid"><p class="empty-msg">데이터 없음</p></div>
-      </div>
-
-      <!-- scenarios panel -->
-      <div class="panel">
-        <div class="panel-header">
-          <span class="panel-title">&#x1F3AF; 활성 시나리오 매칭</span>
-          <div class="panel-controls">
-            <select id="scen-market-select" onchange="fetchScenarios()">
-              <option value="KR">KR</option>
-              <option value="US_NASDAQ">US_NASDAQ</option>
-            </select>
-          </div>
-        </div>
-        <div id="scenarios-content"><p class="empty-msg">데이터 없음</p></div>
-      </div>
-
-      <!-- context layer panel -->
-      <div class="panel">
-        <div class="panel-header">
-          <span class="panel-title">&#x1F9E0; 컨텍스트 트리</span>
-          <div class="panel-controls">
-            <select id="ctx-layer-select" onchange="fetchContext()">
-              <option value="L7_REALTIME">L7_REALTIME</option>
-              <option value="L6_DAILY">L6_DAILY</option>
-              <option value="L5_WEEKLY">L5_WEEKLY</option>
-              <option value="L4_MONTHLY">L4_MONTHLY</option>
-              <option value="L3_QUARTERLY">L3_QUARTERLY</option>
-              <option value="L2_YEARLY">L2_YEARLY</option>
-              <option value="L1_LIFETIME">L1_LIFETIME</option>
-            </select>
-            <input id="ctx-limit" type="number" value="20" min="1" max="200"
-                   style="width:60px;" onchange="fetchContext()">
-          </div>
-        </div>
-        <div id="context-content"><p class="empty-msg">데이터 없음</p></div>
-      </div>
     </div>
 
     <script>
@@ -430,71 +242,6 @@
         </div>`;
       }
 
-      function fmtPrice(v, market) {
-        if (v === null || v === undefined) return '--';
-        const n = parseFloat(v);
-        const sym = market === 'KR' ? '₩' : market === 'JP' ? '¥' : market === 'HK' ? 'HK$' : '$';
-        return sym + n.toLocaleString('en-US', { minimumFractionDigits: 0, maximumFractionDigits: 4 });
-      }
-
-      async function fetchPositions() {
-        const tbody = document.getElementById('positions-body');
-        const countEl = document.getElementById('positions-count');
-        try {
-          const r = await fetch('/api/positions');
-          if (!r.ok) throw new Error('fetch failed');
-          const d = await r.json();
-          countEl.textContent = d.count ?? 0;
-          if (!d.positions || d.positions.length === 0) {
-            tbody.innerHTML = '<tr><td colspan="5" class="pos-empty">현재 보유 중인 포지션 없음</td></tr>';
-            return;
-          }
-          tbody.innerHTML = d.positions.map(p => `
-            <tr>
-              <td><strong>${p.stock_code || '--'}</strong></td>
-              <td><span style="color:var(--muted);font-size:11px">${p.market || '--'}</span></td>
-              <td>${p.quantity ?? '--'}</td>
-              <td>${fmtPrice(p.entry_price, p.market)}</td>
-              <td style="color:var(--muted);font-size:11px">${p.held || '--'}</td>
-            </tr>
-          `).join('');
-        } catch {
-          tbody.innerHTML = '<tr><td colspan="5" class="pos-empty">데이터 로드 실패</td></tr>';
-        }
-      }
-
-      function renderCbGauge(cb) {
-        if (!cb) return;
-        const dot = document.getElementById('cb-dot');
-        const label = document.getElementById('cb-label');
-        const bar = document.getElementById('cb-bar');
-
-        const status = cb.status || 'unknown';
-        const threshold = cb.threshold_pct ?? -3.0;
-        const current = cb.current_pnl_pct;
-
-        // dot color
-        dot.className = `cb-dot ${status}`;
-
-        // label
-        if (current !== null && current !== undefined) {
-          const sign = current > 0 ? '+' : '';
-          label.textContent = `CB ${sign}${current.toFixed(2)}%`;
-        } else {
-          label.textContent = 'CB --';
-        }
-
-        // bar: fill = how much of the threshold has been consumed (0%=safe, 100%=tripped)
-        const colorMap = { ok: 'var(--accent)', warning: 'var(--warn)', tripped: 'var(--red)', unknown: 'var(--border)' };
-        bar.style.background = colorMap[status] || 'var(--border)';
-        if (current !== null && current !== undefined && threshold < 0) {
-          const fillPct = Math.min(Math.max((current / threshold) * 100, 0), 100);
-          bar.style.width = `${fillPct}%`;
-        } else {
-          bar.style.width = '0%';
-        }
-      }
-
       async function fetchStatus() {
         try {
           const r = await fetch('/api/status');
@@ -511,7 +258,6 @@
             pnlEl.className = `card-value ${n > 0 ? 'positive' : n < 0 ? 'negative' : 'neutral'}`;
           }
           document.getElementById('card-pnl-sub').textContent = `결정 ${t.decision_count ?? 0}건`;
-          renderCbGauge(d.circuit_breaker);
         } catch {}
       }
 
@@ -632,129 +378,13 @@
         fetchDecisions(currentMarket);
       }
 
-      function todayStr() {
-        return new Date().toISOString().slice(0, 10);
-      }
-
-      function esc(s) {
-        return String(s ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
-      }
-
-      async function fetchJSON(url) {
-        const r = await fetch(url);
-        if (!r.ok) throw new Error(`HTTP ${r.status}`);
-        return r.json();
-      }
-
-      async function fetchPlaybook() {
-        const market = document.getElementById('pb-market-select').value;
-        const date = todayStr();
-        document.getElementById('pb-date').textContent = date;
-        const el = document.getElementById('playbook-content');
-        try {
-          const data = await fetchJSON(`/api/playbook/${date}?market=${market}`);
-          const stocks = data.stock_playbooks ?? [];
-          if (stocks.length === 0) {
-            el.innerHTML = '<p class="empty-msg">오늘 플레이북 없음</p>';
-            return;
-          }
-          el.innerHTML = stocks.map(sp =>
-            `<details><summary>${esc(sp.stock_code ?? '?')} — ${esc(sp.signal ?? '')}</summary>` +
-            `<pre>${esc(JSON.stringify(sp, null, 2))}</pre></details>`
-          ).join('');
-        } catch {
-          el.innerHTML = '<p class="empty-msg">플레이북 없음 (오늘 미생성 또는 API 오류)</p>';
-        }
-      }
-
-      async function fetchScorecard() {
-        const market = document.getElementById('sc-market-select').value;
-        const date = todayStr();
-        document.getElementById('sc-date').textContent = date;
-        const el = document.getElementById('scorecard-grid');
-        try {
-          const data = await fetchJSON(`/api/scorecard/${date}?market=${market}`);
-          const sc = data.scorecard ?? {};
-          const entries = Object.entries(sc);
-          if (entries.length === 0) {
-            el.innerHTML = '<p class="empty-msg">스코어카드 없음</p>';
-            return;
-          }
-          el.className = 'scorecard-grid';
-          el.innerHTML = entries.map(([k, v]) => `
-            <div class="kpi-card">
-              <div class="kpi-label">${esc(k)}</div>
-              <div class="kpi-value">${typeof v === 'number' ? v.toFixed(2) : esc(String(v))}</div>
-            </div>`).join('');
-        } catch {
-          el.innerHTML = '<p class="empty-msg">스코어카드 없음 (오늘 미생성 또는 API 오류)</p>';
-        }
-      }
-
-      async function fetchScenarios() {
-        const market = document.getElementById('scen-market-select').value;
-        const date = todayStr();
-        const el = document.getElementById('scenarios-content');
-        try {
-          const data = await fetchJSON(`/api/scenarios/active?market=${market}&date_str=${date}&limit=50`);
-          const matches = data.matches ?? [];
-          if (matches.length === 0) {
-            el.innerHTML = '<p class="empty-msg">활성 시나리오 없음</p>';
-            return;
-          }
-          el.innerHTML = `<table class="scenarios-table">
-            <thead><tr><th>종목</th><th>신호</th><th>신뢰도</th><th>매칭 조건</th></tr></thead>
-            <tbody>${matches.map(m => `
-              <tr>
-                <td>${esc(m.stock_code)}</td>
-                <td>${esc(m.signal ?? '-')}</td>
-                <td>${esc(m.confidence ?? '-')}</td>
-                <td><code style="font-size:11px">${esc(JSON.stringify(m.scenario_match ?? {}))}</code></td>
-              </tr>`).join('')}
-            </tbody></table>`;
-        } catch {
-          el.innerHTML = '<p class="empty-msg">데이터 없음</p>';
-        }
-      }
-
-      async function fetchContext() {
-        const layer = document.getElementById('ctx-layer-select').value;
-        const limit = Math.min(Math.max(parseInt(document.getElementById('ctx-limit').value, 10) || 20, 1), 200);
-        const el = document.getElementById('context-content');
-        try {
-          const data = await fetchJSON(`/api/context/${layer}?limit=${limit}`);
-          const entries = data.entries ?? [];
-          if (entries.length === 0) {
-            el.innerHTML = '<p class="empty-msg">컨텍스트 없음</p>';
-            return;
-          }
-          el.innerHTML = `<table class="context-table">
-            <thead><tr><th>timeframe</th><th>key</th><th>value</th><th>updated</th></tr></thead>
-            <tbody>${entries.map(e => `
-              <tr>
-                <td>${esc(e.timeframe)}</td>
-                <td>${esc(e.key)}</td>
-                <td><div class="context-value">${esc(JSON.stringify(e.value ?? e.raw_value))}</div></td>
-                <td style="font-size:11px;color:var(--muted)">${esc((e.updated_at ?? '').slice(0, 16))}</td>
-              </tr>`).join('')}
-            </tbody></table>`;
-        } catch {
-          el.innerHTML = '<p class="empty-msg">데이터 없음</p>';
-        }
-      }
-
       async function refreshAll() {
         document.getElementById('last-updated').textContent = '업데이트 중...';
         await Promise.all([
           fetchStatus(),
           fetchPerformance(),
-          fetchPositions(),
           fetchPnlHistory(currentDays),
           fetchDecisions(currentMarket),
-          fetchPlaybook(),
-          fetchScorecard(),
-          fetchScenarios(),
-          fetchContext(),
         ]);
         const now = new Date();
         const timeStr = now.toLocaleTimeString('ko-KR', { hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false });

src/db.py

@@ -14,11 +14,6 @@ def init_db(db_path: str) -> sqlite3.Connection:
     if db_path != ":memory:":
         Path(db_path).parent.mkdir(parents=True, exist_ok=True)
     conn = sqlite3.connect(db_path)
-    # Enable WAL mode for concurrent read/write (dashboard + trading loop).
-    # WAL does not apply to in-memory databases.
-    if db_path != ":memory:":
-        conn.execute("PRAGMA journal_mode=WAL")
-        conn.execute("PRAGMA busy_timeout=5000")
     conn.execute(
         """
         CREATE TABLE IF NOT EXISTS trades (
@@ -33,13 +28,12 @@ def init_db(db_path: str) -> sqlite3.Connection:
             pnl REAL DEFAULT 0.0,
             market TEXT DEFAULT 'KR',
             exchange_code TEXT DEFAULT 'KRX',
-            decision_id TEXT,
-            mode TEXT DEFAULT 'paper'
+            decision_id TEXT
         )
         """
     )
 
-    # Migration: Add columns if they don't exist (backward-compatible schema upgrades)
+    # Migration: Add market and exchange_code columns if they don't exist
     cursor = conn.execute("PRAGMA table_info(trades)")
     columns = {row[1] for row in cursor.fetchall()}
 
@@ -51,8 +45,6 @@ def init_db(db_path: str) -> sqlite3.Connection:
         conn.execute("ALTER TABLE trades ADD COLUMN selection_context TEXT")
     if "decision_id" not in columns:
         conn.execute("ALTER TABLE trades ADD COLUMN decision_id TEXT")
-    if "mode" not in columns:
-        conn.execute("ALTER TABLE trades ADD COLUMN mode TEXT DEFAULT 'paper'")
 
     # Context tree tables for multi-layered memory management
     conn.execute(
@@ -139,25 +131,6 @@ def init_db(db_path: str) -> sqlite3.Connection:
     conn.execute(
         "CREATE INDEX IF NOT EXISTS idx_decision_logs_confidence ON decision_logs(confidence)"
     )
-
-    # Index for open-position queries (partition by stock_code, market, ordered by timestamp)
-    conn.execute(
-        "CREATE INDEX IF NOT EXISTS idx_trades_stock_market_ts"
-        " ON trades (stock_code, market, timestamp DESC)"
-    )
-
-    # Lightweight key-value store for trading system runtime metrics (dashboard use only)
-    # Intentionally separate from the AI context tree to preserve separation of concerns.
-    conn.execute(
-        """
-        CREATE TABLE IF NOT EXISTS system_metrics (
-            key        TEXT PRIMARY KEY,
-            value      TEXT NOT NULL,
-            updated_at TEXT NOT NULL
-        )
-        """
-    )
-
     conn.commit()
     return conn
 
@@ -175,7 +148,6 @@ def log_trade(
     exchange_code: str = "KRX",
     selection_context: dict[str, any] | None = None,
     decision_id: str | None = None,
-    mode: str = "paper",
 ) -> None:
     """Insert a trade record into the database.
 
@@ -191,8 +163,6 @@ def log_trade(
         market: Market code
         exchange_code: Exchange code
         selection_context: Scanner selection data (RSI, volume_ratio, signal, score)
-        decision_id: Unique decision identifier for audit linking
-        mode: Trading mode ('paper' or 'live') for data separation
     """
     # Serialize selection context to JSON
     context_json = json.dumps(selection_context) if selection_context else None
@@ -201,10 +171,9 @@ def log_trade(
         """
         INSERT INTO trades (
             timestamp, stock_code, action, confidence, rationale,
-            quantity, price, pnl, market, exchange_code, selection_context, decision_id,
-            mode
+            quantity, price, pnl, market, exchange_code, selection_context, decision_id
         )
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         """,
         (
             datetime.now(UTC).isoformat(),
@@ -219,7 +188,6 @@ def log_trade(
             exchange_code,
             context_json,
             decision_id,
-            mode,
         ),
     )
     conn.commit()
@@ -269,6 +237,28 @@ def get_open_position(
     return {"decision_id": row[1], "price": row[2], "quantity": row[3]}
 
 
+def get_open_positions_by_market(
+    conn: sqlite3.Connection, market: str
+) -> list[str]:
+    """Return stock codes with a net positive position in the given market.
+
+    Uses net BUY - SELL quantity aggregation to avoid false positives from
+    the simpler "latest record is BUY" heuristic.  A stock is considered
+    open only when the bot's own recorded trades leave a positive net quantity.
+    """
+    cursor = conn.execute(
+        """
+        SELECT stock_code
+        FROM trades
+        WHERE market = ?
+        GROUP BY stock_code
+        HAVING SUM(CASE WHEN action = 'BUY' THEN quantity ELSE -quantity END) > 0
+        """,
+        (market,),
+    )
+    return [row[0] for row in cursor.fetchall()]
+
+
 def get_recent_symbols(
     conn: sqlite3.Connection, market: str, limit: int = 30
 ) -> list[str]:

src/main.py

@@ -32,6 +32,7 @@ from src.core.risk_manager import CircuitBreakerTripped, FatFingerRejected, Risk
 from src.db import (
     get_latest_buy_trade,
     get_open_position,
+    get_open_positions_by_market,
     get_recent_symbols,
     init_db,
     log_trade,
@@ -42,7 +43,7 @@ from src.logging.decision_logger import DecisionLogger
 from src.logging_config import setup_logging
 from src.markets.schedule import MarketInfo, get_next_market_open, get_open_markets
 from src.notifications.telegram_client import NotificationFilter, TelegramClient, TelegramCommandHandler
-from src.strategy.models import DayPlaybook, MarketOutlook
+from src.strategy.models import DayPlaybook
 from src.strategy.playbook_store import PlaybookStore
 from src.strategy.pre_market_planner import PreMarketPlanner
 from src.strategy.scenario_engine import ScenarioEngine
@@ -81,7 +82,6 @@ def safe_float(value: str | float | None, default: float = 0.0) -> float:
 TRADE_INTERVAL_SECONDS = 60
 SCAN_INTERVAL_SECONDS = 60  # Scan markets every 60 seconds
 MAX_CONNECTION_RETRIES = 3
-_BUY_COOLDOWN_SECONDS = 600  # 10-minute cooldown after insufficient-balance rejection
 
 # Daily trading mode constants (for Free tier API efficiency)
 DAILY_TRADE_SESSIONS = 4  # Number of trading sessions per day
@@ -107,82 +107,6 @@ def _extract_symbol_from_holding(item: dict[str, Any]) -> str:
     return ""
 
 
-def _extract_held_codes_from_balance(
-    balance_data: dict[str, Any],
-    *,
-    is_domestic: bool,
-) -> list[str]:
-    """Return stock codes with a positive orderable quantity from a balance response.
-
-    Uses the broker's live output1 as the source of truth so that partial fills
-    and manual external trades are always reflected correctly.
-    """
-    output1 = balance_data.get("output1", [])
-    if isinstance(output1, dict):
-        output1 = [output1]
-    if not isinstance(output1, list):
-        return []
-
-    codes: list[str] = []
-    for holding in output1:
-        if not isinstance(holding, dict):
-            continue
-        code_key = "pdno" if is_domestic else "ovrs_pdno"
-        code = str(holding.get(code_key, "")).strip().upper()
-        if not code:
-            continue
-        if is_domestic:
-            qty = int(holding.get("ord_psbl_qty") or holding.get("hldg_qty") or 0)
-        else:
-            qty = int(holding.get("ovrs_cblc_qty") or holding.get("hldg_qty") or 0)
-        if qty > 0:
-            codes.append(code)
-    return codes
-
-
-def _extract_held_qty_from_balance(
-    balance_data: dict[str, Any],
-    stock_code: str,
-    *,
-    is_domestic: bool,
-) -> int:
-    """Extract the broker-confirmed orderable quantity for a stock.
-
-    Uses the broker's live balance response (output1) as the source of truth
-    rather than the local DB, because DB records reflect order quantity which
-    may differ from actual fill quantity due to partial fills.
-
-    Domestic fields (VTTC8434R output1):
-        pdno          — 종목코드
-        ord_psbl_qty  — 주문가능수량 (preferred: excludes unsettled)
-        hldg_qty      — 보유수량 (fallback)
-
-    Overseas fields (output1):
-        ovrs_pdno     — 종목코드
-        ovrs_cblc_qty — 해외잔고수량 (preferred)
-        hldg_qty      — 보유수량 (fallback)
-    """
-    output1 = balance_data.get("output1", [])
-    if isinstance(output1, dict):
-        output1 = [output1]
-    if not isinstance(output1, list):
-        return 0
-
-    for holding in output1:
-        if not isinstance(holding, dict):
-            continue
-        code_key = "pdno" if is_domestic else "ovrs_pdno"
-        held_code = str(holding.get(code_key, "")).strip().upper()
-        if held_code != stock_code.strip().upper():
-            continue
-        if is_domestic:
-            qty = int(holding.get("ord_psbl_qty") or holding.get("hldg_qty") or 0)
-        else:
-            qty = int(holding.get("ovrs_cblc_qty") or holding.get("hldg_qty") or 0)
-        return qty
-    return 0
-
-
 def _determine_order_quantity(
     *,
     action: str,
@@ -190,40 +114,16 @@ def _determine_order_quantity(
     total_cash: float,
     candidate: ScanCandidate | None,
     settings: Settings | None,
-    broker_held_qty: int = 0,
-    playbook_allocation_pct: float | None = None,
-    scenario_confidence: int = 80,
 ) -> int:
-    """Determine order quantity using volatility-aware position sizing.
-
-    Priority:
-    1. playbook_allocation_pct (AI-specified) scaled by scenario_confidence
-    2. Fallback: volatility-score-based allocation from scanner candidate
-    """
-    if action == "SELL":
-        return broker_held_qty
+    """Determine order quantity using volatility-aware position sizing."""
+    if action != "BUY":
+        return 1
     if current_price <= 0 or total_cash <= 0:
         return 0
 
     if settings is None or not settings.POSITION_SIZING_ENABLED:
         return 1
 
-    # Use AI-specified allocation_pct if available
-    if playbook_allocation_pct is not None:
-        # Confidence scaling: confidence 80 → 1.0x, confidence 95 → 1.19x
-        confidence_scale = scenario_confidence / 80.0
-        effective_pct = min(
-            settings.POSITION_MAX_ALLOCATION_PCT,
-            max(
-                settings.POSITION_MIN_ALLOCATION_PCT,
-                playbook_allocation_pct * confidence_scale,
-            ),
-        )
-        budget = total_cash * (effective_pct / 100.0)
-        quantity = int(budget // current_price)
-        return max(0, quantity)
-
-    # Fallback: volatility-score-based allocation
     target_score = max(1.0, settings.POSITION_VOLATILITY_TARGET_SCORE)
     observed_score = candidate.score if candidate else target_score
     observed_score = max(1.0, min(100.0, observed_score))
@@ -299,7 +199,6 @@ async def trading_cycle(
     stock_code: str,
     scan_candidates: dict[str, dict[str, ScanCandidate]],
     settings: Settings | None = None,
-    buy_cooldown: dict[str, float] | None = None,
 ) -> None:
     """Execute one trading cycle for a single stock."""
     cycle_start_time = asyncio.get_event_loop().time()
@@ -340,13 +239,7 @@ async def trading_cycle(
         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.
-        # Only activate in paper mode — live mode must use real balance from KIS.
-        if (
-            total_cash <= 0
-            and settings
-            and settings.MODE == "paper"
-            and settings.PAPER_OVERSEAS_CASH > 0
-        ):
+        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 USD",
                 market.exchange_code,
@@ -436,17 +329,6 @@ async def trading_cycle(
             {"volume_ratio": candidate.volume_ratio},
         )
 
-    # Write pnl_pct to system_metrics (dashboard-only table, separate from AI context tree)
-    db_conn.execute(
-        "INSERT OR REPLACE INTO system_metrics (key, value, updated_at) VALUES (?, ?, ?)",
-        (
-            f"portfolio_pnl_pct_{market.code}",
-            json.dumps({"pnl_pct": round(pnl_pct, 4)}),
-            datetime.now(UTC).isoformat(),
-        ),
-    )
-    db_conn.commit()
-
     # Build portfolio data for global rule evaluation
     portfolio_data = {
         "portfolio_pnl_pct": pnl_pct,
@@ -499,61 +381,6 @@ async def trading_cycle(
     )
     stock_playbook = playbook.get_stock_playbook(stock_code)
 
-    # 2.1. Apply market_outlook-based BUY confidence threshold
-    if decision.action == "BUY":
-        base_threshold = (settings.CONFIDENCE_THRESHOLD if settings else 80)
-        outlook = playbook.market_outlook
-        if outlook == MarketOutlook.BEARISH:
-            min_confidence = 90
-        elif outlook == MarketOutlook.BULLISH:
-            min_confidence = 75
-        else:
-            min_confidence = base_threshold
-        if match.confidence < min_confidence:
-            logger.info(
-                "BUY suppressed for %s (%s): confidence %d < %d (market_outlook=%s)",
-                stock_code,
-                market.name,
-                match.confidence,
-                min_confidence,
-                outlook.value,
-            )
-            decision = TradeDecision(
-                action="HOLD",
-                confidence=match.confidence,
-                rationale=(
-                    f"BUY confidence {match.confidence} < {min_confidence} "
-                    f"(market_outlook={outlook.value})"
-                ),
-            )
-
-    # BUY 결정 전 기존 포지션 체크 (중복 매수 방지)
-    if decision.action == "BUY":
-        existing_position = get_open_position(db_conn, stock_code, market.code)
-        if not existing_position and not market.is_domestic:
-            # SELL 지정가 접수 후 미체결 시 DB는 종료로 기록되나 브로커는 여전히 보유 중.
-            # 이중 매수 방지를 위해 라이브 브로커 잔고를 authoritative source로 사용.
-            broker_qty = _extract_held_qty_from_balance(
-                balance_data, stock_code, is_domestic=False
-            )
-            if broker_qty > 0:
-                existing_position = {"price": 0.0, "quantity": broker_qty}
-        if existing_position:
-            decision = TradeDecision(
-                action="HOLD",
-                confidence=decision.confidence,
-                rationale=(
-                    f"Already holding {stock_code} "
-                    f"(entry={existing_position['price']:.4f}, "
-                    f"qty={existing_position['quantity']})"
-                ),
-            )
-            logger.info(
-                "BUY suppressed for %s (%s): already holding open position",
-                stock_code,
-                market.name,
-            )
-
     if decision.action == "HOLD":
         open_position = get_open_position(db_conn, stock_code, market.code)
         if open_position:
@@ -561,10 +388,8 @@ async def trading_cycle(
             if entry_price > 0:
                 loss_pct = (current_price - entry_price) / entry_price * 100
                 stop_loss_threshold = -2.0
-                take_profit_threshold = 3.0
                 if stock_playbook and stock_playbook.scenarios:
                     stop_loss_threshold = stock_playbook.scenarios[0].stop_loss_pct
-                    take_profit_threshold = stock_playbook.scenarios[0].take_profit_pct
 
                 if loss_pct <= stop_loss_threshold:
                     decision = TradeDecision(
@@ -582,22 +407,6 @@ async def trading_cycle(
                         loss_pct,
                         stop_loss_threshold,
                     )
-                elif loss_pct >= take_profit_threshold:
-                    decision = TradeDecision(
-                        action="SELL",
-                        confidence=90,
-                        rationale=(
-                            f"Take-profit triggered ({loss_pct:.2f}% >= "
-                            f"{take_profit_threshold:.2f}%)"
-                        ),
-                    )
-                    logger.info(
-                        "Take-profit override for %s (%s): %.2f%% >= %.2f%%",
-                        stock_code,
-                        market.name,
-                        loss_pct,
-                        take_profit_threshold,
-                    )
     logger.info(
         "Decision for %s (%s): %s (confidence=%d)",
         stock_code,
@@ -658,23 +467,12 @@ async def trading_cycle(
     trade_price = current_price
     trade_pnl = 0.0
     if decision.action in ("BUY", "SELL"):
-        broker_held_qty = (
-            _extract_held_qty_from_balance(
-                balance_data, stock_code, is_domestic=market.is_domestic
-            )
-            if decision.action == "SELL"
-            else 0
-        )
-        matched_scenario = match.matched_scenario
         quantity = _determine_order_quantity(
             action=decision.action,
             current_price=current_price,
             total_cash=total_cash,
             candidate=candidate,
             settings=settings,
-            broker_held_qty=broker_held_qty,
-            playbook_allocation_pct=matched_scenario.allocation_pct if matched_scenario else None,
-            scenario_confidence=match.confidence,
         )
         if quantity <= 0:
             logger.info(
@@ -688,28 +486,8 @@ async def trading_cycle(
             return
         order_amount = current_price * quantity
 
-        # 4. Check BUY cooldown (set when a prior BUY failed due to insufficient balance)
-        if decision.action == "BUY" and buy_cooldown is not None:
-            cooldown_key = f"{market.code}:{stock_code}"
-            cooldown_until = buy_cooldown.get(cooldown_key, 0.0)
-            now = asyncio.get_event_loop().time()
-            if now < cooldown_until:
-                remaining = int(cooldown_until - now)
-                logger.info(
-                    "Skip BUY %s (%s): insufficient-balance cooldown active (%ds remaining)",
-                    stock_code,
-                    market.name,
-                    remaining,
-                )
-                return
-
-        # 5a. Risk check BEFORE order
-        # SELL orders do not consume cash (they receive it), so fat-finger check
-        # is skipped for SELLs — only circuit breaker applies.
+        # 4. Risk check BEFORE order
         try:
-            if decision.action == "SELL":
-                risk.check_circuit_breaker(pnl_pct)
-            else:
             risk.validate_order(
                 current_pnl_pct=pnl_pct,
                 order_amount=order_amount,
@@ -756,23 +534,11 @@ async def trading_cycle(
             # Check if KIS rejected the order (rt_cd != "0")
             if result.get("rt_cd", "") != "0":
                 order_succeeded = False
-                msg1 = result.get("msg1") or ""
                 logger.warning(
                     "Overseas order not accepted for %s: rt_cd=%s msg=%s",
                     stock_code,
                     result.get("rt_cd"),
-                    msg1,
-                )
-                # Set BUY cooldown when the rejection is due to insufficient balance
-                if decision.action == "BUY" and buy_cooldown is not None and "주문가능금액" in msg1:
-                    cooldown_key = f"{market.code}:{stock_code}"
-                    buy_cooldown[cooldown_key] = (
-                        asyncio.get_event_loop().time() + _BUY_COOLDOWN_SECONDS
-                    )
-                    logger.info(
-                        "BUY cooldown set for %s: %.0fs (insufficient balance)",
-                        stock_code,
-                        _BUY_COOLDOWN_SECONDS,
+                    result.get("msg1"),
                 )
         logger.info("Order result: %s", result.get("msg1", "OK"))
 
@@ -828,7 +594,6 @@ async def trading_cycle(
         exchange_code=market.exchange_code,
         selection_context=selection_context,
         decision_id=decision_id,
-        mode=settings.MODE if settings else "paper",
     )
 
     # 7. Latency monitoring
@@ -882,9 +647,6 @@ async def run_daily_session(
 
     logger.info("Starting daily trading session for %d markets", len(open_markets))
 
-    # BUY cooldown: prevents retrying stocks rejected for insufficient balance
-    daily_buy_cooldown: dict[str, float] = {}  # "{market_code}:{stock_code}" -> expiry timestamp
-
     # Process each open market
     for market in open_markets:
         # Use market-local date for playbook keying
@@ -1048,12 +810,11 @@ async def run_daily_session(
                 balance_info.get("frcr_buy_amt_smtl", "0") or "0"
             )
             # Paper mode fallback: VTS overseas balance API often fails for many accounts.
-            # Only activate in paper mode — live mode must use real balance from KIS.
-            if (
-                total_cash <= 0
-                and settings.MODE == "paper"
-                and settings.PAPER_OVERSEAS_CASH > 0
-            ):
+            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:
                 total_cash = settings.PAPER_OVERSEAS_CASH
 
         # Calculate daily P&L %
@@ -1092,33 +853,6 @@ async def run_daily_session(
                 decision.confidence,
             )
 
-            # BUY 중복 방지: 브로커 잔고 기반 (미체결 SELL 리밋 주문 보호)
-            if decision.action == "BUY":
-                daily_existing = get_open_position(db_conn, stock_code, market.code)
-                if not daily_existing and not market.is_domestic:
-                    # SELL 지정가 접수 후 미체결 시 DB는 종료로 기록되나 브로커는 여전히 보유 중.
-                    # 이중 매수 방지를 위해 라이브 브로커 잔고를 authoritative source로 사용.
-                    broker_qty = _extract_held_qty_from_balance(
-                        balance_data, stock_code, is_domestic=False
-                    )
-                    if broker_qty > 0:
-                        daily_existing = {"price": 0.0, "quantity": broker_qty}
-                if daily_existing:
-                    decision = TradeDecision(
-                        action="HOLD",
-                        confidence=decision.confidence,
-                        rationale=(
-                            f"Already holding {stock_code} "
-                            f"(entry={daily_existing['price']:.4f}, "
-                            f"qty={daily_existing['quantity']})"
-                        ),
-                    )
-                    logger.info(
-                        "BUY suppressed for %s (%s): already holding open position",
-                        stock_code,
-                        market.name,
-                    )
-
             # Log decision
             context_snapshot = {
                 "L1": {
@@ -1158,20 +892,12 @@ async def run_daily_session(
             trade_pnl = 0.0
             order_succeeded = True
             if decision.action in ("BUY", "SELL"):
-                daily_broker_held_qty = (
-                    _extract_held_qty_from_balance(
-                        balance_data, stock_code, is_domestic=market.is_domestic
-                    )
-                    if decision.action == "SELL"
-                    else 0
-                )
                 quantity = _determine_order_quantity(
                     action=decision.action,
                     current_price=stock_data["current_price"],
                     total_cash=total_cash,
                     candidate=candidate_map.get(stock_code),
                     settings=settings,
-                    broker_held_qty=daily_broker_held_qty,
                 )
                 if quantity <= 0:
                     logger.info(
@@ -1185,28 +911,8 @@ async def run_daily_session(
                     continue
                 order_amount = stock_data["current_price"] * quantity
 
-                # Check BUY cooldown (insufficient balance)
-                if decision.action == "BUY":
-                    daily_cooldown_key = f"{market.code}:{stock_code}"
-                    daily_cooldown_until = daily_buy_cooldown.get(daily_cooldown_key, 0.0)
-                    now = asyncio.get_event_loop().time()
-                    if now < daily_cooldown_until:
-                        remaining = int(daily_cooldown_until - now)
-                        logger.info(
-                            "Skip BUY %s (%s): insufficient-balance cooldown active (%ds remaining)",
-                            stock_code,
-                            market.name,
-                            remaining,
-                        )
-                        continue
-
                 # Risk check
-                # SELL orders do not consume cash (they receive it), so fat-finger
-                # check is skipped for SELLs — only circuit breaker applies.
                 try:
-                    if decision.action == "SELL":
-                        risk.check_circuit_breaker(pnl_pct)
-                    else:
                     risk.validate_order(
                         current_pnl_pct=pnl_pct,
                         order_amount=order_amount,
@@ -1261,22 +967,11 @@ async def run_daily_session(
                         )
                         if result.get("rt_cd", "") != "0":
                             order_succeeded = False
-                            daily_msg1 = result.get("msg1") or ""
                             logger.warning(
                                 "Overseas order not accepted for %s: rt_cd=%s msg=%s",
                                 stock_code,
                                 result.get("rt_cd"),
-                                daily_msg1,
-                            )
-                            if decision.action == "BUY" and "주문가능금액" in daily_msg1:
-                                daily_cooldown_key = f"{market.code}:{stock_code}"
-                                daily_buy_cooldown[daily_cooldown_key] = (
-                                    asyncio.get_event_loop().time() + _BUY_COOLDOWN_SECONDS
-                                )
-                                logger.info(
-                                    "BUY cooldown set for %s: %.0fs (insufficient balance)",
-                                    stock_code,
-                                    _BUY_COOLDOWN_SECONDS,
+                                result.get("msg1"),
                             )
                     logger.info("Order result: %s", result.get("msg1", "OK"))
 
@@ -1326,7 +1021,6 @@ async def run_daily_session(
                 market=market.code,
                 exchange_code=market.exchange_code,
                 decision_id=decision_id,
-                mode=settings.MODE,
             )
 
     logger.info("Daily trading session completed")
@@ -1442,18 +1136,10 @@ def _start_dashboard_server(settings: Settings) -> threading.Thread | None:
     if not settings.DASHBOARD_ENABLED:
         return None
 
-    # Validate dependencies before spawning the thread so startup failures are
-    # reported synchronously (avoids the misleading "started" → "failed" log pair).
-    try:
-        import uvicorn  # noqa: F401
-        from src.dashboard import create_dashboard_app  # noqa: F401
-    except ImportError as exc:
-        logger.warning("Dashboard server unavailable (missing dependency): %s", exc)
-        return None
-
     def _serve() -> None:
         try:
             import uvicorn
+
             from src.dashboard import create_dashboard_app
 
             app = create_dashboard_app(settings.DB_PATH)
@@ -1464,7 +1150,7 @@ def _start_dashboard_server(settings: Settings) -> threading.Thread | None:
                 log_level="info",
             )
         except Exception as exc:
-            logger.warning("Dashboard server stopped unexpectedly: %s", exc)
+            logger.warning("Dashboard server failed to start: %s", exc)
 
     thread = threading.Thread(
         target=_serve,
@@ -1905,9 +1591,6 @@ async def run(settings: Settings) -> None:
     # Active stocks per market (dynamically discovered by scanner)
     active_stocks: dict[str, list[str]] = {}  # market_code -> [stock_codes]
 
-    # BUY cooldown: prevents retrying a stock rejected for insufficient balance
-    buy_cooldown: dict[str, float] = {}  # "{market_code}:{stock_code}" -> expiry timestamp
-
     # Initialize latency control system
     criticality_assessor = CriticalityAssessor(
         critical_pnl_threshold=-2.5,  # Near circuit breaker at -3.0%
@@ -1988,10 +1671,6 @@ async def run(settings: Settings) -> None:
                     )
                 except CircuitBreakerTripped:
                     logger.critical("Circuit breaker tripped — shutting down")
-                    await telegram.notify_circuit_breaker(
-                        pnl_pct=settings.CIRCUIT_BREAKER_PCT,
-                        threshold=settings.CIRCUIT_BREAKER_PCT,
-                    )
                     shutdown.set()
                     break
                 except Exception as exc:
@@ -2185,38 +1864,22 @@ async def run(settings: Settings) -> None:
                         except Exception as exc:
                             logger.error("Smart Scanner failed for %s: %s", market.name, exc)
 
-                    # Get active stocks from scanner (dynamic, no static fallback).
-                    # Also include currently-held positions so stop-loss /
-                    # take-profit can fire even when a holding drops off the
-                    # scanner.  Broker balance is the source of truth here —
-                    # unlike the local DB it reflects actual fills and any
-                    # manual trades done outside the bot.
+                    # Get active stocks from scanner (dynamic, no static fallback)
+                    # Also include current holdings so stop-loss / take-profit
+                    # can trigger even when a position drops off the scanner.
                     scanner_codes = active_stocks.get(market.code, [])
-                    try:
-                        if market.is_domestic:
-                            held_balance = await broker.get_balance()
-                        else:
-                            held_balance = await overseas_broker.get_overseas_balance(
-                                market.exchange_code
-                            )
-                        held_codes = _extract_held_codes_from_balance(
-                            held_balance, is_domestic=market.is_domestic
-                        )
-                    except Exception as exc:
-                        logger.warning(
-                            "Failed to fetch holdings for %s: %s — skipping holdings merge",
-                            market.name, exc,
-                        )
-                        held_codes = []
-
+                    held_codes = get_open_positions_by_market(db_conn, market.code)
+                    # Union: scanner candidates first, then holdings not already present.
+                    # dict.fromkeys preserves insertion order and removes duplicates.
                     stock_codes = list(dict.fromkeys(scanner_codes + held_codes))
-                    extra_held = [c for c in held_codes if c not in set(scanner_codes)]
-                    if extra_held:
+                    if held_codes:
+                        new_held = [c for c in held_codes if c not in set(scanner_codes)]
+                        if new_held:
                             logger.info(
                                 "Holdings added to loop for %s (not in scanner): %s",
-                            market.name, extra_held,
+                                market.name,
+                                new_held,
                             )
-
                     if not stock_codes:
                         logger.debug("No active stocks for market %s", market.code)
                         continue
@@ -2254,7 +1917,6 @@ async def run(settings: Settings) -> None:
                                     stock_code,
                                     scan_candidates,
                                     settings,
-                                    buy_cooldown,
                                 )
                                 break  # Success — exit retry loop
                             except CircuitBreakerTripped as exc:
@@ -2309,8 +1971,6 @@ async def run(settings: Settings) -> None:
                 except TimeoutError:
                     pass  # Normal — timeout means it's time for next cycle
     finally:
-        # Notify shutdown before closing resources
-        await telegram.notify_system_shutdown("Normal shutdown")
         # Clean up resources
         await command_handler.stop_polling()
         await broker.close()

src/notifications/telegram_client.py

@@ -604,16 +604,6 @@ class TelegramCommandHandler:
             async with session.post(url, json=payload) as resp:
                 if resp.status != 200:
                     error_text = await resp.text()
-                    if resp.status == 409:
-                        # Another bot instance is already polling — stop this poller entirely.
-                        # Retrying would keep conflicting with the other instance.
-                        self._running = False
-                        logger.warning(
-                            "Telegram conflict (409): another instance is already polling. "
-                            "Disabling Telegram commands for this process. "
-                            "Ensure only one instance of The Ouroboros is running at a time.",
-                        )
-                    else:
                     logger.error(
                         "getUpdates API error (status=%d): %s", resp.status, error_text
                     )

src/strategies/v20260220_210124_evolved.py

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

src/strategies/v20260220_210159_evolved.py

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

src/strategies/v20260220_210244_evolved.py

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

src/strategy/models.py

@@ -46,18 +46,6 @@ class StockCondition(BaseModel):
 
     The ScenarioEngine evaluates all non-None fields as AND conditions.
     A condition matches only if ALL specified fields are satisfied.
-
-    Technical indicator fields:
-        rsi_below / rsi_above — RSI threshold
-        volume_ratio_above / volume_ratio_below — volume vs previous day
-        price_above / price_below — absolute price level
-        price_change_pct_above / price_change_pct_below — intraday % change
-
-    Position-aware fields (require market_data enrichment from open position):
-        unrealized_pnl_pct_above — matches if unrealized P&L > threshold (e.g. 3.0 → +3%)
-        unrealized_pnl_pct_below — matches if unrealized P&L < threshold (e.g. -2.0 → -2%)
-        holding_days_above — matches if position held for more than N days
-        holding_days_below — matches if position held for fewer than N days
     """
 
     rsi_below: float | None = None
@@ -68,10 +56,6 @@ class StockCondition(BaseModel):
     price_below: float | None = None
     price_change_pct_above: float | None = None
     price_change_pct_below: float | None = None
-    unrealized_pnl_pct_above: float | None = None
-    unrealized_pnl_pct_below: float | None = None
-    holding_days_above: int | None = None
-    holding_days_below: int | None = None
 
     def has_any_condition(self) -> bool:
         """Check if at least one condition field is set."""
@@ -86,10 +70,6 @@ class StockCondition(BaseModel):
                 self.price_below,
                 self.price_change_pct_above,
                 self.price_change_pct_below,
-                self.unrealized_pnl_pct_above,
-                self.unrealized_pnl_pct_below,
-                self.holding_days_above,
-                self.holding_days_below,
             )
         )
 

src/strategy/pre_market_planner.py

@@ -75,7 +75,6 @@ class PreMarketPlanner:
         market: str,
         candidates: list[ScanCandidate],
         today: date | None = None,
-        current_holdings: list[dict] | None = None,
     ) -> DayPlaybook:
         """Generate a DayPlaybook for a market using Gemini.
 
@@ -83,10 +82,6 @@ class PreMarketPlanner:
             market: Market code ("KR" or "US")
             candidates: Stock candidates from SmartVolatilityScanner
             today: Override date (defaults to date.today()). Use market-local date.
-            current_holdings: Currently held positions with entry_price and unrealized_pnl_pct.
-                Each dict: {"stock_code": str, "name": str, "qty": int,
-                            "entry_price": float, "unrealized_pnl_pct": float,
-                            "holding_days": int}
 
         Returns:
             DayPlaybook with scenarios. Empty/defensive if no candidates or failure.
@@ -111,7 +106,6 @@ class PreMarketPlanner:
                 context_data,
                 self_market_scorecard,
                 cross_market,
-                current_holdings=current_holdings,
             )
 
             # 3. Call Gemini
@@ -124,8 +118,7 @@ class PreMarketPlanner:
 
             # 4. Parse response
             playbook = self._parse_response(
-                decision.rationale, today, market, candidates, cross_market,
-                current_holdings=current_holdings,
+                decision.rationale, today, market, candidates, cross_market
             )
             playbook_with_tokens = playbook.model_copy(
                 update={"token_count": decision.token_count}
@@ -237,7 +230,6 @@ class PreMarketPlanner:
         context_data: dict[str, Any],
         self_market_scorecard: dict[str, Any] | None,
         cross_market: CrossMarketContext | None,
-        current_holdings: list[dict] | None = None,
     ) -> str:
         """Build a structured prompt for Gemini to generate scenario JSON."""
         max_scenarios = self._settings.MAX_SCENARIOS_PER_STOCK
@@ -249,26 +241,6 @@ class PreMarketPlanner:
             for c in candidates
         )
 
-        holdings_text = ""
-        if current_holdings:
-            lines = []
-            for h in current_holdings:
-                code = h.get("stock_code", "")
-                name = h.get("name", "")
-                qty = h.get("qty", 0)
-                entry_price = h.get("entry_price", 0.0)
-                pnl_pct = h.get("unrealized_pnl_pct", 0.0)
-                holding_days = h.get("holding_days", 0)
-                lines.append(
-                    f"  - {code} ({name}): {qty}주 @ {entry_price:,.0f}, "
-                    f"미실현손익 {pnl_pct:+.2f}%, 보유 {holding_days}일"
-                )
-            holdings_text = (
-                "\n## Current Holdings (보유 중 — SELL/HOLD 전략 고려 필요)\n"
-                + "\n".join(lines)
-                + "\n"
-            )
-
         cross_market_text = ""
         if cross_market:
             cross_market_text = (
@@ -301,20 +273,10 @@ class PreMarketPlanner:
                     for key, value in list(layer_data.items())[:5]:
                         context_text += f"  - {key}: {value}\n"
 
-        holdings_instruction = ""
-        if current_holdings:
-            holding_codes = [h.get("stock_code", "") for h in current_holdings]
-            holdings_instruction = (
-                f"- Also include SELL/HOLD scenarios for held stocks: "
-                f"{', '.join(holding_codes)} "
-                f"(even if not in candidates list)\n"
-            )
-
         return (
             f"You are a pre-market trading strategist for the {market} market.\n"
             f"Generate structured trading scenarios for today.\n\n"
             f"## Candidates (from volatility scanner)\n{candidates_text}\n"
-            f"{holdings_text}"
             f"{self_market_text}"
             f"{cross_market_text}"
             f"{context_text}\n"
@@ -332,8 +294,7 @@ class PreMarketPlanner:
             f'      "stock_code": "...",\n'
             f'      "scenarios": [\n'
             f'        {{\n'
-            f'          "condition": {{"rsi_below": 30, "volume_ratio_above": 2.0,'
-            f' "unrealized_pnl_pct_above": 3.0, "holding_days_above": 5}},\n'
+            f'          "condition": {{"rsi_below": 30, "volume_ratio_above": 2.0}},\n'
             f'          "action": "BUY|SELL|HOLD",\n'
             f'          "confidence": 85,\n'
             f'          "allocation_pct": 10.0,\n'
@@ -347,8 +308,7 @@ class PreMarketPlanner:
             f'}}\n\n'
             f"Rules:\n"
             f"- Max {max_scenarios} scenarios per stock\n"
-            f"- Candidates list is the primary source for BUY candidates\n"
-            f"{holdings_instruction}"
+            f"- Only use stocks from the candidates list\n"
             f"- Confidence 0-100 (80+ for actionable trades)\n"
             f"- stop_loss_pct must be <= 0, take_profit_pct must be >= 0\n"
             f"- Return ONLY the JSON, no markdown fences or explanation\n"
@@ -361,19 +321,12 @@ class PreMarketPlanner:
         market: str,
         candidates: list[ScanCandidate],
         cross_market: CrossMarketContext | None,
-        current_holdings: list[dict] | None = None,
     ) -> DayPlaybook:
         """Parse Gemini's JSON response into a validated DayPlaybook."""
         cleaned = self._extract_json(response_text)
         data = json.loads(cleaned)
 
         valid_codes = {c.stock_code for c in candidates}
-        # Holdings are also valid — AI may generate SELL/HOLD scenarios for them
-        if current_holdings:
-            for h in current_holdings:
-                code = h.get("stock_code", "")
-                if code:
-                    valid_codes.add(code)
 
         # Parse market outlook
         outlook_str = data.get("market_outlook", "neutral")
@@ -437,10 +390,6 @@ class PreMarketPlanner:
                 price_below=cond_data.get("price_below"),
                 price_change_pct_above=cond_data.get("price_change_pct_above"),
                 price_change_pct_below=cond_data.get("price_change_pct_below"),
-                unrealized_pnl_pct_above=cond_data.get("unrealized_pnl_pct_above"),
-                unrealized_pnl_pct_below=cond_data.get("unrealized_pnl_pct_below"),
-                holding_days_above=cond_data.get("holding_days_above"),
-                holding_days_below=cond_data.get("holding_days_below"),
             )
 
             if not condition.has_any_condition():

src/strategy/scenario_engine.py

@@ -206,37 +206,6 @@ class ScenarioEngine:
         if condition.price_change_pct_below is not None:
             checks.append(price_change_pct is not None and price_change_pct < condition.price_change_pct_below)
 
-        # Position-aware conditions
-        unrealized_pnl_pct = self._safe_float(market_data.get("unrealized_pnl_pct"))
-        if condition.unrealized_pnl_pct_above is not None or condition.unrealized_pnl_pct_below is not None:
-            if "unrealized_pnl_pct" not in market_data:
-                self._warn_missing_key("unrealized_pnl_pct")
-        if condition.unrealized_pnl_pct_above is not None:
-            checks.append(
-                unrealized_pnl_pct is not None
-                and unrealized_pnl_pct > condition.unrealized_pnl_pct_above
-            )
-        if condition.unrealized_pnl_pct_below is not None:
-            checks.append(
-                unrealized_pnl_pct is not None
-                and unrealized_pnl_pct < condition.unrealized_pnl_pct_below
-            )
-
-        holding_days = self._safe_float(market_data.get("holding_days"))
-        if condition.holding_days_above is not None or condition.holding_days_below is not None:
-            if "holding_days" not in market_data:
-                self._warn_missing_key("holding_days")
-        if condition.holding_days_above is not None:
-            checks.append(
-                holding_days is not None
-                and holding_days > condition.holding_days_above
-            )
-        if condition.holding_days_below is not None:
-            checks.append(
-                holding_days is not None
-                and holding_days < condition.holding_days_below
-            )
-
         return len(checks) > 0 and all(checks)
 
     def _evaluate_global_condition(
@@ -297,9 +266,5 @@ class ScenarioEngine:
             details["current_price"] = self._safe_float(market_data.get("current_price"))
         if condition.price_change_pct_above is not None or condition.price_change_pct_below is not None:
             details["price_change_pct"] = self._safe_float(market_data.get("price_change_pct"))
-        if condition.unrealized_pnl_pct_above is not None or condition.unrealized_pnl_pct_below is not None:
-            details["unrealized_pnl_pct"] = self._safe_float(market_data.get("unrealized_pnl_pct"))
-        if condition.holding_days_above is not None or condition.holding_days_below is not None:
-            details["holding_days"] = self._safe_float(market_data.get("holding_days"))
 
         return details

tests/test_broker.py

@@ -572,156 +572,4 @@ class TestSendOrderTickRounding:
         order_call = mock_post.call_args_list[1]
         body = order_call[1].get("json", {})
         assert body["ORD_DVSN"] == "01"
-
-
-# ---------------------------------------------------------------------------
-# TR_ID live/paper branching (issues #201, #202, #203)
-# ---------------------------------------------------------------------------
-
-
-class TestTRIDBranchingDomestic:
-    """get_balance and send_order must use correct TR_ID for live vs paper mode."""
-
-    def _make_broker(self, settings, mode: str) -> KISBroker:
-        from src.config import Settings
-
-        s = Settings(
-            KIS_APP_KEY=settings.KIS_APP_KEY,
-            KIS_APP_SECRET=settings.KIS_APP_SECRET,
-            KIS_ACCOUNT_NO=settings.KIS_ACCOUNT_NO,
-            GEMINI_API_KEY=settings.GEMINI_API_KEY,
-            DB_PATH=":memory:",
-            ENABLED_MARKETS="KR",
-            MODE=mode,
-        )
-        b = KISBroker(s)
-        b._access_token = "tok"
-        b._token_expires_at = float("inf")
-        b._rate_limiter.acquire = AsyncMock()
-        return b
-
-    @pytest.mark.asyncio
-    async def test_get_balance_paper_uses_vttc8434r(self, settings) -> None:
-        broker = self._make_broker(settings, "paper")
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(
-            return_value={"output1": [], "output2": {}}
-        )
-        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:
-            await broker.get_balance()
-
-        headers = mock_get.call_args[1].get("headers", {})
-        assert headers["tr_id"] == "VTTC8434R"
-
-    @pytest.mark.asyncio
-    async def test_get_balance_live_uses_tttc8434r(self, settings) -> None:
-        broker = self._make_broker(settings, "live")
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(
-            return_value={"output1": [], "output2": {}}
-        )
-        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:
-            await broker.get_balance()
-
-        headers = mock_get.call_args[1].get("headers", {})
-        assert headers["tr_id"] == "TTTC8434R"
-
-    @pytest.mark.asyncio
-    async def test_send_order_buy_paper_uses_vttc0012u(self, settings) -> None:
-        broker = self._make_broker(settings, "paper")
-        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)
-
-        order_headers = mock_post.call_args_list[1][1].get("headers", {})
-        assert order_headers["tr_id"] == "VTTC0012U"
-
-    @pytest.mark.asyncio
-    async def test_send_order_buy_live_uses_tttc0012u(self, settings) -> None:
-        broker = self._make_broker(settings, "live")
-        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)
-
-        order_headers = mock_post.call_args_list[1][1].get("headers", {})
-        assert order_headers["tr_id"] == "TTTC0012U"
-
-    @pytest.mark.asyncio
-    async def test_send_order_sell_paper_uses_vttc0011u(self, settings) -> None:
-        broker = self._make_broker(settings, "paper")
-        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)
-
-        order_headers = mock_post.call_args_list[1][1].get("headers", {})
-        assert order_headers["tr_id"] == "VTTC0011U"
-
-    @pytest.mark.asyncio
-    async def test_send_order_sell_live_uses_tttc0011u(self, settings) -> None:
-        broker = self._make_broker(settings, "live")
-        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)
-
-        order_headers = mock_post.call_args_list[1][1].get("headers", {})
-        assert order_headers["tr_id"] == "TTTC0011U"
+        assert body["ORD_UNPR"] == "0"

tests/test_dashboard.py

@@ -316,100 +316,3 @@ def test_pnl_history_market_filter(tmp_path: Path) -> None:
     # KR has 1 trade with pnl=2.0
     assert len(body["labels"]) >= 1
     assert body["pnl"][0] == 2.0
-
-
-def test_positions_returns_open_buy(tmp_path: Path) -> None:
-    """BUY가 마지막 거래인 종목은 포지션으로 반환되어야 한다."""
-    app = _app(tmp_path)
-    get_positions = _endpoint(app, "/api/positions")
-    body = get_positions()
-    # seed_db: 005930은 BUY (오픈), AAPL은 SELL (마지막)
-    assert body["count"] == 1
-    pos = body["positions"][0]
-    assert pos["stock_code"] == "005930"
-    assert pos["market"] == "KR"
-    assert pos["quantity"] == 1
-    assert pos["entry_price"] == 70000
-
-
-def test_positions_excludes_closed_sell(tmp_path: Path) -> None:
-    """마지막 거래가 SELL인 종목은 포지션에 나타나지 않아야 한다."""
-    app = _app(tmp_path)
-    get_positions = _endpoint(app, "/api/positions")
-    body = get_positions()
-    codes = [p["stock_code"] for p in body["positions"]]
-    assert "AAPL" not in codes
-
-
-def test_positions_empty_when_no_trades(tmp_path: Path) -> None:
-    """거래 내역이 없으면 빈 포지션 목록을 반환해야 한다."""
-    db_path = tmp_path / "empty.db"
-    conn = init_db(str(db_path))
-    conn.close()
-    app = create_dashboard_app(str(db_path))
-    get_positions = _endpoint(app, "/api/positions")
-    body = get_positions()
-    assert body["count"] == 0
-    assert body["positions"] == []
-
-
-def _seed_cb_context(conn: sqlite3.Connection, pnl_pct: float, market: str = "KR") -> None:
-    import json as _json
-    conn.execute(
-        "INSERT OR REPLACE INTO system_metrics (key, value, updated_at) VALUES (?, ?, ?)",
-        (
-            f"portfolio_pnl_pct_{market}",
-            _json.dumps({"pnl_pct": pnl_pct}),
-            "2026-02-22T10:00:00+00:00",
-        ),
-    )
-    conn.commit()
-
-
-def test_status_circuit_breaker_ok(tmp_path: Path) -> None:
-    """pnl_pct가 -2.0%보다 높으면 status=ok를 반환해야 한다."""
-    db_path = tmp_path / "cb_ok.db"
-    conn = init_db(str(db_path))
-    _seed_cb_context(conn, -1.0)
-    conn.close()
-    app = create_dashboard_app(str(db_path))
-    get_status = _endpoint(app, "/api/status")
-    body = get_status()
-    cb = body["circuit_breaker"]
-    assert cb["status"] == "ok"
-    assert cb["current_pnl_pct"] == -1.0
-    assert cb["threshold_pct"] == -3.0
-
-
-def test_status_circuit_breaker_warning(tmp_path: Path) -> None:
-    """pnl_pct가 -2.0% 이하이면 status=warning을 반환해야 한다."""
-    db_path = tmp_path / "cb_warn.db"
-    conn = init_db(str(db_path))
-    _seed_cb_context(conn, -2.5)
-    conn.close()
-    app = create_dashboard_app(str(db_path))
-    get_status = _endpoint(app, "/api/status")
-    body = get_status()
-    assert body["circuit_breaker"]["status"] == "warning"
-
-
-def test_status_circuit_breaker_tripped(tmp_path: Path) -> None:
-    """pnl_pct가 임계값(-3.0%) 이하이면 status=tripped를 반환해야 한다."""
-    db_path = tmp_path / "cb_tripped.db"
-    conn = init_db(str(db_path))
-    _seed_cb_context(conn, -3.5)
-    conn.close()
-    app = create_dashboard_app(str(db_path))
-    get_status = _endpoint(app, "/api/status")
-    body = get_status()
-    assert body["circuit_breaker"]["status"] == "tripped"
-
-
-def test_status_circuit_breaker_unknown_when_no_data(tmp_path: Path) -> None:
-    """L7 context에 pnl_pct 데이터가 없으면 status=unknown을 반환해야 한다."""
-    app = _app(tmp_path)  # seed_db에는 portfolio_pnl_pct 없음
-    get_status = _endpoint(app, "/api/status")
-    body = get_status()
-    cb = body["circuit_breaker"]
-    assert cb["status"] == "unknown"
-    assert cb["current_pnl_pct"] is None

tests/test_db.py

@@ -1,9 +1,6 @@
 """Tests for database helper functions."""
 
-import tempfile
-import os
-
-from src.db import get_open_position, init_db, log_trade
+from src.db import get_open_position, get_open_positions_by_market, init_db, log_trade
 
 
 def test_get_open_position_returns_latest_buy() -> None:
@@ -63,133 +60,85 @@ def test_get_open_position_returns_none_when_no_trades() -> None:
     assert get_open_position(conn, "AAPL", "US_NASDAQ") is None
 
 
-# ---------------------------------------------------------------------------
-# WAL mode tests (issue #210)
-# ---------------------------------------------------------------------------
+# --- get_open_positions_by_market tests ---
 
 
-def test_wal_mode_applied_to_file_db() -> None:
-    """File-based DB must use WAL journal mode for dashboard concurrent reads."""
-    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
-        db_path = f.name
-    try:
-        conn = init_db(db_path)
-        cursor = conn.execute("PRAGMA journal_mode")
-        mode = cursor.fetchone()[0]
-        assert mode == "wal", f"Expected WAL mode, got {mode}"
-        conn.close()
-    finally:
-        os.unlink(db_path)
-        # Clean up WAL auxiliary files if they exist
-        for ext in ("-wal", "-shm"):
-            path = db_path + ext
-            if os.path.exists(path):
-                os.unlink(path)
-
-
-def test_wal_mode_not_applied_to_memory_db() -> None:
-    """:memory: DB must not apply WAL (SQLite does not support WAL for in-memory)."""
-    conn = init_db(":memory:")
-    cursor = conn.execute("PRAGMA journal_mode")
-    mode = cursor.fetchone()[0]
-    # In-memory DBs default to 'memory' journal mode
-    assert mode != "wal", "WAL should not be set on in-memory database"
-    conn.close()
-
-
-# ---------------------------------------------------------------------------
-# mode column tests (issue #212)
-# ---------------------------------------------------------------------------
-
-
-def test_log_trade_stores_mode_paper() -> None:
-    """log_trade must persist mode='paper' in the trades table."""
+def test_get_open_positions_by_market_returns_net_positive_stocks() -> None:
+    """Stocks with net BUY quantity > 0 are included."""
     conn = init_db(":memory:")
     log_trade(
-        conn=conn,
-        stock_code="005930",
-        action="BUY",
-        confidence=85,
-        rationale="test",
-        mode="paper",
+        conn=conn, stock_code="005930", action="BUY", confidence=90,
+        rationale="entry", quantity=5, price=70000.0, market="KR",
+        exchange_code="KRX", decision_id="d1",
     )
-    row = conn.execute("SELECT mode FROM trades ORDER BY id DESC LIMIT 1").fetchone()
-    assert row is not None
-    assert row[0] == "paper"
+    log_trade(
+        conn=conn, stock_code="000660", action="BUY", confidence=85,
+        rationale="entry", quantity=3, price=100000.0, market="KR",
+        exchange_code="KRX", decision_id="d2",
+    )
+
+    result = get_open_positions_by_market(conn, "KR")
+    assert set(result) == {"005930", "000660"}
 
 
-def test_log_trade_stores_mode_live() -> None:
-    """log_trade must persist mode='live' in the trades table."""
+def test_get_open_positions_by_market_excludes_fully_sold_stocks() -> None:
+    """Stocks where BUY qty == SELL qty are excluded (net qty = 0)."""
     conn = init_db(":memory:")
     log_trade(
-        conn=conn,
-        stock_code="005930",
-        action="BUY",
-        confidence=85,
-        rationale="test",
-        mode="live",
+        conn=conn, stock_code="005930", action="BUY", confidence=90,
+        rationale="entry", quantity=3, price=70000.0, market="KR",
+        exchange_code="KRX", decision_id="d1",
     )
-    row = conn.execute("SELECT mode FROM trades ORDER BY id DESC LIMIT 1").fetchone()
-    assert row is not None
-    assert row[0] == "live"
+    log_trade(
+        conn=conn, stock_code="005930", action="SELL", confidence=95,
+        rationale="exit", quantity=3, price=71000.0, market="KR",
+        exchange_code="KRX", decision_id="d2",
+    )
+
+    result = get_open_positions_by_market(conn, "KR")
+    assert "005930" not in result
 
 
-def test_log_trade_default_mode_is_paper() -> None:
-    """log_trade without explicit mode must default to 'paper'."""
+def test_get_open_positions_by_market_includes_partially_sold_stocks() -> None:
+    """Stocks with partial SELL (net qty > 0) are still included."""
     conn = init_db(":memory:")
     log_trade(
-        conn=conn,
-        stock_code="005930",
-        action="HOLD",
-        confidence=50,
-        rationale="test",
+        conn=conn, stock_code="005930", action="BUY", confidence=90,
+        rationale="entry", quantity=5, price=70000.0, market="KR",
+        exchange_code="KRX", decision_id="d1",
     )
-    row = conn.execute("SELECT mode FROM trades ORDER BY id DESC LIMIT 1").fetchone()
-    assert row is not None
-    assert row[0] == "paper"
+    log_trade(
+        conn=conn, stock_code="005930", action="SELL", confidence=95,
+        rationale="partial exit", quantity=2, price=71000.0, market="KR",
+        exchange_code="KRX", decision_id="d2",
+    )
+
+    result = get_open_positions_by_market(conn, "KR")
+    assert "005930" in result
 
 
-def test_mode_column_exists_in_schema() -> None:
-    """trades table must have a mode column after init_db."""
+def test_get_open_positions_by_market_is_market_scoped() -> None:
+    """Only stocks from the specified market are returned."""
     conn = init_db(":memory:")
-    cursor = conn.execute("PRAGMA table_info(trades)")
-    columns = {row[1] for row in cursor.fetchall()}
-    assert "mode" in columns
-
-
-def test_mode_migration_adds_column_to_existing_db() -> None:
-    """init_db must add mode column to existing DBs that lack it (migration)."""
-    import sqlite3
-
-    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
-        db_path = f.name
-    try:
-        # Create DB without mode column (simulate old schema)
-        old_conn = sqlite3.connect(db_path)
-        old_conn.execute(
-            """CREATE TABLE trades (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                timestamp TEXT NOT NULL,
-                stock_code TEXT NOT NULL,
-                action TEXT NOT NULL,
-                confidence INTEGER NOT NULL,
-                rationale TEXT,
-                quantity INTEGER,
-                price REAL,
-                pnl REAL DEFAULT 0.0,
-                market TEXT DEFAULT 'KR',
-                exchange_code TEXT DEFAULT 'KRX',
-                decision_id TEXT
-            )"""
+    log_trade(
+        conn=conn, stock_code="005930", action="BUY", confidence=90,
+        rationale="entry", quantity=3, price=70000.0, market="KR",
+        exchange_code="KRX", decision_id="d1",
+    )
+    log_trade(
+        conn=conn, stock_code="AAPL", action="BUY", confidence=85,
+        rationale="entry", quantity=2, price=200.0, market="NASD",
+        exchange_code="NAS", decision_id="d2",
     )
-        old_conn.commit()
-        old_conn.close()
 
-        # Run init_db — should add mode column via migration
-        conn = init_db(db_path)
-        cursor = conn.execute("PRAGMA table_info(trades)")
-        columns = {row[1] for row in cursor.fetchall()}
-        assert "mode" in columns
-        conn.close()
-    finally:
-        os.unlink(db_path)
+    kr_result = get_open_positions_by_market(conn, "KR")
+    nasd_result = get_open_positions_by_market(conn, "NASD")
+
+    assert kr_result == ["005930"]
+    assert nasd_result == ["AAPL"]
+
+
+def test_get_open_positions_by_market_returns_empty_when_no_trades() -> None:
+    """Empty list returned when no trades exist for the market."""
+    conn = init_db(":memory:")
+    assert get_open_positions_by_market(conn, "KR") == []

tests/test_overseas_broker.py

@@ -414,7 +414,7 @@ class TestSendOverseasOrder:
 
     @pytest.mark.asyncio
     async def test_sell_limit_order(self, overseas_broker: OverseasBroker) -> None:
-        """Limit sell order should use VTTT1001U and ORD_DVSN=00."""
+        """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"})
@@ -428,7 +428,7 @@ class TestSendOverseasOrder:
         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("VTTT1001U")
+        overseas_broker._broker._auth_headers.assert_called_with("VTTT1006U")
 
         call_args = mock_session.post.call_args
         body = call_args[1]["json"]
@@ -640,176 +640,4 @@ class TestPaperOverseasCash:
             GEMINI_API_KEY="g",
         )
         assert settings.PAPER_OVERSEAS_CASH == 0.0
-
-
-# ---------------------------------------------------------------------------
-# TR_ID live/paper branching — overseas (issues #201, #203)
-# ---------------------------------------------------------------------------
-
-
-def _make_overseas_broker_with_mode(mode: str) -> OverseasBroker:
-    s = Settings(
-        KIS_APP_KEY="k",
-        KIS_APP_SECRET="s",
-        KIS_ACCOUNT_NO="12345678-01",
-        GEMINI_API_KEY="g",
-        DB_PATH=":memory:",
-        MODE=mode,
-    )
-    kis = KISBroker(s)
-    kis._access_token = "tok"
-    kis._token_expires_at = float("inf")
-    kis._rate_limiter.acquire = AsyncMock()
-    return OverseasBroker(kis)
-
-
-class TestOverseasTRIDBranching:
-    """get_overseas_balance and send_overseas_order must use correct TR_ID."""
-
-    @pytest.mark.asyncio
-    async def test_get_overseas_balance_paper_uses_vtts3012r(self) -> None:
-        broker = _make_overseas_broker_with_mode("paper")
-        captured: list[str] = []
-
-        async def mock_auth_headers(tr_id: str) -> dict:
-            captured.append(tr_id)
-            return {"tr_id": tr_id, "authorization": "Bearer tok"}
-
-        broker._broker._auth_headers = mock_auth_headers  # type: ignore[method-assign]
-
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(return_value={"output1": [], "output2": []})
-        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
-        mock_resp.__aexit__ = AsyncMock(return_value=False)
-
-        mock_session = MagicMock()
-        mock_session.get = MagicMock(return_value=mock_resp)
-        broker._broker._get_session = MagicMock(return_value=mock_session)
-
-        await broker.get_overseas_balance("NASD")
-        assert "VTTS3012R" in captured
-
-    @pytest.mark.asyncio
-    async def test_get_overseas_balance_live_uses_ttts3012r(self) -> None:
-        broker = _make_overseas_broker_with_mode("live")
-        captured: list[str] = []
-
-        async def mock_auth_headers(tr_id: str) -> dict:
-            captured.append(tr_id)
-            return {"tr_id": tr_id, "authorization": "Bearer tok"}
-
-        broker._broker._auth_headers = mock_auth_headers  # type: ignore[method-assign]
-
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(return_value={"output1": [], "output2": []})
-        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
-        mock_resp.__aexit__ = AsyncMock(return_value=False)
-
-        mock_session = MagicMock()
-        mock_session.get = MagicMock(return_value=mock_resp)
-        broker._broker._get_session = MagicMock(return_value=mock_session)
-
-        await broker.get_overseas_balance("NASD")
-        assert "TTTS3012R" in captured
-
-    @pytest.mark.asyncio
-    async def test_send_overseas_order_buy_paper_uses_vttt1002u(self) -> None:
-        broker = _make_overseas_broker_with_mode("paper")
-        captured: list[str] = []
-
-        async def mock_auth_headers(tr_id: str) -> dict:
-            captured.append(tr_id)
-            return {"tr_id": tr_id, "authorization": "Bearer tok"}
-
-        broker._broker._auth_headers = mock_auth_headers  # type: ignore[method-assign]
-        broker._broker._get_hash_key = AsyncMock(return_value="h")  # type: ignore[method-assign]
-
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(return_value={"rt_cd": "0", "msg1": "OK"})
-        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
-        mock_resp.__aexit__ = AsyncMock(return_value=False)
-
-        mock_session = MagicMock()
-        mock_session.post = MagicMock(return_value=mock_resp)
-        broker._broker._get_session = MagicMock(return_value=mock_session)
-
-        await broker.send_overseas_order("NASD", "AAPL", "BUY", 1)
-        assert "VTTT1002U" in captured
-
-    @pytest.mark.asyncio
-    async def test_send_overseas_order_buy_live_uses_tttt1002u(self) -> None:
-        broker = _make_overseas_broker_with_mode("live")
-        captured: list[str] = []
-
-        async def mock_auth_headers(tr_id: str) -> dict:
-            captured.append(tr_id)
-            return {"tr_id": tr_id, "authorization": "Bearer tok"}
-
-        broker._broker._auth_headers = mock_auth_headers  # type: ignore[method-assign]
-        broker._broker._get_hash_key = AsyncMock(return_value="h")  # type: ignore[method-assign]
-
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(return_value={"rt_cd": "0", "msg1": "OK"})
-        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
-        mock_resp.__aexit__ = AsyncMock(return_value=False)
-
-        mock_session = MagicMock()
-        mock_session.post = MagicMock(return_value=mock_resp)
-        broker._broker._get_session = MagicMock(return_value=mock_session)
-
-        await broker.send_overseas_order("NASD", "AAPL", "BUY", 1)
-        assert "TTTT1002U" in captured
-
-    @pytest.mark.asyncio
-    async def test_send_overseas_order_sell_paper_uses_vttt1001u(self) -> None:
-        broker = _make_overseas_broker_with_mode("paper")
-        captured: list[str] = []
-
-        async def mock_auth_headers(tr_id: str) -> dict:
-            captured.append(tr_id)
-            return {"tr_id": tr_id, "authorization": "Bearer tok"}
-
-        broker._broker._auth_headers = mock_auth_headers  # type: ignore[method-assign]
-        broker._broker._get_hash_key = AsyncMock(return_value="h")  # type: ignore[method-assign]
-
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(return_value={"rt_cd": "0", "msg1": "OK"})
-        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
-        mock_resp.__aexit__ = AsyncMock(return_value=False)
-
-        mock_session = MagicMock()
-        mock_session.post = MagicMock(return_value=mock_resp)
-        broker._broker._get_session = MagicMock(return_value=mock_session)
-
-        await broker.send_overseas_order("NASD", "AAPL", "SELL", 1)
-        assert "VTTT1001U" in captured
-
-    @pytest.mark.asyncio
-    async def test_send_overseas_order_sell_live_uses_tttt1006u(self) -> None:
-        broker = _make_overseas_broker_with_mode("live")
-        captured: list[str] = []
-
-        async def mock_auth_headers(tr_id: str) -> dict:
-            captured.append(tr_id)
-            return {"tr_id": tr_id, "authorization": "Bearer tok"}
-
-        broker._broker._auth_headers = mock_auth_headers  # type: ignore[method-assign]
-        broker._broker._get_hash_key = AsyncMock(return_value="h")  # type: ignore[method-assign]
-
-        mock_resp = AsyncMock()
-        mock_resp.status = 200
-        mock_resp.json = AsyncMock(return_value={"rt_cd": "0", "msg1": "OK"})
-        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
-        mock_resp.__aexit__ = AsyncMock(return_value=False)
-
-        mock_session = MagicMock()
-        mock_session.post = MagicMock(return_value=mock_resp)
-        broker._broker._get_session = MagicMock(return_value=mock_session)
-
-        await broker.send_overseas_order("NASD", "AAPL", "SELL", 1)
-        assert "TTTT1006U" in captured
+        del os.environ["PAPER_OVERSEAS_CASH"]

tests/test_pre_market_planner.py

@@ -830,171 +830,3 @@ class TestSmartFallbackPlaybook:
         ]
         assert len(buy_scenarios) == 1
         assert buy_scenarios[0].condition.volume_ratio_above == 2.0  # VOL_MULTIPLIER default
-
-
-# ---------------------------------------------------------------------------
-# Holdings in prompt (#170)
-# ---------------------------------------------------------------------------
-
-
-class TestHoldingsInPrompt:
-    """Tests for current_holdings parameter in generate_playbook / _build_prompt."""
-
-    def _make_holdings(self) -> list[dict]:
-        return [
-            {
-                "stock_code": "005930",
-                "name": "Samsung",
-                "qty": 10,
-                "entry_price": 71000.0,
-                "unrealized_pnl_pct": 2.3,
-                "holding_days": 3,
-            }
-        ]
-
-    def test_build_prompt_includes_holdings_section(self) -> None:
-        """Prompt should contain a Current Holdings section when holdings are given."""
-        planner = _make_planner()
-        candidates = [_candidate()]
-        holdings = self._make_holdings()
-
-        prompt = planner._build_prompt(
-            "KR",
-            candidates,
-            context_data={},
-            self_market_scorecard=None,
-            cross_market=None,
-            current_holdings=holdings,
-        )
-
-        assert "## Current Holdings" in prompt
-        assert "005930" in prompt
-        assert "+2.30%" in prompt
-        assert "보유 3일" in prompt
-
-    def test_build_prompt_no_holdings_omits_section(self) -> None:
-        """Prompt should NOT contain a Current Holdings section when holdings=None."""
-        planner = _make_planner()
-        candidates = [_candidate()]
-
-        prompt = planner._build_prompt(
-            "KR",
-            candidates,
-            context_data={},
-            self_market_scorecard=None,
-            cross_market=None,
-            current_holdings=None,
-        )
-
-        assert "## Current Holdings" not in prompt
-
-    def test_build_prompt_empty_holdings_omits_section(self) -> None:
-        """Empty list should also omit the holdings section."""
-        planner = _make_planner()
-        candidates = [_candidate()]
-
-        prompt = planner._build_prompt(
-            "KR",
-            candidates,
-            context_data={},
-            self_market_scorecard=None,
-            cross_market=None,
-            current_holdings=[],
-        )
-
-        assert "## Current Holdings" not in prompt
-
-    def test_build_prompt_holdings_instruction_included(self) -> None:
-        """Prompt should include instruction to generate scenarios for held stocks."""
-        planner = _make_planner()
-        candidates = [_candidate()]
-        holdings = self._make_holdings()
-
-        prompt = planner._build_prompt(
-            "KR",
-            candidates,
-            context_data={},
-            self_market_scorecard=None,
-            cross_market=None,
-            current_holdings=holdings,
-        )
-
-        assert "005930" in prompt
-        assert "SELL/HOLD" in prompt
-
-    @pytest.mark.asyncio
-    async def test_generate_playbook_passes_holdings_to_prompt(self) -> None:
-        """generate_playbook should pass current_holdings through to the prompt."""
-        planner = _make_planner()
-        candidates = [_candidate()]
-        holdings = self._make_holdings()
-
-        # Capture the actual prompt sent to Gemini
-        captured_prompts: list[str] = []
-        original_decide = planner._gemini.decide
-
-        async def capture_and_call(data: dict) -> TradeDecision:
-            captured_prompts.append(data.get("prompt_override", ""))
-            return await original_decide(data)
-
-        planner._gemini.decide = capture_and_call  # type: ignore[method-assign]
-
-        await planner.generate_playbook(
-            "KR", candidates, today=date(2026, 2, 8), current_holdings=holdings
-        )
-
-        assert len(captured_prompts) == 1
-        assert "## Current Holdings" in captured_prompts[0]
-        assert "005930" in captured_prompts[0]
-
-    @pytest.mark.asyncio
-    async def test_holdings_stock_allowed_in_parse_response(self) -> None:
-        """Holdings stocks not in candidates list should be accepted in the response."""
-        holding_code = "000660"  # Not in candidates
-        stocks = [
-            {
-                "stock_code": "005930",  # candidate
-                "scenarios": [
-                    {
-                        "condition": {"rsi_below": 30},
-                        "action": "BUY",
-                        "confidence": 85,
-                        "rationale": "oversold",
-                    }
-                ],
-            },
-            {
-                "stock_code": holding_code,  # holding only
-                "scenarios": [
-                    {
-                        "condition": {"price_change_pct_below": -2.0},
-                        "action": "SELL",
-                        "confidence": 90,
-                        "rationale": "stop-loss",
-                    }
-                ],
-            },
-        ]
-        planner = _make_planner(gemini_response=_gemini_response_json(stocks=stocks))
-        candidates = [_candidate()]  # only 005930
-        holdings = [
-            {
-                "stock_code": holding_code,
-                "name": "SK Hynix",
-                "qty": 5,
-                "entry_price": 180000.0,
-                "unrealized_pnl_pct": -1.5,
-                "holding_days": 7,
-            }
-        ]
-
-        pb = await planner.generate_playbook(
-            "KR",
-            candidates,
-            today=date(2026, 2, 8),
-            current_holdings=holdings,
-        )
-
-        codes = [sp.stock_code for sp in pb.stock_playbooks]
-        assert "005930" in codes
-        assert holding_code in codes

tests/test_scenario_engine.py

@@ -440,135 +440,3 @@ class TestEvaluate:
         assert result.action == ScenarioAction.BUY
         assert result.match_details["rsi"] == 25.0
         assert isinstance(result.match_details["rsi"], float)
-
-
-# ---------------------------------------------------------------------------
-# Position-aware condition tests (#171)
-# ---------------------------------------------------------------------------
-
-
-class TestPositionAwareConditions:
-    """Tests for unrealized_pnl_pct and holding_days condition fields."""
-
-    def test_evaluate_condition_unrealized_pnl_above_matches(
-        self, engine: ScenarioEngine
-    ) -> None:
-        """unrealized_pnl_pct_above should match when P&L exceeds threshold."""
-        condition = StockCondition(unrealized_pnl_pct_above=3.0)
-        assert engine.evaluate_condition(condition, {"unrealized_pnl_pct": 5.0}) is True
-
-    def test_evaluate_condition_unrealized_pnl_above_no_match(
-        self, engine: ScenarioEngine
-    ) -> None:
-        """unrealized_pnl_pct_above should NOT match when P&L is below threshold."""
-        condition = StockCondition(unrealized_pnl_pct_above=3.0)
-        assert engine.evaluate_condition(condition, {"unrealized_pnl_pct": 2.0}) is False
-
-    def test_evaluate_condition_unrealized_pnl_below_matches(
-        self, engine: ScenarioEngine
-    ) -> None:
-        """unrealized_pnl_pct_below should match when P&L is under threshold."""
-        condition = StockCondition(unrealized_pnl_pct_below=-2.0)
-        assert engine.evaluate_condition(condition, {"unrealized_pnl_pct": -3.5}) is True
-
-    def test_evaluate_condition_unrealized_pnl_below_no_match(
-        self, engine: ScenarioEngine
-    ) -> None:
-        """unrealized_pnl_pct_below should NOT match when P&L is above threshold."""
-        condition = StockCondition(unrealized_pnl_pct_below=-2.0)
-        assert engine.evaluate_condition(condition, {"unrealized_pnl_pct": -1.0}) is False
-
-    def test_evaluate_condition_holding_days_above_matches(
-        self, engine: ScenarioEngine
-    ) -> None:
-        """holding_days_above should match when position held longer than threshold."""
-        condition = StockCondition(holding_days_above=5)
-        assert engine.evaluate_condition(condition, {"holding_days": 7}) is True
-
-    def test_evaluate_condition_holding_days_above_no_match(
-        self, engine: ScenarioEngine
-    ) -> None:
-        """holding_days_above should NOT match when position held shorter."""
-        condition = StockCondition(holding_days_above=5)
-        assert engine.evaluate_condition(condition, {"holding_days": 3}) is False
-
-    def test_evaluate_condition_holding_days_below_matches(
-        self, engine: ScenarioEngine
-    ) -> None:
-        """holding_days_below should match when position held fewer days."""
-        condition = StockCondition(holding_days_below=3)
-        assert engine.evaluate_condition(condition, {"holding_days": 1}) is True
-
-    def test_evaluate_condition_holding_days_below_no_match(
-        self, engine: ScenarioEngine
-    ) -> None:
-        """holding_days_below should NOT match when held more days."""
-        condition = StockCondition(holding_days_below=3)
-        assert engine.evaluate_condition(condition, {"holding_days": 5}) is False
-
-    def test_combined_pnl_and_holding_days(self, engine: ScenarioEngine) -> None:
-        """Combined position-aware conditions should AND-evaluate correctly."""
-        condition = StockCondition(
-            unrealized_pnl_pct_above=3.0,
-            holding_days_above=5,
-        )
-        # Both met → match
-        assert engine.evaluate_condition(
-            condition,
-            {"unrealized_pnl_pct": 4.5, "holding_days": 7},
-        ) is True
-        # Only pnl met → no match
-        assert engine.evaluate_condition(
-            condition,
-            {"unrealized_pnl_pct": 4.5, "holding_days": 3},
-        ) is False
-
-    def test_missing_unrealized_pnl_does_not_match(
-        self, engine: ScenarioEngine
-    ) -> None:
-        """Missing unrealized_pnl_pct key should not match the condition."""
-        condition = StockCondition(unrealized_pnl_pct_above=3.0)
-        assert engine.evaluate_condition(condition, {}) is False
-
-    def test_missing_holding_days_does_not_match(
-        self, engine: ScenarioEngine
-    ) -> None:
-        """Missing holding_days key should not match the condition."""
-        condition = StockCondition(holding_days_above=5)
-        assert engine.evaluate_condition(condition, {}) is False
-
-    def test_match_details_includes_position_fields(
-        self, engine: ScenarioEngine
-    ) -> None:
-        """match_details should include position fields when condition specifies them."""
-        pb = _playbook(
-            scenarios=[
-                StockScenario(
-                    condition=StockCondition(unrealized_pnl_pct_above=3.0),
-                    action=ScenarioAction.SELL,
-                    confidence=90,
-                    rationale="Take profit",
-                )
-            ]
-        )
-        result = engine.evaluate(
-            pb,
-            "005930",
-            {"unrealized_pnl_pct": 5.0},
-            {},
-        )
-        assert result.action == ScenarioAction.SELL
-        assert "unrealized_pnl_pct" in result.match_details
-        assert result.match_details["unrealized_pnl_pct"] == 5.0
-
-    def test_position_conditions_parse_from_planner(self) -> None:
-        """StockCondition should accept and store new fields from JSON parsing."""
-        condition = StockCondition(
-            unrealized_pnl_pct_above=3.0,
-            unrealized_pnl_pct_below=None,
-            holding_days_above=5,
-            holding_days_below=None,
-        )
-        assert condition.unrealized_pnl_pct_above == 3.0
-        assert condition.holding_days_above == 5
-        assert condition.has_any_condition() is True

tests/test_smart_scanner.py

@@ -350,42 +350,6 @@ class TestSmartVolatilityScanner:
         assert [c.stock_code for c in candidates] == ["ABCD"]
 
 
-class TestImpliedRSIFormula:
-    """Test the implied_rsi formula in SmartVolatilityScanner (issue #181)."""
-
-    def test_neutral_change_gives_neutral_rsi(self) -> None:
-        """0% change → implied_rsi = 50 (neutral)."""
-        # formula: 50 + (change_rate * 2.0)
-        rsi = max(0.0, min(100.0, 50.0 + (0.0 * 2.0)))
-        assert rsi == 50.0
-
-    def test_10pct_change_gives_rsi_70(self) -> None:
-        """10% upward change → implied_rsi = 70 (momentum signal)."""
-        rsi = max(0.0, min(100.0, 50.0 + (10.0 * 2.0)))
-        assert rsi == 70.0
-
-    def test_minus_10pct_gives_rsi_30(self) -> None:
-        """-10% change → implied_rsi = 30 (oversold signal)."""
-        rsi = max(0.0, min(100.0, 50.0 + (-10.0 * 2.0)))
-        assert rsi == 30.0
-
-    def test_saturation_at_25pct(self) -> None:
-        """Saturation occurs at >=25% change (not 12.5% as with old coefficient 4.0)."""
-        rsi_12pct = max(0.0, min(100.0, 50.0 + (12.5 * 2.0)))
-        rsi_25pct = max(0.0, min(100.0, 50.0 + (25.0 * 2.0)))
-        rsi_30pct = max(0.0, min(100.0, 50.0 + (30.0 * 2.0)))
-        # At 12.5% change: RSI = 75 (not 100, unlike old formula)
-        assert rsi_12pct == 75.0
-        # At 25%+ saturation
-        assert rsi_25pct == 100.0
-        assert rsi_30pct == 100.0  # Capped
-
-    def test_negative_saturation(self) -> None:
-        """Saturation at -25% gives RSI = 0."""
-        rsi = max(0.0, min(100.0, 50.0 + (-25.0 * 2.0)))
-        assert rsi == 0.0
-
-
 class TestRSICalculation:
     """Test RSI calculation in VolatilityAnalyzer."""
 

tests/test_telegram_commands.py

@@ -876,54 +876,6 @@ class TestGetUpdates:
 
             assert updates == []
 
-    @pytest.mark.asyncio
-    async def test_get_updates_409_stops_polling(self) -> None:
-        """409 Conflict response stops the poller (_running = False) and returns empty list."""
-        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
-        handler = TelegramCommandHandler(client)
-        handler._running = True  # simulate active poller
-
-        mock_resp = AsyncMock()
-        mock_resp.status = 409
-        mock_resp.text = AsyncMock(
-            return_value='{"ok":false,"error_code":409,"description":"Conflict"}'
-        )
-        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
-        mock_resp.__aexit__ = AsyncMock(return_value=False)
-
-        with patch("aiohttp.ClientSession.post", return_value=mock_resp):
-            updates = await handler._get_updates()
-
-        assert updates == []
-        assert handler._running is False  # poller stopped
-
-    @pytest.mark.asyncio
-    async def test_poll_loop_exits_after_409(self) -> None:
-        """_poll_loop exits naturally after _running is set to False by a 409 response."""
-        import asyncio as _asyncio
-
-        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
-        handler = TelegramCommandHandler(client)
-
-        call_count = 0
-
-        async def mock_get_updates_409() -> list[dict]:
-            nonlocal call_count
-            call_count += 1
-            # Simulate 409 stopping the poller
-            handler._running = False
-            return []
-
-        handler._get_updates = mock_get_updates_409  # type: ignore[method-assign]
-
-        handler._running = True
-        task = _asyncio.create_task(handler._poll_loop())
-        await _asyncio.wait_for(task, timeout=2.0)
-
-        # _get_updates called exactly once, then loop exited
-        assert call_count == 1
-        assert handler._running is False
-
 
 class TestCommandWithArgs:
     """Test register_command_with_args and argument dispatch."""