docs: CLAUDE.md 비협상 규칙 명시 강화 — BULLISH 시 confidence 임계값 포함 (#205)

BULLISH 시장에서도 confidence < 80 → HOLD 규칙이 동일하게 적용됨을 명시.
시장 전망별 임계값: BEARISH=90(더 엄격), BULLISH/NEUTRAL=80(최소값).

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

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 < 80 → force HOLD — cannot be weakened
+- Confidence < 80 → force HOLD — **절대 낮출 수 없음** (BULLISH 시장 포함, 모든 market_outlook에서 최소 80 적용, BEARISH는 90으로 더 엄격)
 - All code changes → corresponding tests → coverage ≥ 80%
 
 ## Contributing

src/db.py

@@ -28,12 +28,13 @@ 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
+            decision_id TEXT,
+            mode TEXT DEFAULT 'paper'
         )
         """
     )
 
-    # Migration: Add market and exchange_code columns if they don't exist
+    # Migration: Add columns if they don't exist (backward-compatible schema upgrades)
     cursor = conn.execute("PRAGMA table_info(trades)")
     columns = {row[1] for row in cursor.fetchall()}
 
@@ -45,6 +46,8 @@ 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(
@@ -167,6 +170,7 @@ 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.
 
@@ -182,6 +186,8 @@ 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
@@ -190,9 +196,10 @@ def log_trade(
         """
         INSERT INTO trades (
             timestamp, stock_code, action, confidence, rationale,
-            quantity, price, pnl, market, exchange_code, selection_context, decision_id
+            quantity, price, pnl, market, exchange_code, selection_context, decision_id,
+            mode
         )
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         """,
         (
             datetime.now(UTC).isoformat(),
@@ -207,6 +214,7 @@ def log_trade(
             exchange_code,
             context_json,
             decision_id,
+            mode,
         ),
     )
     conn.commit()

src/main.py

@@ -524,6 +524,14 @@ async def trading_cycle(
     # 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",
@@ -814,6 +822,7 @@ 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
@@ -1076,6 +1085,33 @@ 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": {
@@ -1283,6 +1319,7 @@ 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")

tests/test_db.py

@@ -58,3 +58,103 @@ def test_get_open_position_returns_none_when_latest_is_sell() -> None:
 def test_get_open_position_returns_none_when_no_trades() -> None:
     conn = init_db(":memory:")
     assert get_open_position(conn, "AAPL", "US_NASDAQ") is None
+
+
+# ---------------------------------------------------------------------------
+# mode column tests (issue #212)
+# ---------------------------------------------------------------------------
+
+
+def test_log_trade_stores_mode_paper() -> None:
+    """log_trade must persist mode='paper' in the trades table."""
+    conn = init_db(":memory:")
+    log_trade(
+        conn=conn,
+        stock_code="005930",
+        action="BUY",
+        confidence=85,
+        rationale="test",
+        mode="paper",
+    )
+    row = conn.execute("SELECT mode FROM trades ORDER BY id DESC LIMIT 1").fetchone()
+    assert row is not None
+    assert row[0] == "paper"
+
+
+def test_log_trade_stores_mode_live() -> None:
+    """log_trade must persist mode='live' in the trades table."""
+    conn = init_db(":memory:")
+    log_trade(
+        conn=conn,
+        stock_code="005930",
+        action="BUY",
+        confidence=85,
+        rationale="test",
+        mode="live",
+    )
+    row = conn.execute("SELECT mode FROM trades ORDER BY id DESC LIMIT 1").fetchone()
+    assert row is not None
+    assert row[0] == "live"
+
+
+def test_log_trade_default_mode_is_paper() -> None:
+    """log_trade without explicit mode must default to 'paper'."""
+    conn = init_db(":memory:")
+    log_trade(
+        conn=conn,
+        stock_code="005930",
+        action="HOLD",
+        confidence=50,
+        rationale="test",
+    )
+    row = conn.execute("SELECT mode FROM trades ORDER BY id DESC LIMIT 1").fetchone()
+    assert row is not None
+    assert row[0] == "paper"
+
+
+def test_mode_column_exists_in_schema() -> None:
+    """trades table must have a mode column after init_db."""
+    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 tempfile
+    import os
+
+    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
+        db_path = f.name
+    try:
+        # Create DB without mode column (simulate old schema)
+        import sqlite3
+        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
+            )"""
+        )
+        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)

tests/test_main.py

@@ -3001,3 +3001,185 @@ async def test_buy_proceeds_when_no_open_position() -> None:
 
     # 포지션이 없으므로 해외 주문이 실행되어야 함
     overseas_broker.send_overseas_order.assert_called_once()
+
+
+class TestOverseasBrokerIntegration:
+    """Test overseas broker live-balance gating for double-buy prevention.
+
+    Issue #195: KIS VTS SELL limit orders are accepted (rt_cd=0) immediately
+    but may not fill until the market price reaches the limit. During this window,
+    the DB records the position as closed, causing the next cycle to BUY again.
+    These tests verify that live broker balance is used as the authoritative source.
+    """
+
+    @pytest.mark.asyncio
+    async def test_overseas_buy_suppressed_by_broker_balance_when_db_shows_closed(
+        self,
+    ) -> None:
+        """BUY must be suppressed when broker still holds shares even if DB says closed.
+
+        Scenario: SELL limit order was accepted (DB shows closed), but hasn't
+        filled yet — broker balance still shows 10 AAPL shares.
+        Expected: send_overseas_order is NOT called.
+        """
+        db_conn = init_db(":memory:")
+        # DB: BUY then SELL recorded → get_open_position returns None (closed)
+        log_trade(
+            conn=db_conn,
+            stock_code="AAPL",
+            action="BUY",
+            confidence=90,
+            rationale="entry",
+            quantity=10,
+            price=180.0,
+            market="US_NASDAQ",
+            exchange_code="NASD",
+        )
+        log_trade(
+            conn=db_conn,
+            stock_code="AAPL",
+            action="SELL",
+            confidence=90,
+            rationale="sell order accepted",
+            quantity=10,
+            price=182.0,
+            market="US_NASDAQ",
+            exchange_code="NASD",
+        )
+
+        overseas_broker = MagicMock()
+        overseas_broker.get_overseas_price = AsyncMock(
+            return_value={"output": {"last": "182.50"}}
+        )
+        # 브로커: 여전히 AAPL 10주 보유 중 (SELL 미체결)
+        overseas_broker.get_overseas_balance = AsyncMock(
+            return_value={
+                "output1": [{"ovrs_pdno": "AAPL", "ovrs_cblc_qty": "10"}],
+                "output2": [
+                    {
+                        "frcr_dncl_amt_2": "50000.00",
+                        "frcr_evlu_tota": "60000.00",
+                        "frcr_buy_amt_smtl": "50000.00",
+                    }
+                ],
+            }
+        )
+        overseas_broker.send_overseas_order = AsyncMock(return_value={"msg1": "주문접수"})
+
+        engine = MagicMock(spec=ScenarioEngine)
+        engine.evaluate = MagicMock(return_value=_make_buy_match("AAPL"))
+
+        market = MagicMock()
+        market.name = "NASDAQ"
+        market.code = "US_NASDAQ"
+        market.exchange_code = "NASD"
+        market.is_domestic = False
+
+        telegram = MagicMock()
+        telegram.notify_trade_execution = AsyncMock()
+        telegram.notify_fat_finger = AsyncMock()
+        telegram.notify_circuit_breaker = AsyncMock()
+        telegram.notify_scenario_matched = AsyncMock()
+
+        decision_logger = MagicMock()
+        decision_logger.log_decision = MagicMock(return_value="decision-id")
+
+        await trading_cycle(
+            broker=MagicMock(),
+            overseas_broker=overseas_broker,
+            scenario_engine=engine,
+            playbook=_make_playbook(market="US"),
+            risk=MagicMock(),
+            db_conn=db_conn,
+            decision_logger=decision_logger,
+            context_store=MagicMock(
+                get_latest_timeframe=MagicMock(return_value=None),
+                set_context=MagicMock(),
+            ),
+            criticality_assessor=MagicMock(
+                assess_market_conditions=MagicMock(return_value=MagicMock(value="NORMAL")),
+                get_timeout=MagicMock(return_value=5.0),
+            ),
+            telegram=telegram,
+            market=market,
+            stock_code="AAPL",
+            scan_candidates={},
+        )
+
+        # 브로커 잔고에 보유 중이므로 BUY 주문이 억제되어야 함 (이중 매수 방지)
+        overseas_broker.send_overseas_order.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_overseas_buy_proceeds_when_broker_shows_no_holding(
+        self,
+    ) -> None:
+        """BUY must proceed when both DB and broker confirm no existing holding.
+
+        Scenario: No prior trades in DB and broker balance shows no AAPL.
+        Expected: send_overseas_order IS called (normal buy flow).
+        """
+        db_conn = init_db(":memory:")
+        # DB: 레코드 없음 (신규 포지션)
+
+        overseas_broker = MagicMock()
+        overseas_broker.get_overseas_price = AsyncMock(
+            return_value={"output": {"last": "182.50"}}
+        )
+        # 브로커: AAPL 미보유
+        overseas_broker.get_overseas_balance = AsyncMock(
+            return_value={
+                "output1": [],
+                "output2": [
+                    {
+                        "frcr_dncl_amt_2": "50000.00",
+                        "frcr_evlu_tota": "50000.00",
+                        "frcr_buy_amt_smtl": "0.00",
+                    }
+                ],
+            }
+        )
+        overseas_broker.send_overseas_order = AsyncMock(return_value={"msg1": "주문접수"})
+
+        engine = MagicMock(spec=ScenarioEngine)
+        engine.evaluate = MagicMock(return_value=_make_buy_match("AAPL"))
+
+        market = MagicMock()
+        market.name = "NASDAQ"
+        market.code = "US_NASDAQ"
+        market.exchange_code = "NASD"
+        market.is_domestic = False
+
+        telegram = MagicMock()
+        telegram.notify_trade_execution = AsyncMock()
+        telegram.notify_fat_finger = AsyncMock()
+        telegram.notify_circuit_breaker = AsyncMock()
+        telegram.notify_scenario_matched = AsyncMock()
+
+        decision_logger = MagicMock()
+        decision_logger.log_decision = MagicMock(return_value="decision-id")
+
+        with patch("src.main.log_trade"):
+            await trading_cycle(
+                broker=MagicMock(),
+                overseas_broker=overseas_broker,
+                scenario_engine=engine,
+                playbook=_make_playbook(market="US"),
+                risk=MagicMock(),
+                db_conn=db_conn,
+                decision_logger=decision_logger,
+                context_store=MagicMock(
+                    get_latest_timeframe=MagicMock(return_value=None),
+                    set_context=MagicMock(),
+                ),
+                criticality_assessor=MagicMock(
+                    assess_market_conditions=MagicMock(return_value=MagicMock(value="NORMAL")),
+                    get_timeout=MagicMock(return_value=5.0),
+                ),
+                telegram=telegram,
+                market=market,
+                stock_code="AAPL",
+                scan_candidates={},
+            )
+
+        # DB도 브로커도 보유 없음 → BUY 주문이 실행되어야 함 (회귀 테스트)
+        overseas_broker.send_overseas_order.assert_called_once()