fix(P0): 인증 누락·레거시 DT 엔진 병존·혼재 종목 재태깅·자정 후 스테일 청산 무력화

감사 CRITICAL 4건: - /daytrading/{watchlist,execute,close-all,cycle} 에 require_api_key 누락 → 인증 없이 전량 청산 가능했음 (CLAUDE.md §4 위반) - 레거시 day_trading._positions 가 엔진 day_trading_state 와 별도로 기동 시 복원돼 같은 포지션이 두 엔진에 존재 → /close-all 시 이중 매도. 복원 제거 + close-all/cycle 을 엔진에 위임, /execute 실매수는 410(엔진 미관리 포지션 방지) - reflect_buy 가 기존 행을 daytrading 으로 재태깅 → 같은 종목 스윙 보유분이 get_swing_holdings 에서 빠져 손절·익절 정지. 신규 행일 때만 태깅 - close_stale_positions 가 인메모리만 순회 → 자정 reset 후 대상이 사라져 무력. ActiveTrade(day_trade/active/전일) 조회 기반으로 변경하고 인메모리가 비어도 실행 Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-09-23 10:49:30 +09:00
parent 6207d13487
commit 70def8fe0b
6 changed files with 214 additions and 30 deletions
--- a/backend/app/api/endpoints/day_trading.py
+++ b/backend/app/api/endpoints/day_trading.py
@@ -51,6 +51,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
 # MCP risk assessment — 모듈 최상단에서 import (순환 참조 시 별도 util 모듈 분리 고려)
 from app.api.endpoints.mcp import request_mcp_risk_assessment
+from app.core.security import require_api_key

 router = APIRouter()
 logger = logging.getLogger(__name__)
@@ -804,7 +805,7 @@ async def get_watchlist():
    }


-@router.post("/watchlist")
+@router.post("/watchlist", dependencies=[Depends(require_api_key)])
 async def set_watchlist(req: WatchlistRequest):
    """감시 종목 설정 (최대 20종목) — 실제 엔진과 이 모듈 양쪽에 반영

@@ -860,9 +861,22 @@ async def get_current_signals():
    }


-@router.post("/execute")
+@router.post("/execute", dependencies=[Depends(require_api_key)])
 async def execute_day_trade(req: ExecuteRequest):
-    """특정 종목 데이트레이딩 신호 스캔 후 진입"""
+    """특정 종목 데이트레이딩 신호 스캔 후 진입.
+
+    [2026-09-23] 실매수(dry_run=False)는 비활성화. 이 경로로 진입한 포지션은 실제 엔진의
+    `day_trading_state`에 등록되지 않아 손절·트레일링·EOD 청산을 전혀 받지 못한다.
+    신호 확인용 dry_run 만 허용한다.
+    """
+    if not req.dry_run:
+        raise HTTPException(
+            status_code=410,
+            detail=(
+                "이 엔드포인트의 실매수는 비활성화되었습니다(엔진 미관리 포지션 방지). "
+                "자동 진입은 스케줄러가, 수동 매수는 /portfolio/buy 를 사용하세요."
+            ),
+        )
    _reset_if_new_day()
    code = req.stock_code
    name = _watchlist.get(code, code)
@@ -975,24 +989,37 @@ async def get_positions():
    }


-@router.post("/close-all")
+@router.post("/close-all", dependencies=[Depends(require_api_key)])
 async def close_all_positions():
-    """전체 포지션 수동 강제 청산 (EOD 대비 수동 실행)"""
-    _reset_if_new_day()
-    await _execute_eod_flat()
+    """전체 포지션 수동 강제 청산 — 실제 엔진(services/daytrading)에 위임.
+
+    [2026-09-23] 이 모듈의 레거시 인메모리 상태로 청산하면 엔진 상태가 그대로 남아
+    30초 뒤 같은 물량을 다시 매도한다(이중 매도). 엔진 경로만 사용한다.
+    """
+    from app.services.daytrading.exit_service import force_close_all
+    _es, _st = _engine()
+    _st.reset_if_new_day()
+    if not _st.positions:
+        return {"status": "ok", "message": "활성 포지션 없음", "exits": [], "daily_pnl": round(_st.daily_pnl, 0)}
+    exits = await force_close_all(reason="수동 전량 청산 (API)")
    return {
        "status": "ok",
-        "message": "전체 데이트레이딩 포지션 청산 완료",
-        "daily_pnl": round(_daily_pnl, 0),
+        "message": f"데이트레이딩 포지션 {len(exits)}건 청산 완료",
+        "exits": exits,
+        "daily_pnl": round(_st.daily_pnl, 0),
    }


-@router.post("/cycle")
+@router.post("/cycle", dependencies=[Depends(require_api_key)])
 async def manual_cycle():
-    """1분 사이클 수동 실행 (테스트/디버그용)"""
-    _reset_if_new_day()
-    result = await run_day_trading_cycle()
-    return result
+    """1 사이클 수동 실행 — 실제 엔진의 청산·진입 로직 호출 (테스트/디버그용)."""
+    from app.services.daytrading.exit_service import check_and_exit_positions
+    from app.services.daytrading.entry_service import scan_and_enter
+    _es, _st = _engine()
+    _st.reset_if_new_day()
+    exits = await check_and_exit_positions()
+    entries = await scan_and_enter()
+    return {"exits": exits, "entries": entries, "positions": _st.position_count()}


@router.get("/status")
--- a/backend/app/main.py
+++ b/backend/app/main.py
@@ -215,11 +215,9 @@ async def lifespan(app: FastAPI):
    except Exception as e:
        logger.warning(f"⚠️ [KRX] 초기 데이터 확인 실패 (non-critical): {e}")

-    try:
-        from app.api.endpoints.day_trading import restore_positions_from_db
-        await restore_positions_from_db()
-    except Exception as e:
-        logger.warning(f"⚠️ 데이트레이딩 포지션 복구 실패 (non-critical): {e}")
+    # [2026-09-23] 레거시 day_trading._positions 복원 제거.
+    # services/daytrading/scheduler 가 day_trading_state 로 복원하므로, 둘 다 복원하면
+    # 같은 포지션이 두 엔진에 존재해 이중 매도가 발생한다.

    # ── httpx 싱글톤 클라이언트 초기화 ──────────────────────────────────────
    from app.api.endpoints.mcp import init_http_client, close_http_client
--- a/backend/app/services/daytrading/exit_service.py
+++ b/backend/app/services/daytrading/exit_service.py
@@ -70,7 +70,8 @@ async def check_and_exit_positions() -> list[dict]:
    exits = []

    if not day_trading_state.positions:
-        return exits
+        # 인메모리가 비어도 DB에 전일 미청산 포지션이 남아 있을 수 있다(자정 reset 이후)
+        return await close_stale_positions()

    # 일일 손실 한도 초과 시 전체 강제 청산
    # [S5] 미실현 손익도 포함하여 일일 손실 한도 판단
@@ -330,16 +331,51 @@ async def close_stale_positions() -> list[dict]:
    today = _kst_now().date()
    results: list[dict] = []

+    # [2026-09-23] 인메모리 positions 만 순회하면 자정 reset_if_new_day() 이후에는
+    # 대상이 사라져 안전장치가 무력해진다 → DB(ActiveTrade)에서도 전일 포지션을 찾는다.
+    stale: dict[str, dict] = {}
    for stock_code in list(day_trading_state.positions.keys()):
        pos = day_trading_state.get_position(stock_code)
-        if not pos:
+        entry_time = (pos or {}).get("entry_time")
+        entry_date = entry_time.date() if hasattr(entry_time, "date") else None
+        if pos and entry_date is not None and entry_date < today:
+            stale[stock_code] = pos
+
+    try:
+        from app.core.database import AsyncSessionLocal
+        from app.models.models import ActiveTrade
+        from sqlalchemy import select as _select
+
+        async with AsyncSessionLocal() as _db:
+            _rows = (await _db.execute(
+                _select(ActiveTrade).where(
+                    ActiveTrade.strategy_name == "day_trade",
+                    ActiveTrade.status == "active",
+                )
+            )).scalars().all()
+        for _row in _rows:
+            _created = _row.created_at.date() if _row.created_at else None
+            if _created is None or _created >= today or _row.stock_code in stale:
+                continue
+            _entry = float(_row.entry_price or 0)
+            stale[_row.stock_code] = {
+                "stock_name": _row.stock_name or _row.stock_code,
+                "strategy": "day_trade",
+                "entry_price": _entry,
+                "quantity": int(_row.quantity or 0),
+                "highest_price": float(_row.highest_since_entry or _entry),
+                "entry_time": _row.created_at,
+                "reason": "",
+                "order_id": _row.order_id or "",
+            }
+    except Exception as _db_err:
+        logger.warning(f"[DayExit] 전일 포지션 DB 조회 실패(인메모리만 처리): {_db_err}")
+
+    for stock_code, pos in stale.items():
+        if int(pos.get("quantity", 0) or 0) <= 0:
            continue
        entry_time = pos.get("entry_time")
-        if entry_time is None:
-            continue
        entry_date = entry_time.date() if hasattr(entry_time, "date") else None
-        if entry_date is None or entry_date >= today:
-            continue

        price = 0.0
        try:
--- a/backend/app/services/portfolio_cache_bridge.py
+++ b/backend/app/services/portfolio_cache_bridge.py
@@ -42,8 +42,10 @@ async def reflect_buy(
            existing.quantity = new_qty
            existing.average_price = Decimal(str(round(new_avg, 2)))
            existing.current_price = Decimal(str(price))
-            if strategy_type == "daytrading":
-                existing.strategy_type = "daytrading"
+            # [2026-09-23] 기존 행의 strategy_type 은 변경하지 않는다.
+            # 스윙 8주 보유 중 DT 4주를 사면 행(12주)이 daytrading 이 되어
+            # get_swing_holdings 에서 빠지고 스윙 8주의 손절·익절이 완전히 멈춘다.
+            # 화면의 DT 그룹은 엔진 포지션(/daytrading/positions)으로 별도 표시한다.
            avg_for_db, qty_for_db = new_avg, new_qty
        else:
            cache.holdings.append(Portfolio(
@@ -55,15 +57,18 @@ async def reflect_buy(
            ))
            avg_for_db, qty_for_db = price, quantity

-        await enqueue_portfolio_upsert({
+        _upsert = {
            "stock_code": stock_code,
            "stock_name": stock_name,
            "quantity": qty_for_db,
            "average_price": round(avg_for_db, 2),
            "current_price": price,
            "market": market,
-            "strategy_type": strategy_type,
-        })
+        }
+        if existing is None:
+            # 신규 행일 때만 전략 태깅 (기존 행은 다른 전략 보유분이 섞여 있을 수 있음)
+            _upsert["strategy_type"] = strategy_type
+        await enqueue_portfolio_upsert(_upsert)
        await cache.apply_buy(stock_code, stock_name, quantity, price)
    except Exception as e:
        logger.warning(f"[cache_bridge] reflect_buy 실패 ({stock_code}): {e}")