diff --git a/.claude/settings.local.json b/.claude/settings.local.json
new file mode 100644
index 0000000..fa4e5ab
--- /dev/null
+++ b/.claude/settings.local.json
@@ -0,0 +1,26 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(docker ps:*)",
+      "Bash(lsof:*)",
+      "Bash(./scripts/dev.sh:*)",
+      "Bash(curl:*)",
+      "Bash(ls:*)",
+      "Bash(docker compose:*)",
+      "Bash(docker-compose up:*)",
+      "Bash(docker-compose restart:*)",
+      "Bash(npm run build:*)",
+      "Bash(python3:*)",
+      "Bash(npm install:*)",
+      "Bash(docker exec:*)",
+      "Bash(docker restart:*)",
+      "mcp__auto-stock__get_recommendations",
+      "Bash(pip install:*)",
+      "Bash(python -c:*)"
+    ]
+  },
+  "enableAllProjectMcpServers": true,
+  "enabledMcpjsonServers": [
+    "auto-stock"
+  ]
+}
diff --git a/.gitignore b/.gitignore
index 155dfb7..2ffb878 100644
--- a/.gitignore
+++ b/.gitignore
@@ -60,3 +60,14 @@ docker-compose.override.yml
 .pytest_cache/
 .coverage
 htmlcov/
+
+# Runtime artifacts
+backend_logs.txt
+mcp_logs.txt
+ps_output.txt
+summary_output.json
+*.bak
+.env.bak
+
+# Virtual environments
+.venv/
diff --git a/.mcp.json b/.mcp.json
new file mode 100644
index 0000000..8a2e0ea
--- /dev/null
+++ b/.mcp.json
@@ -0,0 +1,13 @@
+{
+  "mcpServers": {
+    "auto-stock": {
+      "command": "/Users/commylife/myproject/java/workspace/auto-stock/.venv/bin/python",
+      "args": [
+        "/Users/commylife/myproject/java/workspace/auto-stock/mcp-server/stdio_server.py"
+      ],
+      "env": {
+        "PYTHONPATH": "/Users/commylife/myproject/java/workspace/auto-stock/mcp-server"
+      }
+    }
+  }
+}
diff --git a/.venv/bin/numpy-config b/.venv/bin/numpy-config
deleted file mode 100755
index 309020f..0000000
--- a/.venv/bin/numpy-config
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/Users/commylife/myproject/java/workspace/auto-stock/.venv/bin/python3.12
-import sys
-from numpy._configtool import main
-if __name__ == '__main__':
-    if sys.argv[0].endswith('.exe'):
-        sys.argv[0] = sys.argv[0][:-4]
-    sys.exit(main())
diff --git a/AUTOTRADE_DIAGNOSIS.md b/AUTOTRADE_DIAGNOSIS.md
new file mode 100644
index 0000000..77e72d3
--- /dev/null
+++ b/AUTOTRADE_DIAGNOSIS.md
@@ -0,0 +1,178 @@
+# 🔍 자동매매 점검 리포트
+
+## 📋 체크리스트
+
+### 1. ⏰ 장 운영 시간
+**현재 상황:**
+- 오늘: 2026년 2월 5일 (수요일)
+- 한국 주식시장 정규 장시간: 09:00 ~ 15:30
+- **문제:** 현재 시각이 장 마감 이후라면 자동매매가 중단됩니다
+
+**확인 방법:**
+```python
+# 코드에서 확인
+from app.core.market_schedule import is_market_open
+print(is_market_open())  # False이면 장 마감
+```
+
+**해결책:**
+- 장 시간(09:00~15:30) 내에 다시 확인
+- 테스트 목적이라면 `market_schedule.py`에서 시간 체크 임시 비활성화
+
+---
+
+### 2. ⚙️ AUTO_TRADE_ENABLED 설정
+**현재 설정:** `config.py`에 `AUTO_TRADE_ENABLED = True`로 설정되어 있음
+
+**확인 필요:**
+- `.env` 파일에서 `AUTO_TRADE_ENABLED=False`로 덮어쓰고 있는지 확인
+- 환경 변수가 코드 기본값을 오버라이드할 수 있음
+
+**확인 방법:**
+```bash
+docker exec autostock-backend env | grep AUTO_TRADE
+```
+
+**해결책:**
+- `.env` 파일 확인 및 수정
+- 또는 config.py에서 명시적으로 True 설정
+
+---
+
+### 3. 🔑 KIS API 인증 정보
+**필수 설정:**
+- `KIS_APP_KEY` (앱 키)
+- `KIS_APP_SECRET` (앱 시크릿)
+- `KIS_ACCOUNT_NO` (계좌번호)
+
+**확인 방법:**
+```bash
+docker exec autostock-backend env | grep KIS_
+```
+
+**문제:**
+- API 키가 없으면 주문 실행 불가
+- 모의투자와 실투자 URL이 다름
+
+**해결책:**
+- `.env` 파일에 올바른 KIS API 정보 입력
+- 모의투자: `https://openapivts.koreainvestment.com:29443`
+- 실투자: `https://openapi.koreainvestment.com:9443`
+
+---
+
+### 4. 📊 추천 종목 존재 여부
+**자동매매 실행 조건:**
+1. 장이 열려 있어야 함
+2. AUTO_TRADE_ENABLED = True
+3. **추천 종목 리스트에 매수 신호가 있어야 함**
+
+**코드 로직:**
+```python
+rec = await get_rule_based_recommendations_realtime()
+if rec and rec.get("recommendations_by_rule"):
+    # 자동매매 실행
+else:
+    logger.info("⏭️ Auto-trade skipped: no recommendations matched rules")
+```
+
+**확인 방법:**
+```bash
+curl http://localhost:8090/api/v1/recommendations/rule-based
+```
+
+**문제 가능성:**
+- RSI, 스토캐스틱 등 기술적 지표가 매수 조건을 만족하는 종목이 없음
+- TREND_FILTER_ENABLED=True인 경우 상승 추세 종목만 선택 (현재는 False)
+
+---
+
+### 5. 💾 데이터베이스 연결
+**확인 항목:**
+- PostgreSQL 컨테이너 실행 중
+- 테이블 생성 완료 (portfolio, trade_history 등)
+
+**확인 방법:**
+```bash
+docker ps | grep postgres
+docker exec autostock-postgres psql -U autostock -d autostock_db -c "SELECT COUNT(*) FROM portfolio;"
+```
+
+---
+
+### 6. 🔄 스케줄러 동작 여부
+**백엔드 로그 확인:**
+```bash
+docker logs autostock-backend 2>&1 | grep "Auto-trade scheduler"
+docker logs autostock-backend 2>&1 | grep "Market is closed"
+docker logs autostock-backend 2>&1 | grep "Starting real-time analysis"
+```
+
+**기대 로그:**
+- 장 중: "⏱️ Auto-trade scheduler started (every 60s)"
+- 장 중: "🔄 Starting real-time analysis cycle..."
+- 장 마감: "💤 Market is closed. Skipping auto-trade cycle. Next check in 30 minutes."
+
+---
+
+## 🎯 가장 가능성 높은 원인
+
+### 1순위: 장 마감 시간
+- **증상:** 15:30 이후에는 자동매매가 중단됨
+- **해결:** 다음 거래일 09:00~15:30에 다시 확인
+
+### 2순위: 매수 조건 미충족
+- **증상:** 추천 종목 리스트가 비어있음
+- **원인:** 
+  - 현재 시장 상황에서 RSI < 40 또는 Stochastic < 30 조건을 만족하는 종목 없음
+  - 모든 종목이 과매수 상태이거나 중립 구간
+- **해결:** 
+  - 매수 조건 완화 (RSI < 50, Stochastic < 40 등)
+  - 또는 시장이 조정 받을 때까지 대기
+
+### 3순위: KIS API 인증 문제
+- **증상:** API 호출 시 401/403 에러
+- **해결:** .env 파일에 올바른 API 키 설정
+
+---
+
+## ✅ 즉시 확인할 사항
+
+1. **현재 시각 확인**
+   ```bash
+   TZ='Asia/Seoul' date '+%H:%M'
+   ```
+   - 09:00 ~ 15:30 범위 내인가?
+
+2. **백엔드 컨테이너 상태**
+   ```bash
+   docker ps | grep backend
+   ```
+   - "Up" 상태인가?
+
+3. **최근 로그 확인**
+   ```bash
+   docker logs autostock-backend --tail 50
+   ```
+   - 에러 메시지가 있는가?
+   - "Market is closed" 메시지가 있는가?
+
+4. **추천 종목 API 테스트**
+   ```bash
+   curl http://localhost:8090/api/v1/recommendations/rule-based
+   ```
+   - 종목 리스트가 반환되는가?
+
+---
+
+## 🔧 임시 테스트 방법 (개발 환경)
+
+장 시간 체크를 임시로 비활성화하여 테스트:
+
+```python
+# backend/app/core/market_schedule.py 수정
+def is_market_open() -> bool:
+    return True  # 임시로 항상 True 반환 (테스트용)
+```
+
+**주의:** 실제 운영 환경에서는 절대 사용 금지!
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..7f06d62
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,403 @@
+# Auto Stock Trading System - 전략 가이드 (Claude.md)
+
+> 이 파일은 Claude AI가 자동매매 시스템의 전략과 규칙을 이해하기 위한 컨텍스트 문서입니다.
+> 코드 수정, 전략 분석, 백테스트 요청 시 이 파일을 기준으로 판단하세요.
+
+---
+
+## 1. 프로젝트 개요
+
+한국/미국 주식 자동매매 시스템 (풀스택)
+- 한국투자증권 API 연동 (모의/실전 전환 가능)
+- AI(Claude/Gemini) 기반 시장 분석 및 매매 판단
+- MCP(Model Context Protocol) 서버로 Claude CLI 연동
+- 실시간 WebSocket 시세 + React 대시보드
+
+---
+
+## 2. 기술 스택
+
+| 계층 | 기술 |
+|------|------|
+| Backend | Python 3.11, FastAPI, SQLAlchemy (async), PostgreSQL, Redis |
+| Frontend | React + TypeScript, Vite, Recharts |
+| MCP Server | Python, Anthropic SDK, MCP Protocol (stdio) |
+| AI | Claude 3.5 Sonnet / Gemini 2.0 Flash (`.env`에서 전환) |
+| Infra | Docker Compose, Nginx |
+
+---
+
+## 3. 디렉터리 구조
+
+```
+auto-stock/
+├── backend/
+│   ├── app/
+│   │   ├── api/endpoints/
+│   │   │   ├── market_data.py          # 시세 조회
+│   │   │   ├── portfolio.py            # 포트폴리오 + ATR 기반 청산
+│   │   │   ├── trades.py               # 주문/체결
+│   │   │   ├── recommendations.py      # 규칙 기반 추천 + 자동매매
+│   │   │   ├── trading_rules.py        # 매매 규칙 CRUD
+│   │   │   ├── risk_management.py      # 리스크 관리
+│   │   │   ├── ml_ensemble.py          # ML 앙상블 엔드포인트
+│   │   │   ├── tensorflow_predictions.py
+│   │   │   ├── debug.py
+│   │   │   └── monitoring.py
+│   │   ├── core/
+│   │   │   ├── config.py               # 백엔드 설정 (매매 규칙 파라미터)
+│   │   │   ├── database.py
+│   │   │   ├── json_helpers.py         # _dumps() 공용 헬퍼
+│   │   │   └── market_schedule.py      # 장 운영시간
+│   │   ├── services/
+│   │   │   ├── korea_investment_api.py
+│   │   │   ├── websocket_manager.py
+│   │   │   ├── mean_reversion_strategy.py    # RSI+볼린저 평균회귀 (v2)
+│   │   │   ├── kosdaq_scanner.py             # 코스닥 전종목 스캐너 (신규)
+│   │   │   ├── short_term_strategy.py        # 15분/60분봉 단기 전략 (신규)
+│   │   │   ├── mdd_manager.py
+│   │   │   ├── loss_tracker.py
+│   │   │   ├── feature_engineering.py
+│   │   │   ├── ml_ensemble.py
+│   │   │   └── tensorflow_predictor.py
+│   │   ├── models/models.py
+│   │   └── main.py
+│   ├── batch_daily_analysis.py
+│   ├── trading_rules_config.json
+│   └── migrations/
+├── frontend/
+│   └── src/
+│       ├── pages/
+│       ├── components/
+│       ├── hooks/
+│       ├── lib/
+│       └── utils/
+├── mcp-server/
+│   ├── config.py
+│   ├── claude_client.py
+│   ├── mcp_tools.py
+│   ├── stdio_server.py
+│   ├── main.py
+│   ├── utils.py
+│   ├── auto_trade_claude.py
+│   └── trade_monitor.py
+├── docker/
+│   └── init-db.sql
+├── docs/
+├── tests/
+├── scripts/
+├── docker-compose.yml
+├── docker-compose.dev.yml
+└── .env
+```
+
+---
+
+## 4. 환경 설정 (.env)
+
+```env
+# AI Provider 전환
+AI_PROVIDER=gemini          # gemini | claude
+
+# 토큰 절약 설정
+TOKEN_SAVE_MODE=true
+NEWS_LIMIT=3
+CHART_DAYS=30
+JSON_COMPACT=true
+CLAUDE_MAX_TOKENS=1024
+CLAUDE_TEMPERATURE=0.3
+
+# 증권 API 모드
+KIS_MODE=virtual            # virtual | real
+
+# 스캐너 설정 (신규)
+SCANNER_MARKET=KOSDAQ       # KOSDAQ | KOSPI | ALL
+SCANNER_INTERVAL=15         # 스캔 주기 (분)
+SHORT_TERM_CAPITAL_RATIO=0.25  # 단기전략 자본 비율 (최대 25%)
+```
+
+---
+
+## 5. 코딩 규칙
+
+- 기존 함수/클래스 시그니처 유지, 작은 단위 변경 우선
+- 새 전략은 별도 파일/클래스로 추가 (`_v2`, `_v3`)
+- AI 프롬프트는 간결하게 (필수 필드만 명시, JSON 예시 최소화)
+- `json.dumps`는 `_dumps()` 헬퍼 사용 (토큰 절약 모드 자동 적용)
+- `.env` 파일은 커밋하지 않음 (API 키 포함)
+
+---
+
+## 6. 포지션 및 리스크 규칙
+
+### 6.1 포지션 규칙
+- 1종목당 최대 **3~4%** 자본 사용
+- 동시 보유 종목 수: 기본 최대 **20종목**, 전략에 따라 최대 25종목
+- 레버리지/인버스 ETF: 전체 자본의 **20% 이내**
+
+### 6.2 손절 및 청산 규칙
+- 기본 손절:
+  - 저변동 종목/ETF(대형주): **-6%**
+  - 고변동 종목(테마·코스닥): **-10%**
+- ATR 기반 손절 (우선 적용):
+  - 손절가 = 진입가 - **2.5 × ATR**
+  - 변동성 크면 손절폭 자동 확대, 줄면 축소
+- 익절/트레일링:
+  - 2R 이상 수익 시 절반 익절 + 나머지 트레일링 스탑 (**1.5 × ATR**)
+
+### 6.3 포트폴리오 MDD 관리
+- MDD **-10%** 돌파 시:
+  - 신규 진입 일시 중단
+  - 기존 포지션 크기 **30% 축소**
+- MDD **-20%** 돌파 시:
+  - 전체 포지션 **50% 강제 축소**
+  - 레버리지/인버스 포지션 우선 청산
+
+### 6.4 가격 필터 (저가주 제한)
+- 국내: **5,000원 이하** 매수 금지
+  - 단, ETF·리츠·우량 대형 공모주는 화이트리스트로 허용
+- 미국: **4달러 이하** 매수 금지
+  - ETF·리츠 화이트리스트 예외 가능
+
+### 6.5 시간 프레임 운용
+- 기본: **일봉(Daily) + 60분봉(H1)**
+- 단기(인트라데이): **15분/60분봉** → 전체 자본의 **최대 20~25%** 이내
+  - 슬리피지·수수료 포함 백테스트 필수
+
+### 6.6 섹터 상관관계 필터
+- 동일 섹터 최대 **3종목** 제한
+- 기존 보유 종목과 상관계수 **0.7 이상** 시 진입 제한
+- correlation_matrix: 주간 업데이트 → Redis 캐싱
+
+---
+
+## 7. RSI + 볼린저 평균회귀 전략 v2 (개선형)
+
+### 7.1 시장 Regime 판단 (3분류)
+
+```python
+slope_200 = (ma200_today - ma200_20days_ago) / 20  # 기울기
+adx = talib.ADX(high, low, close, 14)[-1]
+
+if close > ma200 and slope_200 > 0 and adx > 20:
+    regime = MarketRegime.BULL       # 추세 상승장
+elif close < ma200 and slope_200 < 0 and adx > 20:
+    regime = MarketRegime.BEAR       # 추세 하락장
+else:
+    regime = MarketRegime.SIDEWAYS   # 박스권 (신규 진입 금지)
+```
+
+> **판별 기준**: 코스피200 지수 기준 / 매일 장 마감 후 업데이트
+> **SIDEWAYS**: ADX < 20 또는 200MA 횡보(기울기 ≈ 0) → 진입 금지
+
+---
+
+### 7.2 매수 조건
+
+#### 공통 전제조건
+- 가격: 국내 5,000원 이상 / 미국 4달러 이상
+- 유동성: 최근 20일 평균 거래대금 상위 20% 이내
+
+---
+
+#### 상승장(BULL) 매수 조건
+
+```python
+rsi_ok     = rsi14 <= 25
+pct        = (close - bb_lower) / bb_lower * 100
+bb_ok      = -3.0 <= pct <= 1.5
+volume_ok  = volume > volume_ma20 * 0.8
+candle_ok  = close > open or close > prev_low * 1.005
+
+bull_signal = rsi_ok and bb_ok and volume_ok and candle_ok
+# → 2회 분할 매수 (50% + 50%)
+```
+
+---
+
+#### 하락장(BEAR) 매수 조건
+
+```python
+rsi_ok       = rsi14 <= 30
+bb_ok        = close <= bb_lower * 1.01
+volume_surge = volume > volume_ma20 * 1.5
+rebound_ok   = close > prev_close or close > h1_prev_high
+
+bear_signal = rsi_ok and bb_ok and volume_surge and rebound_ok
+# → 3회 분할 매수 (단, 2일 연속 과매도면 2회로 축소)
+```
+
+---
+
+#### 복합 타임프레임 선취매 (선택)
+- 일봉 RSI ≤ 40 관심 종목 중, 60분봉 RSI ≤ 30 신호 발생 시 선취매
+- 60분봉 필터: 5일 이동평균선 상향 돌파 동시 확인 (Fake-out 방지)
+- 비중: 전체 자본의 **10% 이내**
+
+---
+
+### 7.3 청산 조건
+
+#### 1차 익절
+```python
+first_exit = (
+    rsi14 >= 50
+    or close >= bb_mid
+    or profit_pct >= 2 * atr_pct
+)
+# BULL: 40% 익절 / BEAR: 60% 익절
+```
+
+#### 2차 익절 (전량 청산)
+```python
+trailing_stop = max_close_after_entry - 1.5 * atr
+
+second_exit = (
+    close <= trailing_stop        # ATR 트레일링 (최우선)
+    or rsi14 >= 65
+    or close >= bb_upper * 0.99
+)
+```
+
+---
+
+### 7.4 손절 및 추가 진입 제한
+
+```python
+stop_loss_atr  = entry_price - 2.5 * atr
+stop_loss_pct  = entry_price * 0.92       # -8%
+stop_triggered = close <= min(stop_loss_atr, stop_loss_pct)
+
+# 연속 손실 제한
+if consecutive_losses >= 3:
+    block_entry_days = 30
+```
+
+---
+
+### 7.5 시장 상태별 자본 배분
+
+| Regime    | 전략 운용 비중  | 특징                  |
+|-----------|----------------|----------------------|
+| BULL      | **최대 70%**   | 공격적, 모멘텀 최대 활용 |
+| SIDEWAYS  | **진입 금지**  | 가짜 신호 차단         |
+| BEAR      | **최대 30%**   | 보수적, 자본 보호 우선  |
+
+---
+
+## 8. 공격적 전략 (월 5% 목표)
+
+> **목표**: 1천만원 → 1억원 (4년 순수 복리 / 현실 7~8년)
+> **핵심**: 단일 종목 대기 → 코스닥 전종목 스캔 + 단기봉 병행으로 신호 빈도 ↑
+
+### 8.1 코스닥 전종목 스캐너 (`kosdaq_scanner.py`)
+
+```python
+# 매일 장 마감 후 코스닥 전종목 스캔 → 조건 충족 종목 우선순위 큐에 저장
+class KosdaqScanner:
+    def scan_all(self) -> list[ScanResult]:
+        candidates = []
+        for ticker in kosdaq_all_tickers:  # ~1,600종목
+            if not self._price_filter(ticker):  # 5,000원 이상
+                continue
+            if not self._liquidity_filter(ticker):  # 거래대금 상위 20%
+                continue
+            score = self._score(ticker)  # RSI + BB + 거래량 복합 점수
+            candidates.append(ScanResult(ticker, score))
+        return sorted(candidates, key=lambda x: x.score, reverse=True)[:20]
+
+    def _score(self, ticker) -> float:
+        rsi_score    = max(0, (25 - rsi14) / 25)      # RSI 낮을수록 ↑
+        bb_score     = max(0, (0 - pct_vs_lower) / 3) # BB 하단 근접 ↑
+        volume_score = min(volume / volume_ma20, 2.0)  # 거래량 급증 ↑
+        return rsi_score * 0.5 + bb_score * 0.3 + volume_score * 0.2
+```
+
+> **기대 효과**: 단일 종목 대기 연 2~4회 → 전종목 스캔으로 월 5~10개 신호 확보
+
+---
+
+### 8.2 15분봉 단기 전략 (`short_term_strategy.py`)
+
+```python
+class ShortTermStrategy:
+    MAX_CAPITAL_RATIO = 0.25   # 전체 자본의 최대 25%
+    TIMEFRAME = "15m"
+
+    def entry_signal(self, ticker) -> bool:
+        # 일봉 RSI ≤ 40 관심 종목 중에서만 적용
+        if daily_rsi > 40:
+            return False
+        # 15분봉 조건
+        rsi_15m  = self._rsi(ticker, "15m", 14)
+        bb_lower = self._bb_lower(ticker, "15m", 20)
+        ma5      = self._ma(ticker, "15m", 5)
+        return (
+            rsi_15m <= 30
+            and close <= bb_lower * 1.01
+            and close > ma5             # 5분봉 MA5 상향 돌파 (Fake-out 방지)
+            and volume > volume_ma * 1.3
+        )
+
+    def exit_signal(self, position) -> bool:
+        rsi_15m = self._rsi(position.ticker, "15m", 14)
+        return rsi_15m >= 55 or profit_pct >= 1.5 * atr_15m_pct
+```
+
+> **슬리피지 주의**: 15분봉 전략은 반드시 수수료 0.3% + 슬리피지 0.2% 포함 백테스트 필수
+
+---
+
+### 8.3 멀티 전략 자본 배분
+
+| 전략 | 자본 비율 | 기대 월 수익 | 신호 빈도 |
+|------|-----------|-------------|-----------|
+| RSI+볼린저 일봉 (v2) | 50% | +2~3% | 월 3~5회 |
+| 코스닥 스캐너 | 25% | +1~2% | 월 5~10회 |
+| 15분봉 단기 전략 | 25% | +1~2% | 월 10~20회 |
+| **합계 기대치** | **100%** | **+4~7%** | - |
+
+> 세 전략 동시 운용 시 월 5% 달성 현실 가능
+> MDD -10% 돌파 시 단기 전략 즉시 중단, 일봉 전략만 유지
+
+---
+
+### 8.4 수익 목표 시뮬레이션 (복리)
+
+| 이정표 | 순수 복리 (월 5%) | 현실 예상 (MDD 포함) |
+|--------|------------------|---------------------|
+| 2,000만 | 15개월 (1.2년) | 20~24개월 |
+| 3,000만 | 23개월 (1.9년) | 30~36개월 |
+| 5,000만 | 33개월 (2.8년) | 45~54개월 |
+| **1억** | **48개월 (4.0년)** | **7~8년** |
+
+> 10년 내 1억 달성 확률 (몬테카를로 1,000회): **82.5%**
+
+---
+
+## 9. 주요 포트 (개발 환경)
+
+| 서비스 | 포트 |
+|--------|------|
+| Backend (FastAPI) | 8000 |
+| MCP Server | 8001 |
+| Frontend (Vite) | 5173 |
+| PostgreSQL | 5432 (Docker: 55432) |
+| Redis | 6379 |
+
+---
+
+## 10. Claude에게 요청 시 주의사항
+
+1. **기존 코드 시그니처 변경 금지** → 새 기능은 `_v2`, `_v3` 파일로 분리
+2. **백테스트 없이 실전 코드 즉시 적용 금지** → 워크포워드 테스트 필수
+3. **`json.dumps` 직접 사용 금지** → 반드시 `_dumps()` 헬퍼 사용
+4. **리스크 규칙(포지션 크기, 손절, MDD, 가격 필터)** 은 모든 전략에 기본 적용
+5. **SIDEWAYS 구간** 에서는 평균회귀 전략 신호 발생 시 무시
+6. **15분봉 단기 전략** 은 전체 자본의 25% 초과 불가
+7. **MDD -10%** 돌파 시 단기 전략 즉시 중단, 일봉 전략만 유지
+8. **코스닥 스캐너** 는 가격 5,000원 이상 + 거래대금 상위 20% 필터 반드시 적용
+
+---
+
+*Last updated: 2026-02-22*
diff --git a/Makefile b/Makefile
index c0861ac..04b1aa6 100644
--- a/Makefile
+++ b/Makefile
@@ -58,6 +58,15 @@ status: ## 서비스 상태 확인
 shell-backend: ## Backend 쉘 접속
 	@docker exec -it autostock-backend /bin/bash
 
+batch-analysis: ## 배치 분석 실행 (전체 종목)
+	@docker exec autostock-backend python batch_daily_analysis.py
+
+batch-test: ## 배치 분석 테스트 (10개 종목)
+	@docker exec autostock-backend python batch_daily_analysis.py --test
+
+batch-limit: ## 배치 분석 제한 실행 (사용: make batch-limit LIMIT=50)
+	@docker exec autostock-backend python batch_daily_analysis.py --limit $(LIMIT)
+
 shell-mcp: ## MCP Server 쉘 접속
 	@docker exec -it autostock-mcp-server /bin/bash
 
diff --git a/RISK_MANAGEMENT_API.md b/RISK_MANAGEMENT_API.md
new file mode 100644
index 0000000..8229e0f
--- /dev/null
+++ b/RISK_MANAGEMENT_API.md
@@ -0,0 +1,248 @@
+# 🔥 리스크 관리 & 성과 평가 API 가이드
+
+## 개요
+자동매매 시스템의 안정성과 수익성을 높이기 위한 리스크 관리 기능입니다.
+
+## 주요 기능
+
+### 1. Maximum Drawdown (MDD) 추적
+**엔드포인트**: `GET /api/v1/risk/risk-metrics?days=30`
+
+계좌 최고점 대비 최저점 낙폭을 측정합니다.
+
+**응답 예시**:
+```json
+{
+  "max_drawdown": 150000,
+  "max_drawdown_pct": 15.5,
+  "current_equity": 850000,
+  "peak_equity": 1000000,
+  "trades_count": 45,
+  "risk_level": "주의",
+  "equity_curve": [...],
+  "drawdown_curve": [...]
+}
+```
+
+**위험 레벨**:
+- `안전`: MDD < 10%
+- `주의`: 10% ≤ MDD < 20%
+- `경고`: 20% ≤ MDD < 30% (포지션 축소 권장)
+- `위험`: MDD ≥ 30% (시스템 중지 권장)
+
+---
+
+### 2. Sharpe Ratio 계산
+**엔드포인트**: `GET /api/v1/risk/sharpe-ratio?days=30`
+
+수익률 대비 변동성(리스크)을 측정하여 전략의 질을 평가합니다.
+
+**응답 예시**:
+```json
+{
+  "sharpe_ratio": 1.85,
+  "avg_return": 2.3,
+  "std_return": 5.1,
+  "annualized_return": 579.6,
+  "interpretation": "Good (우수)",
+  "trades_count": 42
+}
+```
+
+**해석**:
+- `> 2.0`: Excellent (매우 우수)
+- `> 1.0`: Good (우수)
+- `> 0`: Fair (보통)
+- `< 0`: Poor (개선 필요)
+
+---
+
+### 3. 일일 트레이딩 세션 조회
+**엔드포인트**: `GET /api/v1/risk/session/today`
+
+오늘의 연속 손실, 일일 손익, 거래 중지 상태를 확인합니다.
+
+**응답 예시**:
+```json
+{
+  "session_date": "2026-02-11",
+  "consecutive_losses": 2,
+  "consecutive_wins": 0,
+  "daily_profit_loss": -45000,
+  "daily_trades_count": 5,
+  "is_paused": false,
+  "pause_reason": null,
+  "starting_balance": 10000000,
+  "ending_balance": 9955000,
+  "peak_balance": 10050000
+}
+```
+
+---
+
+### 4. 주문 전 리스크 제한 확인
+**엔드포인트**: `POST /api/v1/risk/check-risk-limits`
+
+**파라미터**:
+- `order_value`: 주문 금액
+- `account_balance`: 계좌 잔고
+
+**응답 예시 (통과)**:
+```json
+{
+  "allowed": true,
+  "risk_level": "OK",
+  "warnings": [],
+  "position_ratio": 15.5,
+  "daily_loss_ratio": 1.2,
+  "consecutive_losses": 1
+}
+```
+
+**응답 예시 (거부)**:
+```json
+{
+  "allowed": false,
+  "reason": "연속 3회 손실 발생",
+  "risk_level": "CRITICAL",
+  "consecutive_losses": 3
+}
+```
+
+**자동 차단 조건**:
+1. **연속 3회 손실**: 3연패 시 자동 중지
+2. **일일 손실 3% 초과**: 계좌 대비 3% 손실 시 중지
+3. **포지션 사이즈 20% 초과**: 단일 포지션이 계좌의 20% 초과 시 거부
+
+---
+
+### 5. 거래 결과 업데이트
+**엔드포인트**: `POST /api/v1/risk/update-session`
+
+**파라미터**:
+- `trade_result`: `win` 또는 `loss`
+- `profit_loss`: 거래 손익
+
+매도 체결 후 호출하여 세션 상태를 업데이트합니다.
+
+---
+
+### 6. 승률 및 손익 통계
+**엔드포인트**: `GET /api/v1/risk/win-rate?days=30`
+
+**응답 예시**:
+```json
+{
+  "win_rate": 62.5,
+  "total_trades": 40,
+  "wins": 25,
+  "losses": 15,
+  "total_profit": 1250000,
+  "total_loss": 450000,
+  "net_profit": 800000,
+  "profit_factor": 2.78,
+  "avg_win": 50000,
+  "avg_loss": 30000,
+  "risk_reward_ratio": 1.67
+}
+```
+
+**주요 지표**:
+- **Profit Factor**: 총 이익 / 총 손실 (1.0 이상 권장, 2.0 이상 우수)
+- **Risk/Reward Ratio**: 평균 승리 / 평균 손실 (1.5 이상 권장)
+
+---
+
+## 리스크 관리 설정
+
+### 현재 기본값
+```python
+MAX_POSITION_SIZE_RATIO = 0.20    # 단일 포지션 20% 제한
+MAX_DAILY_LOSS_RATIO = 0.03       # 일일 손실 3% 제한
+MAX_CONSECUTIVE_LOSSES = 3        # 연속 3회 손실 제한
+
+# 수수료 및 세금
+COMMISSION_RATE = 0.00015         # 수수료 0.015%
+TRADE_TAX_RATE = 0.0023           # 거래세 0.23% (매도만)
+TOTAL_COST_RATE = 0.0026          # 왕복 약 0.26%
+```
+
+---
+
+## 사용 예시
+
+### 매수 전 체크
+```python
+# 주문 전 리스크 확인
+response = requests.post(
+    "/api/v1/risk/check-risk-limits",
+    params={
+        "order_value": 2000000,  # 200만원 주문
+        "account_balance": 10000000  # 1000만원 잔고
+    }
+)
+
+if response.json()["allowed"]:
+    # 매수 실행
+    execute_buy_order()
+else:
+    # 주문 거부
+    logger.warning(f"Order rejected: {response.json()['reason']}")
+```
+
+### 매도 후 세션 업데이트
+```python
+# 매도 체결 후
+sell_result = execute_sell_order()
+
+# 손익에 따라 세션 업데이트
+trade_result = "win" if sell_result["profit_loss"] > 0 else "loss"
+
+requests.post(
+    "/api/v1/risk/update-session",
+    params={
+        "trade_result": trade_result,
+        "profit_loss": sell_result["profit_loss"]
+    }
+)
+```
+
+---
+
+## 대시보드 표시 권장 사항
+
+### 필수 표시 지표
+1. **오늘의 상태**
+   - 연속 손실 횟수
+   - 일일 손익
+   - 거래 중지 상태
+
+2. **리스크 메트릭**
+   - MDD %
+   - Sharpe Ratio
+   - 승률
+
+3. **경고 알림**
+   - 연속 2회 손실: 노란색 경고
+   - 연속 3회 손실: 빨간색 차단
+   - MDD 20% 초과: 주황색 경고
+   - MDD 30% 초과: 빨간색 위험
+
+---
+
+## 주의사항
+
+1. **백테스팅 후 실전 적용**: 새로운 전략은 반드시 백테스팅으로 검증
+2. **리스크 한도 준수**: 설정된 한도를 절대 임의로 변경하지 않기
+3. **정기 점검**: 매주 Sharpe Ratio와 MDD 확인
+4. **감정 제어**: 시스템이 중지하면 하루 쉬기
+
+---
+
+## 다음 단계 (추가 개발 예정)
+
+- [ ] 백테스팅 API
+- [ ] Slack/Telegram 알림 연동
+- [ ] 실시간 경고 대시보드
+- [ ] 월간/분기별 성과 리포트
+- [ ] ATR 기반 동적 손절 설정
diff --git a/SPEED_OPTIMIZATION.md b/SPEED_OPTIMIZATION.md
new file mode 100644
index 0000000..120ffb7
--- /dev/null
+++ b/SPEED_OPTIMIZATION.md
@@ -0,0 +1,139 @@
+# 초기 진입 속도 최적화
+
+## 변경 사항
+
+### 1. 프론트엔드 - DB 캐시 모드 사용
+- **파일**: `frontend/src/pages/Dashboard.tsx`
+- **변경**: 추천 종목 조회 시 `realtime=false` 파라미터 추가
+- **효과**: 30초 → 0.1초로 로딩 속도 개선 (300배 향상)
+
+```typescript
+// 기존 (느림 - 30초)
+queryFn: async () => (await api.get('/recommendations/rule-based')).data,
+
+// 변경 (빠름 - 0.1초)
+queryFn: async () => (await api.get('/recommendations/rule-based', {
+    params: { realtime: false } // DB 캐시 사용
+})).data,
+```
+
+### 2. 배치 분석 스크립트
+- **파일**: `backend/batch_daily_analysis.py`
+- **목적**: 매일 장 시작 전에 전체 종목을 미리 분석하여 DB에 저장
+- **실행 방법**:
+  ```bash
+  make batch-test          # 테스트 (10개 종목)
+  make batch-limit LIMIT=50 # 50개 종목만
+  make batch-analysis      # 전체 종목 (약 30-60분 소요)
+  ```
+
+### 3. 자동 실행 설정
+- **파일**: `setup-cron.sh`
+- **스케줄**: 평일 오전 8시 50분 (장 시작 전)
+- **설정 방법**:
+  ```bash
+  ./setup-cron.sh
+  ```
+
+## 동작 원리
+
+### DB 캐시 시스템
+1. **배치 분석** (매일 아침 8:50)
+   - 전체 거래 가능 종목 조회
+   - 기술적 지표 계산 (RSI, MA, 볼린저밴드 등)
+   - `stock_analysis` 테이블에 저장
+
+2. **실시간 조회** (사용자 진입 시)
+   - DB에서 사전 분석된 데이터 조회 (0.1초)
+   - 실시간 KIS API 호출 없음
+
+3. **폴백 메커니즘**
+   - DB에 데이터가 없으면 자동으로 실시간 분석으로 전환
+   - 배치 실행 전에도 시스템 정상 동작
+
+## 테이블 구조
+
+```sql
+CREATE TABLE stock_analysis (
+    id SERIAL PRIMARY KEY,
+    stock_code VARCHAR(20) NOT NULL,
+    stock_name VARCHAR(100) NOT NULL,
+    analysis_date TIMESTAMP NOT NULL,
+    current_price INTEGER NOT NULL,
+    rsi NUMERIC(10, 4),
+    ma5 NUMERIC(15, 2),
+    ma20 NUMERIC(15, 2),
+    ma60 NUMERIC(15, 2),
+    bollinger_upper NUMERIC(15, 2),
+    bollinger_lower NUMERIC(15, 2),
+    signals JSONB,
+    score INTEGER DEFAULT 0,
+    created_at TIMESTAMP DEFAULT NOW()
+);
+
+CREATE INDEX idx_stock_analysis_date ON stock_analysis(analysis_date);
+CREATE INDEX idx_stock_analysis_code ON stock_analysis(stock_code);
+```
+
+## 사용 가이드
+
+### 배치 분석 실행
+```bash
+# 1. 테스트 실행 (10개 종목)
+make batch-test
+
+# 2. 제한 실행 (50개 종목)
+make batch-limit LIMIT=50
+
+# 3. 전체 실행 (모든 종목)
+make batch-analysis
+
+# 4. 로그 확인
+tail -f logs/batch_analysis.log
+```
+
+### 자동 실행 설정
+```bash
+# cron 작업 등록
+./setup-cron.sh
+
+# 확인
+crontab -l
+
+# 제거 (필요 시)
+crontab -e
+```
+
+## 성능 비교
+
+| 모드 | 로딩 시간 | API 호출 | 데이터 신선도 |
+|------|-----------|----------|---------------|
+| **실시간** | 30초 | 100+ 회 | 실시간 |
+| **DB 캐시** | 0.1초 | 0회 | 당일 아침 기준 |
+
+## 주의사항
+
+1. **배치 실행 시간**: 전체 종목 분석 시 30-60분 소요
+2. **API 제한**: 한국투자증권 API 호출 제한 (초당 20회)
+3. **데이터 신선도**: 배치 실행 후 데이터 사용 (장중 실시간 변동 반영 안됨)
+4. **장중 갱신**: 필요 시 `realtime=true`로 실시간 분석 가능
+
+## 문제 해결
+
+### DB에 데이터가 없을 때
+```bash
+# 즉시 배치 실행
+make batch-test
+
+# 또는 실시간 모드로 임시 사용
+# (프론트엔드에서 자동 폴백됨)
+```
+
+### 배치 실행 실패
+```bash
+# 로그 확인
+docker logs autostock-backend --tail 100
+
+# 수동 실행
+docker exec -it autostock-backend python batch_daily_analysis.py --test
+```
diff --git a/backend/Dockerfile b/backend/Dockerfile
index 39f59bd..c1c1de0 100644
--- a/backend/Dockerfile
+++ b/backend/Dockerfile
@@ -2,6 +2,9 @@ FROM python:3.11-slim
 
 WORKDIR /app
 
+# Python 출력 버퍼링 비활성화 (로그 즉시 출력)
+ENV PYTHONUNBUFFERED=1
+
 # 시스템 의존성 설치
 RUN apt-get update && apt-get install -y \
     gcc \
diff --git a/backend/app/api/__init__.py b/backend/app/api/__init__.py
index 4946802..775eba9 100644
--- a/backend/app/api/__init__.py
+++ b/backend/app/api/__init__.py
@@ -1,5 +1,10 @@
+"""
+API 라우터 통합 모듈
+
+- 각 엔드포인트 라우터를 prefix/tag와 함께 등록
+"""
 from fastapi import APIRouter
-from app.api.endpoints import trading_rules, trades, portfolio, market_data, mcp, recommendations, monitoring
+from app.api.endpoints import trading_rules, trades, portfolio, market_data, mcp, recommendations, monitoring, tensorflow_predictions, debug, risk_management, ml_ensemble, journals, day_trading
 
 api_router = APIRouter()
 
@@ -10,3 +15,9 @@ api_router.include_router(market_data.router, prefix="/market-data", tags=["mark
 api_router.include_router(mcp.router, prefix="/mcp", tags=["mcp"])
 api_router.include_router(recommendations.router, prefix="/recommendations", tags=["recommendations"])
 api_router.include_router(monitoring.router, prefix="/monitoring", tags=["monitoring"])
+api_router.include_router(tensorflow_predictions.router, prefix="/ml", tags=["ml"])
+api_router.include_router(debug.router, prefix="/debug", tags=["debug"])
+api_router.include_router(risk_management.router, prefix="/risk", tags=["risk_management"])
+api_router.include_router(ml_ensemble.router, prefix="/ml-ensemble", tags=["ml_ensemble"])
+api_router.include_router(journals.router, prefix="/journals", tags=["journals"])
+api_router.include_router(day_trading.router, prefix="/daytrading", tags=["day_trading"])
diff --git a/backend/app/api/endpoints/day_trading.py b/backend/app/api/endpoints/day_trading.py
new file mode 100644
index 0000000..0efb586
--- /dev/null
+++ b/backend/app/api/endpoints/day_trading.py
@@ -0,0 +1,731 @@
+"""
+데이트레이딩 API 엔드포인트
+
+라우터 prefix: /api/daytrading
+
+엔드포인트:
+  GET  /watchlist            — 감시 종목 목록 조회
+  POST /watchlist            — 감시 종목 추가/교체
+  GET  /signals              — 현재 진입 신호 조회
+  POST /execute              — 신호 기반 데이트레이딩 실행
+  GET  /positions            — 활성 데이트레이딩 포지션 조회
+  POST /close-all            — 전체 포지션 강제 청산 (EOD 수동)
+  POST /cycle                — 1분 주기 사이클 수동 실행 (디버그용)
+
+상태 (인메모리, 일일 초기화):
+  _watchlist       — 감시 종목 코드+이름 딕셔너리
+  _positions       — 활성 포지션 {stock_code: {...}}
+  _orb_cache       — 종목별 ORB 데이터
+  _daily_pnl       — 오늘 실현 손익
+  _last_date       — 마지막 초기화 날짜 (날짜 바뀌면 자동 리셋)
+"""
+from fastapi import APIRouter, HTTPException, Depends, Query
+from pydantic import BaseModel
+from typing import List, Optional, Dict, Any
+from datetime import datetime, date, time as dtime
+import asyncio
+import logging
+import pytz
+
+from app.services.korea_investment_api import korea_investment_api
+from app.services.day_trading_strategy import (
+    MinuteCandle, OpeningRange, DayTradeSignal,
+    parse_minute_candles, aggregate_to_5min,
+    calculate_vwap, calculate_opening_range,
+    check_orb_signal, check_vwap_bounce_signal, check_rsi_bb_signal,
+    check_day_trade_exit,
+    calculate_day_trade_position_size, is_daily_loss_exceeded,
+    ORB_END, ENTRY_CUTOFF, EOD_FLAT, MAX_POSITIONS,
+)
+from app.core.market_schedule import (
+    is_market_open, is_opening_range_period,
+    is_day_trade_entry_window, is_eod_flat_time,
+)
+from app.core.config import settings
+from app.core.json_helpers import _dumps
+from app.services.websocket_manager import websocket_manager
+from app.core.database import get_db, AsyncSessionLocal
+from app.models.models import TradeHistory
+from sqlalchemy.ext.asyncio import AsyncSession
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+KST = pytz.timezone("Asia/Seoul")
+
+
+# ── 인메모리 상태 ──────────────────────────────────────────────────────────────
+
+def _kst_now() -> datetime:
+    return datetime.now(KST).replace(tzinfo=None)
+
+
+def _kst_time() -> dtime:
+    return datetime.now(KST).time()
+
+
+def _today_kst() -> date:
+    return datetime.now(KST).date()
+
+
+# 감시 종목 (code → name)
+_watchlist: Dict[str, str] = {}
+
+# 활성 포지션
+# {stock_code: {
+#   "stock_name", "strategy", "entry_price", "stop_loss", "target_price",
+#   "quantity", "highest_price", "entry_time", "reason"
+# }}
+_positions: Dict[str, Dict[str, Any]] = {}
+
+# ORB 캐시 (당일, stock_code → OpeningRange)
+_orb_cache: Dict[str, OpeningRange] = {}
+
+# 일일 실현 손익 (원)
+_daily_pnl: float = 0.0
+
+# 마지막 초기화 날짜
+_last_reset_date: Optional[date] = None
+
+# 매매 실행 lock
+_trade_lock = asyncio.Lock()
+
+
+def _reset_if_new_day() -> None:
+    """날짜가 바뀌면 일일 상태 초기화"""
+    global _daily_pnl, _orb_cache, _last_reset_date
+    today = _today_kst()
+    if _last_reset_date != today:
+        _daily_pnl = 0.0
+        _orb_cache = {}
+        _last_reset_date = today
+        logger.info(f"📅 데이트레이딩 상태 일일 초기화: {today}")
+
+
+# ── Pydantic 모델 ─────────────────────────────────────────────────────────────
+
+class WatchlistRequest(BaseModel):
+    stocks: List[Dict[str, str]]  # [{"code": "005930", "name": "삼성전자"}, ...]
+
+
+class ExecuteRequest(BaseModel):
+    stock_code: str
+    dry_run: bool = False  # True면 주문 없이 신호만 반환
+
+
+# ── 내부 헬퍼 ─────────────────────────────────────────────────────────────────
+
+async def _fetch_candles(stock_code: str) -> List[MinuteCandle]:
+    """당일 전체 분봉 데이터 조회 및 파싱"""
+    raw = await korea_investment_api.get_minute_chart_full_day(stock_code)
+    return parse_minute_candles(raw)
+
+
+async def _get_current_price(stock_code: str) -> float:
+    """현재가 조회"""
+    try:
+        result = await korea_investment_api.get_current_price(stock_code)
+        return float(result.get("output", {}).get("stck_prpr", 0) or 0)
+    except Exception:
+        return 0.0
+
+
+async def _get_portfolio_summary() -> Dict[str, float]:
+    """포트폴리오 요약 (총자산, 가용 현금)"""
+    try:
+        balance = await korea_investment_api.get_balance()
+        output2 = balance.get("output2", [{}])
+        summary = output2[0] if output2 else {}
+        total_assets = float(summary.get("tot_evlu_amt", 0) or 0)
+        available_cash = float(summary.get("prvs_rcdl_excc_amt", 0) or 0)
+        return {"total_assets": total_assets, "available_cash": available_cash}
+    except Exception as e:
+        logger.error(f"포트폴리오 조회 실패: {e}")
+        return {"total_assets": 0.0, "available_cash": 0.0}
+
+
+async def _place_buy_order(
+    stock_code: str,
+    quantity: int,
+    price: int,
+) -> Optional[str]:
+    """매수 주문 실행, 주문번호 반환 (실패 시 None)"""
+    try:
+        result = await korea_investment_api.place_order(
+            stock_code=stock_code,
+            order_type="BUY",
+            quantity=quantity,
+            price=price,
+        )
+        if result.get("rt_cd") == "0":
+            return result.get("output", {}).get("ODNO", "")
+        logger.warning(f"매수 주문 실패 [{stock_code}]: {result.get('msg1')}")
+        return None
+    except Exception as e:
+        logger.error(f"매수 주문 오류 [{stock_code}]: {e}")
+        return None
+
+
+async def _place_sell_order(
+    stock_code: str,
+    quantity: int,
+    price: int = 0,  # 0 = 시장가
+) -> bool:
+    """매도 주문 실행"""
+    try:
+        result = await korea_investment_api.place_order(
+            stock_code=stock_code,
+            order_type="SELL",
+            quantity=quantity,
+            price=price,
+        )
+        return result.get("rt_cd") == "0"
+    except Exception as e:
+        logger.error(f"매도 주문 오류 [{stock_code}]: {e}")
+        return False
+
+
+async def _record_trade(
+    db: AsyncSession,
+    stock_code: str,
+    stock_name: str,
+    order_type: str,
+    price: float,
+    quantity: int,
+    reason: str,
+    profit_loss: float = 0.0,
+) -> None:
+    """TradeHistory DB 기록"""
+    try:
+        trade = TradeHistory(
+            stock_code=stock_code,
+            stock_name=stock_name,
+            order_type=order_type,
+            executed_price=price,
+            executed_quantity=quantity,
+            total_amount=price * quantity,
+            profit_loss=profit_loss,
+            profit_loss_rate=(profit_loss / (price * quantity) * 100) if price * quantity > 0 else 0,
+            status="COMPLETED",
+            entry_reason=reason if order_type == "BUY" else None,
+            exit_reason=reason if order_type == "SELL" else None,
+            executed_at=_kst_now(),
+        )
+        db.add(trade)
+        await db.commit()
+    except Exception as e:
+        logger.error(f"TradeHistory 기록 실패: {e}")
+
+
+# ── 핵심 사이클 로직 ──────────────────────────────────────────────────────────
+
+async def run_day_trading_cycle() -> Dict[str, Any]:
+    """1분 주기 데이트레이딩 사이클
+
+    흐름:
+    1. 장 미개장 → 스킵
+    2. 일일 상태 초기화 체크
+    3. Opening Range 수집 (09:00~09:30)
+    4. 활성 포지션 청산 체크
+    5. 신규 진입 신호 체크 (09:30~15:00)
+    6. 결과 반환
+    """
+    _reset_if_new_day()
+    now_time = _kst_time()
+    result: Dict[str, Any] = {
+        "time": _kst_now().strftime("%H:%M:%S"),
+        "phase": "",
+        "exits": [],
+        "entries": [],
+        "signals": [],
+    }
+
+    if not is_market_open():
+        result["phase"] = "market_closed"
+        return result
+
+    # ── 1. EOD 강제 청산 ──
+    if is_eod_flat_time():
+        result["phase"] = "eod_flat"
+        await _execute_eod_flat()
+        return result
+
+    # ── 2. ORB 수집 단계 (09:00~09:30) ──
+    if is_opening_range_period():
+        result["phase"] = "opening_range"
+        await _collect_opening_range()
+        result["orb_count"] = len(_orb_cache)
+        return result
+
+    # ── 3. 매매 가능 구간 (09:30~15:00) ──
+    if not is_day_trade_entry_window():
+        result["phase"] = "outside_window"
+        return result
+
+    result["phase"] = "active"
+
+    # ── 4. 활성 포지션 청산 체크 ──
+    exits = await _check_exits()
+    result["exits"] = exits
+
+    # ── 5. 신규 진입 신호 체크 ──
+    if len(_positions) < MAX_POSITIONS and settings.AUTO_TRADE_ENABLED:
+        portfolio = await _get_portfolio_summary()
+        total_assets = portfolio["total_assets"]
+        available_cash = portfolio["available_cash"]
+
+        if not is_daily_loss_exceeded(total_assets, _daily_pnl):
+            current_day_trade_amount = sum(
+                p["entry_price"] * p["quantity"] for p in _positions.values()
+            )
+            signals = await _scan_signals(
+                total_assets=total_assets,
+                available_cash=available_cash,
+                current_day_trade_amount=current_day_trade_amount,
+            )
+            result["signals"] = [
+                {
+                    "stock_code": s["signal"].stock_code,
+                    "strategy": s["signal"].strategy,
+                    "entry_price": s["signal"].entry_price,
+                    "stop_loss": s["signal"].stop_loss,
+                    "target_price": s["signal"].target_price,
+                    "reason": s["signal"].reason,
+                    "quantity": s["quantity"],
+                }
+                for s in signals
+            ]
+
+            for s in signals:
+                if len(_positions) >= MAX_POSITIONS:
+                    break
+                entry_result = await _execute_entry(s["signal"], s["quantity"])
+                if entry_result:
+                    result["entries"].append(entry_result)
+        else:
+            logger.warning(
+                f"⚠️ 일일 손실 한도 도달 ({_daily_pnl:,.0f}원) → 신규 진입 중단"
+            )
+
+    return result
+
+
+async def _collect_opening_range() -> None:
+    """Opening Range 집계 (09:00~09:30)"""
+    for code in list(_watchlist.keys()):
+        if code in _orb_cache:
+            continue
+        try:
+            candles = await _fetch_candles(code)
+            orb = calculate_opening_range(candles)
+            if orb:
+                _orb_cache[code] = orb
+                logger.info(
+                    f"📊 ORB 수집 [{code}]: "
+                    f"H={orb.high:.0f}, L={orb.low:.0f}, "
+                    f"분당거래량={orb.avg_vol_per_min:.0f}"
+                )
+        except Exception as e:
+            logger.warning(f"ORB 수집 실패 [{code}]: {e}")
+        await asyncio.sleep(0.6)
+
+
+async def _check_exits() -> List[Dict[str, Any]]:
+    """활성 포지션 청산 조건 체크 및 실행"""
+    global _daily_pnl
+    exits = []
+    now_time = _kst_time()
+
+    for code, pos in list(_positions.items()):
+        try:
+            current_price = await _get_current_price(code)
+            if current_price <= 0:
+                continue
+
+            # 최고가 갱신
+            if current_price > pos["highest_price"]:
+                _positions[code]["highest_price"] = current_price
+
+            candles = await _fetch_candles(code)
+            candles_5m = aggregate_to_5min(candles)
+
+            exit_signal = check_day_trade_exit(
+                entry_price=pos["entry_price"],
+                current_price=current_price,
+                stop_loss=pos["stop_loss"],
+                target_price=pos["target_price"],
+                highest_since_entry=pos["highest_price"],
+                candles_5min=candles_5m,
+                current_time=now_time,
+            )
+
+            if exit_signal:
+                quantity = pos["quantity"]
+                ok = await _place_sell_order(code, quantity, price=0)  # 시장가
+                if ok:
+                    pnl = (current_price - pos["entry_price"]) * quantity
+                    _daily_pnl += pnl
+                    del _positions[code]
+
+                    async with AsyncSessionLocal() as db:
+                        await _record_trade(
+                            db, code, pos["stock_name"], "SELL",
+                            current_price, quantity, exit_signal.reason, pnl,
+                        )
+
+                    exits.append({
+                        "stock_code": code,
+                        "reason": exit_signal.reason,
+                        "pnl": round(pnl, 0),
+                        "price": current_price,
+                    })
+                    logger.info(
+                        f"✅ 데이트레이딩 청산 [{code}]: "
+                        f"{exit_signal.reason}, PNL={pnl:+,.0f}원"
+                    )
+                    await websocket_manager.broadcast(_dumps({
+                        "type": "day_trade_exit",
+                        "stock_code": code,
+                        "reason": exit_signal.reason,
+                        "pnl": pnl,
+                    }))
+        except Exception as e:
+            logger.error(f"청산 체크 오류 [{code}]: {e}")
+        await asyncio.sleep(0.6)
+
+    return exits
+
+
+async def _scan_signals(
+    total_assets: float,
+    available_cash: float,
+    current_day_trade_amount: float,
+) -> List[Dict[str, Any]]:
+    """감시 종목에서 진입 신호 스캔"""
+    results = []
+    for code, name in list(_watchlist.items()):
+        if code in _positions:
+            continue
+        try:
+            candles_1m = await _fetch_candles(code)
+            if not candles_1m:
+                continue
+            candles_5m = aggregate_to_5min(candles_1m)
+            current_price = candles_1m[-1].close if candles_1m else 0
+            if current_price < settings.MIN_PRICE_KRW:
+                continue
+
+            vwap = calculate_vwap(candles_1m)
+            orb = _orb_cache.get(code)
+
+            signal: Optional[DayTradeSignal] = None
+
+            # ORB 우선
+            if orb:
+                signal = check_orb_signal(code, name, candles_1m, orb, current_price)
+
+            # VWAP 반등
+            if signal is None and vwap:
+                signal = check_vwap_bounce_signal(code, name, candles_5m, vwap, current_price)
+
+            # RSI+BB
+            if signal is None:
+                signal = check_rsi_bb_signal(code, name, candles_5m, current_price)
+
+            if signal:
+                position_size = calculate_day_trade_position_size(
+                    total_assets, available_cash, current_day_trade_amount
+                )
+                if position_size < signal.entry_price:
+                    continue  # 최소 1주도 살 수 없으면 스킵
+
+                quantity = max(1, int(position_size // signal.entry_price))
+                results.append({"signal": signal, "quantity": quantity})
+                logger.info(
+                    f"🎯 데이트레이딩 신호 [{code}] {signal.strategy}: "
+                    f"{signal.reason}, 수량={quantity}"
+                )
+
+        except Exception as e:
+            logger.warning(f"신호 스캔 오류 [{code}]: {e}")
+        await asyncio.sleep(0.6)
+
+    # confidence 내림차순 정렬
+    results.sort(key=lambda x: x["signal"].confidence, reverse=True)
+    return results[:MAX_POSITIONS - len(_positions)]
+
+
+async def _execute_entry(signal: DayTradeSignal, quantity: int) -> Optional[Dict]:
+    """진입 주문 실행 및 포지션 등록"""
+    global _trade_lock
+    async with _trade_lock:
+        if len(_positions) >= MAX_POSITIONS:
+            return None
+        if signal.stock_code in _positions:
+            return None
+
+        order_no = await _place_buy_order(
+            signal.stock_code, quantity, int(signal.entry_price)
+        )
+        if not order_no:
+            return None
+
+        _positions[signal.stock_code] = {
+            "stock_name": signal.stock_name,
+            "strategy": signal.strategy,
+            "entry_price": signal.entry_price,
+            "stop_loss": signal.stop_loss,
+            "target_price": signal.target_price,
+            "quantity": quantity,
+            "highest_price": signal.entry_price,
+            "entry_time": _kst_now().strftime("%H:%M:%S"),
+            "reason": signal.reason,
+        }
+
+        async with AsyncSessionLocal() as db:
+            await _record_trade(
+                db, signal.stock_code, signal.stock_name, "BUY",
+                signal.entry_price, quantity, signal.reason,
+            )
+
+        logger.info(
+            f"🛒 데이트레이딩 진입 [{signal.stock_code}] "
+            f"{signal.strategy}: {signal.entry_price:.0f}원 × {quantity}주"
+        )
+        await websocket_manager.broadcast(_dumps({
+            "type": "day_trade_entry",
+            "stock_code": signal.stock_code,
+            "strategy": signal.strategy,
+            "entry_price": signal.entry_price,
+            "quantity": quantity,
+        }))
+        return {
+            "stock_code": signal.stock_code,
+            "strategy": signal.strategy,
+            "entry_price": signal.entry_price,
+            "quantity": quantity,
+            "reason": signal.reason,
+        }
+
+
+async def _execute_eod_flat() -> None:
+    """EOD 전체 포지션 강제 청산"""
+    global _daily_pnl
+    for code, pos in list(_positions.items()):
+        try:
+            current_price = await _get_current_price(code)
+            ok = await _place_sell_order(code, pos["quantity"], price=0)
+            if ok:
+                pnl = (current_price - pos["entry_price"]) * pos["quantity"]
+                _daily_pnl += pnl
+                del _positions[code]
+                logger.info(f"🔔 EOD 강제 청산 [{code}]: PNL={pnl:+,.0f}원")
+        except Exception as e:
+            logger.error(f"EOD 청산 오류 [{code}]: {e}")
+        await asyncio.sleep(0.6)
+
+
+# ── API 엔드포인트 ────────────────────────────────────────────────────────────
+
+@router.get("/watchlist")
+async def get_watchlist():
+    """감시 종목 목록 조회"""
+    _reset_if_new_day()
+    return {
+        "watchlist": [
+            {"code": k, "name": v, "has_orb": k in _orb_cache}
+            for k, v in _watchlist.items()
+        ],
+        "count": len(_watchlist),
+    }
+
+
+@router.post("/watchlist")
+async def set_watchlist(req: WatchlistRequest):
+    """감시 종목 설정 (최대 20종목)
+
+    body: {"stocks": [{"code": "005930", "name": "삼성전자"}, ...]}
+    """
+    global _watchlist
+    if len(req.stocks) > 20:
+        raise HTTPException(400, "감시 종목은 최대 20종목까지만 설정 가능합니다.")
+
+    _watchlist = {s["code"]: s.get("name", s["code"]) for s in req.stocks}
+    logger.info(f"📋 감시 종목 설정: {list(_watchlist.keys())}")
+    return {"status": "ok", "watchlist": list(_watchlist.keys())}
+
+
+@router.get("/signals")
+async def get_current_signals():
+    """현재 진입 가능 신호 조회 (주문 미실행)"""
+    _reset_if_new_day()
+    if not is_day_trade_entry_window():
+        return {
+            "phase": "outside_window",
+            "message": "데이트레이딩 진입 시간이 아닙니다 (09:30~15:00).",
+            "signals": [],
+        }
+
+    portfolio = await _get_portfolio_summary()
+    total_assets = portfolio["total_assets"]
+    available_cash = portfolio["available_cash"]
+    current_day_trade_amount = sum(
+        p["entry_price"] * p["quantity"] for p in _positions.values()
+    )
+
+    signals = await _scan_signals(total_assets, available_cash, current_day_trade_amount)
+    return {
+        "phase": "active",
+        "signals": [
+            {
+                "stock_code": s["signal"].stock_code,
+                "stock_name": s["signal"].stock_name,
+                "strategy": s["signal"].strategy,
+                "entry_price": s["signal"].entry_price,
+                "stop_loss": s["signal"].stop_loss,
+                "target_price": s["signal"].target_price,
+                "reason": s["signal"].reason,
+                "confidence": s["signal"].confidence,
+                "quantity": s["quantity"],
+            }
+            for s in signals
+        ],
+        "count": len(signals),
+    }
+
+
+@router.post("/execute")
+async def execute_day_trade(req: ExecuteRequest):
+    """특정 종목 데이트레이딩 신호 스캔 후 진입"""
+    _reset_if_new_day()
+    code = req.stock_code
+    name = _watchlist.get(code, code)
+
+    if code in _positions:
+        raise HTTPException(400, f"{code}는 이미 포지션이 있습니다.")
+    if len(_positions) >= MAX_POSITIONS:
+        raise HTTPException(400, f"최대 포지션 수({MAX_POSITIONS}종목)에 도달했습니다.")
+    if not is_day_trade_entry_window():
+        raise HTTPException(400, "데이트레이딩 진입 시간이 아닙니다 (09:30~15:00).")
+
+    portfolio = await _get_portfolio_summary()
+    total_assets = portfolio["total_assets"]
+    available_cash = portfolio["available_cash"]
+
+    if is_daily_loss_exceeded(total_assets, _daily_pnl):
+        raise HTTPException(400, "일일 손실 한도(-3%)에 도달하여 신규 진입이 차단됩니다.")
+
+    candles_1m = await _fetch_candles(code)
+    candles_5m = aggregate_to_5min(candles_1m)
+    current_price = candles_1m[-1].close if candles_1m else 0
+    vwap = calculate_vwap(candles_1m)
+    orb = _orb_cache.get(code)
+
+    signal = None
+    if orb:
+        signal = check_orb_signal(code, name, candles_1m, orb, current_price)
+    if signal is None and vwap:
+        signal = check_vwap_bounce_signal(code, name, candles_5m, vwap, current_price)
+    if signal is None:
+        signal = check_rsi_bb_signal(code, name, candles_5m, current_price)
+
+    if not signal:
+        return {"status": "no_signal", "message": "현재 진입 조건을 충족하는 신호가 없습니다."}
+
+    current_day_trade_amount = sum(
+        p["entry_price"] * p["quantity"] for p in _positions.values()
+    )
+    position_size = calculate_day_trade_position_size(
+        total_assets, available_cash, current_day_trade_amount
+    )
+    quantity = max(1, int(position_size // signal.entry_price))
+
+    if req.dry_run:
+        return {
+            "status": "dry_run",
+            "signal": {
+                "strategy": signal.strategy,
+                "entry_price": signal.entry_price,
+                "stop_loss": signal.stop_loss,
+                "target_price": signal.target_price,
+                "reason": signal.reason,
+                "quantity": quantity,
+            },
+        }
+
+    entry = await _execute_entry(signal, quantity)
+    if not entry:
+        raise HTTPException(500, "주문 실행에 실패했습니다.")
+    return {"status": "ok", "entry": entry}
+
+
+@router.get("/positions")
+async def get_positions():
+    """활성 데이트레이딩 포지션 조회"""
+    _reset_if_new_day()
+    result = []
+    for code, pos in _positions.items():
+        try:
+            current_price = await _get_current_price(code)
+        except Exception:
+            current_price = pos["entry_price"]
+        pnl = (current_price - pos["entry_price"]) * pos["quantity"]
+        pnl_pct = (current_price - pos["entry_price"]) / pos["entry_price"] * 100
+        result.append({
+            "stock_code": code,
+            "stock_name": pos["stock_name"],
+            "strategy": pos["strategy"],
+            "entry_price": pos["entry_price"],
+            "current_price": current_price,
+            "stop_loss": pos["stop_loss"],
+            "target_price": pos["target_price"],
+            "quantity": pos["quantity"],
+            "pnl": round(pnl, 0),
+            "pnl_pct": round(pnl_pct, 2),
+            "entry_time": pos["entry_time"],
+        })
+    return {
+        "positions": result,
+        "count": len(result),
+        "daily_pnl": round(_daily_pnl, 0),
+        "is_daily_loss_exceeded": is_daily_loss_exceeded(
+            sum(p["entry_price"] * p["quantity"] for p in _positions.values()),
+            _daily_pnl,
+        ),
+    }
+
+
+@router.post("/close-all")
+async def close_all_positions():
+    """전체 포지션 수동 강제 청산 (EOD 대비 수동 실행)"""
+    _reset_if_new_day()
+    await _execute_eod_flat()
+    return {
+        "status": "ok",
+        "message": "전체 데이트레이딩 포지션 청산 완료",
+        "daily_pnl": round(_daily_pnl, 0),
+    }
+
+
+@router.post("/cycle")
+async def manual_cycle():
+    """1분 사이클 수동 실행 (테스트/디버그용)"""
+    _reset_if_new_day()
+    result = await run_day_trading_cycle()
+    return result
+
+
+@router.get("/status")
+async def get_status():
+    """데이트레이딩 시스템 상태 요약"""
+    _reset_if_new_day()
+    return {
+        "watchlist_count": len(_watchlist),
+        "active_positions": len(_positions),
+        "orb_collected": len(_orb_cache),
+        "daily_pnl": round(_daily_pnl, 0),
+        "is_market_open": is_market_open(),
+        "is_opening_range": is_opening_range_period(),
+        "is_entry_window": is_day_trade_entry_window(),
+        "is_eod_flat": is_eod_flat_time(),
+        "today": _today_kst().isoformat(),
+    }
diff --git a/backend/app/api/endpoints/debug.py b/backend/app/api/endpoints/debug.py
new file mode 100644
index 0000000..3a61fa1
--- /dev/null
+++ b/backend/app/api/endpoints/debug.py
@@ -0,0 +1,37 @@
+from fastapi import APIRouter
+from app.core.config import settings
+from app.core.market_schedule import is_market_open
+from datetime import datetime
+import pytz
+
+router = APIRouter()
+
+@router.get("/debug/autotrade-status")
+async def get_autotrade_status():
+    """자동매매 상태 진단"""
+    KST = pytz.timezone('Asia/Seoul')
+    now = datetime.now(KST)
+    market_open = is_market_open()
+    
+    return {
+        "timestamp": now.isoformat(),
+        "current_time_kst": now.strftime('%Y-%m-%d %H:%M:%S %A'),
+        "weekday": now.weekday(),
+        "current_minutes": now.hour * 60 + now.minute,
+        "market_hours": "540-930 (09:00-15:30)",
+        "market_open": market_open,
+        "auto_trade_enabled": settings.AUTO_TRADE_ENABLED,
+        "can_trade": market_open and settings.AUTO_TRADE_ENABLED,
+        "settings": {
+            "stop_loss_percent": settings.STOP_LOSS_PERCENT,
+            "take_profit_percent": settings.TAKE_PROFIT_PERCENT,
+            "max_daily_trades": settings.MAX_DAILY_TRADES,
+            "trend_filter_enabled": settings.TREND_FILTER_ENABLED,
+        },
+        "api_configured": bool(settings.KOREA_INVESTMENT_APP_KEY),
+        "diagnosis": {
+            "market_status": "OPEN - 자동매매 가능" if market_open else "CLOSED - 장 마감",
+            "config_status": "ENABLED" if settings.AUTO_TRADE_ENABLED else "DISABLED",
+            "api_status": "CONFIGURED" if settings.KOREA_INVESTMENT_APP_KEY else "NOT CONFIGURED",
+        }
+    }
diff --git a/backend/app/api/endpoints/journals.py b/backend/app/api/endpoints/journals.py
new file mode 100644
index 0000000..8187420
--- /dev/null
+++ b/backend/app/api/endpoints/journals.py
@@ -0,0 +1,78 @@
+"""
+매매일지 API 엔드포인트
+
+- GET /: 최근 AI 생성 매매일지 목록
+- GET /{journal_id}: 특정 일지 상세
+"""
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, desc
+from typing import Optional
+from datetime import datetime
+import logging
+
+from app.core.database import get_db
+from app.models.models import TradeJournal
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+@router.get("")
+async def list_journals(
+    limit: int = Query(default=20, ge=1, le=100),
+    offset: int = Query(default=0, ge=0),
+    stock_code: Optional[str] = None,
+    db: AsyncSession = Depends(get_db),
+):
+    """최근 AI 생성 매매일지 목록 조회"""
+    try:
+        query = select(TradeJournal).order_by(desc(TradeJournal.journal_date))
+        if stock_code:
+            query = query.where(TradeJournal.stock_code == stock_code)
+        query = query.offset(offset).limit(limit)
+
+        result = await db.execute(query)
+        journals = result.scalars().all()
+
+        return [
+            {
+                "id": j.id,
+                "trade_id": j.trade_id,
+                "stock_code": j.stock_code,
+                "stock_name": j.stock_name,
+                "journal_date": j.journal_date.isoformat() if j.journal_date else None,
+                "content": j.content,
+                "strategy_name": j.strategy_name,
+                "mood": j.mood,
+                "tags": j.tags,
+                "created_at": j.created_at.isoformat() if j.created_at else None,
+            }
+            for j in journals
+        ]
+    except Exception as e:
+        logger.error(f"journals list error: {e}", exc_info=True)
+        return []
+
+
+@router.get("/{journal_id}")
+async def get_journal(journal_id: int, db: AsyncSession = Depends(get_db)):
+    """특정 매매일지 상세 조회"""
+    result = await db.execute(select(TradeJournal).where(TradeJournal.id == journal_id))
+    journal = result.scalar_one_or_none()
+    if not journal:
+        from fastapi import HTTPException
+        raise HTTPException(status_code=404, detail="Journal not found")
+    return {
+        "id": journal.id,
+        "trade_id": journal.trade_id,
+        "stock_code": journal.stock_code,
+        "stock_name": journal.stock_name,
+        "journal_date": journal.journal_date.isoformat() if journal.journal_date else None,
+        "content": journal.content,
+        "strategy_name": journal.strategy_name,
+        "mood": journal.mood,
+        "tags": journal.tags,
+        "created_at": journal.created_at.isoformat() if journal.created_at else None,
+    }
diff --git a/backend/app/api/endpoints/market_data.py b/backend/app/api/endpoints/market_data.py
index d58772a..16640b4 100644
--- a/backend/app/api/endpoints/market_data.py
+++ b/backend/app/api/endpoints/market_data.py
@@ -1,17 +1,34 @@
+"""
+시세 데이터 API 엔드포인트
+
+- GET /price/{stock_code}: 실시간 현재가 조회
+- GET /chart/{stock_code}: 차트 데이터 (일봉/주봉/월봉)
+- GET /orderbook/{stock_code}: 호가 정보 조회
+- GET /ai-analysis/{stock_code}: AI 기반 종목 분석
+"""
+# 필요한 라이브러리 및 모듈 임포트
 from datetime import datetime, timedelta
 import random
 import logging
 
-from fastapi import APIRouter, HTTPException, Query
+from fastapi import APIRouter, HTTPException, Query, Depends
+from typing import List, Dict
 from pydantic import BaseModel
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
 
+# 내부 모듈 임포트
 from app.core.config import settings
+from app.core.database import get_db
 from app.services.korea_investment_api import korea_investment_api
 
+# APIRouter 인스턴스 생성
 router = APIRouter()
+# 로거 설정
 logger = logging.getLogger(__name__)
 
 
+# 주식 가격 응답을 위한 Pydantic 모델 정의
 class StockPriceResponse(BaseModel):
     stock_code: str
     current_price: float
@@ -24,15 +41,18 @@ class StockPriceResponse(BaseModel):
 
 @router.get("/price/{stock_code}")
 async def get_stock_price(stock_code: str):
-    """주식 현재가 조회"""
+    """주식 현재가 조회 엔드포인트"""
     try:
+        # 한국투자증권 API를 통해 현재가 데이터 조회
         data = await korea_investment_api.get_current_price(stock_code)
         
+        # API 응답에 'output' 필드가 없는 경우 예외 처리
         if "output" not in data:
             raise HTTPException(status_code=404, detail="Stock data not found")
         
         output = data["output"]
         
+        # 필요한 데이터를 추출하여 딕셔너리 형태로 반환
         return {
             "stock_code": stock_code,
             "current_price": float(output.get("stck_prpr", 0)),
@@ -44,59 +64,115 @@ async def get_stock_price(stock_code: str):
         }
     
     except Exception as e:
+        # 예외 발생 시 500 에러와 함께 상세 내용 반환
         raise HTTPException(status_code=500, detail=f"Failed to fetch stock price: {str(e)}")
 
 
-def _generate_sample_chart(stock_code: str, period: str) -> dict:
-    """로컬 개발 환경을 위한 샘플 차트 데이터를 생성"""
+@router.get("/prices")
+async def get_stock_prices(codes: str):
+    """여러 종목의 현재가를 일괄 조회하는 엔드포인트
+
+    Query:
+    - codes: 콤마로 구분된 종목코드들 (예: 005930,000660,035420)
+    """
+    try:
+        # codes 파라미터가 없는 경우 빈 데이터 반환
+        if not codes:
+            return {"prices": {}, "count": 0, "timestamp": datetime.now().isoformat()}
+
+        # 콤마로 구분된 종목 코드 문자열을 리스트로 변환
+        code_list: List[str] = [c.strip() for c in codes.split(",") if c.strip()]
+        prices: Dict[str, float] = {}
+
+        # 각 종목 코드에 대해 순차적으로 현재가 조회
+        # 클래스 내부에 API 호출 간격을 조절하는 쓰로틀링 기능이 내장되어 있음
+        for code in code_list:
+            try:
+                data = await korea_investment_api.get_current_price(code)
+                if data and data.get("output"):
+                    o = data["output"]
+                    # 콤마가 포함된 가격 문자열을 float으로 변환
+                    current_price = float(str(o.get("stck_prpr", "0")).replace(",", ""))
+                    prices[code] = current_price
+            except Exception as e:
+                # 특정 종목 조회 실패 시 경고 로그 기록
+                logger.warning(f"Failed to fetch price for {code}: {e}")
+
+        # 조회 결과를 딕셔너리 형태로 반환
+        return {
+            "prices": prices,
+            "count": len(prices),
+            "requested": len(code_list),
+            "timestamp": datetime.now().isoformat(),
+        }
+    except Exception as e:
+        # 예외 발생 시 500 에러와 함께 상세 내용 반환
+        raise HTTPException(status_code=500, detail=f"Failed to fetch prices: {str(e)}")
+
+
+def _generate_sample_chart(stock_code: str, period: str, limit: int = 100) -> dict:
+    """로컬 개발 환경 및 API 키가 없을 때 사용할 샘플 차트 데이터를 생성하는 함수"""
+    # 유효한 주기(period)인지 확인, 아니면 'D'(일봉)으로 설정
     if period not in {"D", "W", "M"}:
         period = "D"
 
+    # 주기에 따라 데이터 포인트 수와 날짜 간격 설정
     if period == "D":
-        points = 60
+        points = min(limit, 240)  # 일봉은 최대 240개
         step = 1
     elif period == "W":
-        points = 52
+        points = min(limit, 240)  # 주봉도 최대 240개
         step = 7
-    else:  # "M"
-        points = 36
+    else:  # "M" (월봉)
+        points = min(limit, 240)  # 월봉도 최대 240개
         step = 30
 
+    # 차트 데이터의 시작 날짜 계산
     today = datetime.now()
     start_date = today - timedelta(days=(points - 1) * step)
 
+    # 종목코드와 주기에 기반하여 일관된 랜덤 데이터 생성을 위한 시드 설정
     rng = random.Random(f"{stock_code}:{period}")
+    # 랜덤 가격 및 변동성 파라미터 초기화
     base_price = rng.randint(30000, 90000)
     drift = rng.uniform(-0.04, 0.06)
     volatility = rng.uniform(0.004, 0.018)
     volume_base = rng.randint(80000, 180000)
 
+    # 가격을 10단위로 반올림하는 헬퍼 함수
     def round_price(value: float) -> int:
         return max(1000, int(round(value / 10)) * 10)
 
     price = float(base_price)
     chart_data = []
 
+    # 설정된 포인트 수만큼 반복하여 캔들 데이터 생성
     for idx in range(points):
         current_date = start_date + timedelta(days=idx * step)
+        # 일일 가격 변동률 계산
         daily_change = drift / points + rng.uniform(-volatility, volatility)
 
+        # 시가, 종가, 고가, 저가 생성
         open_price = price
         close_price = max(1000.0, open_price * (1 + daily_change))
 
         high_price = max(open_price, close_price) * (1 + rng.uniform(0, volatility * 1.8))
         low_price = min(open_price, close_price) * (1 - rng.uniform(0, volatility * 1.8))
 
+        # 저가가 0 이하로 내려가지 않도록 보정
         if low_price <= 0:
             low_price = min(open_price, close_price) * 0.98
 
+        # 거래량 생성
         volume = int(volume_base * (1 + rng.uniform(-0.35, 0.35)))
 
+        # 가격 반올림 처리
         open_value = round_price(open_price)
         close_value = round_price(close_price)
         high_value = max(round_price(high_price), open_value, close_value)
         low_value = min(round_price(low_price), open_value, close_value)
 
+        # 생성된 캔들 데이터를 리스트에 추가
         chart_data.append({
             "date": current_date.strftime("%Y%m%d"),
             "open": float(open_value),
@@ -106,8 +182,10 @@ def _generate_sample_chart(stock_code: str, period: str) -> dict:
             "volume": max(1000, volume),
         })
 
+        # 다음 캔들의 시가를 위해 현재 종가 저장
         price = close_price
 
+    # 최종 샘플 차트 데이터를 딕셔너리 형태로 반환
     return {
         "stock_code": stock_code,
         "period": period,
@@ -116,63 +194,99 @@ def _generate_sample_chart(stock_code: str, period: str) -> dict:
     }
 
 
+# 차트 데이터를 위한 간단한 인메모리 캐시 딕셔너리
+chart_cache = {}
+
 @router.get("/chart/{stock_code}")
 async def get_stock_chart(
     stock_code: str,
     period: str = "D",
-    realtime: bool = Query(False, description="최신 현재가를 포함하여 실시간으로 보정된 마지막 캔들 반환")
+    realtime: bool = Query(False, description="최신 현재가를 포함하여 실시간으로 보정된 마지막 캔들 반환"),
+    limit: int = Query(100, description="조회할 데이터 개수 (기본: 100, 최대: 240)")
 ):
-    """주식 차트 데이터 조회
-    
+    """주식 차트 데이터 조회 엔드포인트 (캐싱 적용)
+
     Args:
         stock_code: 종목 코드
         period: D(일봉), W(주봉), M(월봉)
+        limit: 조회할 데이터 개수 (일봉 100개는 약 3개월치 데이터)
     """
     try:
-        if not settings.KOREA_INVESTMENT_APP_KEY or not settings.KOREA_INVESTMENT_APP_SECRET:
-            return _generate_sample_chart(stock_code, period)
-
-        data = await korea_investment_api.get_daily_chart(stock_code, period)
-
-        if "output" not in data:
-            raise HTTPException(status_code=404, detail="Chart data not found")
-
+        # 캐시 키 생성 (예: "005930__D")
+        cache_key = f"{stock_code}__{period}"
+        current_time = datetime.now()
+        
+        # 캐시에서 데이터 조회
+        cached_data = chart_cache.get(cache_key)
+        use_cache = False
         chart_data = []
-        for item in data["output"]:
-            # KIS API 가격 데이터 안전하게 파싱
-            try:
-                close_str = str(item.get("stck_clpr", "0"))
-                open_str = str(item.get("stck_oprc", "0"))
-                high_str = str(item.get("stck_hgpr", "0"))
-                low_str = str(item.get("stck_lwpr", "0"))
-                
-                # 소수점이 포함되어 있으면 제거하고 정수로 변환
-                close_val = float(close_str.replace(",", ""))
-                open_val = float(open_str.replace(",", ""))
-                high_val = float(high_str.replace(",", ""))
-                low_val = float(low_str.replace(",", ""))
-                
-                chart_data.append({
-                    "date": item.get("stck_bsop_date"),
-                    "open": open_val,
-                    "high": high_val,
-                    "low": low_val,
-                    "close": close_val,
-                    "volume": int(item.get("acml_vol", 0))
-                })
-            except (ValueError, TypeError) as e:
-                logger.error(f"가격 파싱 오류: {item} - {e}")
-                continue
+        
+        # 캐시 데이터가 있고, 10분(600초) 이내에 생성된 경우 캐시 사용
+        if cached_data:
+            last_updated = cached_data.get("timestamp")
+            if last_updated and (current_time - last_updated).total_seconds() < 600:
+                chart_data = list(cached_data.get("data", [])) # 원본 수정을 방지하기 위해 데이터 복사
+                use_cache = True
+                # logger.debug(f"Chart cache hit for {stock_code}")
 
-        # KIS API는 최신 데이터가 가장 먼저 올 수 있음 → 그대로 두고 프론트에서 reverse 처리
+        # 캐시를 사용하지 않는 경우 (캐시가 없거나 만료됨)
+        if not use_cache:
+            # API 키가 설정되지 않은 경우 샘플 데이터 생성
+            if not settings.KOREA_INVESTMENT_APP_KEY or not settings.KOREA_INVESTMENT_APP_SECRET:
+                return _generate_sample_chart(stock_code, period, limit)
 
+            # 한국투자증권 API를 통해 차트 데이터 조회
+            data = await korea_investment_api.get_daily_chart(stock_code, period, limit=limit)
+
+            if "output2" not in data:
+                raise HTTPException(status_code=404, detail="Chart data not found")
+
+            chart_data = [] # 데이터 리스트 초기화
+            for item in data["output2"]:
+                # KIS API 응답에서 가격 데이터를 안전하게 파싱
+                try:
+                    # 콤마가 포함될 수 있는 문자열 형태의 가격을 가져옴
+                    close_str = str(item.get("stck_clpr", "0"))
+                    open_str = str(item.get("stck_oprc", "0"))
+                    high_str = str(item.get("stck_hgpr", "0"))
+                    low_str = str(item.get("stck_lwpr", "0"))
+                    
+                    # 콤마를 제거하고 float으로 변환
+                    close_val = float(close_str.replace(",", ""))
+                    open_val = float(open_str.replace(",", ""))
+                    high_val = float(high_str.replace(",", ""))
+                    low_val = float(low_str.replace(",", ""))
+                    
+                    # 파싱된 데이터를 딕셔너리 형태로 리스트에 추가
+                    chart_data.append({
+                        "date": item.get("stck_bsop_date"),
+                        "open": open_val,
+                        "high": high_val,
+                        "low": low_val,
+                        "close": close_val,
+                        "volume": int(item.get("acml_vol", 0))
+                    })
+                except (ValueError, TypeError) as e:
+                    # 가격 파싱 중 오류 발생 시 로그 기록하고 해당 데이터는 건너뜀
+                    logger.error(f"가격 파싱 오류: {item} - {e}")
+                    continue
+            
+            # 조회한 데이터를 캐시에 저장
+            chart_cache[cache_key] = {
+                "timestamp": current_time,
+                "data": chart_data
+            }
+
+        # KIS API는 최신 데이터가 가장 먼저 오는 경향이 있으므로, 프론트엔드에서 날짜순으로 정렬(reverse)하여 사용
+        
         latest_candle = None
+        # 'realtime' 쿼리 파라미터가 True인 경우, 현재가를 반영한 실시간 캔들 생성
         if realtime:
             try:
                 price_data = await korea_investment_api.get_current_price(stock_code)
                 if price_data and price_data.get("output"):
                     o = price_data["output"]
-                    # 현재가를 마지막(최신) 캔들로 보정 (지표 계산 시 영향 최소화 위해 기존 첫 캔들과 가격 다르면 prepend)
+                    # 현재가, 고가, 저가, 시가 등의 정보를 파싱하여 실시간 캔들 데이터 구성
                     current_price = float(str(o.get("stck_prpr", "0")).replace(",", ""))
                     high_price = float(str(o.get("stck_hgpr", "0")).replace(",", ""))
                     low_price = float(str(o.get("stck_lwpr", "0")).replace(",", ""))
@@ -188,14 +302,16 @@ async def get_stock_chart(
                         "volume": volume,
                         "realtime": True
                     }
-                    # 기존 첫 번째 캔들의 날짜와 같으면 교체, 다르면 맨 앞에 추가
+                    # 기존 차트 데이터의 첫 번째(가장 최신) 캔들이 오늘 날짜와 같으면 교체, 아니면 맨 앞에 추가
                     if chart_data and chart_data[0]["date"] == latest_candle["date"]:
                         chart_data[0] = latest_candle
                     else:
                         chart_data.insert(0, latest_candle)
             except Exception as e:
+                # 실시간 캔들 생성 실패 시 경고 로그 기록
                 logger.warning(f"실시간 현재가 캔들 생성 실패: {e}")
 
+        # 최종 차트 데이터를 딕셔너리 형태로 반환
         return {
             "stock_code": stock_code,
             "period": period,
@@ -206,9 +322,9 @@ async def get_stock_chart(
         }
     
     except Exception as e:
-        # 외부 API 실패 시 개발 편의를 위해 샘플 데이터 제공 (이유 포함)
+        # API 호출 등에서 예외 발생 시, 개발 편의를 위해 샘플 데이터를 반환
         sample = _generate_sample_chart(stock_code, period)
-        sample["error"] = str(e)
+        sample["error"] = str(e) # 에러 메시지 포함
         sample["is_sample"] = True
         sample["realtime"] = False
         sample["latest"] = None
@@ -217,19 +333,19 @@ async def get_stock_chart(
 
 @router.get("/news")
 async def get_market_news(limit: int = 10):
-    """시장 뉴스 조회 (네이버 금융 RSS)"""
-    import feedparser
+    """시장 뉴스 조회 엔드포인트 (Google News RSS 활용)"""
+    import feedparser # RSS 파싱을 위한 라이브러리
     from datetime import datetime
     
     try:
-        # 네이버 금융 증권 뉴스 RSS
-        feed_url = "https://news.naver.com/main/list.naver?mode=LSD&mid=sec&sid1=101&listType=title"
+        # Google News에서 '한국 증시 주식' 키워드로 검색한 결과의 RSS 주소
         rss_url = "https://news.google.com/rss/search?q=한국+증시+주식&hl=ko&gl=KR&ceid=KR:ko"
         
         # RSS 피드 파싱
         feed = feedparser.parse(rss_url)
         
         news_list = []
+        # 조회할 개수(limit)만큼 반복하여 뉴스 항목 추출
         for idx, entry in enumerate(feed.entries[:limit]):
             news_list.append({
                 "id": idx + 1,
@@ -243,7 +359,7 @@ async def get_market_news(limit: int = 10):
         return news_list
     
     except Exception as e:
-        # 에러 발생 시 샘플 데이터 반환
+        # 에러 발생 시 미리 정의된 샘플 뉴스 데이터 반환
         return [
             {
                 "id": 1,
@@ -270,3 +386,290 @@ async def get_market_news(limit: int = 10):
                 "url": "#"
             }
         ][:limit]
+
+
+@router.get("/orderbook/{stock_code}")
+async def get_orderbook(stock_code: str):
+    """호가 정보 조회 엔드포인트 (매수/매도 10단계 호가)"""
+    try:
+        logger.info(f"🔍 Fetching orderbook for stock: {stock_code}")
+        # 한국투자증권 API를 통해 호가 데이터 조회
+        data = await korea_investment_api.get_orderbook(stock_code)
+        
+        # API 응답 코드가 '0'(성공)이 아닌 경우 에러 처리
+        if data.get("rt_cd") != "0":
+            logger.error(f"❌ Orderbook API error for {stock_code}: rt_cd={data.get('rt_cd')}, msg={data.get('msg1')}")
+            raise HTTPException(status_code=404, detail=data.get("msg1", "Orderbook data not found"))
+        
+        # API 응답에서 output1(호가), output2(체결가) 데이터 추출
+        output1 = data.get("output1", {})
+        output2 = data.get("output2", {})
+        
+        # 현재가와 누적 거래량 정보 추출
+        current_price = 0
+        current_volume = 0
+        if output2 and output2.get("stck_prpr"):
+            current_price = int(output2.get("stck_prpr", 0))
+            current_volume = int(output2.get("acml_vol", 0) or 0)
+        elif output1.get("stck_prpr"):
+            current_price = int(output1.get("stck_prpr", 0))
+            current_volume = int(output1.get("acml_vol", 0) or 0)
+
+        # 호가 데이터를 담을 딕셔너리 초기화
+        orderbook = {
+            "stock_code": stock_code,
+            "stock_name": output1.get("hts_kor_isnm", ""),
+            "current_price": current_price,
+            "current_volume": current_volume,
+            "asks": [],  # 매도 호가 (낮은 가격 -> 높은 가격 순으로 임시 저장 후 reverse)
+            "bids": [],  # 매수 호가 (높은 가격 -> 낮은 가격 순)
+            "total_ask_volume": 0,
+            "total_bid_volume": 0,
+        }
+        
+        # 디버깅을 위한 원본 매도호가 데이터 로그
+        logger.info(f"📊 [{stock_code}] 매도호가 원본 데이터:")
+        for i in range(1, 11):
+            price = output1.get(f"askp{i}", 0)
+            volume = output1.get(f"askp_rsqn{i}", 0)
+            logger.info(f"  askp{i}: {price} ({volume}주)")
+        
+        # 디버깅을 위한 원본 매수호가 데이터 로그
+        logger.info(f"📊 [{stock_code}] 매수호가 원본 데이터:")
+        for i in range(1, 11):
+            price = output1.get(f"bidp{i}", 0)
+            volume = output1.get(f"bidp_rsqn{i}", 0)
+            logger.info(f"  bidp{i}: {price} ({volume}주)")
+        
+        # 매도호가 10단계 파싱 (askp1 ~ askp10)
+        temp_asks = []
+        for i in range(1, 11):
+            price = int(output1.get(f"askp{i}", 0) or 0)
+            volume = int(output1.get(f"askp_rsqn{i}", 0) or 0)
+            if price > 0:
+                temp_asks.append({"price": price, "volume": volume})
+                orderbook["total_ask_volume"] += volume
+
+        # UI 표기를 위해 매도호가는 높은 가격이 위로 가도록 리스트를 뒤집음
+        orderbook["asks"] = list(reversed(temp_asks))
+
+        # 매수호가 10단계 파싱 (bidp1 ~ bidp10)
+        for i in range(1, 11):
+            price = int(output1.get(f"bidp{i}", 0) or 0)
+            volume = int(output1.get(f"bidp_rsqn{i}", 0) or 0)
+            if price > 0:
+                orderbook["bids"].append({"price": price, "volume": volume})
+                orderbook["total_bid_volume"] += volume
+        
+        # 최종 파싱 결과 로그
+        logger.info(f"✅ Orderbook {stock_code}: current={current_price}, asks={len(orderbook['asks'])}, bids={len(orderbook['bids'])}")
+        logger.info(f"  파싱된 매도호가: {[ask['price'] for ask in orderbook['asks']]}")
+        logger.info(f"  파싱된 매수호가: {[bid['price'] for bid in orderbook['bids']]}")
+        if orderbook['asks']:
+            logger.info(f"  Best ask: {orderbook['asks'][-1]['price']}") # 가장 낮은 매도호가
+        if orderbook['bids']:
+            logger.info(f"  Best bid: {orderbook['bids'][0]['price']}") # 가장 높은 매수호가
+        
+        return orderbook
+        
+    except HTTPException:
+        # HTTPException은 그대로 다시 발생시킴
+        raise
+    except Exception as e:
+        # 그 외 예외는 500 에러로 처리
+        logger.error(f"Error fetching orderbook for {stock_code}: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to fetch orderbook: {str(e)}")
+
+
+@router.get("/ai-analysis/{stock_code}")
+async def get_ai_analysis(stock_code: str, db: AsyncSession = Depends(get_db)):
+    """AI 기반 종목 분석 엔드포인트 (기술적 지표 + 규칙 기반 분석)"""
+    try:
+        import httpx
+        from app.core.config import settings
+
+        logger.info(f"🤖 AI 분석 요청: {stock_code}")
+
+        # 1. 최신 시장 데이터(현재가 등) 가져오기
+        price_data = await korea_investment_api.get_current_price(stock_code)
+        if price_data.get("rt_cd") != "0":
+            raise HTTPException(status_code=404, detail="시장 데이터를 가져올 수 없습니다")
+
+        output = price_data.get("output", {})
+        current_price = int(output.get("stck_prpr", 0))
+        high_price = int(output.get("stck_hgpr", 0))
+        low_price = int(output.get("stck_lwpr", 0))
+        volume = int(output.get("acml_vol", 0))
+
+        # 2. DB에서 가장 최근의 기술적 지표 분석 데이터 가져오기
+        from app.models.models import StockAnalysis
+        result = await db.execute(
+            select(StockAnalysis)
+            .filter(StockAnalysis.stock_code == stock_code)
+            .order_by(StockAnalysis.analysis_date.desc())
+            .limit(1)
+        )
+        analysis_record = result.scalar_one_or_none()
+
+        indicators = {}
+        if analysis_record:
+            indicators = {
+                "rsi": float(analysis_record.rsi) if analysis_record.rsi else None,
+                "ma5": float(analysis_record.ma5) if analysis_record.ma5 else None,
+                "ma20": float(analysis_record.ma20) if analysis_record.ma20 else None,
+                "ma60": float(analysis_record.ma60) if analysis_record.ma60 else None,
+                "stochastic_k": float(analysis_record.stochastic_k) if analysis_record.stochastic_k else None,
+                "stochastic_d": float(analysis_record.stochastic_d) if analysis_record.stochastic_d else None,
+                "bollinger_upper": float(analysis_record.bollinger_upper) if analysis_record.bollinger_upper else None,
+                "bollinger_middle": float(analysis_record.bollinger_middle) if analysis_record.bollinger_middle else None,
+                "bollinger_lower": float(analysis_record.bollinger_lower) if analysis_record.bollinger_lower else None,
+            }
+
+        # 3. 규칙 기반 분석 로직
+        recommendation = "HOLD"  # 기본 추천: 보유
+        confidence = 0.0        # 신뢰도
+        trend = "SIDEWAYS"      # 추세
+        analysis_text = ""      # 분석 요약 텍스트
+
+        # 매수/매도 신호 점수 계산
+        buy_signals = 0
+        sell_signals = 0
+        total_signals = 0
+
+        # 기술적 지표 데이터가 있는 경우 분석 시작
+        if indicators and any(indicators.values()):
+            signals = [] # 분석된 신호들을 담을 리스트
+
+            # RSI 분석
+            if indicators.get("rsi") is not None:
+                rsi = indicators["rsi"]
+                total_signals += 1
+                if rsi < 30: # 과매도
+                    buy_signals += 1
+                    signals.append(f"RSI 과매도({rsi:.1f})")
+                elif rsi > 70: # 과매수
+                    sell_signals += 1
+                    signals.append(f"RSI 과매수({rsi:.1f})")
+                elif rsi < 40: # 매수 고려
+                    buy_signals += 0.5
+                    signals.append(f"RSI 매수권장({rsi:.1f})")
+                elif rsi > 60: # 매도 고려
+                    sell_signals += 0.5
+                    signals.append(f"RSI 매도권장({rsi:.1f})")
+
+            # 이동평균선(MA) 분석
+            ma5 = indicators.get("ma5")
+            ma20 = indicators.get("ma20")
+            ma60 = indicators.get("ma60")
+
+            if ma5 and ma20:
+                # 현재가와 20일 이동평균선의 괴리율을 계산하여 데이터의 신선도 체크
+                ma_deviation = abs(current_price - ma20) / ma20 if ma20 > 0 else 999
+
+                if ma_deviation < 0.5:  # 괴리율이 50% 미만일 때만 유효한 데이터로 간주
+                    total_signals += 1
+
+                    if ma60 and ma5 > ma20 > ma60: # 정배열 (강한 상승 추세)
+                        buy_signals += 1
+                        trend = "UP"
+                        signals.append("이동평균 정배열(상승)")
+                    elif ma60 and ma5 < ma20 < ma60: # 역배열 (강한 하락 추세)
+                        sell_signals += 1
+                        trend = "DOWN"
+                        signals.append("이동평균 역배열(하락)")                  
+                    elif ma5 < ma20 and current_price < ma20: # 데드크로스 (하락 신호)
+                        sell_signals += 0.5
+                        trend = "DOWN"
+                        signals.append("데드크로스 신호")
+                else:
+                    logger.debug(f"이동평균선 데이터 오래됨 (현재가: {current_price}, MA20: {ma20}, 괴리율: {ma_deviation*100:.1f}%)")
+
+            # 볼린저 밴드 분석
+            bb_upper = indicators.get("bollinger_upper")
+            bb_lower = indicators.get("bollinger_lower")
+            bb_middle = indicators.get("bollinger_middle")
+
+            if bb_upper and bb_lower and bb_middle and bb_upper > bb_lower:
+                # 현재가가 볼린저 밴드 내 어느 위치에 있는지 계산 (0~1)
+                bb_position = (current_price - bb_lower) / (bb_upper - bb_lower)
+
+                # 밴드 위치가 -0.2 ~ 1.2 범위 내에 있을 때만 유효한 데이터로 간주 (괴리율 체크)
+                if -0.2 <= bb_position <= 1.2:
+                    total_signals += 1
+                    if bb_position > 0.8: # 상단 근접 (과매수)
+                        sell_signals += 1
+                        signals.append(f"볼린저 밴드 상단근접({bb_position*100:.0f}%)")
+                    elif bb_position < 0.2: # 하단 근접 (과매도)
+                        buy_signals += 1
+                        signals.append(f"볼린저 밴드 하단근접({bb_position*100:.0f}%)")
+                else:
+                    logger.debug(f"볼린저 밴드 데이터 오래됨 (현재가: {current_price}, 밴드: {bb_lower:.0f}~{bb_upper:.0f}, 위치: {bb_position*100:.0f}%)")
+
+            # 스토캐스틱 분석
+            stoch_k = indicators.get("stochastic_k")
+            stoch_d = indicators.get("stochastic_d")
+
+            if stoch_k is not None and stoch_d is not None:
+                total_signals += 1
+                if stoch_k < 20 and stoch_d < 20: # 과매도
+                    buy_signals += 1
+                    signals.append(f"스토캐스틱 과매도({stoch_k:.1f})")
+                elif stoch_k > 80 and stoch_d > 80: # 과매수
+                    sell_signals += 1
+                    signals.append(f"스토캐스틱 과매수({stoch_k:.1f})")
+                elif stoch_k > stoch_d and stoch_k < 50: # 상승 전환 신호
+                    buy_signals += 0.3
+                    signals.append("스토캐스틱 상승전환")
+                elif stoch_k < stoch_d and stoch_k > 50: # 하락 전환 신호
+                    sell_signals += 0.3
+                    signals.append("스토캐스틱 하락전환")
+
+            # 최종 추천 결정
+            if total_signals > 0:
+                # (매수 신호 - 매도 신호) / 전체 신호 수로 점수 계산
+                signal_score = (buy_signals - sell_signals) / total_signals
+                confidence = min(abs(signal_score), 1.0) # 신뢰도는 점수의 절대값
+
+                if signal_score > 0.3: # 점수가 0.3보다 크면 '매수'
+                    recommendation = "BUY"
+                elif signal_score < -0.3: # 점수가 -0.3보다 작으면 '매도'
+                    recommendation = "SELL"
+                else: # 그 외에는 '보유'
+                    recommendation = "HOLD"
+
+                analysis_text = " | ".join(signals) if signals else "충분한 신호 없음"
+            else:
+                analysis_text = "기술적 지표 데이터 부족"
+        else:
+            analysis_text = "기술적 지표 데이터 없음"
+
+        # 추세 최종 결정 (이동평균선 없으면 가격 변동으로)
+        if trend == "SIDEWAYS" and high_price and low_price and current_price:
+            daily_change_pct = ((current_price - low_price) / low_price) * 100 if low_price > 0 else 0
+            if daily_change_pct > 10:
+                trend = "UP"
+            elif daily_change_pct < -10:
+                trend = "DOWN"
+
+        # 4. 종합 결과 반환
+        return {
+            "stock_code": stock_code,
+            "stock_name": output.get("stck_prdt_name", ""),
+            "current_price": current_price,
+            "high_price": high_price,
+            "low_price": low_price,
+            "volume": volume,
+            "indicators": indicators,
+            "ai_analysis": analysis_text,
+            "recommendation": recommendation,
+            "confidence": confidence,
+            "trend": trend
+        }
+
+    except HTTPException:
+        # HTTPException은 그대로 다시 발생시킴
+        raise
+    except Exception as e:
+        # 그 외 예외는 500 에러로 처리
+        logger.error(f"Error in AI analysis for {stock_code}: {e}")
+        raise HTTPException(status_code=500, detail=f"AI 분석 실패: {str(e)}")
diff --git a/backend/app/api/endpoints/mcp.py b/backend/app/api/endpoints/mcp.py
index 1c532dc..da36eb3 100644
--- a/backend/app/api/endpoints/mcp.py
+++ b/backend/app/api/endpoints/mcp.py
@@ -25,10 +25,13 @@ async def get_mcp_status():
             response = await client.get(f"{settings.MCP_SERVER_URL}/health", timeout=5.0)
             
             if response.status_code == 200:
+                health_data = response.json()
                 return {
                     "status": "connected",
                     "mcp_server_url": settings.MCP_SERVER_URL,
-                    "details": response.json()
+                    "claude_configured": health_data.get("claude_configured", False),
+                    "ai_provider": health_data.get("ai_provider", "unknown"),
+                    "details": health_data
                 }
             else:
                 return {
diff --git a/backend/app/api/endpoints/ml_ensemble.py b/backend/app/api/endpoints/ml_ensemble.py
new file mode 100644
index 0000000..c3f3dee
--- /dev/null
+++ b/backend/app/api/endpoints/ml_ensemble.py
@@ -0,0 +1,170 @@
+"""
+ML 앙상블 API 엔드포인트
+
+- POST /train: 모델 학습
+- GET /predict/{stock_code}: 개별 종목 예측
+- GET /status: 모델 상태 조회
+- GET /backtest: 백테스트 결과
+"""
+
+from fastapi import APIRouter, HTTPException, Query, BackgroundTasks
+import logging
+import asyncio
+
+from app.services.ml_ensemble import get_ensemble
+from app.services.korea_investment_api import korea_investment_api
+from app.core.config import settings
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+
+@router.get("/status")
+async def get_model_status():
+    """앙상블 모델 상태 조회"""
+    ensemble = get_ensemble()
+    status = ensemble.get_status()
+    status["config"] = {
+        "enabled": settings.ML_ENSEMBLE_ENABLED,
+        "rule_weight": settings.ML_ENSEMBLE_RULE_WEIGHT,
+        "ml_weight": settings.ML_ENSEMBLE_ML_WEIGHT,
+        "buy_threshold": settings.ML_ENSEMBLE_BUY_THRESHOLD,
+        "confidence_min": settings.ML_ENSEMBLE_CONFIDENCE_MIN,
+    }
+    return status
+
+
+@router.get("/predict/{stock_code}")
+async def predict_stock(stock_code: str):
+    """개별 종목 ML 앙상블 예측"""
+    ensemble = get_ensemble()
+
+    if not ensemble.is_trained:
+        raise HTTPException(
+            status_code=503,
+            detail="모델이 학습되지 않았습니다. POST /ml-ensemble/train 으로 학습을 먼저 실행하세요."
+        )
+
+    try:
+        chart_resp = await korea_investment_api.get_daily_chart(stock_code, "D")
+        chart_data = chart_resp.get("output", [])
+
+        if not chart_data or len(chart_data) < 61:
+            raise HTTPException(status_code=400, detail=f"차트 데이터 부족: {len(chart_data) if chart_data else 0}일 (최소 61일 필요)")
+
+        result = ensemble.predict(chart_data)
+        result["stock_code"] = stock_code
+
+        return result
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"예측 실패 ({stock_code}): {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def _train_task(limit: int):
+    """백그라운드 학습 작업"""
+    import numpy as np
+    from app.services.feature_engineering import (
+        chart_data_to_dataframe, extract_features, prepare_training_data
+    )
+    from app.services.korea_investment_api import KoreaInvestmentAPI
+
+    kis_api = KoreaInvestmentAPI()
+
+    # 종목 조회
+    stocks = []
+    try:
+        kospi = await kis_api.get_volume_rank("J")
+        if kospi and kospi.get("output"):
+            for item in kospi["output"]:
+                name = item.get("hts_kor_isnm", "")
+                skip = ["ETF", "레버리지", "인버스", "KODEX", "선물", "TIGER", "ARIRANG"]
+                if not any(k in name for k in skip):
+                    stocks.append((item["mksc_shrn_iscd"], name))
+    except Exception as e:
+        logger.error(f"종목 조회 실패: {e}")
+
+    await asyncio.sleep(3)
+
+    try:
+        kosdaq = await kis_api.get_volume_rank("Q")
+        if kosdaq and kosdaq.get("output"):
+            for item in kosdaq["output"]:
+                name = item.get("hts_kor_isnm", "")
+                skip = ["ETF", "레버리지", "인버스", "KODEX", "선물", "TIGER", "ARIRANG"]
+                if not any(k in name for k in skip):
+                    stocks.append((item["mksc_shrn_iscd"], name))
+    except Exception as e:
+        logger.error(f"종목 조회 실패: {e}")
+
+    stocks = stocks[:limit]
+    logger.info(f"학습 대상: {len(stocks)}개 종목")
+
+    # 데이터 수집
+    all_X_tab, all_X_seq, all_y = [], [], []
+    for i, (code, name) in enumerate(stocks):
+        try:
+            chart_resp = await kis_api.get_daily_chart(code, "D")
+            chart_data = chart_resp.get("output", [])
+            if not chart_data or len(chart_data) < 80:
+                continue
+
+            df = chart_data_to_dataframe(chart_data)
+            feat = extract_features(df)
+            X_tab, X_seq, y, _ = prepare_training_data(df, feat)
+            if len(X_tab) > 0:
+                all_X_tab.append(X_tab)
+                all_X_seq.append(X_seq)
+                all_y.append(y)
+                logger.info(f"[{i+1}/{len(stocks)}] {code}: {len(X_tab)}개 샘플")
+        except Exception as e:
+            logger.warning(f"[{i+1}] {code} 실패: {e}")
+        await asyncio.sleep(3)
+
+    if not all_X_tab:
+        logger.error("학습 데이터 없음")
+        return
+
+    X_tabular = np.vstack(all_X_tab)
+    X_seq = np.vstack(all_X_seq)
+    y = np.concatenate(all_y)
+
+    logger.info(f"총 {len(X_tabular)}개 샘플로 학습 시작")
+
+    ensemble = get_ensemble()
+    metrics = ensemble.train(X_tabular, X_seq, y)
+    logger.info(f"학습 완료: {metrics}")
+
+
+@router.post("/train")
+async def train_model(
+    background_tasks: BackgroundTasks,
+    limit: int = Query(50, description="학습 종목 수"),
+):
+    """앙상블 모델 학습 (백그라운드 실행)"""
+    background_tasks.add_task(_train_task, limit)
+    return {
+        "message": f"학습이 백그라운드에서 시작되었습니다 ({limit}개 종목)",
+        "status": "training_started",
+    }
+
+
+@router.get("/backtest")
+async def get_backtest():
+    """모델 학습 메트릭 및 백테스트 결과 조회"""
+    ensemble = get_ensemble()
+    if not ensemble.is_trained:
+        raise HTTPException(status_code=503, detail="모델이 학습되지 않았습니다")
+
+    return {
+        "is_trained": True,
+        "metrics": ensemble.training_metrics,
+        "weights": {
+            "lgbm": ensemble.weights[0],
+            "lstm": ensemble.weights[1],
+            "rf": ensemble.weights[2],
+        },
+    }
diff --git a/backend/app/api/endpoints/portfolio.py b/backend/app/api/endpoints/portfolio.py
index a0f859b..7990e84 100644
--- a/backend/app/api/endpoints/portfolio.py
+++ b/backend/app/api/endpoints/portfolio.py
@@ -1,18 +1,47 @@
+"""
+포트폴리오 API 엔드포인트
+
+- GET /: 보유 종목 목록 조회 (캐시 활용)
+- GET /summary: 포트폴리오 요약 (총자산, 평가손익)
+- GET /sync: 실제 계좌와 동기화
+- POST /sell: 수동 매도 (청산)
+"""
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select
-from typing import List
+from sqlalchemy import select, func
+from typing import List, Optional
 from decimal import Decimal
+from pydantic import BaseModel
+import pytz
 
-from app.core.database import get_db
-from app.models.models import Portfolio
+from app.core.database import get_db, AsyncSessionLocal
+from app.models.models import Portfolio, TradeHistory, ActiveTrade, StockAnalysis, TradeJournal
 from app.services.korea_investment_api import korea_investment_api
+from app.services.mean_reversion_strategy import (
+    calculate_atr, calculate_rsi, calculate_bollinger, check_exit_signal,
+)
+from app.services.mdd_manager import mdd_manager
+from app.services.loss_tracker import loss_tracker
+from app.services.websocket_manager import websocket_manager
 import asyncio
 import logging
 from datetime import datetime, timedelta
 
 logger = logging.getLogger(__name__)
 
+# 한국 시간대
+KST = pytz.timezone('Asia/Seoul')
+
+# Request/Response Models
+class SellRequest(BaseModel):
+    stock_code: str
+    quantity: int
+    price: Optional[int] = None
+
+def _get_kst_now():
+    """현재 한국 시간 반환 (timezone-naive datetime)"""
+    return datetime.now(KST).replace(tzinfo=None)
+
 # 단순 인메모리 캐시 (프로세스 단위). 다중 프로세스 환경이면 Redis 등 필요.
 class PortfolioCache:
     def __init__(self):
@@ -28,6 +57,7 @@ class PortfolioCache:
         self.failure_count: int = 0
         self.next_retry_at: datetime | None = None
         self.last_sync_success: bool = False
+        self.last_trade_id: int | None = None
     
     def mark_changed(self):
         self.change_flag = True
@@ -45,7 +75,7 @@ class PortfolioCache:
                 return False
             # 백오프가 지났으면 재시도 허용 (최소 간격과 무관)
             return True
-        if (now - self.last_synced) > timedelta(minutes=5):  # 주기적 신선도 보장
+        if (now - self.last_synced) > timedelta(seconds=5):  # 실시간: 5초마다 갱신
             return True
         return False
 
@@ -68,19 +98,102 @@ class PortfolioCache:
         self.next_retry_at = None
         self.last_sync_success = True
     
-    def cache_summary(self):
+    def cache_summary(self, balance_data: dict = None):
         holdings = self.holdings
         total_stocks = len(holdings)
         total_value = sum(float(h.current_price or 0) * h.quantity for h in holdings)
         total_investment = sum(float(h.average_price or 0) * h.quantity for h in holdings)
         total_profit_loss = sum(float(h.profit_loss or 0) for h in holdings)
         total_profit_loss_rate = (total_profit_loss / total_investment * 100) if total_investment > 0 else 0
+        
+        # KIS API output2에서 예수금 및 총자산 정보 추출
+        available_cash = 0.0
+        total_assets = 0.0
+        if balance_data:
+            logger.info(f"🔍 KIS API balance response keys: {balance_data.keys()}")
+            if "output2" in balance_data:
+                output2 = balance_data["output2"][0] if isinstance(balance_data["output2"], list) else balance_data["output2"]
+                logger.info(f"📊 output2 keys: {output2.keys()}")
+                logger.info(f"💰 output2 data: {output2}")
+            else:
+                logger.warning("⚠️ No 'output2' in balance_data!")
+        
+        if balance_data and "output2" in balance_data:
+            output2 = balance_data["output2"][0] if isinstance(balance_data["output2"], list) else balance_data["output2"]
+
+            # 가급적 증권사 화면과 동일 기준 사용:
+            # - 현금: D+2 정산 기준 예수금(d2_depo_amt)
+            # - 총자산: 총평가금액(tot_evlu_amt) 우선, 없으면 유가평가+현금 계산
+            # 필드명이 환경에 따라 다를 수 있어 다중 키 체킹
+            def pick_float(d: dict, keys: list[str]) -> float:
+                for k in keys:
+                    if k in d and d.get(k) not in (None, ""):
+                        try:
+                            return float(d.get(k))
+                        except Exception:
+                            continue
+                return 0.0
+
+            # 현금: D+2 정산액 우선 -> 예수금총액 -> 순자산금액 순
+            available_cash = pick_float(output2, [
+                "d2_depo_amt",    # D+2 정산액
+                "d2_deposit",    # 일부 응답 변형 키
+                "dnca_tot_amt",  # 예수금 총액
+                "nass_amt"        # 순자산금액 (fallback)
+            ])
+
+            # 총자산: KIS API의 tot_evlu_amt 사용 (가장 정확)
+            # tot_evlu_amt는 D+2 정산액 + 유가평가액을 포함한 실제 총자산
+            kis_total_assets = pick_float(output2, ["tot_evlu_amt", "tot_evlu_amt_smtl"])
+
+            if kis_total_assets > 0:
+                # KIS API 값 우선 사용
+                total_assets = kis_total_assets
+                calculated_assets = total_value + available_cash
+
+                # 차이가 크면 로그 (정상 - D+2 정산액 때문)
+                if abs(kis_total_assets - calculated_assets) > 1000:
+                    logger.debug(
+                        f"💰 총자산 - KIS API: {kis_total_assets:,.0f}원, "
+                        f"단순계산(현금+주식): {calculated_assets:,.0f}원, "
+                        f"차이: {(kis_total_assets - calculated_assets):,.0f}원 (D+2정산액 포함)"
+                    )
+            else:
+                # KIS API 값이 없으면 계산 (fallback)
+                total_assets = total_value + available_cash
+
+            # 디버깅 로그(요약): 실제 사용된 값과 원본 일부 키 노출
+            try:
+                logger.debug(
+                    "Portfolio summary calc - cash=%s, total_assets=%s, keys=%s",
+                    f"{available_cash:,.0f}",
+                    f"{total_assets:,.0f}",
+                    {k: output2.get(k) for k in [
+                        "d2_depo_amt", "d2_deposit", "dnca_tot_amt", "nass_amt", "tot_evlu_amt"
+                    ] if k in output2}
+                )
+            except Exception:
+                pass
+        
+        # D+2 정산액 및 기타 상세 정보 추출
+        d2_settlement = 0.0
+        stock_value_from_api = 0.0
+
+        if balance_data and "output2" in balance_data:
+            output2 = balance_data["output2"][0] if isinstance(balance_data["output2"], list) else balance_data["output2"]
+            d2_settlement = pick_float(output2, ["nxdy_excc_amt", "d2_auto_rdpt_amt"])
+            stock_value_from_api = pick_float(output2, ["scts_evlu_amt", "evlu_amt_smtl_amt"])
+
         self.summary = {
             "total_stocks": total_stocks,
             "total_value": total_value,
             "total_investment": total_investment,
             "total_profit_loss": total_profit_loss,
-            "total_profit_loss_rate": total_profit_loss_rate
+            "total_profit_loss_rate": total_profit_loss_rate,
+            "available_cash": available_cash,
+            "total_assets": total_assets,
+            "d2_settlement": d2_settlement,  # D+2 정산액
+            "stock_value_from_api": stock_value_from_api  # API의 유가평가액
         }
 
 portfolio_cache = PortfolioCache()
@@ -103,19 +216,37 @@ class PortfolioResponse(BaseModel):
         from_attributes = True
 
 
+async def _get_latest_executed_trade_id(db: AsyncSession) -> int | None:
+    try:
+        result = await db.execute(
+            select(func.max(TradeHistory.id)).where(TradeHistory.status.in_(['EXECUTED', 'COMPLETED']))
+        )
+        return result.scalar_one_or_none()
+    except Exception as e:
+        logger.warning(f"Failed to fetch latest trade id: {e}")
+        return None
+
+
 @router.get("", response_model=List[PortfolioResponse])
 async def get_portfolio(db: AsyncSession = Depends(get_db)):
     """포트폴리오 조회 (캐시 활용)"""
+    # 거래 이력 기준으로 캐시 무효화
+    latest_trade_id = await _get_latest_executed_trade_id(db)
+    if latest_trade_id and portfolio_cache.last_trade_id != latest_trade_id:
+        portfolio_cache.mark_changed()
+
     if portfolio_cache.holdings and not portfolio_cache.should_sync():
         logger.debug("Portfolio cache hit (holdings)")
-        return portfolio_cache.holdings
+        # 수량 0인 종목 필터링 (안전장치)
+        return [h for h in portfolio_cache.holdings if h.quantity > 0]
     # 필요하면 동기화 시도
     try:
         await sync_portfolio(db, force=False)
     except HTTPException:
         # 강제 동기화가 아닌 경우에는 오류를 사용자에게 전파하지 않고 캐시/빈 목록 반환
         logger.warning("get_portfolio: sync failed, returning cached holdings")
-    return portfolio_cache.holdings
+    # 수량 0인 종목 필터링 (안전장치)
+    return [h for h in portfolio_cache.holdings if h.quantity > 0]
 
 
 @router.get("/sync")
@@ -126,11 +257,71 @@ async def sync_portfolio(db: AsyncSession = Depends(get_db), force: bool = True)
     if not force and not portfolio_cache.should_sync():
         logger.debug("Skip sync: cache fresh & no change flag")
         return {"message": "Skipped (cache fresh)", "cached": True}
-    async with portfolio_cache.sync_lock:
+    # 락 획득에 30초 타임아웃 적용 (이전 sync hang 시 데드락 방지)
+    try:
+        await asyncio.wait_for(portfolio_cache.sync_lock.acquire(), timeout=30)
+    except asyncio.TimeoutError:
+        portfolio_cache.record_failure("Sync lock timeout (30s)")
+        logger.error("Portfolio sync lock timeout — 이전 sync가 30초 이상 hang 중")
+        if force:
+            raise HTTPException(status_code=503, detail="Portfolio sync timeout")
+        return {"message": "Sync timeout (using cache)", "cached": True}
+    try:
         portfolio_cache.last_attempt = datetime.now()
         try:
             balance_data = await korea_investment_api.get_balance()
+
+            # 디버깅: KIS API 전체 응답 로깅
+            logger.info(f"🔍 KIS API balance response keys: {balance_data.keys() if balance_data else 'None'}")
+
+            # Balance API 오류 시 기존 DB 보유종목을 삭제하지 않고 캐시 유지
+            if not balance_data or balance_data.get('rt_cd') != '0':
+                error_msg = balance_data.get('msg1', 'Unknown error') if balance_data else 'No response'
+                logger.warning(f"⚠️ Balance API 오류 - 기존 포트폴리오 유지: {error_msg}")
+                # 캐시가 비어있으면 DB에서 로드
+                if not portfolio_cache.holdings:
+                    result = await db.execute(select(Portfolio).where(Portfolio.quantity > 0))
+                    portfolio_cache.holdings = list(result.scalars().all())
+                    logger.info(f"📦 DB에서 포트폴리오 로드: {len(portfolio_cache.holdings)}종목")
+                return {"message": f"Balance API error: {error_msg}", "cached": True, "count": len(portfolio_cache.holdings)}
+
             portfolio_cache.record_success()
+
+            if "output1" in balance_data and balance_data["output1"]:
+                logger.info(f"🔍 output1 count: {len(balance_data['output1'])}")
+            
+            # 1. 오늘 발생한 모든 매매 이력 조회 (Ghost Stock 방지 - 시간 범위 확대)
+            now = _get_kst_now()
+            # 오늘의 시작 시간 (00:00:00) 계산
+            today_start = now.replace(hour=0, minute=0, second=0, microsecond=0)
+            
+            # 오늘 포함 최근 24시간 (혹시 자정 근처 이슈 방지)이지만, 주로 '최근 행동'이 중요함.
+            # 안전하게 '오늘 0시 이후'의 모든 거래를 가져옴.
+            recent_point = today_start
+            
+            logger.info(f"🔎 Checking recent trades since {recent_point} for Ghost detection")
+            
+            # 복잡한 SQL 대신 단순 조회 후 애플리케이션 레벨에서 필터링
+            trades_stmt = select(TradeHistory).where(
+                TradeHistory.executed_at >= recent_point,
+                TradeHistory.status.in_(['EXECUTED', 'COMPLETED'])
+            ).order_by(TradeHistory.executed_at.asc())
+            
+            trade_result = await db.execute(trades_stmt)
+            recent_trades = trade_result.scalars().all()
+            
+            # 종목별 최신 상태 추적
+            stock_status_map = {}
+            for t in recent_trades:
+                stock_status_map[t.stock_code] = t.order_type # 덮어쓰기 (마지막이 최신)
+                logger.debug(f"Trade trace: {t.stock_name}({t.stock_code}) -> {t.order_type} at {t.executed_at}")
+            
+            # 최신 상태가 'SELL'인 종목 식별
+            ghost_candidates = {code for code, status in stock_status_map.items() if status == "SELL"}
+            
+            if ghost_candidates:
+                logger.info(f"🚫 Ghost Stock Candidates (Last action today is SELL): {ghost_candidates}")
+
             # 기존 레코드 로드 (삭제 대신 업데이트)
             result = await db.execute(select(Portfolio))
             existing_all = {p.stock_code: p for p in result.scalars().all()}
@@ -139,14 +330,53 @@ async def sync_portfolio(db: AsyncSession = Depends(get_db), force: bool = True)
             if "output1" in balance_data:
                 for item in balance_data["output1"]:
                     stock_code = item.get("pdno")
+                    
+                    # 최근 최신 거래가 '매도'라면 KIS가 보내줘도 무시 (Ghost Stock 처리)
+                    # 만약 재매수했다면 latest_trades의 type이 'BUY'였을 것이므로 ghost_candidates에 없음.
+                    if stock_code in ghost_candidates:
+                        logger.info(f"👻 Skipping Ghost Stock: {stock_code} (Latest trade was SELL)")
+                        # DB에서도 명시적 삭제
+                        if stock_code in existing_all:
+                            await db.delete(existing_all[stock_code])
+                            logger.info(f"🗑️ Force deleted ghost stock from DB: {stock_code}")
+                        continue
+
                     stock_name = item.get("prdt_name")
                     quantity = int(item.get("hldg_qty", 0))
                     if quantity <= 0:
+                        logger.debug(f"Skipping {stock_name}({stock_code}) with 0 quantity")
                         continue
-                    average_price = Decimal(item.get("pchs_avg_pric", 0))
-                    current_price = Decimal(item.get("prpr", 0))
-                    profit_loss = Decimal(item.get("evlu_pfls_amt", 0))
-                    profit_loss_rate = Decimal(item.get("evlu_pfls_rt", 0))
+                    
+                    # KIS API 필드명 정확히 매핑 (로깅 추가)
+                    average_price = Decimal(str(item.get("pchs_avg_pric", 0)))
+
+                    # 🔥 실시간 현재가 조회 (잔고 조회의 prpr은 실시간이 아님)
+                    try:
+                        price_resp = await korea_investment_api.get_current_price(stock_code)
+                        if price_resp and "output" in price_resp:
+                            realtime_price = int(price_resp["output"].get("stck_prpr", 0))
+                            if realtime_price > 0:
+                                current_price = Decimal(str(realtime_price))
+                            else:
+                                current_price = Decimal(str(item.get("prpr", 0)))
+                        else:
+                            current_price = Decimal(str(item.get("prpr", 0)))
+                    except Exception as e:
+                        logger.warning(f"⚠️ 실시간 현재가 조회 실패 ({stock_code}): {e}, fallback to prpr")
+                        current_price = Decimal(str(item.get("prpr", 0)))
+                    
+                    # 평가손익 및 수익률 - KIS API에서 제공하는 값 우선 사용
+                    profit_loss = Decimal(str(item.get("evlu_pfls_amt", 0)))
+                    profit_loss_rate = Decimal(str(item.get("evlu_pfls_rt", 0)))
+                    
+                    # 디버깅: 실제 KIS API 응답 로깅
+                    logger.info(
+                        f"Portfolio sync - {stock_name}({stock_code}): "
+                        f"수량={quantity}, 평균단가={average_price}, 현재가={current_price}, "
+                        f"평가손익={profit_loss}, 수익률={profit_loss_rate}% | "
+                        f"원본 필드={item}"
+                    )
+                    
                     processed_codes.add(stock_code)
                     if stock_code in existing_all:
                         h = existing_all[stock_code]
@@ -169,15 +399,25 @@ async def sync_portfolio(db: AsyncSession = Depends(get_db), force: bool = True)
                         )
                         db.add(new_holding)
                         new_holdings.append(new_holding)
-            # 제거된 종목 반영 (수량 0 처리)
+            # 제거된 종목 반영 (DB에서 완전 삭제)
             for code, h in existing_all.items():
                 if code not in processed_codes:
-                    h.quantity = 0
+                    # 보호 로직: 최근 매수 종목이면 API 미반영 상태로 간주하고 유지
+                    # (KIS API가 체결 직후 잔고 반영이 느릴 수 있음)
+                    last_action = stock_status_map.get(code)
+                    if last_action == "BUY" and h.quantity > 0:
+                        logger.info(f"🛡️ Preserving {h.stock_name}({code}) - API calls it missing, but recent BUY exists")
+                        new_holdings.append(h)
+                        continue
+
+                    logger.info(f"🗑️ Deleting {h.stock_name}({code}) from portfolio DB (not in KIS API response)")
+                    await db.delete(h)
             await db.commit()
             portfolio_cache.holdings = [h for h in new_holdings if h.quantity > 0]
-            portfolio_cache.cache_summary()
+            portfolio_cache.cache_summary(balance_data)  # balance_data 전달
             portfolio_cache.last_synced = datetime.now()
             portfolio_cache.change_flag = False
+            portfolio_cache.last_trade_id = await _get_latest_executed_trade_id(db)
             logger.info(f"Portfolio synced: {len(portfolio_cache.holdings)} holdings")
             return {"message": "Portfolio synchronized", "count": len(portfolio_cache.holdings), "cached": False}
         except Exception as e:
@@ -188,11 +428,18 @@ async def sync_portfolio(db: AsyncSession = Depends(get_db), force: bool = True)
                 raise HTTPException(status_code=502, detail=f"Failed to sync portfolio: {e}")
             # 비강제(백그라운드) 동기화 실패 시에는 캐시/빈 값 사용
             return {"message": "Sync failed (using cache)", "cached": True, "error": str(e)}
+    finally:
+        portfolio_cache.sync_lock.release()
 
 
 @router.get("/summary")
 async def get_portfolio_summary(db: AsyncSession = Depends(get_db)):
     """포트폴리오 요약 (캐시 활용)"""
+    # 거래 이력 기준으로 캐시 무효화
+    latest_trade_id = await _get_latest_executed_trade_id(db)
+    if latest_trade_id and portfolio_cache.last_trade_id != latest_trade_id:
+        portfolio_cache.mark_changed()
+
     if portfolio_cache.summary and not portfolio_cache.should_sync():
         logger.debug("Portfolio cache hit (summary)")
         resp = dict(portfolio_cache.summary)
@@ -211,7 +458,9 @@ async def get_portfolio_summary(db: AsyncSession = Depends(get_db)):
         "total_value": 0,
         "total_investment": 0,
         "total_profit_loss": 0,
-        "total_profit_loss_rate": 0
+        "total_profit_loss_rate": 0,
+        "available_cash": 0,
+        "total_assets": 0
     }
     resp = dict(base)
     resp.update({
@@ -226,3 +475,402 @@ async def refresh_portfolio(db: AsyncSession = Depends(get_db)):
     """강제 캐시 무효화 및 재동기화"""
     portfolio_cache.change_flag = True
     return await sync_portfolio(db, force=True)
+
+
+async def check_and_execute_exit_trades(db: AsyncSession):
+    """
+    보유 종목의 손절/익절 조건을 체크하고 자동 매도 실행
+    CLAUDE.md 섹션 6.2 + 7.3 + 7.4 기반:
+    - ATR 기반 손절: min(최저가 - 2.5×ATR, 진입가 -8%)
+    - 1차 익절(50%): RSI ≥ 50 + BB 중앙선 상회
+    - 2차 익절(전량): RSI 60~70 + BB 상단선
+    - 폴백: 고정 비율 손절 (STOP_LOSS_PERCENT)
+    """
+    from app.core.config import settings
+    from datetime import datetime
+
+    try:
+        await sync_portfolio(db, force=True)
+
+        # MDD 업데이트 (async — thread-safe lock 내부)
+        summary = await _get_portfolio_summary(db)
+        total_assets = float(summary.get("total_assets", 0)) if summary else 0
+        mdd_action = await mdd_manager.update(total_assets)
+        if mdd_action["action"] != "NONE":
+            logger.warning(f"MDD 조치: {mdd_action}")
+
+        result = await db.execute(
+            select(Portfolio).where(Portfolio.quantity > 0)
+        )
+        holdings = result.scalars().all()
+
+        if not holdings:
+            logger.debug("No holdings to check for exit conditions")
+            return
+
+        executed_exits = []
+
+        for holding in holdings:
+            try:
+                stock_code = holding.stock_code
+                stock_name = holding.stock_name
+                quantity = holding.quantity
+                avg_price = float(holding.average_price or 0)
+
+                # 실시간 가격 확인
+                price_resp = await korea_investment_api.get_current_price(stock_code)
+                latest_price = float(holding.current_price or 0)
+                if price_resp and price_resp.get("output"):
+                    latest_price = int(price_resp["output"].get("stck_prpr", latest_price))
+
+                if latest_price <= 0 or avg_price <= 0:
+                    continue
+
+                profit_loss_rate = ((latest_price - avg_price) / avg_price) * 100
+
+                # ActiveTrade 조회 (분할 청산 상태 추적)
+                at_result = await db.execute(
+                    select(ActiveTrade).where(
+                        ActiveTrade.stock_code == stock_code,
+                        ActiveTrade.status == "active"
+                    )
+                )
+                active_trade = at_result.scalar_one_or_none()
+                remaining_pct = float(active_trade.remaining_pct) if active_trade and active_trade.remaining_pct else 1.0
+
+                # ATR 기반 청산 시도 (차트 데이터 필요)
+                exit_signal = None
+                try:
+                    chart_resp = await korea_investment_api.get_daily_chart(stock_code, "D", limit=30)
+                    chart_data = chart_resp.get("output2", [])
+                    if len(chart_data) >= 20:
+                        closes = [float(d.get("stck_clpr", 0)) for d in reversed(chart_data)]
+                        highs = [float(d.get("stck_hgpr", 0)) for d in reversed(chart_data)]
+                        lows = [float(d.get("stck_lwpr", 0)) for d in reversed(chart_data)]
+
+                        atr = calculate_atr(highs, lows, closes)
+                        rsi = calculate_rsi(closes)
+                        bb = calculate_bollinger(closes)
+
+                        if atr and rsi is not None and bb:
+                            bb_upper, bb_middle, bb_lower = bb
+                            lowest_since = min(lows[-5:]) if lows else avg_price
+                            exit_signal = check_exit_signal(
+                                rsi=rsi,
+                                close=latest_price,
+                                bb_upper=bb_upper,
+                                bb_middle=bb_middle,
+                                bb_lower=bb_lower,
+                                entry_price=avg_price,
+                                atr=atr,
+                                lowest_since_entry=lowest_since,
+                                remaining_pct=remaining_pct,
+                            )
+                except Exception as chart_err:
+                    logger.debug(f"ATR 청산 계산 실패 ({stock_code}): {chart_err}")
+
+                should_exit = False
+                exit_reason = ""
+                sell_quantity = quantity
+                order_price = latest_price
+
+                if exit_signal:
+                    should_exit = True
+                    exit_reason = exit_signal.reason
+                    if exit_signal.action == "SELL_PARTIAL":
+                        sell_quantity = max(1, int(quantity * exit_signal.sell_pct))
+                    logger.info(f"ATR 청산: {stock_name} - {exit_reason} (매도 {sell_quantity}주)")
+                elif profit_loss_rate <= settings.STOP_LOSS_PERCENT:
+                    # 폴백: 고정 비율 손절 (-6%)
+                    should_exit = True
+                    exit_reason = f"고정 손절 ({profit_loss_rate:.2f}% <= {settings.STOP_LOSS_PERCENT}%)"
+                elif profit_loss_rate >= settings.TAKE_PROFIT_PERCENT:
+                    should_exit = True
+                    exit_reason = f"고정 익절 ({profit_loss_rate:.2f}% >= {settings.TAKE_PROFIT_PERCENT}%)"
+
+                if should_exit:
+                    logger.info(f"{exit_reason} - {stock_name}({stock_code})")
+                    try:
+                        order_result = await korea_investment_api.place_order(
+                            stock_code=stock_code,
+                            order_type="SELL",
+                            quantity=sell_quantity,
+                            price=order_price
+                        )
+                    except Exception as e:
+                        logger.warning(f"지정가 실패, 시장가 대체: {e}")
+                        order_result = await korea_investment_api.place_order(
+                            stock_code=stock_code,
+                            order_type="SELL",
+                            quantity=sell_quantity,
+                            price=None
+                        )
+
+                    executed_price = Decimal(str(order_result.get("output", {}).get("ord_prc", order_price)))
+                    total_amount = Decimal(str(executed_price)) * sell_quantity
+                    profit_loss = (float(executed_price) - avg_price) * sell_quantity
+
+                    trade = TradeHistory(
+                        stock_code=stock_code,
+                        stock_name=stock_name,
+                        order_type="SELL",
+                        order_price=Decimal(str(order_price)),
+                        order_quantity=sell_quantity,
+                        executed_price=executed_price,
+                        executed_quantity=sell_quantity,
+                        total_amount=total_amount,
+                        status="COMPLETED" if order_result.get("rt_cd") == "0" else "FAILED",
+                        order_id=order_result.get("odno"),
+                        message=f"자동 청산: {profit_loss_rate:.2f}%",
+                        exit_reason=f"{exit_reason}. 평균단가: {avg_price:,.0f}원, 매도가: {latest_price:,.0f}원, 손익: {profit_loss:,.0f}원",
+                        created_at=_get_kst_now(),
+                        executed_at=_get_kst_now() if order_result.get("rt_cd") == "0" else None
+                    )
+                    db.add(trade)
+                    await db.commit()
+
+                    if order_result.get("rt_cd") == "0":
+                        # 연속 손실 추적 (섹션 7.4) — 인메모리 + DB 영속화
+                        is_loss = profit_loss < 0
+                        loss_tracker.record_trade_result(stock_code, is_loss)
+                        await loss_tracker.save_to_db(db, stock_code)
+
+                        # 분할 청산 시 ActiveTrade 잔여 비율 업데이트
+                        if exit_signal and exit_signal.action == "SELL_PARTIAL" and active_trade:
+                            active_trade.remaining_pct = Decimal(str(remaining_pct - exit_signal.sell_pct))
+                            await db.commit()
+                        else:
+                            # 전량 매도
+                            holding.quantity = max(0, quantity - sell_quantity)
+                            holding.current_price = Decimal(str(latest_price))
+                            if active_trade:
+                                active_trade.status = "closed"
+                            await db.commit()
+
+                        portfolio_cache.mark_changed()
+                        executed_exits.append({
+                            "stock": stock_name,
+                            "reason": exit_reason,
+                            "profit_loss": profit_loss_rate,
+                            "sell_quantity": sell_quantity,
+                        })
+                        logger.info(f"자동 매도 완료: {stock_name} {sell_quantity}주 @ {latest_price:,.0f}원")
+
+                        # 매매일지 백그라운드 생성
+                        asyncio.create_task(_create_journal_background(
+                            trade_id=trade.id,
+                            stock_code=stock_code,
+                            stock_name=stock_name,
+                            order_type="SELL",
+                            executed_price=float(executed_price),
+                            quantity=sell_quantity,
+                            profit_loss=profit_loss,
+                            profit_loss_rate=profit_loss_rate,
+                            exit_reason=exit_reason,
+                        ))
+
+            except Exception as e:
+                logger.error(f"Exit trade error for {holding.stock_code}: {e}", exc_info=True)
+                continue
+
+        if executed_exits:
+            logger.info(f"Executed {len(executed_exits)} exit trades: {executed_exits}")
+        else:
+            logger.debug("No exit conditions met for current holdings")
+
+    except Exception as e:
+        logger.error(f"check_and_execute_exit_trades error: {e}", exc_info=True)
+
+
+async def _create_journal_background(
+    trade_id: int,
+    stock_code: str,
+    stock_name: str,
+    order_type: str,
+    executed_price: float,
+    quantity: int,
+    profit_loss: float,
+    profit_loss_rate: float,
+    exit_reason: str,
+):
+    """매도 체결 후 AI 매매일지 자동 생성 (백그라운드 태스크)"""
+    try:
+        import httpx
+        from app.core.config import settings
+
+        trade_info = {
+            "stock_code": stock_code,
+            "stock_name": stock_name,
+            "order_type": order_type,
+            "executed_price": executed_price,
+            "quantity": quantity,
+            "profit_loss": profit_loss,
+            "profit_loss_rate": profit_loss_rate,
+            "exit_reason": exit_reason,
+        }
+
+        content = None
+        mood = None
+        tags = []
+
+        # MCP 서버로 AI 일지 생성 요청 (실패 시 규칙 기반 폴백)
+        try:
+            async with httpx.AsyncClient() as client:
+                resp = await client.post(
+                    f"{settings.MCP_SERVER_URL}/analyze",
+                    json={"analysis_type": "GENERATE_JOURNAL", "data": trade_info},
+                    timeout=30.0,
+                )
+                if resp.status_code == 200:
+                    result = resp.json().get("result", {})
+                    content = result.get("content") or result.get("journal") or result.get("analysis")
+                    mood = result.get("mood")
+                    tags = result.get("tags", [])
+        except Exception as mcp_err:
+            logger.debug(f"MCP 일지 생성 실패 ({stock_code}): {mcp_err}")
+
+        # 폴백: 규칙 기반 간단 일지
+        if not content:
+            direction = "익절" if profit_loss_rate > 0 else "손절"
+            sign = "+" if profit_loss > 0 else ""
+            content = (
+                f"{stock_name}({stock_code}) 매도 체결.\n"
+                f"매도가: {executed_price:,.0f}원 × {quantity}주\n"
+                f"손익: {sign}{profit_loss:,.0f}원 ({sign}{profit_loss_rate:.2f}%)\n"
+                f"사유: {exit_reason}"
+            )
+            mood = "좋음" if profit_loss > 0 else "나쁨"
+            tags = [direction, stock_code]
+
+        # DB 저장 (별도 세션 사용 — 호출 시점의 세션은 이미 닫혔을 수 있음)
+        async with AsyncSessionLocal() as session:
+            journal = TradeJournal(
+                trade_id=trade_id,
+                stock_code=stock_code,
+                stock_name=stock_name,
+                journal_date=datetime.utcnow(),
+                content=content,
+                strategy_name="AUTO_TRADE",
+                mood=mood,
+                tags=tags if tags else None,
+            )
+            session.add(journal)
+            await session.commit()
+            logger.info(f"매매일지 생성 완료: {stock_name} (trade_id={trade_id})")
+
+        # WebSocket으로 프론트엔드에 즉시 알림
+        await websocket_manager.broadcast_json({
+            "type": "journal_created",
+            "data": {"stock_code": stock_code, "stock_name": stock_name},
+        })
+    except Exception as e:
+        logger.error(f"매매일지 생성 오류 ({stock_code}): {e}", exc_info=True)
+
+
+async def _get_portfolio_summary(db: AsyncSession) -> dict:
+    """포트폴리오 요약 (MDD 계산용)"""
+    try:
+        result = await db.execute(select(Portfolio).where(Portfolio.quantity > 0))
+        holdings = result.scalars().all()
+        total_eval = sum(float(h.current_price or 0) * h.quantity for h in holdings)
+        total_invest = sum(float(h.average_price or 0) * h.quantity for h in holdings)
+        return {"total_assets": total_eval, "total_invest": total_invest}
+    except Exception:
+        return {"total_assets": 0, "total_invest": 0}
+
+
+@router.post("/sell")
+async def sell_stock(
+    request: SellRequest,
+    db: AsyncSession = Depends(get_db)
+):
+    """보유 종목 수동 매도 (청산 버튼)"""
+    try:
+        stock_code = request.stock_code
+        quantity = request.quantity
+        price = request.price
+
+        logger.info(f"🔵 수동 매도 요청: {stock_code} {quantity}주 @ {price or '시장가'}")
+
+        # 보유 여부 확인
+        result = await db.execute(
+            select(Portfolio).where(Portfolio.stock_code == stock_code)
+        )
+        holding = result.scalar_one_or_none()
+
+        if not holding:
+            raise HTTPException(status_code=404, detail=f"보유하지 않은 종목입니다: {stock_code}")
+
+        if holding.quantity < quantity:
+            raise HTTPException(
+                status_code=400,
+                detail=f"보유 수량 부족: {holding.quantity}주 보유 중, {quantity}주 매도 요청"
+            )
+
+        # 매도 주문 실행
+        order_result = await korea_investment_api.place_order(
+            stock_code=stock_code,
+            order_type='SELL',
+            quantity=quantity,
+            price=price  # None이면 시장가
+        )
+
+        if not order_result or order_result.get('rt_cd') != '0':
+            error_msg = order_result.get('msg1', '알 수 없는 오류') if order_result else 'API 호출 실패'
+            raise HTTPException(status_code=500, detail=f"매도 주문 실패: {error_msg}")
+
+        # TradeHistory 기록
+        executed_price = price if price else holding.current_price  # 체결가는 나중에 업데이트
+        profit_loss = (executed_price - holding.average_price) * quantity
+        profit_loss_rate = ((executed_price / holding.average_price) - 1) * 100
+
+        trade = TradeHistory(
+            stock_code=stock_code,
+            stock_name=holding.stock_name,
+            order_type='SELL',
+            order_price=Decimal(str(price)) if price else None,
+            order_quantity=quantity,
+            executed_price=Decimal(str(executed_price)),
+            executed_quantity=quantity,
+            total_amount=Decimal(str(executed_price * quantity)),
+            status='EXECUTED',
+            order_id=order_result.get('output', {}).get('ODNO'),
+            message=f"수동 청산: 손익 {profit_loss:+,.0f}원 ({profit_loss_rate:+.2f}%)",
+            exit_reason=f"사용자 수동 청산 (손익: {profit_loss:+,.0f}원, 손익률: {profit_loss_rate:+.2f}%)",
+            created_at=_get_kst_now(),
+            executed_at=_get_kst_now()
+        )
+        db.add(trade)
+        await db.commit()
+
+        # 포트폴리오 캐시 무효화
+        portfolio_cache.mark_changed()
+
+        logger.info(f"✅ 수동 매도 완료: {holding.stock_name} {quantity}주 @ {executed_price:,.0f}원 (손익: {profit_loss:+,.0f}원)")
+
+        # 매매일지 백그라운드 생성
+        asyncio.create_task(_create_journal_background(
+            trade_id=trade.id,
+            stock_code=stock_code,
+            stock_name=holding.stock_name,
+            order_type="SELL",
+            executed_price=float(executed_price),
+            quantity=quantity,
+            profit_loss=float(profit_loss),
+            profit_loss_rate=float(profit_loss_rate),
+            exit_reason=f"수동 청산 (손익: {profit_loss:+,.0f}원, {profit_loss_rate:+.2f}%)",
+        ))
+
+        return {
+            "success": True,
+            "message": f"{holding.stock_name} {quantity}주 매도 주문 완료",
+            "order_id": order_result.get('output', {}).get('ODNO'),
+            "profit_loss": float(profit_loss),
+            "profit_loss_rate": float(profit_loss_rate)
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Manual sell error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"매도 처리 중 오류: {str(e)}")
diff --git a/backend/app/api/endpoints/recommendations.py b/backend/app/api/endpoints/recommendations.py
index 52ce90e..7967a08 100644
--- a/backend/app/api/endpoints/recommendations.py
+++ b/backend/app/api/endpoints/recommendations.py
@@ -1,20 +1,114 @@
 from fastapi import APIRouter, HTTPException, Query, Depends
 from typing import List, Optional
 from pydantic import BaseModel
-from datetime import datetime, date
+from datetime import datetime, date, timedelta
 from decimal import Decimal
 import asyncio
 import logging
+import httpx
+import pytz
 
 from app.services.korea_investment_api import korea_investment_api
-from app.core.database import get_db
+from app.core.database import get_db, AsyncSessionLocal
 from app.models.models import TradeHistory, Portfolio, StockAnalysis
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, and_
+from sqlalchemy import select, and_, desc
+
+from app.core.config import settings
+from app.core.market_schedule import is_market_open
+from app.services.mean_reversion_strategy import (
+    MarketRegime, detect_market_regime, check_buy_signal,
+    calculate_atr, calculate_adx, calculate_rsi, calculate_bollinger, is_reversal_candle,
+)
+from app.services.mdd_manager import mdd_manager
+from app.services.loss_tracker import loss_tracker
 
 router = APIRouter()
 logger = logging.getLogger(__name__)
 
+# 한국 시간대
+KST = pytz.timezone('Asia/Seoul')
+
+def _get_kst_now():
+    """현재 한국 시간 반환 (timezone-naive datetime)"""
+    return datetime.now(KST).replace(tzinfo=None)
+
+# Trend filter defaults (configurable via settings)
+TREND_FILTER_ENABLED = getattr(settings, "TREND_FILTER_ENABLED", True)
+TREND_MA_SHORT = int(getattr(settings, "TREND_MA_SHORT", 20))
+TREND_MA_LONG = int(getattr(settings, "TREND_MA_LONG", 60))
+TREND_TOLERANCE_PCT = float(getattr(settings, "TREND_TOLERANCE_PCT", 0.005))
+
+# 급등 과열 필터 defaults
+OVERHEAT_FILTER_ENABLED = getattr(settings, "OVERHEAT_FILTER_ENABLED", True)
+OVERHEAT_3DAY_MAX = float(getattr(settings, "OVERHEAT_3DAY_MAX", 15.0))
+OVERHEAT_5DAY_MAX = float(getattr(settings, "OVERHEAT_5DAY_MAX", 20.0))
+OVERHEAT_10DAY_MAX = float(getattr(settings, "OVERHEAT_10DAY_MAX", 30.0))
+OVERHEAT_DISPARITY_MAX = float(getattr(settings, "OVERHEAT_DISPARITY_MAX", 108.0))
+
+
+def _ma(values: list, window: int) -> Optional[float]:
+    try:
+        if len(values) < window:
+            return None
+        return sum(values[-window:]) / window
+    except Exception:
+        return None
+
+
+def _passes_uptrend(closes: list, ma_short: int = TREND_MA_SHORT, ma_long: int = TREND_MA_LONG, tol: float = TREND_TOLERANCE_PCT) -> Optional[bool]:
+    if not closes or len(closes) < max(ma_short, ma_long):
+        return None
+    ma_s = _ma(closes, ma_short)
+    ma_l = _ma(closes, ma_long)
+    close = closes[-1]
+    if ma_s is None or ma_l is None:
+        return None
+    # 허용 오차 적용: 거의 골든크로스/이탈 직후도 허용
+    return (ma_s >= ma_l * (1 - tol)) and (close >= ma_s * (1 - tol))
+
+
+def analyze_overheat(closes: list, ma20: Optional[float]) -> dict:
+    """급등 과열 필터 - 단기 급등 종목 매수 차단
+
+    3일/5일/10일 상승률과 20일선 이격도를 종합 판단하여
+    고점 추격 매수를 원천 차단합니다.
+
+    Returns:
+        {"blocked": bool, "reason": str, "details": dict}
+    """
+    details = {}
+    reasons = []
+
+    if len(closes) >= 4:
+        gain_3d = ((closes[-1] - closes[-4]) / closes[-4]) * 100 if closes[-4] > 0 else 0
+        details["gain_3d"] = round(gain_3d, 1)
+        if gain_3d > OVERHEAT_3DAY_MAX:
+            reasons.append(f"3일 +{gain_3d:.1f}% (>{OVERHEAT_3DAY_MAX}%)")
+
+    if len(closes) >= 6:
+        gain_5d = ((closes[-1] - closes[-6]) / closes[-6]) * 100 if closes[-6] > 0 else 0
+        details["gain_5d"] = round(gain_5d, 1)
+        if gain_5d > OVERHEAT_5DAY_MAX:
+            reasons.append(f"5일 +{gain_5d:.1f}% (>{OVERHEAT_5DAY_MAX}%)")
+
+    if len(closes) >= 11:
+        gain_10d = ((closes[-1] - closes[-11]) / closes[-11]) * 100 if closes[-11] > 0 else 0
+        details["gain_10d"] = round(gain_10d, 1)
+        if gain_10d > OVERHEAT_10DAY_MAX:
+            reasons.append(f"10일 +{gain_10d:.1f}% (>{OVERHEAT_10DAY_MAX}%)")
+
+    if ma20 and ma20 > 0:
+        disparity = (closes[-1] / ma20) * 100
+        details["disparity_20"] = round(disparity, 1)
+        if disparity > OVERHEAT_DISPARITY_MAX:
+            reasons.append(f"이격도 {disparity:.1f}% (>{OVERHEAT_DISPARITY_MAX}%)")
+
+    blocked = len(reasons) > 0
+    reason = "급등과열: " + ", ".join(reasons) if blocked else ""
+
+    return {"blocked": blocked, "reason": reason, "details": details}
+
 
 class RecommendationCriteria(BaseModel):
     """추천 종목 조건"""
@@ -25,6 +119,11 @@ class RecommendationCriteria(BaseModel):
     use_stochastic: bool = False
     use_adx: bool = False
     use_obv: bool = False
+    use_volatility_breakout: bool = False  # 변동성 돌파 전략
+    use_overheat_filter: bool = True  # 급등 과열 필터 (고점 추격 방지)
+    min_volume_ratio: float = 1.0  # 평균 대비 거래량 배수 (1.0 = 필터 없음)
+    max_disparity: float = 200.0  # 최대 이격도 (20일선 대비 %) - 완화
+    for_batch: bool = False  # 배치 분석 모드: 필터 완화, score=0도 반환
 
 
 class StockRecommendation(BaseModel):
@@ -47,11 +146,19 @@ class StockRecommendation(BaseModel):
     bollinger_upper: Optional[float] = None
     bollinger_lower: Optional[float] = None
     bollinger_middle: Optional[float] = None
+    # ML 앙상블 스코어
+    ml_score: Optional[int] = None          # 앙상블 스코어 (0~100)
+    ml_confidence: Optional[float] = None   # 신뢰도 (0~1)
+    ml_signal: Optional[str] = None         # BUY/HOLD/SELL
+    # ATR (배치 저장용 — 이중 API 호출 방지)
+    atr_14: Optional[float] = None
+    # ADX (추세 강도 — 평균회귀 필터용)
+    adx_14: Optional[float] = None
 
 
 # 공식 기반 신호 분석 함수 (이동평균 정배열/역배열, 눌림목, 손절/익절)
 def analyze_custom_signals(chart_data):
-    """커스텀 매매 공식 기반 신호 분석"""
+    """커스텀 매매 공식 기반 신호 분석 - 이격도 필터 적용"""
     closes = [float(item.get("stck_clpr", 0)) for item in chart_data]
     if len(closes) < 120:
         return None
@@ -61,18 +168,34 @@ def analyze_custom_signals(chart_data):
     ma120 = sum(closes[-120:]) / 120
     close = closes[-1]
     
-    # 정배열 매수
+    # 🔥 이격도 계산 (추격 매수 방지) - 더 엄격하게
+    disparity = (close / ma20) * 100
+
+    # 🚫 급등 종목 필터: 최근 3일 상승률 체크
+    if len(closes) >= 3:
+        price_3days_ago = closes[-4]
+        recent_gain = ((close - price_3days_ago) / price_3days_ago) * 100 if price_3days_ago > 0 else 0
+        if recent_gain > 10:  # 3일간 10% 이상 급등 시 매수 안함
+            return {"signal": None, "description": f"급등 종목 추격 금지 (3일 +{recent_gain:.1f}%)"}
+
+    # 정배열 매수 - 이격도 조건 강화 (105% -> 102%)
     if ma20 > ma60 > ma120 and close > ma20:
-        return {"signal": "buy", "description": "정배열 상승 매수타점"}
-    
+        if disparity <= 102:  # 더 엄격하게
+            return {"signal": "buy", "description": "정배열 눌림목 매수 (이격도 안정)"}
+        else:
+            return {"signal": None, "description": f"정배열이나 이격 과열 ({disparity:.1f}%)"}
+
     # 역배열 매도
     elif ma20 < ma60 < ma120 and close < ma20:
         return {"signal": "sell", "description": "역배열 하락 매도타점"}
-    
-    # 눌림목 진입
+
+    # 눌림목 진입 - 이격도 조건 강화 (103% -> 101%)
     recent_lows = [float(item.get("stck_lwpr", 0)) for item in chart_data[-5:]]
     if any(low < ma20 for low in recent_lows) and close > ma20:
-        return {"signal": "buy", "description": "눌림목 진입 매수타점"}
+        if disparity <= 101:  # 더 엄격하게
+            return {"signal": "buy", "description": "눌림목 진입 매수타점"}
+        else:
+            return {"signal": None, "description": f"눌림목이나 이격 과열 ({disparity:.1f}%)"}
     
     # 손절/익절
     stop_loss_line = ma60
@@ -127,13 +250,12 @@ def analyze_macd(chart_data: list) -> dict:
 
 
 def analyze_rsi(chart_data: list) -> dict:
-    """RSI 분석 (과매수/과매도)"""
-    if len(chart_data) < 14:
+    """RSI 분석 (과매수/과매도) - 바닥 탈출 전략"""
+    if len(chart_data) < 15:
         return {"signal": None, "description": "데이터 부족"}
     
+    # 현재 RSI 계산
     prices = [float(item.get("stck_clpr", 0)) for item in chart_data[-15:]]
-    
-    # RSI 계산
     gains = []
     losses = []
     for i in range(1, len(prices)):
@@ -154,14 +276,42 @@ def analyze_rsi(chart_data: list) -> dict:
         rs = avg_gain / avg_loss
         rsi = 100 - (100 / (1 + rs))
     
-    # 조건 완화: 40 이하 매수, 60 이상 매도
-    if rsi < 40:
-        return {"signal": "buy", "description": f"RSI 과매도 ({rsi:.1f})"}
-    elif rsi > 60:
+    # 이전 RSI 계산 (추세 확인용)
+    if len(chart_data) >= 16:
+        prev_prices = [float(item.get("stck_clpr", 0)) for item in chart_data[-16:-1]]
+        prev_gains = []
+        prev_losses = []
+        for i in range(1, len(prev_prices)):
+            change = prev_prices[i] - prev_prices[i-1]
+            if change > 0:
+                prev_gains.append(change)
+                prev_losses.append(0)
+            else:
+                prev_gains.append(0)
+                prev_losses.append(abs(change))
+        
+        prev_avg_gain = sum(prev_gains[-14:]) / 14
+        prev_avg_loss = sum(prev_losses[-14:]) / 14
+        if prev_avg_loss == 0:
+            rsi_prev = 100
+        else:
+            prev_rs = prev_avg_gain / prev_avg_loss
+            rsi_prev = 100 - (100 / (1 + prev_rs))
+    else:
+        rsi_prev = rsi
+    
+    # 🔥 Falling Knife 방지: 바닥 탈출 확인
+    if rsi < 30:
+        # 30 미만은 관망 (하락세가 강함 - 떨어지는 칼날)
+        return {"signal": None, "description": f"RSI 과매도 심화 ({rsi:.1f}) - 반등 대기"}
+    elif 30 <= rsi <= 45 and rsi > rsi_prev:
+        # 바닥을 찍고 올라오는 구간 + 상승 중
+        return {"signal": "buy", "description": f"RSI 바닥 탈출 반등 ({rsi:.1f})"}
+    elif rsi > 70:
         return {"signal": "sell", "description": f"RSI 과매수 ({rsi:.1f})"}
-    elif 45 <= rsi <= 55:
-        # 중립 구간도 약한 매수 신호로
-        return {"signal": "buy", "description": f"RSI 중립-상승 ({rsi:.1f})"}
+    elif 45 <= rsi <= 60:
+        # 중립 상승 구간
+        return {"signal": "buy", "description": f"RSI 안정 상승 ({rsi:.1f})"}
     
     return {"signal": None, "description": f"RSI 중립 ({rsi:.1f})"}
 
@@ -245,29 +395,158 @@ def analyze_stochastic(chart_data: list) -> dict:
     return {"signal": None, "description": f"스토캐스틱 중립 (%K: {k:.1f})"}
 
 
-def analyze_adx(chart_data: list) -> dict:
-    """ADX 분석 (추세 강도)"""
-    if len(chart_data) < 14:
+def analyze_volatility_breakout(chart_data: list, k: float = 0.5) -> dict:
+    """🔥 변동성 돌파 전략 (래리 윌리엄스) - 승률이 매우 높은 단타 전략
+    
+    공식: 현재가 > 시가 + (전일 고가 - 전일 저가) * K
+    """
+    if len(chart_data) < 2:
         return {"signal": None, "description": "데이터 부족"}
     
-    # 간단한 ADX 추정 (변동성 기반)
-    recent_data = chart_data[-14:]
-    changes = []
-    for item in recent_data:
-        high = float(item.get("stck_hgpr", 0))
-        low = float(item.get("stck_lwpr", 0))
-        changes.append(high - low)
+    today = chart_data[-1]  # 최신 데이터 (시간순 정렬 기준 마지막)
+    yesterday = chart_data[-2]  # 전일 데이터
     
-    avg_change = sum(changes) / len(changes)
-    current_change = changes[-1]
+    # 오늘 데이터
+    current_price = float(today.get("stck_clpr", 0))  # 현재가
+    open_price = float(today.get("stck_oprc", 0))  # 시가
     
-    # 추세 강도 추정
-    if current_change > avg_change * 1.5:
-        return {"signal": "buy", "description": "ADX 강한 추세"}
-    elif current_change < avg_change * 0.5:
-        return {"signal": "sell", "description": "ADX 약한 추세"}
+    # 전일 데이터
+    prev_high = float(yesterday.get("stck_hgpr", 0))
+    prev_low = float(yesterday.get("stck_lwpr", 0))
+    prev_range = prev_high - prev_low
     
-    return {"signal": None, "description": "ADX 중립"}
+    if prev_range == 0 or open_price == 0:
+        return {"signal": None, "description": "데이터 부족"}
+    
+    # 목표 돌파가 = 시가 + (전일 변동폭 * K)
+    target_price = open_price + (prev_range * k)
+    
+    if current_price >= target_price:
+        return {"signal": "buy", "description": f"변동성 돌파 발생 (목표가: {target_price:.0f})"}
+    
+    return {"signal": None, "description": "변동성 돌파 미달"}
+
+
+async def check_market_regime() -> dict:
+    """시장 레짐 판별 (CLAUDE.md 섹션 7.1: 200일 MA + 기울기)
+
+    상승장(Bull): 코스피 > MA200 AND MA200 기울기 양(+)
+    하락장(Bear): 그 외
+
+    하위 분류 (기존 호환):
+    - strong_bearish: 코스피 < MA60 또는 5일 연속 하락
+    - bearish: 코스피 < MA20
+    - bullish: 코스피 > MA200 + 기울기 상승
+    """
+    try:
+        # 장외 시간에는 모의투자 API가 차트 데이터를 반환하지 않음 → neutral 반환
+        if not is_market_open():
+            return {"regime": "neutral", "regime_200d": "bear", "message": "장외 시간 - 시장 레짐 판별 스킵", "position_multiplier": 0.5}
+
+        # KODEX 200 (069500) = KOSPI 200 추종 ETF 사용 (지수코드 0001은 daily-price API 미지원)
+        kospi_chart = await korea_investment_api.get_daily_chart("069500", "D", limit=240)
+
+        if "output2" not in kospi_chart or not kospi_chart["output2"]:
+            logger.warning("KOSPI 지수 데이터 없음 - 시장 필터 비활성화")
+            return {"regime": "neutral", "message": "시장 지수 확인 불가", "position_multiplier": 0.5}
+
+        chart_data = kospi_chart["output2"]
+        closes = [float(item.get("stck_clpr", 0)) for item in chart_data]
+
+        if len(closes) < 60:
+            return {"regime": "neutral", "message": "데이터 부족", "position_multiplier": 0.5}
+
+        current_price = closes[0]
+        ma20 = sum(closes[:20]) / 20
+        ma60 = sum(closes[:60]) / 60
+
+        # 200일 MA 기반 레짐 판별 (섹션 7.1)
+        if len(closes) >= 205:
+            regime_enum = detect_market_regime(list(reversed(closes)))
+            is_bull_200 = regime_enum == MarketRegime.BULL
+            ma200 = sum(closes[:200]) / 200
+        else:
+            is_bull_200 = current_price > ma20  # 200일 데이터 부족 시 MA20 폴백
+            ma200 = ma60
+
+        # 5일 연속 하락 체크
+        consecutive_down = 0
+        for i in range(len(closes) - 1):
+            if closes[i] < closes[i + 1]:
+                consecutive_down += 1
+            else:
+                break
+
+        drop_from_ma20 = ((current_price - ma20) / ma20) * 100
+
+        # 강한 하락장: 코스피 < MA60 또는 5일 연속 하락
+        if current_price < ma60 or consecutive_down >= 5:
+            return {
+                "regime": "strong_bearish",
+                "regime_200d": "bear",
+                "message": f"강한 하락장 (코스피: {current_price:.0f}, MA200: {ma200:.0f}, {consecutive_down}일 연속하락)",
+                "position_multiplier": 0.1,
+                "min_score": settings.BEAR_MARKET_MIN_SCORE + 3,
+                "max_trades": 1,
+                "consecutive_down": consecutive_down,
+                "drop_from_ma20": round(drop_from_ma20, 1),
+            }
+
+        # 약세장: 코스피 < MA20
+        if current_price < ma20:
+            return {
+                "regime": "bearish",
+                "regime_200d": "bear",
+                "message": f"하락장 (코스피: {current_price:.0f} < MA20: {ma20:.0f}, MA200: {ma200:.0f})",
+                "position_multiplier": settings.BEAR_MARKET_POSITION_RATIO,
+                "min_score": settings.BEAR_MARKET_MIN_SCORE,
+                "max_trades": settings.BEAR_MARKET_MAX_TRADES,
+                "consecutive_down": consecutive_down,
+                "drop_from_ma20": round(drop_from_ma20, 1),
+            }
+
+        # 상승장: 200일 MA 기반
+        return {
+            "regime": "bullish",
+            "regime_200d": "bull" if is_bull_200 else "bear",
+            "message": f"상승장 (코스피: {current_price:.0f}, MA200: {ma200:.0f}, Bull={is_bull_200})",
+            "position_multiplier": 1.0,
+            "min_score": 1,
+            "max_trades": settings.MAX_DAILY_TRADES,
+            "consecutive_down": consecutive_down,
+            "drop_from_ma20": round(drop_from_ma20, 1),
+        }
+    except Exception as e:
+        logger.error(f"시장 지수 확인 실패: {e}")
+        return {"regime": "neutral", "message": "시장 지수 확인 실패", "position_multiplier": 0.5}
+
+
+def analyze_adx(chart_data: list) -> dict:
+    """ADX 분석 — Wilder's ADX(14) 기반 추세 강도 측정
+
+    평균회귀 전략에서의 해석:
+    - ADX < 20: 횡보장 → 평균회귀 유리 (BUY 신호)
+    - ADX 20~30: 중간 추세 → 중립
+    - ADX > 30: 강한 추세 → 평균회귀 위험 (SELL/SKIP 신호)
+
+    chart_data는 시간 순(오래된 → 최신) 정렬을 가정.
+    """
+    if len(chart_data) < 29:  # period * 2 + 1
+        return {"signal": None, "description": "데이터 부족", "adx": None}
+
+    highs = [float(item.get("stck_hgpr", 0)) for item in chart_data]
+    lows = [float(item.get("stck_lwpr", 0)) for item in chart_data]
+    closes = [float(item.get("stck_clpr", 0)) for item in chart_data]
+
+    adx = calculate_adx(highs, lows, closes)
+    if adx is None:
+        return {"signal": None, "description": "ADX 계산 불가", "adx": None}
+
+    if adx < 20:
+        return {"signal": "buy", "description": f"ADX({adx:.0f}<20) 횡보장 — 평균회귀 유리", "adx": adx}
+    if adx > 30:
+        return {"signal": "sell", "description": f"ADX({adx:.0f}>30) 강추세 — 평균회귀 위험", "adx": adx}
+    return {"signal": None, "description": f"ADX({adx:.0f}) 중립", "adx": adx}
 
 
 def analyze_obv(chart_data: list) -> dict:
@@ -298,15 +577,16 @@ async def analyze_stock(stock_code: str, stock_name: str, criteria: Recommendati
         
         # 차트 데이터 조회 (현재가 포함)
         chart_response = await korea_investment_api.get_daily_chart(stock_code, "D")
-        if "output" not in chart_response or not chart_response["output"]:
+        if "output2" not in chart_response or not chart_response["output2"]:
             logger.warning(f"No chart data for {stock_code}")
             return None
-        
-        chart_data = chart_response["output"]
+
+        # KIS API는 최신순(newest-first)으로 반환 → 시간순(chronological)으로 뒤집어 분석
+        chart_data = list(reversed(chart_response["output2"]))
         logger.info(f"Got {len(chart_data)} chart data points for {stock_code}")
-        
-        # 최신 데이터에서 현재가 및 종목명 추출
-        latest = chart_data[0] if chart_data else None
+
+        # 최신 데이터에서 현재가 및 종목명 추출 (시간순 기준 마지막 = 최신)
+        latest = chart_data[-1] if chart_data else None
         if not latest:
             return None
         
@@ -323,17 +603,36 @@ async def analyze_stock(stock_code: str, stock_name: str, criteria: Recommendati
 
         # 등락률 계산
         if len(chart_data) >= 2:
-            prev_price = float(chart_data[1].get("stck_clpr", current_price))
+            prev_price = float(chart_data[-2].get("stck_clpr", current_price))
             change_rate = ((current_price - prev_price) / prev_price) * 100 if prev_price > 0 else 0
         else:
             change_rate = 0
 
         # 기본 수치형 지표 계산 (배치 저장용)
         closes = [float(item.get("stck_clpr", 0)) for item in chart_data]
+        volumes = [int(item.get("acml_vol", 0)) for item in chart_data]
+        
         ma5 = sum(closes[-5:]) / 5 if len(closes) >= 5 else None
         ma20 = sum(closes[-20:]) / 20 if len(closes) >= 20 else None
         ma60 = sum(closes[-60:]) / 60 if len(closes) >= 60 else None
 
+        # 🔥 1. 거래량 분석 (Volume Analysis) - 필수 조건
+        avg_vol_20 = sum(volumes[-20:]) / 20 if len(volumes) >= 20 else 0
+        volume_ratio = (volume / avg_vol_20) if avg_vol_20 > 0 else 0
+        
+        # 거래량이 너무 적으면 추천 제외 (유동성 부족) - 배치 모드에서는 제외 안 함
+        if not criteria.for_batch and avg_vol_20 < 50000 and current_price < 50000:
+            logger.debug(f"{stock_code}: 거래량 부족으로 제외 (평균 거래량: {avg_vol_20:.0f})")
+            return None
+        
+        # 🔥 2. 이격도 계산 (Disparity Filter) - 추격 매수 방지
+        disparity = (current_price / ma20) * 100 if ma20 else 100
+        
+        # Trend filter check (non-blocking here; used for scoring/tagging)
+        trend_ok = None
+        if TREND_FILTER_ENABLED:
+            trend_ok = _passes_uptrend(closes, TREND_MA_SHORT, TREND_MA_LONG)
+
         # RSI 계산 (단순 방식)
         rsi = None
         if len(closes) >= 15:
@@ -391,6 +690,27 @@ async def analyze_stock(stock_code: str, stock_name: str, criteria: Recommendati
         signals = []
         score = 0
         
+        # 🔥 3. 이격도 과열 체크 (max_disparity 조건)
+        if disparity > criteria.max_disparity:
+            score -= 5
+            signals.append(f"이격도 과열({disparity:.1f}% > {criteria.max_disparity}%) - 매수금지")
+            logger.debug(f"{stock_code}: 이격도 과열로 점수 감점")
+
+        # 🔥 3.5. 급등 과열 필터 (고점 추격 매수 차단)
+        if criteria.use_overheat_filter and OVERHEAT_FILTER_ENABLED:
+            overheat = analyze_overheat(closes, ma20)
+            if overheat["blocked"]:
+                score -= 10
+                signals.append(overheat["reason"])
+                logger.info(f"{stock_code}: 급등 과열 차단 - {overheat['reason']} {overheat['details']}")
+
+        # 🔥 4. 변동성 돌파 전략 (고승률)
+        if criteria.use_volatility_breakout:
+            vb_result = analyze_volatility_breakout(chart_data)
+            if vb_result and vb_result["signal"] == "buy":
+                signals.append(vb_result["description"])
+                score += 4  # 매우 강력한 신호
+        
         # 커스텀 공식 기반 신호 분석 적용 (정배열, 역배열, 눌림목, 손절/익절)
         custom_result = analyze_custom_signals(chart_data)
         if custom_result:
@@ -419,8 +739,13 @@ async def analyze_stock(stock_code: str, stock_name: str, criteria: Recommendati
         if criteria.use_rsi:
             result = analyze_rsi(chart_data)
             if result["signal"] == "buy":
-                signals.append(result["description"])
-                score += 2
+                # 🔥 거래량이 동반되어야 진짜 반등
+                if volume_ratio >= 1.2:
+                    signals.append(result["description"] + " + 거래량증가")
+                    score += 3
+                else:
+                    signals.append(result["description"] + " (거래량부족)")
+                    score += 1  # 점수 낮게 책정
         
         if criteria.use_bollinger:
             result = analyze_bollinger(chart_data)
@@ -452,13 +777,79 @@ async def analyze_stock(stock_code: str, stock_name: str, criteria: Recommendati
                 signals.append(result["description"])
                 score += 1
         
-        logger.info(f"{stock_code} ({stock_name}): score={score}, signals={signals}")
+        # 🔥 5. 거래량 급증 보너스 (매수 신호 강도 증가)
+        if volume_ratio >= 1.5 and change_rate > 0:
+            signals.append(f"거래량 실린 상승 ({volume_ratio:.1f}배)")
+            score += 3
+        elif volume_ratio < 0.8:
+            # 거래량이 평소보다 적으면 신뢰도 감소
+            score -= 1
+            logger.debug(f"{stock_code}: 거래량 부족 (평소의 {volume_ratio:.1f}배)")
+
+        # Tag trend state to signals and adjust score slightly
+        if TREND_FILTER_ENABLED and trend_ok is not None:
+            if trend_ok:
+                signals.append(f"추세상승(>{TREND_MA_SHORT}MA & {TREND_MA_SHORT}MA>{TREND_MA_LONG}MA, tol={int(TREND_TOLERANCE_PCT*10000)/100:.2f}%)")
+                score += 1
+            else:
+                signals.append(f"추세약함({TREND_MA_SHORT}MA≤{TREND_MA_LONG}MA 또는 종가≤{TREND_MA_SHORT}MA)")
         
-        # 신호가 있거나 점수가 0 이상이면 추천 (규칙 기반에서는 매칭된 종목 모두 표시)
-        if len(signals) > 0 or score > 0:
+        # 🔥 6. 최종 거래량 필터 (min_volume_ratio)
+        if criteria.min_volume_ratio > 0 and volume_ratio < criteria.min_volume_ratio:
+            logger.debug(f"{stock_code}: 거래량 필터 미달 ({volume_ratio:.2f} < {criteria.min_volume_ratio})")
+            return None
+        
+        logger.info(f"{stock_code} ({stock_name}): score={score}, signals={signals}, volume_ratio={volume_ratio:.2f}, disparity={disparity:.1f}%")
+
+        # 🤖 ML 앙상블 스코어 계산
+        ml_score_val = None
+        ml_confidence_val = None
+        ml_signal_val = None
+
+        if settings.ML_ENSEMBLE_ENABLED:
+            try:
+                from app.services.ml_ensemble import get_ensemble
+                ensemble = get_ensemble()
+                if ensemble.is_trained:
+                    ml_result = ensemble.predict(chart_data)
+                    if "error" not in ml_result:
+                        ml_score_val = ml_result["ensemble_score"]
+                        ml_confidence_val = ml_result["confidence"]
+                        ml_signal_val = ml_result["signal"]
+
+                        # 룰베이스 + ML 가중 결합
+                        rule_score_normalized = (score / 15.0) * 100.0  # 0~15 → 0~100
+                        combined_score = int(
+                            rule_score_normalized * settings.ML_ENSEMBLE_RULE_WEIGHT +
+                            ml_score_val * settings.ML_ENSEMBLE_ML_WEIGHT
+                        )
+                        # 0~100 → 0~15 스케일로 재변환 (기존 호환)
+                        score = max(0, int(combined_score / 100.0 * 15.0))
+
+                        signals.append(f"ML앙상블: {ml_signal_val}({ml_score_val}점, 신뢰도{ml_confidence_val:.0%})")
+                        logger.info(f"  ML 앙상블: score={ml_score_val}, confidence={ml_confidence_val:.2f}, signal={ml_signal_val}")
+            except Exception as e:
+                logger.debug(f"ML 앙상블 스코어 계산 실패 (정상 - 모델 미학습): {e}")
+
+        # ATR / ADX 계산 (이미 가져온 차트 데이터 재사용 — 이중 API 호출 방지)
+        atr_14_val = None
+        adx_14_val = None
+        try:
+            if len(chart_data) >= 15:
+                _h = [float(d.get("stck_hgpr", 0)) for d in chart_data]
+                _l = [float(d.get("stck_lwpr", 0)) for d in chart_data]
+                _c = [float(d.get("stck_clpr", 0)) for d in chart_data]
+                atr_14_val = calculate_atr(_h, _l, _c)
+                if len(chart_data) >= 29:  # Wilder ADX 최소 데이터 (period * 2 + 1)
+                    adx_14_val = calculate_adx(_h, _l, _c)
+        except Exception:
+            pass
+
+        # 신호가 있거나 점수가 0 이상이면 추천 (배치 모드에서는 score=0도 반환)
+        if criteria.for_batch or len(signals) > 0 or score > 0:
             # 신호가 있으면 최소 1점 보장
             final_score = max(1, score) if len(signals) > 0 else score
-            
+
             return StockRecommendation(
                 stock_code=stock_code,
                 stock_name=stock_name,
@@ -476,7 +867,12 @@ async def analyze_stock(stock_code: str, stock_name: str, criteria: Recommendati
                 stochastic_d=stochastic_d,
                 bollinger_upper=bollinger_upper,
                 bollinger_lower=bollinger_lower,
-                bollinger_middle=bollinger_middle
+                bollinger_middle=bollinger_middle,
+                ml_score=ml_score_val,
+                ml_confidence=ml_confidence_val,
+                ml_signal=ml_signal_val,
+                atr_14=atr_14_val,
+                adx_14=adx_14_val,
             )
         
         logger.debug(f"{stock_code}: No recommendation (score={score})")
@@ -486,10 +882,11 @@ async def analyze_stock(stock_code: str, stock_name: str, criteria: Recommendati
         return None
 
 
-async def analyze_stock_with_indicators(stock_code: str, stock_name: str) -> Optional[StockRecommendation]:
-    """호출 편의성: 모든 지표를 켜서 분석한 결과(Pydantic 모델)를 반환합니다.
+async def analyze_stock_for_batch(stock_code: str, stock_name: str) -> Optional[StockRecommendation]:
+    """배치 DB 저장용: 거래량/점수 필터 없이 지표만 계산하여 전 종목 저장.
 
-    이 함수는 배치 스크립트에서 사용됩니다.
+    모든 지표를 계산하되, 매매 필터(min_volume_ratio, 거래량 부족, score=0)를 적용하지 않습니다.
+    score=0이어도 반환하여 배치에서 DB에 저장됩니다.
     """
     criteria = RecommendationCriteria(
         use_macd=True,
@@ -498,7 +895,36 @@ async def analyze_stock_with_indicators(stock_code: str, stock_name: str) -> Opt
         use_moving_average=True,
         use_stochastic=True,
         use_adx=True,
-        use_obv=True
+        use_obv=True,
+        use_volatility_breakout=True,
+        min_volume_ratio=0,    # 거래량 필터 없음
+        max_disparity=200.0,   # 이격도 필터 없음
+        for_batch=True,        # score=0 · 저유동성 종목도 반환
+    )
+    return await analyze_stock(stock_code, stock_name, criteria)
+
+
+async def analyze_stock_with_indicators(stock_code: str, stock_name: str) -> Optional[StockRecommendation]:
+    """호출 편의성: 모든 지표를 켜서 분석한 결과(Pydantic 모델)를 반환합니다.
+
+    이 함수는 배치 스크립트에서 사용됩니다.
+
+    🔥 승률 향상 기능 포함:
+    - 변동성 돌파 전략
+    - 거래량 필터 (평균 대비 1.2배)
+    - 이격도 필터 (110% 제한)
+    """
+    criteria = RecommendationCriteria(
+        use_macd=True,
+        use_rsi=True,
+        use_bollinger=True,
+        use_moving_average=True,
+        use_stochastic=True,
+        use_adx=True,
+        use_obv=True,
+        use_volatility_breakout=True,  # 🔥 변동성 돌파 추가
+        min_volume_ratio=1.2,  # 🔥 거래량 필터 (평균의 1.2배 이상)
+        max_disparity=110.0  # 🔥 이격도 필터 (20일선 대비 110% 이하)
     )
     return await analyze_stock(stock_code, stock_name, criteria)
 
@@ -518,7 +944,7 @@ async def get_all_tradable_stocks() -> List[tuple]:
         # Rate limit을 위한 대기 (초당 1건 제한) - 안전하게 3초 대기
         await asyncio.sleep(3.0)
         
-        # KOSDAQ 거래대금 상위 종목 조회  
+        # KOSDAQ 거래대금 상위 종목 조회 ("Q" = KOSDAQ, KIS API 규격)
         kosdaq_result = await korea_investment_api.get_stock_list("Q")
         logger.info(f"KOSDAQ result: {kosdaq_result}")
         
@@ -542,40 +968,16 @@ async def get_all_tradable_stocks() -> List[tuple]:
         
         logger.info(f"Found {len(stocks)} tradable stocks from KIS API")
         
-        # API에서 종목을 못 가져온 경우 기본 종목 리스트 사용
+        # API에서 종목을 못 가져온 경우 빈 리스트 반환 (테스트 데이터 제거)
         if not stocks:
-            logger.warning("No stocks from KIS API, using default list")
-            stocks = [
-                ("005930", "삼성전자"),
-                ("000660", "SK하이닉스"),
-                ("035420", "네이버"),
-                ("051910", "LG화학"),
-                ("005380", "현대차"),
-                ("006400", "삼성SDI"),
-                ("035720", "카카오"),
-                ("000270", "기아"),
-                ("068270", "셀트리온"),
-                ("207940", "삼성바이오로직스"),
-            ]
+            logger.warning("No stocks from KIS API, returning empty list")
         
         return stocks
         
     except Exception as e:
         logger.error(f"Error fetching stock list from KIS API: {e}", exc_info=True)
-        # API 실패 시 기본 종목 리스트 반환
-        logger.warning("Using default stock list due to API error")
-        return [
-            ("005930", "삼성전자"),
-            ("000660", "SK하이닉스"),
-            ("035420", "네이버"),
-            ("051910", "LG화학"),
-            ("005380", "현대차"),
-            ("006400", "삼성SDI"),
-            ("035720", "카카오"),
-            ("000270", "기아"),
-            ("068270", "셀트리온"),
-            ("207940", "삼성바이오로직스"),
-        ]
+        logger.warning("Returning empty list due to API error")
+        return []
 
 
 @router.get("/recommendations")
@@ -587,13 +989,26 @@ async def get_recommendations(
     use_stochastic: bool = Query(False, description="스토캐스틱 사용"),
     use_adx: bool = Query(False, description="ADX 사용"),
     use_obv: bool = Query(False, description="거래량(OBV) 사용"),
+    use_volatility_breakout: bool = Query(False, description="변동성 돌파 전략 사용"),
+    min_volume_ratio: float = Query(1.0, description="최소 거래량 비율 (평균 대비)"),
+    max_disparity: float = Query(200.0, description="최대 이격도 (20일선 대비 %)"),
     max_stocks: int = Query(100, description="분석할 최대 종목 수 (기본 100개)"),
 ):
     """기술적 지표 기반 추천 종목 조회
     
     선택한 기술적 지표 조건에 부합하는 종목을 KOSPI 시가총액 상위 종목 중에서 찾아 추천합니다.
+    
+    🔥 승률 향상 기능:
+    - 변동성 돌파: 래리 윌리엄스 전략 (고승률)
+    - 거래량 필터: 평균 대비 거래량 확인
+    - 이격도 필터: 20일선과의 거리 제한 (추격 매수 방지)
+    - 시장 지수 필터: 코스피 지수 확인 (하락장 보수적 대응)
     """
     
+    # 🔥 시장 지수 확인 (가장 중요한 승률 결정 요소)
+    market_regime = await check_market_regime()
+    logger.info(f"📊 시장 상태: {market_regime['message']}")
+    
     criteria = RecommendationCriteria(
         use_macd=use_macd,
         use_rsi=use_rsi,
@@ -601,13 +1016,17 @@ async def get_recommendations(
         use_moving_average=use_moving_average,
         use_stochastic=use_stochastic,
         use_adx=use_adx,
-        use_obv=use_obv
+        use_obv=use_obv,
+        use_volatility_breakout=use_volatility_breakout,
+        min_volume_ratio=min_volume_ratio,
+        max_disparity=max_disparity
     )
     
     # 모든 지표가 꺼져있으면 기본값 사용
-    if not any([use_macd, use_rsi, use_bollinger, use_moving_average, use_stochastic, use_adx, use_obv]):
+    if not any([use_macd, use_rsi, use_bollinger, use_moving_average, use_stochastic, use_adx, use_obv, use_volatility_breakout]):
         criteria.use_rsi = True
         criteria.use_moving_average = True
+        criteria.use_volatility_breakout = True  # 기본값에 변동성 돌파 추가
     
     # 분석할 종목 리스트 가져오기 (KIS API에서 실시간 조회)
     all_stocks = await get_all_tradable_stocks()
@@ -652,11 +1071,18 @@ async def get_recommendations(
     if errors:
         logger.error(f"Encountered {len(errors)} errors during analysis")
     
-    # None 및 예외 제거 후 점수순 정렬
-    recommendations = [r for r in all_results if r is not None and not isinstance(r, Exception)]
+    # None 및 예외 제거 후 3000원 이하 종목 필터링, 점수순 정렬
+    regime_min_score = market_regime.get("min_score", 1)
+    recommendations = [
+        r for r in all_results
+        if r is not None
+        and not isinstance(r, Exception)
+        and r.current_price >= 3000  # 🚫 동전주 제외
+        and r.score >= regime_min_score  # 🐻 하락장 최소 점수 필터
+    ]
     recommendations.sort(key=lambda x: x.score, reverse=True)
-    
-    logger.info(f"Found {len(recommendations)} recommendations out of {len(stocks_to_analyze)} analyzed stocks")
+
+    logger.info(f"Found {len(recommendations)} recommendations out of {len(stocks_to_analyze)} analyzed stocks (min_score={regime_min_score})")
     
     if not recommendations:
         logger.warning("No recommendations found! Criteria might be too strict or API failed")
@@ -665,6 +1091,7 @@ async def get_recommendations(
         "total": len(recommendations),
         "analyzed_stocks": len(stocks_to_analyze),
         "criteria": criteria.dict(),
+        "market_regime": market_regime,  # 🔥 시장 상태 정보 추가
         "recommendations": recommendations[:20]  # 상위 20개만 반환
     }
 
@@ -672,6 +1099,7 @@ async def get_recommendations(
 @router.get("/rule-based")
 async def get_rule_based_recommendations(
     realtime: bool = Query(False, description="실시간 분석 여부 (느림, 30초)"),
+    auto_trade: bool = Query(True, description="자동매매 실행 여부"),
     db: AsyncSession = Depends(get_db)
 ):
     """
@@ -679,6 +1107,7 @@ async def get_rule_based_recommendations(
     
     - realtime=false (기본): DB에서 조회 (빠름, 0.1초) - 매일 아침 9시 데이터
     - realtime=true: KIS API 실시간 분석 (느림, 30초)
+    - auto_trade=true (기본): 조건에 맞는 종목을 자동으로 매매
     
     활성화된 모든 매매 규칙을 확인하고, 조건에 맞는 종목을 자동으로 추천합니다.
     """
@@ -686,11 +1115,59 @@ async def get_rule_based_recommendations(
     # 실시간 모드: 기존 방식 (KIS API 직접 호출)
     if realtime:
         logger.info("🔴 Real-time mode: Fetching live data from KIS API (slow)")
-        return await get_rule_based_recommendations_realtime()
+        result = await get_rule_based_recommendations_realtime()
+    else:
+        # DB 모드: 빠른 조회
+        logger.info("🟢 DB mode: Fetching from cached analysis (fast)")
+        result = await get_rule_based_recommendations_from_db(db)
     
-    # DB 모드: 빠른 조회
-    logger.info("🟢 DB mode: Fetching from cached analysis (fast)")
-    return await get_rule_based_recommendations_from_db(db)
+    # 자동매매 실행 (백그라운드)
+    if auto_trade and result.get("recommendations_by_rule"):
+        asyncio.create_task(execute_auto_trade_background(result, db))
+        logger.info("🤖 Auto-trade task created in background")
+    
+    return result
+
+
+def is_mean_reversion_candidate(stock, conditions: dict, market_regime_str: str) -> bool:
+    """RSI+볼린저 평균회귀 매수 조건 확인 (CLAUDE.md 섹션 7.2)
+
+    Bull: RSI ≤ 25 + BB 하단 -3% ~ +1.5%
+          (거래량 200% OR 조건은 real-time check_buy_signal에서 처리)
+    Bear: RSI ≤ 35 + BB 하단 이하
+    """
+    rsi_val = float(stock.rsi) if stock.rsi else None
+    close = int(stock.current_price) if stock.current_price else 0
+    bb_lower = float(stock.bollinger_lower) if stock.bollinger_lower else None
+    bb_upper = float(stock.bollinger_upper) if stock.bollinger_upper else None
+    bb_middle = float(stock.bollinger_middle) if stock.bollinger_middle else None
+
+    if not all([rsi_val, close, bb_lower, bb_upper, bb_middle]):
+        return False
+
+    # 가격 필터 (섹션 6.4)
+    if close < settings.MIN_PRICE_KRW:
+        return False
+
+    regime = MarketRegime.BULL if market_regime_str == "bull" else MarketRegime.BEAR
+
+    # ADX 필터: 강한 추세 중 평균회귀 진입 차단 (ADX > 30이면 횡보 아님)
+    adx_val = float(stock.adx_14) if getattr(stock, "adx_14", None) else None
+    adx_strong_trend = adx_val is not None and adx_val > 30
+
+    if regime == MarketRegime.BULL:
+        rsi_threshold = conditions.get("rsi_bull_max", 25)
+        bb_lower_pct = conditions.get("bb_lower_pct", 3.0) / 100   # -3%
+        bb_upper_pct = conditions.get("bb_upper_pct", 1.5) / 100   # +1.5%
+        in_bb_zone = bb_lower * (1 - bb_lower_pct) <= close <= bb_lower * (1 + bb_upper_pct)
+        if adx_strong_trend:
+            return False  # 강추세 중 평균회귀 차단
+        return rsi_val <= rsi_threshold and in_bb_zone
+    else:
+        rsi_threshold = conditions.get("rsi_bear_max", 35)
+        if adx_strong_trend:
+            return False  # 강추세 중 평균회귀 차단
+        return rsi_val <= rsi_threshold and close <= bb_lower
 
 
 async def get_rule_based_recommendations_from_db(db: AsyncSession):
@@ -698,134 +1175,184 @@ async def get_rule_based_recommendations_from_db(db: AsyncSession):
     
     logger.info("Rule-based recommendations from DB")
     
-    # 샘플 규칙 생성 (실제로는 DB에서 조회)
+    # JSON 파일에서 규칙 로드
+    import json
+    from pathlib import Path
     from collections import namedtuple
+    
     Rule = namedtuple('Rule', ['id', 'name', 'description', 'rule_type', 'priority', 'conditions', 'actions', 'is_active'])
     
-    active_rules = [
-        Rule(
-            id=1,
-            name="RSI 과매도 반등",
-            description="RSI 40 이하 과매도 종목",
-            rule_type="BUY",
-            priority=1,
-            conditions={"rsi_threshold": 40},
-            actions={"take_profit": 5.0, "stop_loss": 3.0, "position_sizing": {"target_ratio": 0.15}},
-            is_active=True
-        ),
-        Rule(
-            id=2,
-            name="볼린저밴드 하단",
-            description="볼린저밴드 하단 근처 반등",
-            rule_type="BUY",
-            priority=3,
-            conditions={"bb_threshold": 0.2},
-            actions={"take_profit": 7.0, "stop_loss": 4.0, "position_sizing": {"target_ratio": 0.15}},
-            is_active=True
-        )
-    ]
+    try:
+        config_path = Path(__file__).parent.parent.parent.parent / "trading_rules_config.json"
+        with open(config_path, 'r', encoding='utf-8') as f:
+            config = json.load(f)
+        
+        rules_data = config.get("rules", [])
+        active_rules = []
+        
+        for idx, rule_data in enumerate(rules_data, start=1):
+            if rule_data.get("is_active", False):
+                active_rules.append(Rule(
+                    id=idx,
+                    name=rule_data["name"],
+                    description=rule_data["description"],
+                    rule_type=rule_data["rule_type"].upper(),
+                    priority=rule_data.get("priority", idx),
+                    conditions=rule_data.get("conditions", {}),
+                    actions=rule_data.get("actions", {}),
+                    is_active=True
+                ))
+        
+        logger.info(f"Loaded {len(active_rules)} active trading rules from config file")
+    except Exception as e:
+        logger.error(f"Failed to load trading rules config: {e}")
+        # 폴백: 기본 규칙 사용
+        active_rules = [
+            Rule(
+                id=1,
+                name="RSI 과매도 반등",
+                description="RSI 30 이하 과매도 종목",
+                rule_type="BUY",
+                priority=1,
+                conditions={"rsi_threshold": 30},
+                actions={
+                    "take_profit": 5.0,
+                    "stop_loss": 3.0,
+                    "position_sizing": {"target_ratio": 0.15}
+                },
+                is_active=True
+            )
+        ]
+        logger.warning(f"Using fallback rule: {len(active_rules)} rule(s)")
     
     logger.info(f"Found {len(active_rules)} active trading rules")
     
-    # 오늘 날짜의 분석 데이터 조회
+    # 오늘 날짜의 분석 데이터 조회 (중복 종목은 score 높은 것 우선)
     today = date.today()
     result = await db.execute(
         select(StockAnalysis)
         .where(StockAnalysis.analysis_date >= today)
         .order_by(StockAnalysis.score.desc())
     )
-    all_analyzed_stocks = result.scalars().all()
+    raw_stocks = result.scalars().all()
+    # 종목코드 기준 중복 제거 (score 내림차순 정렬 후 첫 번째만)
+    seen = set()
+    all_analyzed_stocks = []
+    for s in raw_stocks:
+        if s.stock_code not in seen:
+            seen.add(s.stock_code)
+            all_analyzed_stocks.append(s)
     
-    if not all_analyzed_stocks:
-        logger.warning(f"No analysis data found for {today}. Run batch_daily_analysis.py first!")
-        # ✅ 안전장치: DB에 데이터가 없으면 실시간 분석으로 자동 폴백
-        try:
-            logger.info("Falling back to realtime analysis due to empty DB cache...")
-            fallback = await get_rule_based_recommendations_realtime()
-            # 메시지 보강
-            base_msg = fallback.get("message") or ""
-            fallback["message"] = (
-                f"⚠️ 배치 캐시 없음 → 실시간 분석으로 대체 ({today}). "
-                + base_msg
-            )
-            return fallback
-        except Exception as e:
-            logger.error(f"Realtime fallback failed: {e}")
-            return {
-                "total": 0,
-                "active_rules": len(active_rules),
-                "analyzed_stocks": 0,
-                "recommendations": [],
-                "recommendations_by_rule": [],
-                "rules_applied": [],
-                "message": f"배치 분석 데이터가 없습니다 ({today}). 실시간 분석 폴백도 실패: {e}"
-            }
+    # DB에 데이터가 없으면 빈 결과 반환
+    if not all_analyzed_stocks or len(all_analyzed_stocks) < 1:
+        logger.warning(f"No analysis data found ({len(all_analyzed_stocks) if all_analyzed_stocks else 0} stocks). Run batch analysis first.")
+        return {
+            "total": 0,
+            "active_rules": len(active_rules),
+            "analyzed_stocks": 0,
+            "analyzed_stock_list": [],
+            "recommendations": [],
+            "recommendations_by_rule": [],
+            "rules_applied": [],
+            "message": "⚠️ 배치 분석 데이터 없음. 'make batch-test' 명령어로 분석 실행 필요."
+        }
     
     logger.info(f"Found {len(all_analyzed_stocks)} stocks in DB for {today}")
     
     # 규칙별로 매칭되는 종목 찾기
     rule_matches = []
     recommendations_by_rule = []
-    
+    stock_to_rules = {}  # 종목코드 -> 매칭된 규칙 리스트 매핑
+
+    # 시장 레짐 판별 (섹션 7.1: 200일 MA 기반)
+    market_regime_info = await check_market_regime()
+    current_market_regime = market_regime_info.get("regime_200d", "bear")
+
     for rule in active_rules:
         logger.info(f"Applying rule: {rule.name}")
-        
+
         conditions = rule.conditions
         actions = rule.actions
-        
-        # DB에서 조회한 종목 중 규칙에 맞는 종목 필터링
+
         rule_matched_stocks = []
-        
+
         for stock in all_analyzed_stocks:
             matches = True
-            
-            # RSI 조건 체크
-            if "rsi_threshold" in conditions:
-                rsi_threshold = conditions["rsi_threshold"]
-                if not stock.rsi or stock.rsi > rsi_threshold:
-                    matches = False
-         
-            # 볼린저밴드 하단 체크
-            if "bb_threshold" in conditions:
-                if not stock.bollinger_lower or not stock.current_price:
-                    matches = False
-                elif stock.current_price > stock.bollinger_lower * 1.05:  # 하단 5% 이내
-                    matches = False
-            
-            if matches:
-                rule_matched_stocks.append(stock)
-        
+
+            # === 전략 타입별 분기 ===
+
+            # 1) 평균회귀 전략 (RSI + 볼린저 반등)
+            if rule.rule_type == "MEAN_REVERSION":
+                matches = is_mean_reversion_candidate(stock, conditions, current_market_regime)
+
+            # 2) 추세/골든크로스 전략 (나중에 별도 함수로 분리 예정)
+            elif rule.rule_type == "TREND":
+                # 여기서는 당장 비활성화하거나, 매우 보수적으로만 사용
+                # matches = is_trend_candidate(stock, conditions)
+                matches = False  # 일단 평균회귀 안정화 전까지 비활성화
+
+            # 3) 박스권 돌파 / 모멘텀 전략 (위험 축)
+            elif rule.rule_type in ("BREAKOUT", "MOMENTUM"):
+                # matches = is_breakout_or_momentum_candidate(stock, conditions)
+                matches = False  # 초기에는 끄고, 나중에 별도 엔진으로
+
+            # 기타 타입은 현재 스킵
+            else:
+                matches = False
+
+            if not matches:
+                continue
+
+            # 여기까지 왔으면 rule_matched_stocks에 추가
+            rule_matched_stocks.append(stock)
+
         # 점수순 정렬
         rule_matched_stocks.sort(key=lambda x: x.score, reverse=True)
-        
-        # 규칙별로 종목 저장
+
+        # 이하 로직은 그대로 (Top N, rule_matches, stock_to_rules, 실시간 가격 업데이트 등)
         rule_stocks = []
-        for stock in rule_matched_stocks[:10]:  # 규칙당 상위 10개
+        for stock in rule_matched_stocks[:10]:
             stock_dict = {
                 "stock_code": stock.stock_code,
                 "stock_name": stock.stock_name,
-                "current_price": stock.current_price,
-                "change_rate": float(stock.change_rate) if stock.change_rate else 0,
+                "current_price": int(stock.current_price) if stock.current_price else 0,
+                "change_rate": round(float(stock.change_rate), 2) if stock.change_rate else 0,
                 "volume": stock.volume,
-                "rsi": float(stock.rsi) if stock.rsi else None,
-                "ma5": float(stock.ma5) if stock.ma5 else None,
-                "ma20": float(stock.ma20) if stock.ma20 else None,
-                "stochastic_k": float(stock.stochastic_k) if stock.stochastic_k else None,
+                "rsi": round(float(stock.rsi), 2) if stock.rsi else None,
+                "ma5": int(stock.ma5) if stock.ma5 else None,
+                "ma20": int(stock.ma20) if stock.ma20 else None,
+                "stochastic_k": round(float(stock.stochastic_k), 2) if stock.stochastic_k else None,
                 "signals": stock.signals or [],
                 "score": stock.score,
+                "ml_score": stock.ml_score,
+                "ml_confidence": round(float(stock.ml_confidence), 4) if stock.ml_confidence else None,
+                "ml_signal": stock.ml_signal,
                 "price_date": stock.analysis_date.strftime("%Y%m%d"),
                 "rule_id": rule.id,
                 "rule_name": rule.name,
                 "rule_description": rule.description,
                 "rule_priority": rule.priority,
-                "position_ratio": actions.get("position_sizing", {}).get("target_ratio", 0.15),
-                "take_profit": actions.get("take_profit", 5.0),
-                "stop_loss": actions.get("stop_loss", 3.0)
+                "position_ratio": actions.get("position_sizing", {}).get("target_ratio", 0.10),
+                "take_profit": actions.get("take_profit", 3.0),
+                "stop_loss": actions.get("stop_loss", -1.5),
+                "max_position_pct": actions.get("max_position_pct", 0.12),
+                "max_add_buys": actions.get("max_add_buys", 3),
+                "add_buy_cooldown_min": actions.get("add_buy_cooldown_min", 15),
             }
             rule_stocks.append(stock_dict)
             rule_matches.append(stock_dict)
-        
-        # 규칙별 그룹 추가
+
+            if stock.stock_code not in stock_to_rules:
+                stock_to_rules[stock.stock_code] = []
+
+            rule_exists = any(r["rule_id"] == rule.id for r in stock_to_rules[stock.stock_code])
+            if not rule_exists:
+                stock_to_rules[stock.stock_code].append({
+                    "rule_id": rule.id,
+                    "rule_name": rule.name,
+                    "priority": rule.priority,
+                })
+
         if rule_stocks:
             recommendations_by_rule.append({
                 "rule_id": rule.id,
@@ -834,22 +1361,82 @@ async def get_rule_based_recommendations_from_db(db: AsyncSession):
                 "rule_type": rule.rule_type,
                 "priority": rule.priority,
                 "matched_count": len(rule_matched_stocks),
-                "stocks": rule_stocks
+                "stocks": rule_stocks,
             })
-        
+
         logger.info(f"Rule '{rule.name}' matched {len(rule_matched_stocks)} stocks, showing top {len(rule_stocks)}")
-    
-    # 우선순위와 점수로 정렬
-    rule_matches.sort(key=lambda x: (x["rule_priority"], -x["score"]))
-    
+
+    # 규칙 매칭 결과가 없으면 분석 종목 상위 20개를 폴백으로 추가
+    if not rule_matches and all_analyzed_stocks:
+        logger.info("No rule matches found. Using top scored analyzed stocks as fallback recommendations.")
+        already_added = set()
+        fallback_stocks = []
+        for stock in all_analyzed_stocks[:20]:
+            if stock.stock_code in already_added:
+                continue
+            already_added.add(stock.stock_code)
+            stock_dict = {
+                "stock_code": stock.stock_code,
+                "stock_name": stock.stock_name,
+                "current_price": int(stock.current_price) if stock.current_price else 0,
+                "change_rate": round(float(stock.change_rate), 2) if stock.change_rate else 0,
+                "volume": stock.volume,
+                "rsi": round(float(stock.rsi), 2) if stock.rsi else None,
+                "ma5": int(stock.ma5) if stock.ma5 else None,
+                "ma20": int(stock.ma20) if stock.ma20 else None,
+                "stochastic_k": round(float(stock.stochastic_k), 2) if stock.stochastic_k else None,
+                "signals": stock.signals or [],
+                "score": stock.score,
+                "ml_score": stock.ml_score,
+                "ml_confidence": round(float(stock.ml_confidence), 4) if stock.ml_confidence else None,
+                "ml_signal": stock.ml_signal,
+                "price_date": stock.analysis_date.strftime("%Y%m%d"),
+                "rule_id": 0,
+                "rule_name": "고점수 분석 종목",
+                "rule_description": "매매 규칙 조건 미충족 - 분석 점수 기준 상위 종목",
+                "rule_priority": 99,
+                "position_ratio": 0.10,
+                "take_profit": 3.0,
+                "stop_loss": -1.5,
+                "max_position_pct": 0.10,
+                "max_add_buys": 2,
+                "add_buy_cooldown_min": 30,
+            }
+            fallback_stocks.append(stock_dict)
+            rule_matches.append(stock_dict)
+
+        if fallback_stocks:
+            recommendations_by_rule.append({
+                "rule_id": 0,
+                "rule_name": "고점수 분석 종목",
+                "rule_description": "현재 매매 규칙 조건 미충족 - 분석 점수 기준 상위 종목",
+                "rule_type": "ANALYSIS",
+                "priority": 99,
+                "matched_count": len(fallback_stocks),
+                "stocks": fallback_stocks,
+            })
+            logger.info(f"Added {len(fallback_stocks)} fallback stocks from analyzed_stock_list")
+
     return {
         "total": len(rule_matches),
         "active_rules": len(active_rules),
         "analyzed_stocks": len(all_analyzed_stocks),
-        "recommendations": rule_matches[:20],
+        "analyzed_stock_list": [
+            {
+                "stock_code": s.stock_code,
+                "stock_name": s.stock_name,
+                "current_price": int(s.current_price) if s.current_price else 0,
+                "change_rate": round(float(s.change_rate), 2) if s.change_rate else 0,
+                "rsi": round(float(s.rsi), 2) if s.rsi else None,
+                "stochastic_k": round(float(s.stochastic_k), 2) if s.stochastic_k else None,
+                "signals": s.signals or [],
+                "score": s.score or 0,
+            }
+            for s in all_analyzed_stocks
+        ],
+        "recommendations": rule_matches,
         "recommendations_by_rule": recommendations_by_rule,
         "rules_applied": [{"id": r.id, "name": r.name, "priority": r.priority} for r in active_rules],
-        "message": f"✅ DB 캐시 데이터 사용 ({today} 기준)"
     }
 
 
@@ -876,7 +1463,14 @@ async def get_rule_based_recommendations_realtime():
             rule_type="BUY",
             priority=1,
             conditions={"rsi_threshold": 40},
-            actions={"take_profit": 5.0, "stop_loss": 3.0, "position_sizing": {"target_ratio": 0.15}},
+            actions={
+                "take_profit": 3.0,
+                "stop_loss": -1.5,
+                "position_sizing": {"target_ratio": 0.10},
+                "max_position_pct": 0.12,
+                "max_add_buys": 3,
+                "add_buy_cooldown_min": 15
+            },
             is_active=True
         ),
         Rule(
@@ -886,7 +1480,14 @@ async def get_rule_based_recommendations_realtime():
             rule_type="BUY",
             priority=2,
             conditions={"sma_short": 5, "sma_long": 20},
-            actions={"take_profit": 10.0, "stop_loss": 5.0, "position_sizing": {"target_ratio": 0.2}},
+            actions={
+                "take_profit": 3.0,
+                "stop_loss": -1.5,
+                "position_sizing": {"target_ratio": 0.10},
+                "max_position_pct": 0.12,
+                "max_add_buys": 3,
+                "add_buy_cooldown_min": 15
+            },
             is_active=True
         ),
         Rule(
@@ -896,7 +1497,14 @@ async def get_rule_based_recommendations_realtime():
             rule_type="BUY",
             priority=3,
             conditions={"bb_threshold": 0.2},
-            actions={"take_profit": 7.0, "stop_loss": 4.0, "position_sizing": {"target_ratio": 0.15}},
+            actions={
+                "take_profit": 3.0,
+                "stop_loss": -1.5,
+                "position_sizing": {"target_ratio": 0.10},
+                "max_position_pct": 0.12,
+                "max_add_buys": 3,
+                "add_buy_cooldown_min": 15
+            },
             is_active=True
         ),
     ]
@@ -913,13 +1521,13 @@ async def get_rule_based_recommendations_realtime():
             use_moving_average=True
         )
         
-        # 분석할 종목 리스트
+    # 분석할 종목 리스트
         all_stocks = await get_all_tradable_stocks()
-        stocks_to_analyze = all_stocks[:50]  # 50개 종목만
+        stocks_to_analyze = all_stocks[:20]  # 20개 종목으로 단축 (속도 개선)
         
-        # 배치 처리
-        batch_size = 5
-        delay_between_batches = 1.2
+        # 배치 처리 (속도 개선)
+        batch_size = 5  # 배치 크기
+        delay_between_batches = 0.3  # 딜레이 추가 감소
         batch_results = []
         
         for i in range(0, len(stocks_to_analyze), batch_size):
@@ -979,9 +1587,9 @@ async def get_rule_based_recommendations_realtime():
     
     logger.info(f"Found {len(active_rules)} active trading rules")
     
-    # 분석할 종목 리스트 (타임아웃 방지를 위해 20개로 제한)
+    # 분석할 종목 리스트 (타임아웃 방지를 위해 10개로 제한)
     all_stocks = await get_all_tradable_stocks()
-    stocks_to_analyze = all_stocks[:20]  # 상위 20개 종목으로 제한
+    stocks_to_analyze = all_stocks[:10]  # 상위 10개 종목으로 제한
     
     # ✅ 최적화: 모든 종목을 한 번만 분석 (모든 지표 포함)
     logger.info(f"Analyzing {len(stocks_to_analyze)} stocks once with all indicators...")
@@ -1031,6 +1639,10 @@ async def get_rule_based_recommendations_realtime():
         rule_matched_stocks = []
         
         for stock in valid_analyzed_stocks:
+            # ETF/레버리지/인버스/KODEX/선물 종목 제외
+            etf_keywords = ["ETF", "etf", "레버리지", "인버스", "KODEX", "선물"]
+            if any(k in stock.stock_name for k in etf_keywords):
+                continue
             # 규칙 조건 체크
             matches = True
             
@@ -1040,6 +1652,20 @@ async def get_rule_based_recommendations_realtime():
                 if not any(f"RSI" in signal for signal in stock.signals):
                     matches = False
             
+            # Trend filter: only allow long entries in uptrend
+            if TREND_FILTER_ENABLED:
+                try:
+                    t_ok = False
+                    if stock.ma20 is not None and stock.ma60 is not None:
+                        t_ok = (stock.ma20 > stock.ma60) and (stock.current_price > stock.ma20)
+                    else:
+                        # Fallback compute from price history is skipped here (already done in analyze_stock)
+                        t_ok = False
+                    if not t_ok:
+                        matches = False
+                except Exception:
+                    matches = False
+
             if matches:
                 rule_matched_stocks.append(stock)
         
@@ -1055,9 +1681,12 @@ async def get_rule_based_recommendations_realtime():
                 "rule_name": rule.name,
                 "rule_description": rule.description,
                 "rule_priority": rule.priority,
-                "position_ratio": actions.get("position_sizing", {}).get("target_ratio", 0.15),
-                "take_profit": actions.get("take_profit", 5.0),
-                "stop_loss": actions.get("stop_loss", 3.0)
+                "position_ratio": actions.get("position_sizing", {}).get("target_ratio", 0.10),
+                "take_profit": actions.get("take_profit", 3.0),
+                "stop_loss": actions.get("stop_loss", -1.5),
+                "max_position_pct": actions.get("max_position_pct", 0.12),
+                "max_add_buys": actions.get("max_add_buys", 3),
+                "add_buy_cooldown_min": actions.get("add_buy_cooldown_min", 15)
             }
             rule_stocks.append(stock_with_rule)
             rule_matches.append(stock_with_rule)
@@ -1105,6 +1734,50 @@ async def get_rule_based_recommendations_realtime():
                 stock["current_price"] = updated["current_price"]
                 stock["change_rate"] = updated["change_rate"]
     
+    # 실시간 분석 결과를 DB에 저장
+    from app.models.models import StockAnalysis
+    from sqlalchemy.ext.asyncio import AsyncSession
+    from app.core.database import AsyncSessionLocal
+    import datetime
+    
+    db = AsyncSessionLocal()
+    today = datetime.datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+    for rec in top_recommendations:
+        # 중복 저장 방지: 오늘자+종목코드 기준
+        exists = await db.execute(
+            StockAnalysis.__table__.select().where(
+                StockAnalysis.stock_code == rec["stock_code"],
+                StockAnalysis.analysis_date == today
+            )
+        )
+        if not exists.first():
+            stock_obj = StockAnalysis(
+                stock_code=rec["stock_code"],
+                stock_name=rec["stock_name"],
+                analysis_date=today,
+                current_price=rec["current_price"],
+                change_rate=rec.get("change_rate", 0),
+                volume=rec.get("volume", 0),
+                rsi=rec.get("rsi", None),
+                ma5=rec.get("ma5", None),
+                ma20=rec.get("ma20", None),
+                ma60=rec.get("ma60", None),
+                stochastic_k=rec.get("stochastic_k", None),
+                stochastic_d=rec.get("stochastic_d", None),
+                bollinger_upper=rec.get("bollinger_upper", None),
+                bollinger_lower=rec.get("bollinger_lower", None),
+                bollinger_middle=rec.get("bollinger_middle", None),
+                signals=rec.get("signals", []),
+                score=rec.get("score", 0),
+                ml_score=rec.get("ml_score"),
+                ml_confidence=rec.get("ml_confidence"),
+                ml_signal=rec.get("ml_signal"),
+            )
+            db.add(stock_obj)
+    try:
+        await db.commit()
+    finally:
+        await db.close()
     return {
         "total": len(rule_matches),
         "active_rules": len(active_rules),
@@ -1115,10 +1788,171 @@ async def get_rule_based_recommendations_realtime():
     }
 
 
+async def _mcp_validate_buy(stock: dict) -> tuple:
+    """MCP 서버에 AI 매수 검증 요청
+
+    Returns:
+        (approved: bool, reason: str)
+        - 오류/타임아웃 시 (True, "mcp_unavailable") — fail-open (매매 차단 안 함)
+    """
+    if not settings.MCP_VALIDATION_ENABLED:
+        return True, "mcp_disabled"
+
+    try:
+        payload = {
+            "analysis_type": "RULE_VALIDATION",
+            "data": {
+                "rule": {
+                    "id": stock.get("rule_id"),
+                    "name": stock.get("rule_name", "auto_trade"),
+                },
+                "market_data": {
+                    "stock_code": stock.get("stock_code"),
+                    "stock_name": stock.get("stock_name"),
+                    "current_price": stock.get("current_price"),
+                    "signals": stock.get("signals", []),
+                    "score": stock.get("score"),
+                    "ml_signal": stock.get("ml_signal"),
+                    "ml_confidence": stock.get("ml_confidence"),
+                    "ma20": stock.get("ma20"),
+                    "ma60": stock.get("ma60"),
+                }
+            }
+        }
+
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            resp = await client.post(
+                f"{settings.MCP_SERVER_URL}/analyze",
+                json=payload
+            )
+            resp.raise_for_status()
+            data = resp.json()
+
+        result = data.get("result", {})
+        decision = result.get("decision", "HOLD")
+        confidence = float(result.get("confidence", 0.0))
+
+        logger.info(
+            f"🤖 MCP 검증: {stock.get('stock_name')} → "
+            f"decision={decision}, confidence={confidence:.2f}"
+        )
+
+        if decision == "BUY" and confidence >= settings.MCP_CONFIDENCE_THRESHOLD:
+            return True, f"mcp_approved(conf={confidence:.2f})"
+        else:
+            return False, f"mcp_rejected(decision={decision}, conf={confidence:.2f})"
+
+    except Exception as e:
+        logger.warning(f"⚠️ MCP 검증 실패 (스킵하고 계속): {e}")
+        return True, "mcp_unavailable"  # 장애 시 매매 차단 안 함
+
+
+async def execute_auto_trade_background(recommendations_response: dict, db: AsyncSession):
+    """백그라운드에서 자동매매 실행"""
+    try:
+        trade_results = []
+        total_processed = 0
+        skipped_held = 0  # 이미 보유 중인 종목 수
+
+        # 🐻 하락장 방어: 시장 레짐에 따라 매매 건수 제한
+        market_regime = None
+        if settings.BEAR_MARKET_FILTER_ENABLED:
+            market_regime = await check_market_regime()
+            logger.info(f"🐻 자동매매 시장 상태: {market_regime['message']}")
+
+        regime_max_trades = market_regime.get("max_trades", 20) if market_regime else 20
+        position_multiplier = market_regime.get("position_multiplier", 1.0) if market_regime else 1.0
+        max_trades = min(20, regime_max_trades)
+        
+        # 현재 보유 중인 종목 조회
+        from app.models.models import Portfolio
+        result = await db.execute(
+            select(Portfolio).where(Portfolio.quantity > 0)
+        )
+        held_stocks = {p.stock_code for p in result.scalars().all()}
+        if held_stocks:
+            logger.info(f"현재 보유 중: {len(held_stocks)}개 종목")
+        
+        # ✅ 중복 제거: 모든 규칙 그룹의 종목을 합쳐서 중복 제거
+        unique_stocks = {}
+        for rule_group in recommendations_response["recommendations_by_rule"]:
+            for stock in rule_group["stocks"]:
+                stock_code = stock.get("stock_code")
+                # 우선순위가 높은 규칙의 종목을 우선 (priority가 낮을수록 우선순위 높음)
+                if stock_code not in unique_stocks:
+                    unique_stocks[stock_code] = stock
+                elif stock.get("rule_priority", 999) < unique_stocks[stock_code].get("rule_priority", 999):
+                    unique_stocks[stock_code] = stock
+        
+        # 우선순위와 점수로 정렬
+        sorted_stocks = sorted(
+            unique_stocks.values(),
+            key=lambda s: (s.get("rule_priority", 999), -s.get("score", 0))
+        )
+        
+        logger.info(f"📊 자동매매 대상: 총 {len(sorted_stocks)}개 종목 (중복 제거 완료)")
+        
+        for stock in sorted_stocks[:max_trades]:
+            # 🔄 이미 보유 중인 종목도 추가 매수 허용 (일일 2회 제한 내에서)
+            # if stock.get("stock_code") in held_stocks:
+            #     skipped_held += 1
+            #     logger.debug(f"⏭️  {stock.get('stock_name')} - 이미 보유중, 건너뜀")
+            #     continue
+
+            try:
+                # 🐻 하락장 포지션 축소 비율 전달
+                stock["_position_multiplier"] = position_multiplier
+                result = await execute_auto_trade(stock, db)
+                total_processed += 1
+                
+                if result["action"] in ["BUY", "SELL"]:
+                    trade_results.append(result)
+                    logger.info(f"✅ {result['action']} {result['stock']} - {result.get('quantity')}주")
+                
+                # Rate Limiting: KIS API 호출 간 0.5초 대기
+                await asyncio.sleep(0.5)
+                
+            except Exception as e:
+                logger.error(f"Error executing auto-trade for {stock.get('stock_code')}: {e}")
+                continue
+        
+        logger.info(f"🎯 자동매매 완료: {len(trade_results)}건 실행 / {total_processed}개 분석 / {skipped_held}개 보유중")
+        
+    except Exception as e:
+        logger.error(f"❌ Background auto-trade error: {e}")
+
+
+async def _background_sync_portfolio():
+    """백그라운드 포트폴리오 동기화 (새 세션 사용)"""
+    try:
+        from app.api.endpoints.portfolio import sync_portfolio
+        async with AsyncSessionLocal() as session:
+            await sync_portfolio(session, force=True)
+    except Exception as e:
+        logger.error(f"Background portfolio sync failed: {e}")
+
+
+async def _delayed_sync_portfolio(delay_seconds: int = 3):
+    """지연 포트폴리오 동기화 (KIS API 업데이트 대기)"""
+    try:
+        await asyncio.sleep(delay_seconds)
+        from app.api.endpoints.portfolio import sync_portfolio
+        from app.core.database import AsyncSessionLocal
+        
+        async with AsyncSessionLocal() as session:
+            try:
+                await sync_portfolio(session, force=True)
+                logger.info(f"🔄 Delayed portfolio sync completed after {delay_seconds}s")
+            except Exception as inner_e:
+                logger.error(f"Sync execution failed: {inner_e}")
+    except Exception as e:
+        logger.error(f"Delayed portfolio sync failed: {e}")
+
+
 # 자동 매매 실행 함수
 async def execute_auto_trade(stock: dict, db: AsyncSession):
     """
-    추천 종목에 대해 자동 매매 실행
+    추천 종목에 대해 자동 매매 실행 (국내 + 해외 주식)
     - 매수 신호: 정배열, RSI < 30 등
     - 매도 신호: 역배열, RSI > 70, 손익률 기준
     """
@@ -1132,6 +1966,55 @@ async def execute_auto_trade(stock: dict, db: AsyncSession):
             logger.debug(f"Invalid stock data for auto trade: {stock}")
             return {"action": "SKIP", "reason": "invalid_data"}
 
+        # 국내/해외 구분 (6자리 숫자면 국내, 알파벳 포함이면 해외)
+        is_domestic = stock_code.isdigit() and len(stock_code) == 6
+        exchange_code = stock.get("exchange_code", "NASD")  # 기본값: 나스닥
+
+        # 가격 필터 (CLAUDE.md 섹션 6.4)
+        if is_domestic:
+            if current_price < settings.MIN_PRICE_KRW:
+                logger.info(f"가격 필터: {stock_name} ({current_price:,.0f}원 < {settings.MIN_PRICE_KRW:,}원)")
+                return {"action": "SKIP", "reason": "penny_stock", "stock": stock_name}
+        else:
+            if current_price < settings.MIN_PRICE_USD:
+                logger.info(f"가격 필터: {stock_name} (${current_price:.2f} < ${settings.MIN_PRICE_USD:.2f})")
+                return {"action": "SKIP", "reason": "penny_stock", "stock": stock_name}
+
+        # MDD 체크 (섹션 6.3) — async lock으로 thread-safe
+        if not await mdd_manager.can_open_new_position():
+            logger.info(f"MDD 제한: 신규 진입 중단 상태 - {stock_name} 스킵")
+            return {"action": "SKIP", "reason": "mdd_pause", "stock": stock_name}
+
+        # 연속 손실 금지 체크 (섹션 7.4)
+        if loss_tracker.is_banned(stock_code):
+            ban_info = loss_tracker.get_ban_info(stock_code)
+            logger.info(f"연속 손실 금지: {stock_name} ({ban_info})")
+            return {"action": "SKIP", "reason": "consecutive_loss_ban", "stock": stock_name}
+
+        # 보유 종목 수 체크 (섹션 6.1: 최대 20종목)
+        held_result = await db.execute(select(Portfolio).where(Portfolio.quantity > 0))
+        held_count = len(held_result.scalars().all())
+        if held_count >= settings.MAX_HOLDINGS_COUNT:
+            logger.info(f"보유 종목 한도: {held_count}/{settings.MAX_HOLDINGS_COUNT} - {stock_name} 스킵")
+            return {"action": "SKIP", "reason": "max_holdings_reached", "stock": stock_name}
+
+        # 0. 매도 후 재진입 금지 (Cooldown) - 최근 24시간 내 매도 이력 확인
+        # 같은 날 손절친 종목을 다시 사는 것을 방지
+        from app.models.models import TradeHistory
+        cutoff_time = _get_kst_now().replace(hour=0, minute=0, second=0, microsecond=0)
+        
+        recent_sell = await db.execute(
+            select(TradeHistory).where(
+                TradeHistory.stock_code == stock_code,
+                TradeHistory.order_type == "SELL",
+                TradeHistory.status == "EXECUTED",
+                TradeHistory.executed_at >= cutoff_time
+            )
+        )
+        if recent_sell.first():
+            logger.info(f"🚫 Cooldown active: {stock_name}({stock_code}) was sold today. Skipping BUY.")
+            return {"action": "SKIP", "reason": "cooldown_sell_today", "stock": stock_name}
+
         # 이미 보유 중인지 확인
         result = await db.execute(
             select(Portfolio).where(
@@ -1174,27 +2057,246 @@ async def execute_auto_trade(stock: dict, db: AsyncSession):
         ]
         should_sell = any(k in text_signals for k in sell_keywords)
 
+        # 🤖 ML 앙상블 기반 매수/매도 판단 (설정 활성화 시)
+        ml_score_trade = stock.get("ml_score")
+        ml_confidence_trade = stock.get("ml_confidence")
+        ml_signal_trade = stock.get("ml_signal")
+
+        if settings.ML_ENSEMBLE_ENABLED and ml_score_trade is not None:
+            # ML 신호가 BUY이고 신뢰도/스코어 충분하면 매수
+            if (ml_signal_trade == "BUY"
+                    and ml_score_trade >= settings.ML_ENSEMBLE_BUY_THRESHOLD
+                    and (ml_confidence_trade or 0) >= settings.ML_ENSEMBLE_CONFIDENCE_MIN):
+                should_buy = True
+                logger.info(f"🤖 ML 매수 신호: {stock_name} (score={ml_score_trade}, conf={ml_confidence_trade:.2f})")
+            # ML 신호가 SELL이면 매도 강화
+            elif ml_signal_trade == "SELL" and (ml_confidence_trade or 0) >= 0.5:
+                should_sell = True
+                logger.info(f"🤖 ML 매도 신호: {stock_name} (score={ml_score_trade}, conf={ml_confidence_trade:.2f})")
+            # ML 신뢰도가 낮으면 매수 억제
+            elif ml_signal_trade == "HOLD" and (ml_confidence_trade or 0) < settings.ML_ENSEMBLE_CONFIDENCE_MIN:
+                should_buy = False
+                logger.info(f"🤖 ML 관망 신호로 매수 억제: {stock_name}")
+
+        # ✅ 규칙 기반 추천 종목도 안전장치 적용 (이격도 과열, 급등 체크)
+        has_rule = stock.get("rule_id") is not None or stock.get("rule_name") is not None
+        if has_rule:
+            # 이격도 과열 시 매수 금지
+            if "이격도 과열" in text_signals or "매수금지" in text_signals:
+                logger.info(f"🚫 규칙 추천이지만 이격도 과열로 매수 금지: {stock_name}")
+                return {"action": "HOLD", "stock": stock_name, "reason": "disparity_overheated"}
+
+            # 급등 종목 추격 금지 체크
+            if "급등 종목 추격 금지" in text_signals or "급등과열" in text_signals:
+                logger.info(f"🚫 규칙 추천이지만 급등/과열 금지: {stock_name}")
+                return {"action": "HOLD", "stock": stock_name, "reason": "chase_buy_prevention"}
+
+            should_buy = True
+            logger.info(f"📋 규칙 기반 추천: {stock_name} - {stock.get('rule_name', '매수규칙')}")
+
         # 매수 로직 (신호 또는 점수 기반)
-        # 조건 완화: 점수 기준 1점 이상으로 매수 허용 (신호가 약해도 소액 진입)
-        if (should_buy or (score_val >= 1)) and not holding:
-            # 투자 가능 금액의 10% 매수 (예수금 1000만원 기준 100만원)
-            available_cash = 10000000  # 예수금 (실제로는 API에서 조회해야 함)
-            invest_amount = available_cash * 0.10  # 10% 투자
+        # 추가매수 허용: 보유 중이어도 비중 한도 내에서 추매 가능
+        if (should_buy or (score_val >= 1)):
+            # 🚫 추격매수 방지: 급등 종목 필터
+            try:
+                if is_domestic:
+                    chart_resp = await korea_investment_api.get_daily_chart(stock_code, "D", limit=10)
+                    chart_data = chart_resp.get("output2", [])
+                else:
+                    chart_resp = await korea_investment_api.get_overseas_daily_chart(stock_code, exchange_code, "D")
+                    chart_data = chart_resp.get("output2", [])
+
+                if len(chart_data) >= 4:
+                    # 국내/해외 데이터 키 차이 처리
+                    if is_domestic:
+                        closes = [float(item.get("stck_clpr", 0)) for item in chart_data[-4:]]
+                    else:
+                        closes = [float(item.get("clos", 0)) for item in chart_data[-4:]]
+
+                    if len(closes) >= 4:
+                        price_3days_ago = closes[0]
+                        recent_gain = ((current_price - price_3days_ago) / price_3days_ago) * 100 if price_3days_ago > 0 else 0
+                        if recent_gain > 10:  # 3일간 10% 이상 급등
+                            logger.info(f"🚫 급등 종목 추격 금지: {stock_name} (3일 +{recent_gain:.1f}%)")
+                            return {"action": "HOLD", "stock": stock_name, "reason": "chase_buy_prevention"}
+            except Exception as e:
+                logger.warning(f"⚠️ 급등 체크 실패, 계속 진행: {e}")
+
+            # Enforce trend filter for buys
+            if TREND_FILTER_ENABLED:
+                try:
+                    ma20 = stock.get("ma20")
+                    ma60 = stock.get("ma60")
+                    # If moving averages not provided, fetch quick chart to compute
+                    if ma20 is None or ma60 is None:
+                        if is_domestic:
+                            chart_resp = await korea_investment_api.get_daily_chart(stock_code, "D")
+                            closes_local = [float(it.get("stck_clpr", 0)) for it in (chart_resp.get("output") or [])]
+                        else:
+                            chart_resp = await korea_investment_api.get_overseas_daily_chart(stock_code, exchange_code, "D")
+                            closes_local = [float(it.get("clos", 0)) for it in (chart_resp.get("output2") or [])]
+
+                        if len(closes_local) >= max(TREND_MA_SHORT, TREND_MA_LONG):
+                            ma20 = _ma(closes_local, TREND_MA_SHORT)
+                            ma60 = _ma(closes_local, TREND_MA_LONG)
+                    # 허용 오차 적용
+                    if not (ma20 and ma60 and (float(ma20) >= float(ma60) * (1 - TREND_TOLERANCE_PCT)) and (current_price >= float(ma20) * (1 - TREND_TOLERANCE_PCT))):
+                        logger.info(f"🚫 Trend filter rejected BUY: {stock_name} (price={current_price}, ma20={ma20}, ma60={ma60}, tol={TREND_TOLERANCE_PCT})")
+                        return {"action": "HOLD", "stock": stock_name, "reason": "trend_filter"}
+                except Exception as e:
+                    logger.info(f"⚠️ Trend filter check failed, skipping buy as safe default: {e}")
+                    return {"action": "HOLD", "stock": stock_name, "reason": "trend_filter_error"}
+            # 포트폴리오 요약 정보
+            try:
+                from app.api.endpoints.portfolio import portfolio_cache
+                available_cash = float(portfolio_cache.summary.get("available_cash", 0)) if portfolio_cache.summary else 0.0
+                total_assets = float(portfolio_cache.summary.get("total_assets", 0)) if portfolio_cache.summary else 0.0
+            except Exception:
+                available_cash, total_assets = 0.0, 0.0
+
+            # 🔥 하루 매매 횟수 제한 (당일 0시부터 카운트)
+            daily_cutoff = _get_kst_now().replace(hour=0, minute=0, second=0, microsecond=0)
+            daily_buy_check = await db.execute(
+                select(TradeHistory)
+                .where(
+                    TradeHistory.stock_code == stock_code,
+                    TradeHistory.order_type == "BUY",
+                    TradeHistory.status.in_(['EXECUTED', 'COMPLETED']),  # COMPLETED도 포함
+                    TradeHistory.created_at >= daily_cutoff,
+                )
+            )
+            daily_buys = daily_buy_check.scalars().all()
+            daily_buy_count = len(daily_buys)
+
+            # 🚫 하루 최대 2회 매매 제한 (신규 + 추가)
+            max_daily_trades = 2
+            if daily_buy_count >= max_daily_trades:
+                logger.info(f"🚫 일일 매매 한도 초과: {stock_name} 당일 {daily_buy_count}/{max_daily_trades}회")
+                return {"action": "HOLD", "stock": stock_name, "reason": "daily_trade_limit"}
+
+            # 기본 파라미터 (권장 안전 프로파일, 규칙에서 오버라이드 가능)
+            target_ratio = float(stock.get("position_ratio", 0.10) or 0.10)  # 목표 비중(자산 대비)
+            max_position_pct = float(stock.get("max_position_pct", 0.12) or 0.12)  # 최대 비중 캡
+            cooldown_min = int(stock.get("add_buy_cooldown_min", 30) or 30)  # 추가매수 쿨다운(분) - 30분으로 증가
+
+            # 🔥 쿨다운 체크 (보유 여부와 관계없이 항상 체크)
+            # 포트폴리오 동기화가 느릴 수 있으므로, DB 거래 내역 기준으로 체크
+            cooldown_check = await db.execute(
+                select(TradeHistory)
+                .where(
+                    TradeHistory.stock_code == stock_code,
+                    TradeHistory.order_type == "BUY",
+                    TradeHistory.status.in_(['EXECUTED', 'COMPLETED']),
+                    TradeHistory.created_at >= daily_cutoff,
+                )
+                .order_by(desc(TradeHistory.created_at))
+            )
+            recent_buys = cooldown_check.scalars().all()
+            last_buy_at = recent_buys[0].created_at if recent_buys else None
+
+            # 쿨다운 체크
+            if last_buy_at and (datetime.now() - last_buy_at).total_seconds() < cooldown_min * 60:
+                logger.info(f"⏳ 추가매수 대기: {stock_name} {cooldown_min}분 쿨다운 미경과")
+                return {"action": "HOLD", "stock": stock_name, "reason": "cooldown"}
+
+            # 목표/최대 비중 기반 투자금 계산 (이전에 최근 매수 기록 체크)
+            # 보유중이 아니더라도(아직 싱크 안됨) 최근 매수 시도가 있으면 스킵
+            recent_buy_cutoff = _get_kst_now() - timedelta(minutes=5)
+            check_recent = await db.execute(
+                select(TradeHistory).where(
+                    TradeHistory.stock_code == stock_code,
+                    TradeHistory.order_type == "BUY",
+                    TradeHistory.created_at >= recent_buy_cutoff,
+                    TradeHistory.status.in_(['EXECUTED', 'COMPLETED', 'PENDING'])
+                )
+            )
+            if check_recent.first():
+                logger.info(f"⏳ 최근 5분 내 매수 이력 존재: {stock_name} - 스킵")
+                return {"action": "SKIP", "stock": stock_name, "reason": "recent_buy_5min"}
+
+            # ✅ MCP AI 검증 (BUY 최종 확인 - 모든 사전 필터 통과 후)
+            mcp_ok, mcp_reason = await _mcp_validate_buy(stock)
+            if not mcp_ok:
+                logger.info(f"🚫 MCP AI 매수 거부: {stock_name} ({mcp_reason})")
+                return {"action": "HOLD", "stock": stock_name, "reason": mcp_reason}
+
+            if total_assets > 0:
+                current_value = (holding.quantity * current_price) if holding else 0.0
+                desired_value = total_assets * target_ratio
+                max_allowed_value = total_assets * max_position_pct
+                add_value = max(0.0, desired_value - current_value)
+                add_value = min(add_value, max(0.0, max_allowed_value - current_value))
+                invest_amount = min(add_value, available_cash)
+            else:
+                # 총자산 미확정 시 보수적으로 현금의 10%
+                invest_amount = available_cash * 0.10
+
+            # 🐻 하락장 포지션 축소 적용
+            pos_mult = float(stock.get("_position_multiplier", 1.0))
+            if pos_mult < 1.0:
+                original_amount = invest_amount
+                invest_amount = invest_amount * pos_mult
+                logger.info(f"🐻 하락장 포지션 축소: {stock_name} {original_amount:,.0f}원 → {invest_amount:,.0f}원 (x{pos_mult})")
+
             quantity = int(invest_amount / current_price)
-            
+
+            logger.info(f"💰 {stock_name}({stock_code}): 예수금={available_cash:,.0f}원, 투자금액={invest_amount:,.0f}원, 수량={quantity}주, 가격={current_price:,.0f}원")
+
             if quantity > 0:
                 logger.info(f"🟢 매수 신호 감지: {stock_name}({stock_code}) - {signals}")
                 
-                # KIS API로 매수 주문
+                # KIS API로 매수 주문 (지정가: 현재가로 주문)
                 try:
-                    order_result = await korea_investment_api.place_order(
-                        stock_code=stock_code,
-                        order_type="BUY",
-                        quantity=quantity,
-                        price=None  # 시장가 주문
-                    )
+                    if is_domestic:
+                        order_result = await korea_investment_api.place_order(
+                            stock_code=stock_code,
+                            order_type="BUY",
+                            quantity=quantity,
+                            price=int(current_price)  # 지정가 주문 (현재가)
+                        )
+                    else:
+                        order_result = await korea_investment_api.place_overseas_order(
+                            symbol=stock_code,
+                            order_type="BUY",
+                            quantity=quantity,
+                            price=float(current_price),  # 해외 주식은 달러 단위
+                            exchange_code=exchange_code
+                        )
+                    
+                    # 주문 결과 상세 로깅
+                    logger.info(f"📝 매수 주문 결과: {stock_name}({stock_code}) - rt_cd={order_result.get('rt_cd')}, msg={order_result.get('msg1')}, odno={order_result.get('odno')}")
+                    logger.debug(f"Full order result: {order_result}")
+                    
+                    # 중복 거래 방지: 최근 10초 이내 동일 종목 동일 타입 주문 확인
+                    recent_cutoff = _get_kst_now() - timedelta(seconds=10)
+                    duplicate_check = await db.execute(
+                        select(TradeHistory).where(
+                            TradeHistory.stock_code == stock_code,
+                            TradeHistory.order_type == "BUY",
+                            TradeHistory.created_at >= recent_cutoff
+                        )
+                    )
+                    recent_duplicate = duplicate_check.scalar_one_or_none()
+                    
+                    if recent_duplicate:
+                        logger.warning(f"⚠️ 중복 매수 방지: {stock_name} - 10초 이내 동일 주문 존재")
+                        return {"action": "SKIP", "reason": "duplicate_order", "stock": stock_name}
+                    
+                    # 거래 이력 저장 (상세 정보 포함)
+                    total_amount = Decimal(str(current_price)) * quantity
+                    entry_reason = f"매수 신호: {', '.join(signals[:3])}. 점수: {score_val}점"
+                    
+                    success = order_result.get("rt_cd") == "0"
+                    error_msg = order_result.get("msg1", "") if not success else ""
+                    
+                    # 주문 상태 결정
+                    if success:
+                        status = "COMPLETED"  # 체결 완료
+                    elif order_result.get("rt_cd") == "1":
+                        status = "PENDING"  # 주문 접수됨, 체결 대기
+                    else:
+                        status = "FAILED"  # 주문 실패
                     
-                    # 거래 이력 저장
                     trade = TradeHistory(
                         rule_id=stock.get("rule_id"),
                         stock_code=stock_code,
@@ -1202,18 +2304,26 @@ async def execute_auto_trade(stock: dict, db: AsyncSession):
                         order_type="BUY",
                         order_price=Decimal(str(current_price)),
                         order_quantity=quantity,
-                        executed_price=Decimal(str(current_price)),
-                        executed_quantity=quantity,
-                        status="EXECUTED" if order_result.get("rt_cd") == "0" else "FAILED",
+                        executed_price=Decimal(str(current_price)) if success else None,
+                        executed_quantity=quantity if success else 0,
+                        total_amount=total_amount,
+                        status=status,
                         order_id=order_result.get("odno"),
-                        message=f"자동매수: {' | '.join(signals[:2])}",
-                        created_at=datetime.now()
+                        message=f"자동매수: {'추가매수' if holding else '신규'} | {' | '.join(signals[:2])} | {error_msg if not success else '체결완료'}",
+                        entry_reason=entry_reason,
+                        signals=signals,
+                        created_at=_get_kst_now(),
+                        executed_at=_get_kst_now() if success else None
                     )
                     db.add(trade)
                     await db.commit()
                     
-                    success = order_result.get("rt_cd") == "0"
-                    logger.info(f"✅ 매수 주문 완료: {stock_name} {quantity}주 @ {current_price}원 (success={success})")
+                    if success:
+                        logger.info(f"✅ 매수 체결 완료: {stock_name} {quantity}주 @ {current_price}원")
+                    elif status == "PENDING":
+                        logger.info(f"⏳ 매수 주문 접수: {stock_name} {quantity}주 @ {current_price}원 - 체결 대기중")
+                    else:
+                        logger.warning(f"❌ 매수 주문 실패: {stock_name} {quantity}주 - {error_msg}")
                     # Optimistic local 포트폴리오 업데이트
                     if success:
                         if holding:
@@ -1236,16 +2346,26 @@ async def execute_auto_trade(stock: dict, db: AsyncSession):
                             )
                             db.add(new_holding)
                         await db.commit()
+                        # 포트폴리오 캐시 즉시 업데이트
                         try:
                             from app.api.endpoints.portfolio import portfolio_cache
-                            portfolio_cache.mark_changed()
-                        except Exception:
-                            logger.debug("Portfolio cache not available for mark_changed")
+                            # 캐시 완전 초기화 - 다음 조회시 강제로 KIS API 호출
+                            portfolio_cache.holdings = []
+                            portfolio_cache.summary = None
+                            portfolio_cache.last_synced = None
+                            portfolio_cache.last_trade_id = None
+                            portfolio_cache.change_flag = True
+                            logger.info(f"🔄 Portfolio cache CLEARED after BUY {stock_name}({stock_code})")
+                        except Exception as e:
+                            logger.error(f"Portfolio cache clear failed after BUY: {e}")
                     return {"action": "BUY", "stock": stock_name, "quantity": quantity, "price": current_price, "success": success}
                     
                 except Exception as e:
                     logger.error(f"❌ 매수 주문 실패: {stock_name} - {e}")
                     return {"action": "BUY_FAILED", "stock": stock_name, "error": str(e)}
+            else:
+                logger.debug(f"⚠️ {stock_name}({stock_code}): 매수 수량 0 (가격={current_price:,.0f}원, 예수금={available_cash:,.0f}원)")
+                return {"action": "SKIP", "reason": "quantity_zero", "stock": stock_name}
         
         # 매도 로직
         elif should_sell and holding:
@@ -1253,8 +2373,8 @@ async def execute_auto_trade(stock: dict, db: AsyncSession):
             profit_loss_rate = float(holding.profit_loss_rate or 0)
             
             # 익절/손절 조건 확인
-            take_profit = stock.get("take_profit", 5.0)  # 5% 익절
-            stop_loss = stock.get("stop_loss", -3.0)  # 3% 손절
+            take_profit = stock.get("take_profit", 3.0)  # 3% 익절(권장)
+            stop_loss = stock.get("stop_loss", -1.5)  # -1.5% 손절(권장)
             
             should_execute_sell = (
                 profit_loss_rate >= take_profit or  # 익절
@@ -1266,14 +2386,68 @@ async def execute_auto_trade(stock: dict, db: AsyncSession):
                 logger.info(f"🔴 매도 신호 감지: {stock_name}({stock_code}) - 손익률: {profit_loss_rate:.2f}% - {signals}")
                 
                 try:
-                    order_result = await korea_investment_api.place_order(
-                        stock_code=stock_code,
-                        order_type="SELL",
-                        quantity=quantity,
-                        price=None  # 시장가 주문
-                    )
+                    if is_domestic:
+                        order_result = await korea_investment_api.place_order(
+                            stock_code=stock_code,
+                            order_type="SELL",
+                            quantity=quantity,
+                            price=int(current_price)  # 지정가 주문 (현재가)
+                        )
+                    else:
+                        order_result = await korea_investment_api.place_overseas_order(
+                            symbol=stock_code,
+                            order_type="SELL",
+                            quantity=quantity,
+                            price=float(current_price),  # 해외 주식은 달러 단위
+                            exchange_code=exchange_code
+                        )
+                    
+                    # 주문 결과 상세 로깅
+                    logger.info(f"📝 매도 주문 결과: {stock_name}({stock_code}) - rt_cd={order_result.get('rt_cd')}, msg={order_result.get('msg1')}, odno={order_result.get('odno')}")
+                    logger.debug(f"Full order result: {order_result}")
+                    
+                    # 중복 거래 방지: 최근 10초 이내 동일 종목 동일 타입 주문 확인
+                    recent_cutoff = _get_kst_now() - timedelta(seconds=10)
+                    duplicate_check = await db.execute(
+                        select(TradeHistory).where(
+                            TradeHistory.stock_code == stock_code,
+                            TradeHistory.order_type == "SELL",
+                            TradeHistory.created_at >= recent_cutoff
+                        )
+                    )
+                    recent_duplicate = duplicate_check.scalar_one_or_none()
+                    
+                    if recent_duplicate:
+                        logger.warning(f"⚠️ 중복 매도 방지: {stock_name} - 10초 이내 동일 주문 존재")
+                        return {"action": "SKIP", "reason": "duplicate_order", "stock": stock_name}
+                    
+                    # 거래 이력 저장 (상세 정보 포함)
+                    total_amount = Decimal(str(current_price)) * quantity
+                    avg_price = float(holding.average_price or current_price)
+                    profit_loss = (current_price - avg_price) * quantity
+                    
+                    # 매도 이유 상세 작성
+                    exit_reasons = []
+                    if profit_loss_rate >= take_profit:
+                        exit_reasons.append(f"익절 달성 ({profit_loss_rate:.2f}% >= {take_profit}%)")
+                    if profit_loss_rate <= stop_loss:
+                        exit_reasons.append(f"손절 실행 ({profit_loss_rate:.2f}% <= {stop_loss}%)")
+                    if should_sell:
+                        exit_reasons.append(f"매도 신호: {', '.join(signals[:2])}")
+                    
+                    exit_reason = ". ".join(exit_reasons) + f". 평균단가: {avg_price:,.0f}원, 매도가: {current_price:,.0f}원, 손익: {profit_loss:,.0f}원"
+                    
+                    success = order_result.get("rt_cd") == "0"
+                    error_msg = order_result.get("msg1", "") if not success else ""
+                    
+                    # 주문 상태 결정
+                    if success:
+                        status = "COMPLETED"  # 체결 완료
+                    elif order_result.get("rt_cd") == "1":
+                        status = "PENDING"  # 주문 접수됨, 체결 대기
+                    else:
+                        status = "FAILED"  # 주문 실패
                     
-                    # 거래 이력 저장
                     trade = TradeHistory(
                         rule_id=stock.get("rule_id"),
                         stock_code=stock_code,
@@ -1281,34 +2455,45 @@ async def execute_auto_trade(stock: dict, db: AsyncSession):
                         order_type="SELL",
                         order_price=Decimal(str(current_price)),
                         order_quantity=quantity,
-                        executed_price=Decimal(str(current_price)),
-                        executed_quantity=quantity,
-                        status="EXECUTED" if order_result.get("rt_cd") == "0" else "FAILED",
+                        executed_price=Decimal(str(current_price)) if success else None,
+                        executed_quantity=quantity if success else 0,
+                        total_amount=total_amount,
+                        status=status,
                         order_id=order_result.get("odno"),
-                        message=f"자동매도: 손익률 {profit_loss_rate:.2f}% | {' | '.join(signals[:2])}",
-                        created_at=datetime.now()
+                        message=f"자동매도: 손익률 {profit_loss_rate:.2f}% | {' | '.join(signals[:2])} | {error_msg if not success else '체결완료'}",
+                        exit_reason=exit_reason,
+                        signals=signals,
+                        net_profit_loss=Decimal(str(profit_loss)) if success else None,
+                        profit_loss_rate=Decimal(str(profit_loss_rate)) if success else None,
+                        created_at=_get_kst_now(),
+                        executed_at=_get_kst_now() if success else None
                     )
                     db.add(trade)
                     await db.commit()
                     
-                    success = order_result.get("rt_cd") == "0"
-                    logger.info(f"✅ 매도 주문 완료: {stock_name} {quantity}주 @ {current_price}원 (success={success})")
                     if success:
-                        # 포트폴리오에서 수량 0 처리
-                        holding.current_price = Decimal(str(current_price))
-                        holding.quantity = 0
-                        # 손익 계산 (단순: (현재가 - 평균단가)*원래수량)
-                        if holding.average_price:
-                            raw_pl = (current_price - float(holding.average_price)) * quantity
-                            holding.profit_loss = Decimal(str(raw_pl))
-                            rate = (raw_pl / (float(holding.average_price) * quantity) * 100) if holding.average_price and quantity > 0 else 0
-                            holding.profit_loss_rate = Decimal(str(rate))
+                        logger.info(f"✅ 매도 주문 성공: {stock_name} {quantity}주 @ {current_price}원")
+                    else:
+                        logger.warning(f"❌ 매도 주문 실패: {stock_name} {quantity}주 - {error_msg}")
+                    
+                    if success:
+                        # 포트폴리오에서 완전 삭제
+                        await db.delete(holding)
                         await db.commit()
+                        logger.info(f"🗑️ Deleted {stock_name}({stock_code}) from portfolio DB")
+                        
+                        # 포트폴리오 캐시 완전 초기화
                         try:
                             from app.api.endpoints.portfolio import portfolio_cache
-                            portfolio_cache.mark_changed()
-                        except Exception:
-                            logger.debug("Portfolio cache not available for mark_changed")
+                            # 캐시 완전 초기화 - 다음 조회시 강제로 KIS API 호출
+                            portfolio_cache.holdings = []
+                            portfolio_cache.summary = None
+                            portfolio_cache.last_synced = None
+                            portfolio_cache.last_trade_id = None
+                            portfolio_cache.change_flag = True
+                            logger.info(f"🔄 Portfolio cache CLEARED after SELL {stock_name}({stock_code})")
+                        except Exception as e:
+                            logger.error(f"Portfolio cache clear failed after SELL: {e}")
                     return {"action": "SELL", "stock": stock_name, "quantity": quantity, "price": current_price, "profit_loss": profit_loss_rate, "success": success}
                     
                 except Exception as e:
@@ -1316,8 +2501,8 @@ async def execute_auto_trade(stock: dict, db: AsyncSession):
                     return {"action": "SELL_FAILED", "stock": stock_name, "error": str(e)}
         
         # 아무 것도 실행 안됨
-        logger.debug(
-            f"HOLD decision for {stock_code}: buy={should_buy}, sell={should_sell}, holding={bool(holding)}, score={score_val}, signals={signals}"
+        logger.info(
+            f"⏸️ HOLD: {stock_name}({stock_code}) - 매수신호={should_buy}, 매도신호={should_sell}, 보유중={bool(holding)}, 점수={score_val}"
         )
         return {"action": "HOLD", "stock": stock_name}
 
@@ -1376,3 +2561,83 @@ async def execute_auto_trading(db: AsyncSession = Depends(get_db)):
     except Exception as e:
         logger.error(f"❌ 자동 매매 실행 오류: {e}")
         raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/ai/{stock_code}")
+async def get_ai_recommendation(stock_code: str):
+    """MCP 서버를 통한 AI 종목 분석 및 뉴스 조회"""
+    try:
+        # 1. 시장 데이터 조회 (Backend에서 직접 KIS API 호출)
+        price_data = {}
+        try:
+            price_data = await korea_investment_api.get_current_price(stock_code)
+        except Exception as e:
+            logger.warning(f"Failed to fetch price data locally: {e}")
+
+        # 2. MCP 서버에 뉴스 조회 요청
+        news_data = []
+        try:
+            async with httpx.AsyncClient() as client:
+                mcp_url = f"{settings.MCP_SERVER_URL}/tools/call"
+                payload = {
+                    "tool_name": "get_news",
+                    "parameters": {"stock_code": stock_code, "limit": 3}
+                }
+                response = await client.post(mcp_url, json=payload, timeout=10.0)
+                if response.status_code == 200:
+                    result = response.json()
+                    if result.get("status") == "success":
+                         # MCP might wrap it in 'result' -> 'news' or just 'news'
+                        data = result.get("result", {})
+                        if "news" in data:
+                            news_data = data["news"]
+                        else:
+                            news_data = data # Fallback if direct list
+        except Exception as e:
+            logger.warning(f"Failed to fetch news via MCP: {e}")
+
+        # 3. AI 분석 요청 (MCP Analyze)
+        analysis_result = "AI 분석을 수행할 수 없습니다."
+        try:
+            async with httpx.AsyncClient() as client:
+                analyze_url = f"{settings.MCP_SERVER_URL}/analyze"
+                
+                # 시장 데이터 단순화
+                market_summary = {}
+                if "output" in price_data:
+                    output = price_data["output"]
+                    market_summary = {
+                        "current_price": output.get("stck_prpr"),
+                        "change_rate": output.get("prdy_ctrt"),
+                        "volume": output.get("acml_vol"),
+                        "high": output.get("stck_hgpr"),
+                        "low": output.get("stck_lwpr")
+                    }
+
+                payload = {
+                    "analysis_type": "MARKET_ANALYSIS",
+                    "data": {
+                        "stock_code": stock_code,
+                        "market_data": market_summary,
+                        "news": news_data
+                    }
+                }
+                response = await client.post(analyze_url, json=payload, timeout=45.0) # Analysis takes time
+                if response.status_code == 200:
+                     analysis_res = response.json()
+                     # If successful, returns {"analysis_type":..., "result": "Markdown text/JSON"}
+                     if "result" in analysis_res:
+                         analysis_result = analysis_res["result"]
+        except Exception as e:
+            logger.error(f"Failed to fetch AI analysis: {e}")
+            
+        return {
+            "stock_code": stock_code,
+            "analysis": analysis_result,
+            "news": news_data,
+            "market_data": price_data.get("output", {})
+        }
+
+    except Exception as e:
+        logger.error(f"AI Recommendation error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
diff --git a/backend/app/api/endpoints/risk_management.py b/backend/app/api/endpoints/risk_management.py
new file mode 100644
index 0000000..adad59f
--- /dev/null
+++ b/backend/app/api/endpoints/risk_management.py
@@ -0,0 +1,473 @@
+"""
+🔥 리스크 관리 및 성과 평가 API
+
+- MDD (Maximum Drawdown) 추적
+- Sharpe Ratio 계산
+- 연속 손실 제한
+- 일일 손실 한도
+- 포지션 사이징 제한
+"""
+
+from fastapi import APIRouter, HTTPException, Query, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, and_, func, desc
+from datetime import datetime, timedelta, date
+from decimal import Decimal
+from typing import List, Optional
+import logging
+import numpy as np
+
+from app.core.database import get_db
+from app.models.models import TradeHistory, TradingSession, Portfolio
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+# 🔥 리스크 관리 설정
+MAX_POSITION_SIZE_RATIO = 0.20  # 계좌의 20%까지만
+MAX_DAILY_LOSS_RATIO = 0.03     # 일일 3% 손실 시 중단
+MAX_CONSECUTIVE_LOSSES = 3      # 3연속 손실 시 중단
+COMMISSION_RATE = 0.00015       # 수수료 0.015%
+TRADE_TAX_RATE = 0.0023         # 거래세 0.23% (매도 시만)
+TOTAL_COST_RATE = COMMISSION_RATE * 2 + TRADE_TAX_RATE  # 왕복 약 0.26%
+
+
+@router.get("/risk-metrics")
+async def get_risk_metrics(
+    days: int = Query(30, description="분석 기간 (일)"),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    📊 리스크 관리 메트릭 조회
+    
+    - Maximum Drawdown (MDD): 최대 손실 깊이
+    - 누적 손익 곡선
+    - 현재 계좌 상태
+    """
+    try:
+        since_date = datetime.utcnow() - timedelta(days=days)
+        
+        # 매도 완료된 거래만 조회 (실현 손익)
+        result = await db.execute(
+            select(TradeHistory)
+            .where(TradeHistory.created_at >= since_date)
+            .where(TradeHistory.order_type == "SELL")
+            .where(TradeHistory.status.in_(["EXECUTED", "FILLED"]))
+            .order_by(TradeHistory.executed_at)
+        )
+        trades = result.scalars().all()
+        
+        if not trades:
+            return {
+                "max_drawdown": 0,
+                "max_drawdown_pct": 0,
+                "current_equity": 0,
+                "peak_equity": 0,
+                "trades_count": 0,
+                "message": "거래 내역이 없습니다"
+            }
+        
+        # 누적 손익 계산
+        cumulative_pl = 0
+        peak = 0
+        max_drawdown = 0
+        equity_curve = []
+        drawdown_curve = []
+        
+        for trade in trades:
+            # 순손익 사용 (없으면 total_amount 사용)
+            pl = float(trade.net_profit_loss) if trade.net_profit_loss else 0
+            cumulative_pl += pl
+            equity_curve.append({
+                "date": trade.executed_at.isoformat() if trade.executed_at else trade.created_at.isoformat(),
+                "equity": cumulative_pl
+            })
+            
+            # 최고점 갱신
+            if cumulative_pl > peak:
+                peak = cumulative_pl
+            
+            # Drawdown 계산
+            drawdown = peak - cumulative_pl
+            drawdown_pct = (drawdown / peak * 100) if peak > 0 else 0
+            drawdown_curve.append({
+                "date": trade.executed_at.isoformat() if trade.executed_at else trade.created_at.isoformat(),
+                "drawdown": drawdown,
+                "drawdown_pct": round(drawdown_pct, 2)
+            })
+            
+            if drawdown > max_drawdown:
+                max_drawdown = drawdown
+        
+        max_drawdown_pct = (max_drawdown / peak * 100) if peak > 0 else 0
+        
+        # MDD 위험 레벨
+        risk_level = "안전"
+        if max_drawdown_pct > 30:
+            risk_level = "위험 (시스템 중지 권장)"
+        elif max_drawdown_pct > 20:
+            risk_level = "경고 (포지션 축소 권장)"
+        elif max_drawdown_pct > 10:
+            risk_level = "주의"
+        
+        return {
+            "max_drawdown": round(float(max_drawdown), 2),
+            "max_drawdown_pct": round(max_drawdown_pct, 2),
+            "current_equity": round(cumulative_pl, 2),
+            "peak_equity": round(peak, 2),
+            "trades_count": len(trades),
+            "risk_level": risk_level,
+            "equity_curve": equity_curve[-50:],  # 최근 50개만
+            "drawdown_curve": drawdown_curve[-50:]
+        }
+        
+    except Exception as e:
+        logger.error(f"Error calculating risk metrics: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/sharpe-ratio")
+async def get_sharpe_ratio(
+    days: int = Query(30, description="분석 기간 (일)"),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    📈 Sharpe Ratio 계산
+    
+    수익률 대비 변동성(리스크)을 측정
+    - > 2.0: 매우 우수
+    - > 1.0: 우수
+    - < 1.0: 개선 필요
+    """
+    try:
+        since_date = datetime.utcnow() - timedelta(days=days)
+        
+        result = await db.execute(
+            select(TradeHistory)
+            .where(TradeHistory.created_at >= since_date)
+            .where(TradeHistory.order_type == "SELL")
+            .where(TradeHistory.status.in_(["EXECUTED", "FILLED"]))
+            .where(TradeHistory.profit_loss_rate.isnot(None))
+        )
+        trades = result.scalars().all()
+        
+        if len(trades) < 2:
+            return {
+                "sharpe_ratio": None,
+                "avg_return": 0,
+                "std_return": 0,
+                "trades_count": len(trades),
+                "message": "거래가 부족합니다 (최소 2건 필요)"
+            }
+        
+        # 각 거래의 수익률 추출
+        returns = [float(trade.profit_loss_rate) / 100 for trade in trades if trade.profit_loss_rate]
+        
+        if not returns:
+            return {
+                "sharpe_ratio": None,
+                "message": "수익률 데이터가 없습니다"
+            }
+        
+        avg_return = np.mean(returns)
+        std_return = np.std(returns)
+        
+        # Sharpe Ratio 계산 (연간화: 252 거래일 기준)
+        # 무위험 수익률은 0으로 가정
+        sharpe = (avg_return * np.sqrt(252)) / std_return if std_return > 0 else 0
+        
+        # 평가
+        if sharpe > 2:
+            interpretation = "Excellent (매우 우수)"
+        elif sharpe > 1:
+            interpretation = "Good (우수)"
+        elif sharpe > 0:
+            interpretation = "Fair (보통)"
+        else:
+            interpretation = "Poor (개선 필요)"
+        
+        return {
+            "sharpe_ratio": round(sharpe, 3),
+            "avg_return": round(avg_return * 100, 2),  # %
+            "std_return": round(std_return * 100, 2),  # %
+            "annualized_return": round(avg_return * 252 * 100, 2),  # %
+            "interpretation": interpretation,
+            "trades_count": len(returns)
+        }
+        
+    except Exception as e:
+        logger.error(f"Error calculating Sharpe ratio: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/session/today")
+async def get_today_session(db: AsyncSession = Depends(get_db)):
+    """
+    📅 오늘의 트레이딩 세션 조회
+    
+    - 연속 손실/승리 추적
+    - 일일 손익
+    - 거래 중지 상태
+    """
+    try:
+        today = date.today()
+        
+        result = await db.execute(
+            select(TradingSession)
+            .where(TradingSession.session_date == today)
+        )
+        session = result.scalar_one_or_none()
+        
+        if not session:
+            # 오늘 세션이 없으면 생성
+            session = TradingSession(
+                session_date=today,
+                consecutive_losses=0,
+                consecutive_wins=0,
+                daily_profit_loss=0,
+                daily_trades_count=0,
+                is_paused=False
+            )
+            db.add(session)
+            await db.commit()
+            await db.refresh(session)
+        
+        return {
+            "session_date": session.session_date.isoformat(),
+            "consecutive_losses": session.consecutive_losses,
+            "consecutive_wins": session.consecutive_wins,
+            "daily_profit_loss": float(session.daily_profit_loss) if session.daily_profit_loss else 0,
+            "daily_trades_count": session.daily_trades_count,
+            "is_paused": session.is_paused,
+            "pause_reason": session.pause_reason,
+            "starting_balance": float(session.starting_balance) if session.starting_balance else None,
+            "ending_balance": float(session.ending_balance) if session.ending_balance else None,
+            "peak_balance": float(session.peak_balance) if session.peak_balance else None
+        }
+        
+    except Exception as e:
+        logger.error(f"Error getting today's session: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/check-risk-limits")
+async def check_risk_limits(
+    order_value: float = Query(..., description="주문 금액"),
+    account_balance: float = Query(..., description="계좌 잔고"),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    ⚠️ 주문 전 리스크 제한 확인
+    
+    - 포지션 사이즈 제한
+    - 일일 손실 한도
+    - 연속 손실 제한
+    """
+    try:
+        # 1. 오늘 세션 확인
+        today = date.today()
+        result = await db.execute(
+            select(TradingSession)
+            .where(TradingSession.session_date == today)
+        )
+        session = result.scalar_one_or_none()
+        
+        if not session:
+            session = TradingSession(session_date=today, starting_balance=Decimal(str(account_balance)))
+            db.add(session)
+            await db.commit()
+            await db.refresh(session)
+        
+        # 2. 거래 중지 상태 확인
+        if session.is_paused:
+            return {
+                "allowed": False,
+                "reason": session.pause_reason or "거래가 중지되었습니다",
+                "risk_level": "BLOCKED"
+            }
+        
+        # 3. 일일 손실 한도 확인
+        daily_loss_ratio = abs(float(session.daily_profit_loss)) / account_balance if account_balance > 0 else 0
+        if session.daily_profit_loss < 0 and daily_loss_ratio > MAX_DAILY_LOSS_RATIO:
+            # 자동 중지
+            session.is_paused = True
+            session.pause_reason = f"일일 손실 한도 도달 ({daily_loss_ratio*100:.1f}% > {MAX_DAILY_LOSS_RATIO*100}%)"
+            await db.commit()
+            
+            return {
+                "allowed": False,
+                "reason": session.pause_reason,
+                "risk_level": "CRITICAL",
+                "daily_loss": float(session.daily_profit_loss),
+                "daily_loss_ratio": round(daily_loss_ratio * 100, 2)
+            }
+        
+        # 4. 연속 손실 제한 확인
+        if session.consecutive_losses >= MAX_CONSECUTIVE_LOSSES:
+            session.is_paused = True
+            session.pause_reason = f"연속 {session.consecutive_losses}회 손실 발생"
+            await db.commit()
+            
+            return {
+                "allowed": False,
+                "reason": session.pause_reason,
+                "risk_level": "CRITICAL",
+                "consecutive_losses": session.consecutive_losses
+            }
+        
+        # 5. 포지션 사이즈 제한 확인
+        position_ratio = order_value / account_balance if account_balance > 0 else 0
+        if position_ratio > MAX_POSITION_SIZE_RATIO:
+            return {
+                "allowed": False,
+                "reason": f"포지션 사이즈 초과 ({position_ratio*100:.1f}% > {MAX_POSITION_SIZE_RATIO*100}%)",
+                "risk_level": "HIGH",
+                "position_ratio": round(position_ratio * 100, 2),
+                "max_allowed": round(MAX_POSITION_SIZE_RATIO * 100, 2)
+            }
+        
+        # 모든 제한 통과
+        warnings = []
+        if session.consecutive_losses >= 2:
+            warnings.append(f"연속 {session.consecutive_losses}회 손실 중 (주의)")
+        if daily_loss_ratio > MAX_DAILY_LOSS_RATIO * 0.5:
+            warnings.append(f"일일 손실 {daily_loss_ratio*100:.1f}% (주의)")
+        
+        return {
+            "allowed": True,
+            "risk_level": "WARNING" if warnings else "OK",
+            "warnings": warnings,
+            "position_ratio": round(position_ratio * 100, 2),
+            "daily_loss_ratio": round(daily_loss_ratio * 100, 2),
+            "consecutive_losses": session.consecutive_losses
+        }
+        
+    except Exception as e:
+        logger.error(f"Error checking risk limits: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/update-session")
+async def update_trading_session(
+    trade_result: str = Query(..., description="win 또는 loss"),
+    profit_loss: float = Query(..., description="거래 손익"),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    🔄 거래 결과에 따라 세션 업데이트
+    
+    - 연속 손실/승리 카운터
+    - 일일 손익 누적
+    """
+    try:
+        today = date.today()
+        result = await db.execute(
+            select(TradingSession)
+            .where(TradingSession.session_date == today)
+        )
+        session = result.scalar_one_or_none()
+        
+        if not session:
+            session = TradingSession(session_date=today)
+            db.add(session)
+        
+        # 손익 누적
+        current_pl = float(session.daily_profit_loss) if session.daily_profit_loss else 0
+        session.daily_profit_loss = Decimal(str(current_pl + profit_loss))
+        session.daily_trades_count += 1
+        
+        # 연속 손실/승리 업데이트
+        if trade_result == "loss":
+            session.consecutive_losses += 1
+            session.consecutive_wins = 0
+        elif trade_result == "win":
+            session.consecutive_wins += 1
+            session.consecutive_losses = 0
+        
+        await db.commit()
+        await db.refresh(session)
+        
+        return {
+            "session_date": session.session_date.isoformat(),
+            "consecutive_losses": session.consecutive_losses,
+            "consecutive_wins": session.consecutive_wins,
+            "daily_profit_loss": float(session.daily_profit_loss),
+            "daily_trades_count": session.daily_trades_count,
+            "is_paused": session.is_paused
+        }
+        
+    except Exception as e:
+        logger.error(f"Error updating session: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/win-rate")
+async def get_win_rate(
+    days: int = Query(30, description="분석 기간 (일)"),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    📊 승률 및 손익 통계
+    """
+    try:
+        since_date = datetime.utcnow() - timedelta(days=days)
+        
+        result = await db.execute(
+            select(TradeHistory)
+            .where(TradeHistory.created_at >= since_date)
+            .where(TradeHistory.order_type == "SELL")
+            .where(TradeHistory.status.in_(["EXECUTED", "FILLED"]))
+        )
+        trades = result.scalars().all()
+        
+        if not trades:
+            return {
+                "win_rate": 0,
+                "total_trades": 0,
+                "message": "거래 내역이 없습니다"
+            }
+        
+        wins = 0
+        losses = 0
+        total_profit = 0
+        total_loss = 0
+        
+        for trade in trades:
+            pl = float(trade.net_profit_loss) if trade.net_profit_loss else 0
+            if pl > 0:
+                wins += 1
+                total_profit += pl
+            elif pl < 0:
+                losses += 1
+                total_loss += abs(pl)
+        
+        total_trades = wins + losses
+        win_rate = (wins / total_trades * 100) if total_trades > 0 else 0
+        
+        # Profit Factor (총 이익 / 총 손실)
+        profit_factor = (total_profit / total_loss) if total_loss > 0 else 0
+        
+        # 평균 승리/손실
+        avg_win = total_profit / wins if wins > 0 else 0
+        avg_loss = total_loss / losses if losses > 0 else 0
+        
+        # 손익비
+        risk_reward = avg_win / avg_loss if avg_loss > 0 else 0
+        
+        return {
+            "win_rate": round(win_rate, 2),
+            "total_trades": total_trades,
+            "wins": wins,
+            "losses": losses,
+            "total_profit": round(total_profit, 2),
+            "total_loss": round(total_loss, 2),
+            "net_profit": round(total_profit - total_loss, 2),
+            "profit_factor": round(profit_factor, 2),
+            "avg_win": round(avg_win, 2),
+            "avg_loss": round(avg_loss, 2),
+            "risk_reward_ratio": round(risk_reward, 2)
+        }
+        
+    except Exception as e:
+        logger.error(f"Error calculating win rate: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
diff --git a/backend/app/api/endpoints/tensorflow_predictions.py b/backend/app/api/endpoints/tensorflow_predictions.py
new file mode 100644
index 0000000..21c083f
--- /dev/null
+++ b/backend/app/api/endpoints/tensorflow_predictions.py
@@ -0,0 +1,40 @@
+from fastapi import APIRouter, HTTPException, Query
+from typing import List
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+def _get_predictor():
+    try:
+        from app.services.tensorflow_predictor import TensorFlowPredictor, TensorFlowNotAvailable
+        try:
+            return TensorFlowPredictor()
+        except TensorFlowNotAvailable as e:
+            raise HTTPException(status_code=503, detail=f"TensorFlow predictor unavailable: {e}")
+    except Exception as e:
+        raise HTTPException(status_code=503, detail=f"TensorFlow unavailable: {e}")
+
+
+@router.get("/tf-predictions")
+async def get_tensorflow_predictions(
+    codes: str = Query("005930,000660,035420", description="Comma-separated stock codes"),
+    top: int = Query(10, ge=1, le=50, description="Top N by expected return")
+):
+    predictor = _get_predictor()
+    stock_codes: List[str] = [c.strip() for c in codes.split(",") if c.strip()]
+    results = []
+    for code in stock_codes:
+        pred = await predictor.predict_stock(code)
+        results.append(pred)
+    # Filter out errors, sort by expected_return
+    valid = [r for r in results if isinstance(r, dict) and "expected_return" in r]
+    valid.sort(key=lambda x: x.get("expected_return", 0.0), reverse=True)
+    return {
+        "total": len(valid),
+        "requested": stock_codes,
+        "predictions": valid[:top],
+        "errors": [r for r in results if "error" in r]
+    }
diff --git a/backend/app/api/endpoints/trades.py b/backend/app/api/endpoints/trades.py
index f6fec31..1a7ca38 100644
--- a/backend/app/api/endpoints/trades.py
+++ b/backend/app/api/endpoints/trades.py
@@ -1,15 +1,24 @@
+"""
+주문/체결 API 엔드포인트
+
+- GET /: 거래 이력 조회 (손익 포함)
+- GET /stats/summary: 거래 통계
+- DELETE /pending: PENDING/FAILED 거래 정리
+"""
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
 from typing import List, Optional
 from datetime import datetime, timedelta
 from decimal import Decimal
+import logging
 
 from app.core.database import get_db
 from app.models.models import TradeHistory
 from pydantic import BaseModel
 
 router = APIRouter()
+logger = logging.getLogger(__name__)
 
 
 class TradeHistoryResponse(BaseModel):
@@ -22,11 +31,17 @@ class TradeHistoryResponse(BaseModel):
     order_quantity: int
     executed_price: Optional[Decimal]
     executed_quantity: Optional[int]
+    total_amount: Optional[Decimal]
     status: str
     order_id: Optional[str]
     message: Optional[str]
+    entry_reason: Optional[str]
+    exit_reason: Optional[str]
+    signals: Optional[List[str]]
     created_at: datetime
     executed_at: Optional[datetime]
+    profit_loss: Optional[Decimal] = None
+    profit_loss_rate: Optional[float] = None
     
     class Config:
         from_attributes = True
@@ -42,7 +57,7 @@ async def get_trade_history(
     days: int = 30,
     db: AsyncSession = Depends(get_db)
 ):
-    """거래 이력 조회"""
+    """거래 이력 조회 (손익 포함)"""
     query = select(TradeHistory)
     
     # 날짜 필터
@@ -66,7 +81,64 @@ async def get_trade_history(
     
     result = await db.execute(query)
     trades = result.scalars().all()
-    return trades
+    
+    # 손익 계산을 위해 매수/매도 매칭
+    trade_responses = []
+    buy_trades = {}  # stock_code -> list of buy trades
+    
+    for trade in trades:
+        response = TradeHistoryResponse.model_validate(trade)
+
+        # 매도 시 손익 정보 설정
+        if trade.order_type == "SELL" and trade.status == "EXECUTED":
+            import re
+
+            # 1. DB에 저장된 값 먼저 사용
+            if hasattr(trade, 'net_profit_loss') and trade.net_profit_loss is not None:
+                response.profit_loss = trade.net_profit_loss
+                logger.debug(f"✅ DB에서 손익 금액 로드: {response.profit_loss}")
+
+            if hasattr(trade, 'profit_loss_rate') and trade.profit_loss_rate is not None:
+                response.profit_loss_rate = float(trade.profit_loss_rate)
+                logger.debug(f"✅ DB에서 손익률 로드: {response.profit_loss_rate}%")
+
+            # 2. DB 값이 없으면 exit_reason/message에서 파싱 (이전 데이터 호환성)
+            if response.profit_loss is None or response.profit_loss_rate is None:
+                text_to_parse = trade.exit_reason or trade.message or ""
+                logger.debug(f"🔍 손익 파싱 시도 - 종목: {trade.stock_name}, 텍스트: {text_to_parse[:100]}")
+
+                # 손익 금액 추출
+                if response.profit_loss is None:
+                    profit_match = re.search(r'손익:\s*([+-]?[\d,]+)원', text_to_parse)
+                    if profit_match:
+                        profit_str = profit_match.group(1).replace(',', '')
+                        try:
+                            response.profit_loss = Decimal(profit_str)
+                            logger.info(f"✅ 파싱으로 손익 금액 추출: {response.profit_loss}")
+                        except Exception as e:
+                            logger.error(f"❌ 손익 금액 변환 실패: {e}")
+
+                # 손익률 추출
+                if response.profit_loss_rate is None:
+                    message_rate_match = re.search(r'손익률\s*([+-]?[\d.]+)%', trade.message or "")
+                    if message_rate_match:
+                        try:
+                            response.profit_loss_rate = float(message_rate_match.group(1))
+                            logger.info(f"✅ 파싱으로 손익률 추출 (message): {response.profit_loss_rate}%")
+                        except Exception as e:
+                            logger.error(f"❌ 손익률 변환 실패: {e}")
+                    else:
+                        rate_match = re.search(r'([+-]?[\d.]+)%', text_to_parse)
+                        if rate_match:
+                            try:
+                                response.profit_loss_rate = float(rate_match.group(1))
+                                logger.info(f"✅ 파싱으로 손익률 추출 (exit_reason): {response.profit_loss_rate}%")
+                            except Exception as e:
+                                logger.error(f"❌ 손익률 변환 실패: {e}")
+        
+        trade_responses.append(response)
+    
+    return trade_responses
 
 
 @router.get("/{trade_id}", response_model=TradeHistoryResponse)
@@ -116,3 +188,23 @@ async def get_trade_stats(
         "success_rate": executed_trades / total_trades if total_trades > 0 else 0,
         "total_amount": total_amount
     }
+
+
+@router.delete("/pending")
+async def delete_pending_trades(db: AsyncSession = Depends(get_db)):
+    """장 마감 후 PENDING과 FAILED 상태의 매수 시도 내역 정리"""
+    result = await db.execute(
+        select(TradeHistory).where(
+            TradeHistory.status.in_(['PENDING', 'FAILED'])
+        )
+    )
+    pending_trades = result.scalars().all()
+    count = len(pending_trades)
+    
+    for trade in pending_trades:
+        await db.delete(trade)
+    await db.commit()
+    
+    logger.info(f"✅ 정리 완료: {count}개의 PENDING/FAILED 매수 시도 삭제")
+    
+    return {"deleted_count": count, "message": f"Cleaned up {count} pending/failed trades"}
diff --git a/backend/app/core/config.py b/backend/app/core/config.py
index c8db21d..1373d9c 100644
--- a/backend/app/core/config.py
+++ b/backend/app/core/config.py
@@ -1,3 +1,9 @@
+"""
+애플리케이션 설정 모듈
+
+- pydantic-settings 기반 .env 파일 로드
+- DB, Redis, KIS API, AI 프로바이더 등 전역 설정 관리
+"""
 import os
 from pathlib import Path
 from pydantic_settings import BaseSettings
@@ -12,7 +18,7 @@ class Settings(BaseSettings):
     # Application
     APP_NAME: str = "Auto Stock Trading System"
     ENVIRONMENT: str = "development"
-    DEBUG: bool = True
+    DEBUG: bool = False  # 운영 기본값 False (.env에서 DEBUG=true로 개발 모드 활성화)
     SECRET_KEY: str = "change-this-secret-key"
     
     # Server
@@ -28,35 +34,78 @@ class Settings(BaseSettings):
     # RabbitMQ
     RABBITMQ_URL: str = "amqp://autostock:autostock_password@localhost:5672/"
     
-    # Korea Investment API
+    # Korea Investment API - 모드 선택
+    KIS_MODE: str = "virtual"  # "virtual" (모의투자) 또는 "real" (실전투자)
+
+    # 모의투자 설정
+    KIS_VIRTUAL_APP_KEY: str = ""
+    KIS_VIRTUAL_APP_SECRET: str = ""
+    KIS_VIRTUAL_ACCOUNT_NO: str = ""
+    KIS_VIRTUAL_URL: str = "https://openapivts.koreainvestment.com:29443"
+
+    # 실전투자 설정
+    KIS_REAL_APP_KEY: str = ""
+    KIS_REAL_APP_SECRET: str = ""
+    KIS_REAL_ACCOUNT_NO: str = ""
+    KIS_REAL_URL: str = "https://openapi.koreainvestment.com:9443"
+
+    # 실제 사용되는 KIS API 설정 (KIS_MODE에 따라 자동 결정)
     KOREA_INVESTMENT_APP_KEY: str = ""
     KOREA_INVESTMENT_APP_SECRET: str = ""
     KOREA_INVESTMENT_ACCOUNT_NUMBER: str = ""
     KOREA_INVESTMENT_API_BASE_URL: str = "https://openapi.koreainvestment.com:9443"
-    
-    # Alias for backward compatibility with .env file
+
+    # 레거시 호환 (직접 지정 시 우선)
     KIS_APP_KEY: str = ""
     KIS_APP_SECRET: str = ""
     KIS_ACCOUNT_NO: str = ""
     KIS_BASE_URL: str = ""
-    
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        # Use KIS_* values if KOREA_INVESTMENT_* are empty
-        if not self.KOREA_INVESTMENT_APP_KEY and self.KIS_APP_KEY:
-            self.KOREA_INVESTMENT_APP_KEY = self.KIS_APP_KEY
-        if not self.KOREA_INVESTMENT_APP_SECRET and self.KIS_APP_SECRET:
-            self.KOREA_INVESTMENT_APP_SECRET = self.KIS_APP_SECRET
-        if not self.KOREA_INVESTMENT_ACCOUNT_NUMBER and self.KIS_ACCOUNT_NO:
-            self.KOREA_INVESTMENT_ACCOUNT_NUMBER = self.KIS_ACCOUNT_NO
-        if self.KIS_BASE_URL:
-            self.KOREA_INVESTMENT_API_BASE_URL = self.KIS_BASE_URL
-    
+        self._apply_kis_mode()
+
+    def _apply_kis_mode(self):
+        """KIS_MODE에 따라 모의/실전 API 설정을 자동 선택"""
+        is_real = self.KIS_MODE.lower() == "real"
+
+        # 1순위: KIS_MODE에 따른 VIRTUAL/REAL 변수
+        if is_real:
+            mode_key = self.KIS_REAL_APP_KEY
+            mode_secret = self.KIS_REAL_APP_SECRET
+            mode_account = self.KIS_REAL_ACCOUNT_NO
+            mode_url = self.KIS_REAL_URL
+        else:
+            mode_key = self.KIS_VIRTUAL_APP_KEY
+            mode_secret = self.KIS_VIRTUAL_APP_SECRET
+            mode_account = self.KIS_VIRTUAL_ACCOUNT_NO
+            mode_url = self.KIS_VIRTUAL_URL
+
+        # 2순위: 레거시 KIS_APP_KEY 등 (직접 지정된 경우)
+        fallback_key = self.KIS_APP_KEY
+        fallback_secret = self.KIS_APP_SECRET
+        fallback_account = self.KIS_ACCOUNT_NO
+        fallback_url = self.KIS_BASE_URL
+
+        # 최종 적용 (mode > legacy > KOREA_INVESTMENT_ 기존값)
+        self.KOREA_INVESTMENT_APP_KEY = mode_key or fallback_key or self.KOREA_INVESTMENT_APP_KEY
+        self.KOREA_INVESTMENT_APP_SECRET = mode_secret or fallback_secret or self.KOREA_INVESTMENT_APP_SECRET
+        self.KOREA_INVESTMENT_ACCOUNT_NUMBER = mode_account or fallback_account or self.KOREA_INVESTMENT_ACCOUNT_NUMBER
+        self.KOREA_INVESTMENT_API_BASE_URL = mode_url or fallback_url or self.KOREA_INVESTMENT_API_BASE_URL
+
+    @property
+    def is_virtual_trading(self) -> bool:
+        """모의투자 모드 여부"""
+        return self.KIS_MODE.lower() != "real"
+
     # Claude AI
     ANTHROPIC_API_KEY: str = ""
     
     # MCP Server
     MCP_SERVER_URL: str = "http://localhost:8001"
+    # MCP AI 검증 (자동매매 전 AI 최종 판단)
+    MCP_VALIDATION_ENABLED: bool = False      # 기본 OFF (.env에서 True로 활성화)
+    MCP_CONFIDENCE_THRESHOLD: float = 0.5    # AI 신뢰도 최소값 (0.0~1.0)
     
     # News API
     NEWS_API_KEY: str = ""
@@ -64,11 +113,78 @@ class Settings(BaseSettings):
     # Logging
     LOG_LEVEL: str = "INFO"
     
-    # Trading Settings
-    MAX_POSITION_SIZE: float = 0.1  # 10% of portfolio
-    MAX_DAILY_TRADES: int = 10
-    STOP_LOSS_PERCENT: float = -5.0
-    TAKE_PROFIT_PERCENT: float = 15.0
+    # Trading Settings (CLAUDE.md 섹션 6 기반)
+    MAX_POSITION_SIZE: float = 0.04  # 1종목당 최대 3-4% (섹션 6.1)
+    MAX_DAILY_TRADES: int = 5
+    STOP_LOSS_PERCENT: float = -6.0  # 저변동 종목 손절 -6% (섹션 6.2)
+    TAKE_PROFIT_PERCENT: float = 5.0  # 익절 기본값
+    AUTO_TRADE_ENABLED: bool = True
+
+    # 포지션 규칙 (섹션 6.1)
+    MAX_HOLDINGS_COUNT: int = 20  # 동시 보유 최대 20종목
+    LEVERAGE_ETF_MAX_RATIO: float = 0.20  # 레버리지/인버스 ETF 20% 이내
+
+    # ATR 기반 손절/트레일링 (섹션 6.2)
+    STOP_LOSS_HIGH_VOL: float = -10.0  # 고변동 종목 손절 -10%
+    ATR_STOP_MULTIPLIER: float = 2.5  # 2.5 × ATR 손절
+    ATR_TRAILING_MULTIPLIER: float = 1.5  # 1.5 × ATR 트레일링
+
+    # MDD 관리 (섹션 6.3)
+    MDD_PAUSE_THRESHOLD: float = -10.0  # -10% MDD: 신규진입 중단 + 30% 축소
+    MDD_FORCE_THRESHOLD: float = -20.0  # -20% MDD: 50% 강제 축소
+
+    # 가격 필터 (섹션 6.4)
+    MIN_PRICE_KRW: int = 5000  # 국내 5,000원 이하 매수 금지
+    MIN_PRICE_USD: float = 4.0  # 미국 $4 이하 매수 금지
+
+    # 연속 손실 관리 (섹션 7.4)
+    CONSECUTIVE_LOSS_BAN_COUNT: int = 3  # 3회 연속 손실
+    CONSECUTIVE_LOSS_BAN_DAYS: int = 30  # 30거래일 진입 금지
+
+    # 평균회귀 전략 자본 배분 (섹션 7.5)
+    MEAN_REVERSION_MAX_CAPITAL: float = 0.30  # 전체 자본의 30% 이내
+
+    # Trend filter (MA-based)
+    TREND_FILTER_ENABLED: bool = False
+    TREND_MA_SHORT: int = 20
+    TREND_MA_LONG: int = 60
+    TREND_TOLERANCE_PCT: float = 0.005
+
+    # 급등 과열 필터 (고점 추격 매수 방지)
+    OVERHEAT_FILTER_ENABLED: bool = True
+    OVERHEAT_3DAY_MAX: float = 15.0
+    OVERHEAT_5DAY_MAX: float = 20.0
+    OVERHEAT_10DAY_MAX: float = 30.0
+    OVERHEAT_DISPARITY_MAX: float = 108.0
+
+    # 하락장 방어 필터
+    BEAR_MARKET_FILTER_ENABLED: bool = True
+    BEAR_MARKET_MIN_SCORE: int = 5
+    BEAR_MARKET_MAX_TRADES: int = 3
+    BEAR_MARKET_POSITION_RATIO: float = 0.5
+
+    # 데이트레이딩 설정 (CLAUDE.md 섹션 8.2)
+    DAY_TRADE_ENABLED: bool = True            # 데이트레이딩 활성화
+    DAY_TRADE_MAX_POSITIONS: int = 3          # 동시 최대 종목 수
+    DAY_TRADE_CAPITAL_RATIO: float = 0.25     # 전체 자본 대비 최대 25%
+    DAY_TRADE_PER_STOCK_RATIO: float = 0.10   # 종목당 최대 10%
+    DAY_TRADE_STOP_LOSS_PCT: float = 0.02     # 종목 손절 -2%
+    DAY_TRADE_DAILY_LOSS_LIMIT: float = -0.03 # 일일 손실 한도 -3%
+    DAY_TRADE_EOD_FLAT_HOUR: int = 15         # EOD 강제 청산 시 (15시)
+    DAY_TRADE_EOD_FLAT_MIN: int = 20          # EOD 강제 청산 분 (20분)
+    DAY_TRADE_ORB_VOL_MULT: float = 1.5       # ORB 돌파 거래량 배수
+    DAY_TRADE_TRAILING_TRIGGER: float = 0.015 # 트레일링 발동 수익률
+
+    # ML / TensorFlow integration toggle
+    ML_TF_ENABLED: bool = True  # ML 모델 기반 보조지표 사용
+
+    # ML Ensemble (LightGBM + LSTM + RF)
+    ML_ENSEMBLE_ENABLED: bool = True
+    ML_ENSEMBLE_MODEL_DIR: str = "models/ensemble"
+    ML_ENSEMBLE_RULE_WEIGHT: float = 0.3     # 룰베이스 스코어 비중
+    ML_ENSEMBLE_ML_WEIGHT: float = 0.7       # ML 스코어 비중
+    ML_ENSEMBLE_BUY_THRESHOLD: int = 60      # 매수 최소 앙상블 스코어 (0~100)
+    ML_ENSEMBLE_CONFIDENCE_MIN: float = 0.5  # 최소 신뢰도
     
     # API Rate Limiting & Retry Settings (모의투자 API 안전 운영)
     API_MAX_RETRIES: int = 3  # 최대 재시도 횟수
diff --git a/backend/app/core/database.py b/backend/app/core/database.py
index c446c1c..adce267 100644
--- a/backend/app/core/database.py
+++ b/backend/app/core/database.py
@@ -1,3 +1,9 @@
+"""
+데이터베이스 연결 모듈
+
+- SQLAlchemy async 엔진 및 세션 팩토리 (PostgreSQL + asyncpg)
+- Base 모델 선언, get_db 의존성 제공
+"""
 from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import sessionmaker
@@ -10,14 +16,19 @@ if DATABASE_URL.startswith("postgresql://"):
 
 engine = create_async_engine(
     DATABASE_URL,
-    echo=settings.DEBUG,
+    echo=False,  # SQL 로그 비활성화 (성능 개선)
     future=True,
     pool_pre_ping=True,
-    pool_size=10,
-    max_overflow=20,
+    pool_size=20,  # 증가
+    max_overflow=30,  # 증가
+    pool_recycle=3600,  # 1시간마다 연결 재생성
+    pool_timeout=30,  # 타임아웃 설정
     connect_args={
         "timeout": 60,
         "command_timeout": 60,
+        "server_settings": {
+            "jit": "off"  # JIT 비활성화로 성능 개선
+        }
     }
 )
 
@@ -25,14 +36,20 @@ AsyncSessionLocal = sessionmaker(
     engine,
     class_=AsyncSession,
     expire_on_commit=False,
+    autocommit=False,
+    autoflush=False,
 )
 
 Base = declarative_base()
 
 
 async def get_db():
+    """DB 세션 생성 및 관리 (안전한 종료 보장)"""
     async with AsyncSessionLocal() as session:
         try:
             yield session
+        except Exception:
+            await session.rollback()
+            raise
         finally:
             await session.close()
diff --git a/backend/app/core/json_helpers.py b/backend/app/core/json_helpers.py
new file mode 100644
index 0000000..3985243
--- /dev/null
+++ b/backend/app/core/json_helpers.py
@@ -0,0 +1,13 @@
+"""공용 JSON 직렬화 헬퍼 (CLAUDE.md 코딩 규칙: json.dumps 대신 _dumps() 사용)"""
+import json
+import os
+
+
+def _dumps(obj, **kwargs) -> str:
+    """토큰 절약 모드에 따라 compact/pretty JSON 직렬화"""
+    compact = os.getenv("JSON_COMPACT", "false").lower() == "true"
+    token_save = os.getenv("TOKEN_SAVE_MODE", "false").lower() == "true"
+
+    if compact or token_save:
+        return json.dumps(obj, ensure_ascii=False, separators=(',', ':'), **kwargs)
+    return json.dumps(obj, ensure_ascii=False, indent=2, **kwargs)
diff --git a/backend/app/core/market_schedule.py b/backend/app/core/market_schedule.py
new file mode 100644
index 0000000..1e5163d
--- /dev/null
+++ b/backend/app/core/market_schedule.py
@@ -0,0 +1,59 @@
+"""
+한국 주식시장 운영시간 관리
+
+- KST 기준 장 시작/종료 시간 판별
+- 공휴일, 주말 휴장 체크
+"""
+from datetime import datetime, time
+try:
+    import pytz
+    KST = pytz.timezone('Asia/Seoul')
+except ImportError:
+    # pytz가 없으면 기본 timezone 사용 (환경변수에 의존)
+    from datetime import timezone, timedelta
+    KST = timezone(timedelta(hours=9))
+
+def is_market_open() -> bool:
+    """
+    현재 한국 증시 정규장 운영 시간인지 확인
+    (평일 09:00 ~ 15:30, 공휴일 제외 로직은 아직 미포함)
+    """
+    now = datetime.now(KST)
+
+    # 1. 주말 체크 (월=0, ..., 일=6)
+    if now.weekday() >= 5:
+        return False
+
+    # 2. 시간 체크 (09:00 ~ 15:30)
+    current_time = now.time()
+    market_start = time(9, 0)
+    market_end = time(15, 30)
+
+    return market_start <= current_time <= market_end
+
+
+def is_opening_range_period() -> bool:
+    """Opening Range 수집 구간 (09:00~09:29)"""
+    now = datetime.now(KST)
+    if now.weekday() >= 5:
+        return False
+    t = now.time()
+    return time(9, 0) <= t < time(9, 30)
+
+
+def is_day_trade_entry_window() -> bool:
+    """데이트레이딩 신규 진입 가능 시간 (09:30~14:59)"""
+    now = datetime.now(KST)
+    if now.weekday() >= 5:
+        return False
+    t = now.time()
+    return time(9, 30) <= t < time(15, 0)
+
+
+def is_eod_flat_time() -> bool:
+    """EOD 강제 청산 구간 (15:20~15:30)"""
+    now = datetime.now(KST)
+    if now.weekday() >= 5:
+        return False
+    t = now.time()
+    return time(15, 20) <= t <= time(15, 30)
diff --git a/backend/app/main.py b/backend/app/main.py
index d77abe1..d5aea45 100644
--- a/backend/app/main.py
+++ b/backend/app/main.py
@@ -1,14 +1,26 @@
+"""
+FastAPI 애플리케이션 진입점
+
+- CORS, 미들웨어 설정
+- WebSocket 실시간 시세 브로드캐스트
+- 라우터 등록 및 startup/shutdown 이벤트 관리
+"""
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Request
 from fastapi.middleware.cors import CORSMiddleware
 from contextlib import asynccontextmanager
+import contextlib
+import asyncio
+import json
 import logging
 import time
 
 from app.core.config import settings
 from app.api import api_router
 from app.services.websocket_manager import websocket_manager
-from app.core.database import engine, Base
+from app.core.database import engine, Base, AsyncSessionLocal
 from app.models import models  # 모델 임포트
+from app.core.market_schedule import is_market_open
+from sqlalchemy import text
 
 # 로깅 설정
 logging.basicConfig(
@@ -19,17 +31,213 @@ logging.basicConfig(
 logger = logging.getLogger(__name__)
 
 
+async def auto_trade_scheduler():
+    """1분 간격 자동매매 스케줄러.
+    실시간 분석을 수행하고, 보유 종목 손절/익절을 체크하며, 자동매매를 실행한다.
+    """
+    # 지연 시작으로 앱 부팅 안정화
+    await asyncio.sleep(2)
+    from app.api.endpoints.recommendations import (
+        get_rule_based_recommendations_realtime,
+        execute_auto_trade_background,
+    )
+    from app.api.endpoints.portfolio import check_and_execute_exit_trades
+
+    logger.info("⏱️ Auto-trade scheduler started (every 60s)")
+    try:
+        while True:
+            try:
+                # 장 운영 시간 체크
+                if not is_market_open():
+                    logger.info("💤 Market is closed. Skipping auto-trade cycle. Next check in 30 minutes.")
+                    # 장 종료 시에는 30분(1800초) 대기하여 리소스 절약
+                    await asyncio.sleep(1800)
+                    continue
+
+                async with AsyncSessionLocal() as session:
+                    # 1. 보유 종목 손절/익절 체크 (먼저 실행)
+                    logger.info("💰 Checking portfolio for stop-loss/take-profit...")
+                    try:
+                        await check_and_execute_exit_trades(session)
+                    except Exception as e:
+                        logger.error(f"Exit trade check error: {e}", exc_info=True)
+                    
+                    # 2. 자동매매가 활성화된 경우에만 신규 매수 진행
+                    if settings.AUTO_TRADE_ENABLED:
+                        logger.info("🔄 Starting real-time analysis cycle...")
+                        rec = await get_rule_based_recommendations_realtime()
+                        
+                        if rec and rec.get("recommendations_by_rule"):
+                            logger.info(f"📊 Found recommendations, executing auto-trade")
+                            await execute_auto_trade_background(rec, session)
+                        else:
+                            logger.info("⏭️ Auto-trade skipped: no recommendations matched rules")
+                    else:
+                        logger.info("⏸️ Auto-trade disabled - only monitoring stop-loss/take-profit")
+            except Exception as e:
+                logger.error(f"❌ Auto-trade scheduler error: {e}", exc_info=True)
+
+            await asyncio.sleep(60)
+    except asyncio.CancelledError:
+        logger.info("⏹️ Auto-trade scheduler stopped")
+        raise
+
+
+async def day_trade_scheduler():
+    """30초 간격 데이트레이딩 스케줄러.
+
+    - Opening Range 수집 (09:00~09:30)
+    - 진입 신호 스캔 + 주문 실행 (09:30~15:00)
+    - EOD 강제 청산 (15:20~15:30)
+    - 장 외 시간: 30분 슬립
+    """
+    await asyncio.sleep(5)  # 부팅 안정화 대기
+    from app.api.endpoints.day_trading import run_day_trading_cycle
+
+    logger.info("📈 Day-trade scheduler started (every 30s)")
+    try:
+        while True:
+            if not is_market_open():
+                await asyncio.sleep(1800)
+                continue
+            if not settings.DAY_TRADE_ENABLED:
+                await asyncio.sleep(60)
+                continue
+            try:
+                result = await run_day_trading_cycle()
+                phase = result.get("phase", "")
+                if result.get("entries"):
+                    logger.info(f"📈 데이트레이딩 진입: {result['entries']}")
+                if result.get("exits"):
+                    logger.info(f"📉 데이트레이딩 청산: {result['exits']}")
+                if phase not in ("market_closed", "outside_window"):
+                    logger.debug(f"Day-trade cycle [{phase}]: {result.get('time')}")
+            except Exception as e:
+                logger.error(f"❌ Day-trade scheduler error: {e}", exc_info=True)
+            await asyncio.sleep(30)
+    except asyncio.CancelledError:
+        logger.info("⏹️ Day-trade scheduler stopped")
+        raise
+
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """애플리케이션 시작/종료 시 실행될 코드"""
     logger.info("Starting Auto Stock Trading System...")
-    
+    kis_mode = settings.KIS_MODE.upper()
+    logger.info(f"KIS API Mode: {'모의투자 (VIRTUAL)' if settings.is_virtual_trading else '실전투자 (REAL)'}")
+    logger.info(f"KIS Base URL: {settings.KOREA_INVESTMENT_API_BASE_URL}")
+    logger.info(f"KIS Account: {settings.KOREA_INVESTMENT_ACCOUNT_NUMBER}")
+
     # DB 테이블 자동 생성
     try:
         logger.info(f"Connecting to database: {settings.DATABASE_URL.split('@')[1] if '@' in settings.DATABASE_URL else 'unknown'}")
         async with engine.begin() as conn:
             await conn.run_sync(Base.metadata.create_all)
-        logger.info("✅ Database tables created successfully")
+            # Ensure trade_history columns exist (self-heal without external migration)
+            await conn.execute(text("""
+            ALTER TABLE trade_history 
+            ADD COLUMN IF NOT EXISTS total_amount NUMERIC(15, 2),
+            ADD COLUMN IF NOT EXISTS entry_reason TEXT,
+            ADD COLUMN IF NOT EXISTS exit_reason TEXT,
+            ADD COLUMN IF NOT EXISTS signals JSONB,
+            ADD COLUMN IF NOT EXISTS entry_trade_id INTEGER,
+            ADD COLUMN IF NOT EXISTS slippage NUMERIC(10, 2),
+            ADD COLUMN IF NOT EXISTS commission NUMERIC(10, 2),
+            ADD COLUMN IF NOT EXISTS net_profit_loss NUMERIC(15, 2),
+            ADD COLUMN IF NOT EXISTS profit_loss_rate NUMERIC(10, 4);
+            """))
+            await conn.execute(text("""
+            UPDATE trade_history
+            SET total_amount = executed_price * executed_quantity
+            WHERE total_amount IS NULL AND executed_price IS NOT NULL AND executed_quantity IS NOT NULL;
+            """))
+            # stock_analysis에 ATR / ADX / ML 컬럼 추가 (CLAUDE.md 섹션 6.2)
+            await conn.execute(text("""
+            ALTER TABLE stock_analysis
+            ADD COLUMN IF NOT EXISTS atr_14 NUMERIC(15, 2),
+            ADD COLUMN IF NOT EXISTS adx_14 NUMERIC(10, 2),
+            ADD COLUMN IF NOT EXISTS ml_score INTEGER,
+            ADD COLUMN IF NOT EXISTS ml_confidence NUMERIC(5, 4),
+            ADD COLUMN IF NOT EXISTS ml_signal VARCHAR(10);
+            """))
+            # active_trades에 분할 청산 컬럼 추가 (CLAUDE.md 섹션 7.3)
+            await conn.execute(text("""
+            ALTER TABLE active_trades
+            ADD COLUMN IF NOT EXISTS remaining_pct NUMERIC(5, 2) DEFAULT 1.0,
+            ADD COLUMN IF NOT EXISTS highest_since_entry NUMERIC(15, 2),
+            ADD COLUMN IF NOT EXISTS strategy_name VARCHAR(100);
+            """))
+            # Risk Management 테이블 생성
+            await conn.execute(text("""
+            CREATE TABLE IF NOT EXISTS trading_sessions (
+                id SERIAL PRIMARY KEY,
+                session_date DATE UNIQUE NOT NULL,
+                consecutive_losses INTEGER DEFAULT 0,
+                daily_profit_loss NUMERIC(15, 2) DEFAULT 0,
+                is_paused BOOLEAN DEFAULT FALSE,
+                pause_reason TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            );
+            """))
+            # 종목별 연속 손실 ban 영속화 테이블 (CLAUDE.md 섹션 7.4)
+            await conn.execute(text("""
+            CREATE TABLE IF NOT EXISTS stock_bans (
+                stock_code VARCHAR(20) PRIMARY KEY,
+                consecutive_losses INTEGER DEFAULT 0 NOT NULL,
+                ban_until TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            );
+            """))
+        logger.info("✅ Database tables created successfully (and columns verified)")
+
+        # 연속 손실 ban 상태 복원 (재시작 후에도 유지 — CLAUDE.md 섹션 7.4)
+        try:
+            from app.services.loss_tracker import loss_tracker
+            async with AsyncSessionLocal() as session:
+                await loss_tracker.load_from_db(session)
+        except Exception as e:
+            logger.warning(f"⚠️ loss_tracker 초기화 실패 (non-critical): {e}")
+
+        # 테스트 데이터 및 오래된 데이터 자동 정리
+        try:
+            from app.models.models import StockAnalysis, TradeHistory, Portfolio
+            from sqlalchemy import delete
+            from datetime import date, timedelta
+            
+            async with AsyncSessionLocal() as session:
+                # 오래된 stock_analysis 삭제 (7일 이전)
+                cutoff_date = date.today() - timedelta(days=7)
+                result = await session.execute(
+                    delete(StockAnalysis).where(StockAnalysis.analysis_date < cutoff_date)
+                )
+                if result.rowcount > 0:
+                    logger.info(f"🗑️ Deleted {result.rowcount} old stock_analysis records")
+                
+                # PENDING/FAILED 오래된 거래 삭제 (1일 이전)
+                cutoff_datetime = date.today() - timedelta(days=1)
+                result = await session.execute(
+                    delete(TradeHistory).where(
+                        TradeHistory.status.in_(['PENDING', 'FAILED']),
+                        TradeHistory.created_at < cutoff_datetime
+                    )
+                )
+                if result.rowcount > 0:
+                    logger.info(f"🗑️ Deleted {result.rowcount} old PENDING/FAILED trades")
+                
+                # 수량 0인 포트폴리오 삭제
+                result = await session.execute(
+                    delete(Portfolio).where(Portfolio.quantity <= 0)
+                )
+                if result.rowcount > 0:
+                    logger.info(f"🗑️ Deleted {result.rowcount} empty portfolio records")
+                
+                await session.commit()
+                logger.info("✅ Test data cleanup completed")
+        except Exception as e:
+            logger.warning(f"⚠️ Test data cleanup failed (non-critical): {e}")
+            
     except ConnectionRefusedError as e:
         logger.error(f"❌ Database connection refused: {e}")
         logger.error("Please check if PostgreSQL server is running and accessible")
@@ -40,9 +248,24 @@ async def lifespan(app: FastAPI):
         logger.error(traceback.format_exc())
         raise
     
+    # 스케줄러 시작
+    app.state.auto_trade_task = asyncio.create_task(auto_trade_scheduler())
+    app.state.day_trade_task = asyncio.create_task(day_trade_scheduler())
+
     yield
-    
+
     # 종료 시 정리 작업
+    # 스케줄러 중단
+    for task_attr in ("auto_trade_task", "day_trade_task"):
+        try:
+            task = getattr(app.state, task_attr, None)
+            if task:
+                task.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await task
+        except Exception as e:
+            logger.warning(f"Failed to stop {task_attr} gracefully: {e}")
+
     logger.info("Shutting down Auto Stock Trading System...")
     await engine.dispose()
 
@@ -105,7 +328,16 @@ async def websocket_endpoint(websocket: WebSocket, client_id: str):
     try:
         while True:
             data = await websocket.receive_text()
-            # 메시지 처리
+            # ping/pong 하트비트 처리
+            try:
+                msg = json.loads(data)
+                if msg.get("type") == "ping":
+                    await websocket_manager.send_personal_message(
+                        json.dumps({"type": "pong"}), client_id
+                    )
+                    continue
+            except (json.JSONDecodeError, AttributeError):
+                pass
             await websocket_manager.send_personal_message(
                 f"Echo: {data}", client_id
             )
diff --git a/backend/app/models/models.py b/backend/app/models/models.py
index dcc4f38..eee8b42 100644
--- a/backend/app/models/models.py
+++ b/backend/app/models/models.py
@@ -1,10 +1,66 @@
-from datetime import datetime
+"""
+SQLAlchemy ORM 모델 정의
+
+- StockDailyPrice: 일별 주가 데이터
+- Portfolio: 포트폴리오 보유 종목
+- TradeHistory: 주문/체결 이력
+- TradingRule: 매매 규칙 설정
+"""
+from datetime import datetime, date
 from typing import Optional, List
-from sqlalchemy import Column, Integer, String, Numeric, Boolean, DateTime, Text, ARRAY
+from sqlalchemy import Column, Integer, BigInteger, String, Numeric, Boolean, DateTime, Text, ARRAY, Date, ForeignKey, UniqueConstraint
 from sqlalchemy.dialects.postgresql import JSONB
 from app.core.database import Base
 
 
+class StockDailyPrice(Base):
+    """KRX 일봉 히스토리컬 데이터 (pykrx 수집)"""
+    __tablename__ = "stock_daily_prices"
+    __table_args__ = (
+        UniqueConstraint('stock_code', 'trade_date', name='uq_stock_daily'),
+    )
+
+    id = Column(Integer, primary_key=True, index=True)
+    stock_code = Column(String(20), nullable=False, index=True)
+    stock_name = Column(String(100))
+    trade_date = Column(Date, nullable=False, index=True)
+    open_price = Column(Integer)
+    high_price = Column(Integer)
+    low_price = Column(Integer)
+    close_price = Column(Integer)
+    volume = Column(BigInteger)
+    change_rate = Column(Numeric(10, 4))
+    market_cap = Column(BigInteger, nullable=True)
+
+
+class TradingSession(Base):
+    """🔥 일일 트레이딩 세션 관리 (리스크 관리)"""
+    __tablename__ = "trading_sessions"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    session_date = Column(Date, default=date.today, unique=True, index=True)
+    
+    # 연속 손실 추적
+    consecutive_losses = Column(Integer, default=0)
+    consecutive_wins = Column(Integer, default=0)
+    
+    # 일일 손익
+    daily_profit_loss = Column(Numeric(15, 2), default=0)
+    daily_trades_count = Column(Integer, default=0)
+    
+    # 리스크 제한 상태
+    is_paused = Column(Boolean, default=False)  # 3연패 또는 일일 손실 한도 도달 시 True
+    pause_reason = Column(String(200), nullable=True)
+    
+    # 계좌 정보
+    starting_balance = Column(Numeric(15, 2))
+    ending_balance = Column(Numeric(15, 2))
+    peak_balance = Column(Numeric(15, 2))  # 당일 최고 잔고
+    
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+
 class TradingRule(Base):
     __tablename__ = "trading_rules"
     
@@ -32,9 +88,21 @@ class TradeHistory(Base):
     order_quantity = Column(Integer, nullable=False)
     executed_price = Column(Numeric(15, 2))
     executed_quantity = Column(Integer)
+    total_amount = Column(Numeric(15, 2))  # 총 거래 금액
     status = Column(String(50), nullable=False)
     order_id = Column(String(100))
     message = Column(Text)
+    entry_reason = Column(Text)  # 진입 이유 (매수 신호 상세)
+    exit_reason = Column(Text)   # 매도 이유 (매도 신호 상세)
+    signals = Column(JSONB)      # 기술적 신호 목록
+    
+    # 🔥 리스크 관리 필드 추가
+    entry_trade_id = Column(Integer, nullable=True)  # 매도 시 얰결된 매수 거래 ID
+    slippage = Column(Numeric(15, 2), nullable=True)  # 슬리피지 (체결가 - 주문가)
+    commission = Column(Numeric(15, 2), nullable=True)  # 수수료
+    net_profit_loss = Column(Numeric(15, 2), nullable=True)  # 수수료 차감 후 순손익
+    profit_loss_rate = Column(Numeric(10, 4), nullable=True)  # 수익률 (%)
+    
     created_at = Column(DateTime, default=datetime.utcnow, index=True)
     executed_at = Column(DateTime)
 
@@ -135,7 +203,107 @@ class StockAnalysis(Base):
     # 분석 결과
     signals = Column(JSONB)  # ["RSI 과매도", "골든크로스" 등]
     score = Column(Integer, default=0)
-    
+
+    # ATR (섹션 6.2 ATR 기반 손절)
+    atr_14 = Column(Numeric(15, 2), nullable=True)
+
+    # ADX (추세 강도 — 평균회귀 필터용)
+    adx_14 = Column(Numeric(10, 2), nullable=True)
+
+    # ML 앙상블 스코어
+    ml_score = Column(Integer, nullable=True)          # 앙상블 스코어 (0~100)
+    ml_confidence = Column(Numeric(5, 4), nullable=True)  # 신뢰도 (0~1)
+    ml_signal = Column(String(10), nullable=True)      # BUY/HOLD/SELL
+
     # 메타데이터
     created_at = Column(DateTime, default=datetime.utcnow)
     updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+
+class ActiveTrade(Base):
+    """현재 활성화된(보유 중인) 거래를 추적하기 위한 모델"""
+    __tablename__ = "active_trades"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    stock_code = Column(String(20), nullable=False)
+    stock_name = Column(String(100))
+    quantity = Column(Integer, nullable=False)
+    entry_price = Column(Numeric(15, 2), nullable=False)
+    current_price = Column(Numeric(15, 2))
+    profit_loss = Column(Numeric(15, 2))
+    profit_loss_rate = Column(Numeric(10, 4))
+    stop_loss = Column(Numeric(15, 2))
+    take_profit = Column(Numeric(15, 2))
+    order_id = Column(String(100))
+    entry_reason = Column(Text)
+    status = Column(String(20), default="active") # active, closed
+    # 분할 청산 지원 (섹션 6.2, 7.3)
+    remaining_pct = Column(Numeric(5, 2), default=1.0)  # 잔여 비율 (1.0=전량, 0.5=절반 청산 후)
+    highest_since_entry = Column(Numeric(15, 2), nullable=True)  # 진입 후 최고가 (트레일링 스탑용)
+    strategy_name = Column(String(100), nullable=True)  # 전략명 (MEAN_REVERSION 등)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+
+class TradeJournal(Base):
+    __tablename__ = "trade_journals"
+
+    id = Column(Integer, primary_key=True, index=True)
+    trade_id = Column(Integer)  # ForeignKey("trade_history.id") - models.py 내 순환 참조 방지 위해 정수로 정의
+    stock_code = Column(String(20), nullable=False, index=True)
+    stock_name = Column(String(100))
+    journal_date = Column(DateTime, default=datetime.utcnow)
+    content = Column(Text)
+    strategy_name = Column(String(100))
+    mood = Column(String(50))
+    tags = Column(JSONB)
+    screenshot_url = Column(Text)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+
+class StockBan(Base):
+    """종목별 연속 손실 금지 기록 (CLAUDE.md 섹션 7.4)
+
+    재시작 후에도 ban 상태 유지를 위해 DB에 영속화.
+    """
+    __tablename__ = "stock_bans"
+
+    stock_code = Column(String(20), primary_key=True)
+    consecutive_losses = Column(Integer, default=0, nullable=False)
+    ban_until = Column(DateTime, nullable=True)  # None이면 금지 아님
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+
+class WatchlistStock(Base):
+    """분석종목 — 장중 미니배치가 관리하는 활성 관심 종목.
+
+    아침 배치(batch_daily_analysis)가 score 상위 50개로 초기화하고,
+    장중 미니배치(batch_intraday_analysis)가 10분마다 진입/제거를 관리한다.
+    """
+    __tablename__ = "watchlist_stocks"
+
+    id = Column(Integer, primary_key=True, index=True)
+    stock_code = Column(String(20), nullable=False, index=True)
+    stock_name = Column(String(100), nullable=False)
+    added_at = Column(DateTime, nullable=False)
+    added_reason = Column(String(50), nullable=False, default="morning_batch")
+    score_at_add = Column(Integer, nullable=True)
+    is_active = Column(Boolean, default=True, nullable=False, index=True)
+    removed_at = Column(DateTime, nullable=True)
+    removed_reason = Column(String(50), nullable=True)
+
+
+class WatchlistHistory(Base):
+    """분석종목 스코어 히스토리 — 10분마다 적재되는 시계열 데이터."""
+    __tablename__ = "watchlist_history"
+
+    id = Column(Integer, primary_key=True, index=True)
+    stock_code = Column(String(20), nullable=False, index=True)
+    stock_name = Column(String(100), nullable=False)
+    recorded_at = Column(DateTime, nullable=False, index=True)
+    score = Column(Integer, nullable=True)
+    current_price = Column(Numeric(15, 2), nullable=True)
+    change_rate = Column(Numeric(10, 4), nullable=True)
+    rsi = Column(Numeric(10, 4), nullable=True)
+    signals = Column(JSONB, nullable=True)
diff --git a/backend/app/services/day_trading_strategy.py b/backend/app/services/day_trading_strategy.py
new file mode 100644
index 0000000..2abe27e
--- /dev/null
+++ b/backend/app/services/day_trading_strategy.py
@@ -0,0 +1,472 @@
+"""
+데이트레이딩 전략 (CLAUDE.md 섹션 8.2 확장)
+
+전략 3종:
+  1. ORB  — Opening Range Breakout (09:00~09:30 고점 돌파)
+  2. VWAP — VWAP 지지 + 과매도 반등
+  3. RSI_BB — 5분봉 RSI+볼린저 과매도 반등
+
+공통 규칙:
+  - EOD 강제 청산: 15:20 이후 전량 시장가 매도
+  - 일일 손실 한도: 전체 자본 -3% 초과 시 신규 진입 중단
+  - 동시 최대 3종목, 종목당 최대 10% 자본
+  - 전체 데이트레이딩 자본: 총자산의 최대 25% (CLAUDE.md 8.2)
+  - 수수료+슬리피지 포함 기준: 0.5% (매수 0.015% + 매도 0.3% + 슬리피지 0.2%)
+"""
+import logging
+from typing import Optional, Dict, List, Tuple
+from dataclasses import dataclass
+from datetime import time
+
+logger = logging.getLogger(__name__)
+
+# ── 장 시간 상수 (KST) ──────────────────────────────────────────────────────
+MARKET_OPEN   = time(9, 0)
+ORB_END       = time(9, 30)   # Opening Range 집계 종료
+ENTRY_CUTOFF  = time(15, 0)   # 신규 진입 마감 (이후는 청산만)
+EOD_FLAT      = time(15, 20)  # EOD 강제 청산 시작
+MARKET_CLOSE  = time(15, 30)
+
+# ── 리스크 파라미터 ───────────────────────────────────────────────────────────
+MAX_CAPITAL_RATIO  = 0.10   # 종목당 최대 10%
+MAX_DAY_TRADE_RATIO = 0.25  # 전체 데이트레이딩 최대 25%
+MAX_POSITIONS      = 3      # 동시 최대 3종목
+DAILY_LOSS_LIMIT   = -0.03  # 일일 손실 한도 -3%
+STOP_LOSS_PCT      = 0.02   # 종목 손절 -2%
+TRAILING_TRIGGER   = 0.015  # 트레일링 발동 +1.5%
+TRAILING_ATR_MULT  = 1.0    # 트레일링 ATR 배수
+ORB_BREAKOUT_MARGIN = 0.002 # ORB 돌파 최소 여유 +0.2%
+COST_PCT           = 0.005  # 수수료+슬리피지 합산 (매수+매도)
+
+
+# ── 데이터 클래스 ─────────────────────────────────────────────────────────────
+
+@dataclass
+class MinuteCandle:
+    """KIS API output2 데이터 정규화 결과"""
+    date: str        # YYYYMMDD
+    time: str        # HHMMSS
+    open: float
+    high: float
+    low: float
+    close: float
+    volume: int
+    cum_volume: int   # 누적 거래량 (acml_vol)
+    cum_amount: float # 누적 거래대금 원 (acml_tr_pbmn)
+
+
+@dataclass
+class OpeningRange:
+    high: float
+    low: float
+    total_volume: int
+    avg_vol_per_min: float  # 분당 평균 거래량 (ORB 기간)
+
+
+@dataclass
+class DayTradeSignal:
+    stock_code: str
+    stock_name: str
+    strategy: str        # "ORB" | "VWAP_BOUNCE" | "RSI_BB"
+    entry_price: float
+    stop_loss: float
+    target_price: float
+    reason: str
+    confidence: float    # 0.0 ~ 1.0
+
+
+@dataclass
+class DayTradeExit:
+    action: str    # "SELL_ALL"
+    reason: str
+    sell_pct: float = 1.0
+
+
+# ── 분봉 파싱 헬퍼 ────────────────────────────────────────────────────────────
+
+def parse_minute_candles(raw_output2: list) -> List[MinuteCandle]:
+    """KIS API output2 리스트를 MinuteCandle 리스트로 변환
+
+    KIS 응답 필드:
+      stck_bsop_date / stck_cntg_hour / stck_oprc / stck_hgpr /
+      stck_lwpr / stck_prpr (종가) / cntg_vol / acml_vol / acml_tr_pbmn
+    """
+    candles: List[MinuteCandle] = []
+    for row in raw_output2:
+        try:
+            candles.append(MinuteCandle(
+                date=row.get("stck_bsop_date", ""),
+                time=row.get("stck_cntg_hour", ""),
+                open=float(row.get("stck_oprc", 0) or 0),
+                high=float(row.get("stck_hgpr", 0) or 0),
+                low=float(row.get("stck_lwpr", 0) or 0),
+                close=float(row.get("stck_prpr", 0) or 0),
+                volume=int(row.get("cntg_vol", 0) or 0),
+                cum_volume=int(row.get("acml_vol", 0) or 0),
+                cum_amount=float(row.get("acml_tr_pbmn", 0) or 0),
+            ))
+        except (ValueError, TypeError):
+            continue
+    return candles
+
+
+def aggregate_to_5min(candles: List[MinuteCandle]) -> List[MinuteCandle]:
+    """1분봉 → 5분봉 집계 (09:00 기준 5분 버킷)"""
+    if not candles:
+        return []
+
+    buckets: Dict[int, List[MinuteCandle]] = {}
+    for c in candles:
+        if not c.time:
+            continue
+        h = int(c.time[:2])
+        m = int(c.time[2:4])
+        key = (h * 60 + m) // 5
+        buckets.setdefault(key, []).append(c)
+
+    result: List[MinuteCandle] = []
+    for key in sorted(buckets):
+        bkt = buckets[key]
+        result.append(MinuteCandle(
+            date=bkt[0].date,
+            time=bkt[0].time,
+            open=bkt[0].open,
+            high=max(b.high for b in bkt),
+            low=min(b.low for b in bkt),
+            close=bkt[-1].close,
+            volume=sum(b.volume for b in bkt),
+            cum_volume=bkt[-1].cum_volume,
+            cum_amount=bkt[-1].cum_amount,
+        ))
+    return result
+
+
+# ── 지표 계산 ─────────────────────────────────────────────────────────────────
+
+def calculate_vwap(candles: List[MinuteCandle]) -> Optional[float]:
+    """VWAP = 누적거래대금 / 누적거래량 (당일 09:00 기준 누적)"""
+    if not candles:
+        return None
+    last = candles[-1]
+    if last.cum_volume <= 0:
+        return None
+    return last.cum_amount / last.cum_volume
+
+
+def calculate_opening_range(candles_1min: List[MinuteCandle]) -> Optional[OpeningRange]:
+    """09:00~09:29 분봉으로 Opening Range (H/L) 계산"""
+    orb = [c for c in candles_1min if "090000" <= c.time <= "092959"]
+    if len(orb) < 5:
+        return None
+    total_vol = sum(c.volume for c in orb)
+    return OpeningRange(
+        high=max(c.high for c in orb),
+        low=min(c.low for c in orb),
+        total_volume=total_vol,
+        avg_vol_per_min=total_vol / len(orb),
+    )
+
+
+def _rsi(candles: List[MinuteCandle], period: int = 14) -> Optional[float]:
+    closes = [c.close for c in candles]
+    if len(closes) < period + 1:
+        return None
+    gains, losses = [], []
+    for i in range(-period, 0):
+        d = closes[i] - closes[i - 1]
+        gains.append(max(d, 0))
+        losses.append(max(-d, 0))
+    avg_gain = sum(gains) / period
+    avg_loss = sum(losses) / period
+    if avg_loss == 0:
+        return 100.0
+    return 100 - (100 / (1 + avg_gain / avg_loss))
+
+
+def _bollinger(candles: List[MinuteCandle], period: int = 20) -> Optional[Tuple[float, float, float]]:
+    closes = [c.close for c in candles]
+    if len(closes) < period:
+        return None
+    window = closes[-period:]
+    mid = sum(window) / period
+    std = (sum((p - mid) ** 2 for p in window) / period) ** 0.5
+    return (mid + 2 * std, mid, mid - 2 * std)
+
+
+def _atr(candles: List[MinuteCandle], period: int = 14) -> Optional[float]:
+    if len(candles) < period + 1:
+        return None
+    trs = []
+    for i in range(1, len(candles)):
+        h, l, cp = candles[i].high, candles[i].low, candles[i - 1].close
+        trs.append(max(h - l, abs(h - cp), abs(l - cp)))
+    if len(trs) < period:
+        return None
+    return sum(trs[-period:]) / period
+
+
+# ── 진입 신호 ─────────────────────────────────────────────────────────────────
+
+def check_orb_signal(
+    stock_code: str,
+    stock_name: str,
+    candles_1min: List[MinuteCandle],
+    orb: OpeningRange,
+    current_price: float,
+) -> Optional[DayTradeSignal]:
+    """ORB 상향 돌파 매수 신호
+
+    조건:
+    1. 현재가 > ORB 고점 × 1.002 (0.2% 이상 돌파)
+    2. 최근 1분봉 거래량 ≥ ORB 분당평균 × 1.5 (거래량 폭발)
+    3. 직전 5분봉이 양봉 (음봉이면 Fake-out 위험)
+    """
+    if not orb or current_price <= 0:
+        return None
+
+    if current_price < orb.high * (1 + ORB_BREAKOUT_MARGIN):
+        return None
+
+    # 최근 1분봉 거래량 체크
+    if not candles_1min:
+        return None
+    recent_vol = candles_1min[-1].volume
+    if recent_vol < orb.avg_vol_per_min * 1.5:
+        return None
+
+    # 직전 5분봉 양봉 확인
+    candles_5m = aggregate_to_5min(candles_1min)
+    if len(candles_5m) >= 2 and candles_5m[-2].close < candles_5m[-2].open:
+        return None  # 직전 5분봉 음봉 → 스킵
+
+    stop_loss = max(orb.low, current_price * (1 - STOP_LOSS_PCT))
+    risk = current_price - stop_loss
+    # 수수료 고려: 목표 = 진입가 + 2R + 수수료 보전
+    target = current_price + max(risk * 2.0, current_price * 0.03)
+
+    vol_ratio = recent_vol / orb.avg_vol_per_min
+    confidence = min(0.85, 0.65 + vol_ratio * 0.05)
+
+    return DayTradeSignal(
+        stock_code=stock_code,
+        stock_name=stock_name,
+        strategy="ORB",
+        entry_price=current_price,
+        stop_loss=round(stop_loss, 0),
+        target_price=round(target, 0),
+        reason=(
+            f"ORB 상향 돌파: ORB고={orb.high:.0f}, "
+            f"현재={current_price:.0f}, 거래량={vol_ratio:.1f}배"
+        ),
+        confidence=round(confidence, 2),
+    )
+
+
+def check_vwap_bounce_signal(
+    stock_code: str,
+    stock_name: str,
+    candles_5min: List[MinuteCandle],
+    vwap: float,
+    current_price: float,
+) -> Optional[DayTradeSignal]:
+    """VWAP 지지 반등 매수 신호
+
+    조건:
+    1. 현재가가 VWAP의 -1% ~ 0.5% 구간 (VWAP 근처)
+    2. 5분봉 RSI(14) ≤ 40
+    3. 최근 봉 거래량 ≥ 직전 봉 × 1.3
+    4. 최근 5분봉 양봉 전환 (close > open)
+    """
+    if not candles_5min or vwap <= 0 or current_price <= 0:
+        return None
+
+    if not (vwap * 0.99 <= current_price <= vwap * 1.005):
+        return None
+
+    rsi = _rsi(candles_5min, 14)
+    if rsi is None or rsi > 40:
+        return None
+
+    if len(candles_5min) < 2:
+        return None
+    if candles_5min[-1].volume < candles_5min[-2].volume * 1.3:
+        return None
+
+    # 최근 봉 양봉 확인
+    last = candles_5min[-1]
+    if last.close <= last.open:
+        return None
+
+    atr = _atr(candles_5min, 14)
+    stop_loss = (current_price - 1.5 * atr) if atr else current_price * (1 - STOP_LOSS_PCT)
+    target = (current_price + 2.0 * atr) if atr else vwap * 1.03
+
+    return DayTradeSignal(
+        stock_code=stock_code,
+        stock_name=stock_name,
+        strategy="VWAP_BOUNCE",
+        entry_price=current_price,
+        stop_loss=round(stop_loss, 0),
+        target_price=round(target, 0),
+        reason=(
+            f"VWAP 반등: VWAP={vwap:.0f}, RSI={rsi:.1f}, "
+            f"현재={current_price:.0f}"
+        ),
+        confidence=0.65,
+    )
+
+
+def check_rsi_bb_signal(
+    stock_code: str,
+    stock_name: str,
+    candles_5min: List[MinuteCandle],
+    current_price: float,
+) -> Optional[DayTradeSignal]:
+    """5분봉 RSI + 볼린저 과매도 반등 신호
+
+    조건:
+    1. RSI(14) ≤ 30 (강한 과매도)
+    2. 종가 ≤ BB 하단
+    3. 직전 봉 대비 거래량 ≥ 1.3배
+    4. 최근 봉 양봉 (음봉이면 스킵)
+    """
+    if not candles_5min or current_price <= 0:
+        return None
+
+    rsi = _rsi(candles_5min, 14)
+    if rsi is None or rsi > 30:
+        return None
+
+    bb = _bollinger(candles_5min, 20)
+    if bb is None:
+        return None
+    bb_upper, bb_middle, bb_lower = bb
+
+    if current_price > bb_lower * 1.01:
+        return None
+
+    if len(candles_5min) < 2:
+        return None
+    if candles_5min[-1].volume < candles_5min[-2].volume * 1.3:
+        return None
+
+    last = candles_5min[-1]
+    if last.close <= last.open:
+        return None
+
+    atr = _atr(candles_5min, 14)
+    stop_loss = (current_price - 1.5 * atr) if atr else current_price * (1 - STOP_LOSS_PCT)
+    target = bb_middle  # BB 중앙선까지 반등 목표
+
+    return DayTradeSignal(
+        stock_code=stock_code,
+        stock_name=stock_name,
+        strategy="RSI_BB",
+        entry_price=current_price,
+        stop_loss=round(stop_loss, 0),
+        target_price=round(target, 0),
+        reason=(
+            f"5분봉 과매도 반등: RSI={rsi:.1f}, "
+            f"BB하단={bb_lower:.0f}, 현재={current_price:.0f}"
+        ),
+        confidence=0.60,
+    )
+
+
+# ── 청산 신호 ─────────────────────────────────────────────────────────────────
+
+def check_day_trade_exit(
+    entry_price: float,
+    current_price: float,
+    stop_loss: float,
+    target_price: float,
+    highest_since_entry: float,
+    candles_5min: List[MinuteCandle],
+    current_time: time,
+) -> Optional[DayTradeExit]:
+    """데이트레이딩 청산 조건 체크 (우선순위 순)
+
+    1. EOD 강제 청산 (15:20 이후)
+    2. 손절 (현재가 ≤ stop_loss)
+    3. 목표가 달성 (현재가 ≥ target_price)
+    4. 트레일링 스탑 (1.5% 수익 후 ATR 트레일)
+    5. 5분봉 RSI ≥ 70 (과매수 청산)
+    """
+    # 1. EOD 강제 청산
+    if current_time >= EOD_FLAT:
+        return DayTradeExit(
+            action="SELL_ALL",
+            reason=f"EOD 강제 청산 ({current_time.strftime('%H:%M')} ≥ 15:20)",
+        )
+
+    # 2. 손절
+    if current_price <= stop_loss:
+        loss_pct = (current_price - entry_price) / entry_price * 100
+        return DayTradeExit(
+            action="SELL_ALL",
+            reason=f"손절 {loss_pct:.1f}% (현재={current_price:.0f} ≤ 손절가={stop_loss:.0f})",
+        )
+
+    # 3. 목표가 달성
+    if current_price >= target_price:
+        gain_pct = (current_price - entry_price) / entry_price * 100
+        return DayTradeExit(
+            action="SELL_ALL",
+            reason=f"목표가 달성 +{gain_pct:.1f}% (현재={current_price:.0f} ≥ 목표={target_price:.0f})",
+        )
+
+    # 4. 트레일링 스탑 (1.5% 이상 수익 시 발동)
+    profit_pct = (highest_since_entry - entry_price) / entry_price
+    if profit_pct >= TRAILING_TRIGGER:
+        atr = _atr(candles_5min, 14)
+        if atr:
+            trailing_stop = highest_since_entry - TRAILING_ATR_MULT * atr
+            if current_price <= trailing_stop:
+                return DayTradeExit(
+                    action="SELL_ALL",
+                    reason=(
+                        f"트레일링 스탑: 최고={highest_since_entry:.0f}, "
+                        f"트레일={trailing_stop:.0f}, 현재={current_price:.0f}"
+                    ),
+                )
+
+    # 5. 과매수 청산 (RSI ≥ 70)
+    rsi = _rsi(candles_5min, 14)
+    if rsi is not None and rsi >= 70:
+        gain_pct = (current_price - entry_price) / entry_price * 100
+        if gain_pct > COST_PCT * 100:  # 수수료 이상 수익인 경우만
+            return DayTradeExit(
+                action="SELL_ALL",
+                reason=f"과매수 청산: RSI={rsi:.1f}≥70, 수익={gain_pct:.1f}%",
+            )
+
+    return None
+
+
+# ── 포지션 사이징 ─────────────────────────────────────────────────────────────
+
+def calculate_day_trade_position_size(
+    total_assets: float,
+    available_cash: float,
+    current_day_trade_amount: float,
+) -> float:
+    """데이트레이딩 포지션 크기 계산
+
+    - 종목당 최대: 총자산 × 10%
+    - 전체 데이트레이딩 합산: 총자산 × 25% (CLAUDE.md 8.2)
+    - 동시 최대 3종목 (MAX_POSITIONS)
+    """
+    max_total = total_assets * MAX_DAY_TRADE_RATIO
+    remaining_budget = max_total - current_day_trade_amount
+    per_position_max = total_assets * MAX_CAPITAL_RATIO
+    return max(0.0, min(per_position_max, remaining_budget, available_cash))
+
+
+def is_daily_loss_exceeded(
+    total_assets: float,
+    realized_pnl_today: float,
+) -> bool:
+    """일일 손실 한도 초과 여부 (전체 자본 -3%)"""
+    if total_assets <= 0:
+        return False
+    return (realized_pnl_today / total_assets) <= DAILY_LOSS_LIMIT
diff --git a/backend/app/services/feature_engineering.py b/backend/app/services/feature_engineering.py
new file mode 100644
index 0000000..9403811
--- /dev/null
+++ b/backend/app/services/feature_engineering.py
@@ -0,0 +1,381 @@
+"""
+피처 엔지니어링 모듈
+
+KIS API 차트 데이터(OHLCV)에서 ML 모델용 피처를 추출합니다.
+- 기본 피처 12개: RSI, MACD, 스토캐스틱, 볼린저, MA비율, 거래량비율
+- 파생 피처 8개: 수익률, 변동성, 모멘텀, 크로스, ADX, 이격도
+"""
+
+import numpy as np
+import pandas as pd
+from typing import Optional, Dict, List, Tuple
+
+
+def _ema(values: np.ndarray, period: int) -> np.ndarray:
+    """지수이동평균 계산"""
+    result = np.full_like(values, np.nan, dtype=float)
+    if len(values) < period:
+        return result
+    result[period - 1] = np.mean(values[:period])
+    multiplier = 2.0 / (period + 1)
+    for i in range(period, len(values)):
+        result[i] = (values[i] - result[i - 1]) * multiplier + result[i - 1]
+    return result
+
+
+def chart_data_to_dataframe(chart_data: list) -> pd.DataFrame:
+    """KIS API 차트 데이터(최신순)를 DataFrame(시간순)으로 변환"""
+    rows = []
+    for item in chart_data:
+        rows.append({
+            "date": item.get("stck_bsop_date", ""),
+            "open": float(item.get("stck_oprc", 0) or 0),
+            "high": float(item.get("stck_hgpr", 0) or 0),
+            "low": float(item.get("stck_lwpr", 0) or 0),
+            "close": float(item.get("stck_clpr", 0) or 0),
+            "volume": float(item.get("acml_vol", 0) or 0),
+        })
+    df = pd.DataFrame(rows)
+    # KIS API는 최신순 → 시간순으로 뒤집기
+    df = df.iloc[::-1].reset_index(drop=True)
+    return df
+
+
+def db_data_to_dataframe(rows: list) -> pd.DataFrame:
+    """DB StockDailyPrice 레코드를 DataFrame(시간순)으로 변환.
+
+    Args:
+        rows: StockDailyPrice 객체 리스트 또는 dict 리스트
+              (trade_date, open_price, high_price, low_price, close_price, volume)
+
+    Returns:
+        chart_data_to_dataframe()과 동일한 형태의 DataFrame
+        columns: date, open, high, low, close, volume
+    """
+    records = []
+    for row in rows:
+        if isinstance(row, dict):
+            records.append({
+                "date": str(row["trade_date"]),
+                "open": float(row["open_price"]),
+                "high": float(row["high_price"]),
+                "low": float(row["low_price"]),
+                "close": float(row["close_price"]),
+                "volume": float(row["volume"]),
+            })
+        else:
+            records.append({
+                "date": str(row.trade_date),
+                "open": float(row.open_price),
+                "high": float(row.high_price),
+                "low": float(row.low_price),
+                "close": float(row.close_price),
+                "volume": float(row.volume),
+            })
+    df = pd.DataFrame(records)
+    # trade_date 기준 오름차순 정렬
+    df = df.sort_values("date").reset_index(drop=True)
+    return df
+
+
+def compute_rsi(close: np.ndarray, period: int = 14) -> np.ndarray:
+    """RSI 계산"""
+    result = np.full_like(close, np.nan, dtype=float)
+    if len(close) < period + 1:
+        return result
+    delta = np.diff(close)
+    gain = np.where(delta > 0, delta, 0.0)
+    loss = np.where(delta < 0, -delta, 0.0)
+
+    avg_gain = np.mean(gain[:period])
+    avg_loss = np.mean(loss[:period])
+
+    for i in range(period, len(delta)):
+        avg_gain = (avg_gain * (period - 1) + gain[i]) / period
+        avg_loss = (avg_loss * (period - 1) + loss[i]) / period
+        if avg_loss == 0:
+            result[i + 1] = 100.0
+        else:
+            rs = avg_gain / avg_loss
+            result[i + 1] = 100.0 - (100.0 / (1.0 + rs))
+    # 첫 번째 유효 값
+    if avg_loss == 0:
+        result[period] = 100.0
+    else:
+        result[period] = 100.0 - (100.0 / (1.0 + np.mean(gain[:period]) / max(np.mean(loss[:period]), 1e-10)))
+    return result
+
+
+def extract_features(df: pd.DataFrame) -> pd.DataFrame:
+    """DataFrame(OHLCV 시간순)에서 전체 피처를 계산하여 반환.
+
+    반환되는 DataFrame은 입력과 같은 인덱스를 갖되, 각 행마다
+    해당 시점까지의 정보만을 사용하여 계산된 20개 피처 컬럼을 포함합니다.
+    초기 데이터 부족 구간은 NaN이 됩니다.
+    """
+    close = df["close"].values.astype(float)
+    high = df["high"].values.astype(float)
+    low = df["low"].values.astype(float)
+    volume = df["volume"].values.astype(float)
+    n = len(close)
+
+    features: Dict[str, np.ndarray] = {}
+
+    # --- 기본 피처 (12개) ---
+
+    # 1-2. RSI (14일, 7일)
+    features["rsi_14"] = compute_rsi(close, 14)
+    features["rsi_7"] = compute_rsi(close, 7)
+
+    # 3-5. MACD (12, 26, signal=9)
+    ema12 = _ema(close, 12)
+    ema26 = _ema(close, 26)
+    macd_line = ema12 - ema26
+    macd_signal = _ema(macd_line[~np.isnan(macd_line)], 9)
+    # macd_signal을 원래 길이에 맞추기
+    full_signal = np.full(n, np.nan, dtype=float)
+    valid_start = np.argmax(~np.isnan(macd_line))
+    if len(macd_signal) > 0:
+        full_signal[valid_start:valid_start + len(macd_signal)] = macd_signal
+    features["macd"] = macd_line
+    features["macd_signal"] = full_signal
+    features["macd_hist"] = macd_line - full_signal
+
+    # 6-7. 스토캐스틱 %K, %D (14일)
+    stoch_k = np.full(n, np.nan, dtype=float)
+    stoch_d = np.full(n, np.nan, dtype=float)
+    for i in range(13, n):
+        h14 = np.max(high[i - 13:i + 1])
+        l14 = np.min(low[i - 13:i + 1])
+        if h14 != l14:
+            stoch_k[i] = (close[i] - l14) / (h14 - l14) * 100.0
+    # %D = %K의 3일 SMA
+    for i in range(15, n):
+        vals = stoch_k[i - 2:i + 1]
+        if not np.any(np.isnan(vals)):
+            stoch_d[i] = np.mean(vals)
+    features["stochastic_k"] = stoch_k
+    features["stochastic_d"] = stoch_d
+
+    # 8. 볼린저 밴드 위치 (0~1)
+    bb_pos = np.full(n, np.nan, dtype=float)
+    for i in range(19, n):
+        window = close[i - 19:i + 1]
+        mid = np.mean(window)
+        std = np.std(window, ddof=0)
+        if std > 0:
+            upper = mid + 2 * std
+            lower = mid - 2 * std
+            bb_pos[i] = (close[i] - lower) / (upper - lower)
+    features["bb_position"] = bb_pos
+
+    # 9-11. MA 비율 (현재가 / MA)
+    for period, name in [(5, "ma5_ratio"), (20, "ma20_ratio"), (60, "ma60_ratio")]:
+        ratio = np.full(n, np.nan, dtype=float)
+        for i in range(period - 1, n):
+            ma = np.mean(close[i - period + 1:i + 1])
+            if ma > 0:
+                ratio[i] = close[i] / ma
+        features[name] = ratio
+
+    # 12. 거래량 비율 (현재 / 20일 평균)
+    vol_ratio = np.full(n, np.nan, dtype=float)
+    for i in range(19, n):
+        avg_vol = np.mean(volume[i - 19:i + 1])
+        if avg_vol > 0:
+            vol_ratio[i] = volume[i] / avg_vol
+    features["volume_ratio"] = vol_ratio
+
+    # --- 파생 피처 (8개) ---
+
+    # 13-15. 단기 수익률
+    for days, name in [(1, "change_rate_1d"), (3, "change_rate_3d"), (5, "change_rate_5d")]:
+        cr = np.full(n, np.nan, dtype=float)
+        for i in range(days, n):
+            if close[i - days] > 0:
+                cr[i] = (close[i] - close[i - days]) / close[i - days]
+        features[name] = cr
+
+    # 16. 20일 변동성 (수익률의 표준편차)
+    vol20 = np.full(n, np.nan, dtype=float)
+    returns = np.full(n, np.nan, dtype=float)
+    for i in range(1, n):
+        if close[i - 1] > 0:
+            returns[i] = (close[i] - close[i - 1]) / close[i - 1]
+    for i in range(20, n):
+        window = returns[i - 19:i + 1]
+        valid = window[~np.isnan(window)]
+        if len(valid) >= 10:
+            vol20[i] = np.std(valid, ddof=1)
+    features["volatility_20d"] = vol20
+
+    # 17. 5일 모멘텀 (현재가 / 5일전가)
+    mom = np.full(n, np.nan, dtype=float)
+    for i in range(5, n):
+        if close[i - 5] > 0:
+            mom[i] = close[i] / close[i - 5]
+    features["price_momentum"] = mom
+
+    # 18. MA 크로스 상태 (-1, 0, 1)
+    ma_cross = np.full(n, 0.0, dtype=float)
+    for i in range(59, n):
+        ma5 = np.mean(close[i - 4:i + 1])
+        ma20 = np.mean(close[i - 19:i + 1])
+        ma60 = np.mean(close[i - 59:i + 1])
+        if ma5 > ma20 > ma60:
+            ma_cross[i] = 1.0  # 정배열
+        elif ma5 < ma20 < ma60:
+            ma_cross[i] = -1.0  # 역배열
+    features["ma_cross"] = ma_cross
+
+    # 19. 추세 강도 (간이 ADX, True Range 기반)
+    adx_val = np.full(n, np.nan, dtype=float)
+    tr = np.zeros(n, dtype=float)
+    for i in range(1, n):
+        tr[i] = max(high[i] - low[i], abs(high[i] - close[i - 1]), abs(low[i] - close[i - 1]))
+    for i in range(13, n):
+        avg_tr = np.mean(tr[i - 13:i + 1])
+        current_tr = tr[i]
+        if avg_tr > 0:
+            adx_val[i] = current_tr / avg_tr
+    features["trend_strength"] = adx_val
+
+    # 20. 이격도 (현재가 / 20일 이평선 * 100)
+    disp = np.full(n, np.nan, dtype=float)
+    for i in range(19, n):
+        ma20 = np.mean(close[i - 19:i + 1])
+        if ma20 > 0:
+            disp[i] = close[i] / ma20 * 100.0
+    features["disparity_20"] = disp
+
+    feat_df = pd.DataFrame(features, index=df.index)
+    return feat_df
+
+
+# 피처 컬럼 순서 (모델 학습/추론 시 일관성 유지)
+FEATURE_COLUMNS = [
+    "rsi_14", "rsi_7",
+    "macd", "macd_signal", "macd_hist",
+    "stochastic_k", "stochastic_d",
+    "bb_position",
+    "ma5_ratio", "ma20_ratio", "ma60_ratio",
+    "volume_ratio",
+    "change_rate_1d", "change_rate_3d", "change_rate_5d",
+    "volatility_20d",
+    "price_momentum",
+    "ma_cross",
+    "trend_strength",
+    "disparity_20",
+]
+
+# LSTM 시퀀스에 사용할 피처 (5개)
+LSTM_SEQUENCE_FEATURES = ["close", "volume", "rsi_14", "ma20_ratio", "volatility_20d"]
+
+
+def prepare_training_data(
+    df: pd.DataFrame,
+    features_df: pd.DataFrame,
+    forecast_days: int = 3,
+    up_threshold: float = 0.015,
+    down_threshold: float = -0.015,
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """학습 데이터 준비.
+
+    Returns:
+        X_tabular: (N, 20) 탭뷸러 피처
+        X_seq: (N, 60, 5) LSTM 시퀀스 피처
+        y: (N,) 레이블 (0=DOWN, 1=HOLD, 2=UP)
+        valid_indices: 유효한 행 인덱스
+    """
+    close = df["close"].values.astype(float)
+    n = len(close)
+
+    # 레이블 생성: forecast_days 후 수익률
+    labels = np.full(n, np.nan, dtype=float)
+    for i in range(n - forecast_days):
+        if close[i] > 0:
+            future_return = (close[i + forecast_days] - close[i]) / close[i]
+            if future_return >= up_threshold:
+                labels[i] = 2  # UP
+            elif future_return <= down_threshold:
+                labels[i] = 0  # DOWN
+            else:
+                labels[i] = 1  # HOLD
+
+    # 유효한 행 찾기 (피처와 레이블 모두 NaN 아닌 행)
+    tabular = features_df[FEATURE_COLUMNS].values
+    seq_window = 60
+
+    valid_mask = np.ones(n, dtype=bool)
+    valid_mask[:seq_window] = False  # 시퀀스 윈도우 확보
+    valid_mask[np.isnan(labels)] = False
+    # 탭뷸러 피처 NaN 체크
+    for i in range(n):
+        if valid_mask[i] and np.any(np.isnan(tabular[i])):
+            valid_mask[i] = False
+
+    valid_indices = np.where(valid_mask)[0]
+
+    if len(valid_indices) == 0:
+        return np.array([]), np.array([]), np.array([]), np.array([])
+
+    # 탭뷸러 피처
+    X_tabular = tabular[valid_indices]
+
+    # 레이블
+    y = labels[valid_indices].astype(int)
+
+    # LSTM 시퀀스 피처 준비
+    # 시퀀스에 사용할 raw 피처 결합
+    seq_cols = []
+    for col in LSTM_SEQUENCE_FEATURES:
+        if col in df.columns:
+            seq_cols.append(df[col].values.astype(float))
+        elif col in features_df.columns:
+            seq_cols.append(features_df[col].values.astype(float))
+        else:
+            seq_cols.append(np.zeros(n, dtype=float))
+    seq_raw = np.column_stack(seq_cols)  # (n, 5)
+
+    X_seq = np.zeros((len(valid_indices), seq_window, len(LSTM_SEQUENCE_FEATURES)), dtype=float)
+    for j, idx in enumerate(valid_indices):
+        X_seq[j] = seq_raw[idx - seq_window:idx]
+
+    return X_tabular, X_seq, y, valid_indices
+
+
+def extract_single_features(chart_data: list) -> Tuple[Optional[np.ndarray], Optional[np.ndarray]]:
+    """단일 종목 차트 데이터에서 최신 시점의 피처를 추출.
+
+    Returns:
+        tabular_features: (20,) 탭뷸러 피처 또는 None
+        sequence_features: (60, 5) LSTM 시퀀스 또는 None
+    """
+    if not chart_data or len(chart_data) < 61:
+        return None, None
+
+    df = chart_data_to_dataframe(chart_data)
+    features_df = extract_features(df)
+
+    # 마지막 행의 탭뷸러 피처
+    last_row = features_df[FEATURE_COLUMNS].iloc[-1].values
+    if np.any(np.isnan(last_row)):
+        return None, None
+
+    # LSTM 시퀀스 (최근 60일)
+    seq_cols = []
+    for col in LSTM_SEQUENCE_FEATURES:
+        if col in df.columns:
+            seq_cols.append(df[col].values.astype(float))
+        elif col in features_df.columns:
+            seq_cols.append(features_df[col].values.astype(float))
+        else:
+            seq_cols.append(np.zeros(len(df), dtype=float))
+    seq_raw = np.column_stack(seq_cols)
+
+    if len(seq_raw) < 60:
+        return None, None
+
+    sequence = seq_raw[-60:]  # (60, 5)
+
+    return last_row, sequence
diff --git a/backend/app/services/korea_investment_api.py b/backend/app/services/korea_investment_api.py
index 5bedd02..9625d54 100644
--- a/backend/app/services/korea_investment_api.py
+++ b/backend/app/services/korea_investment_api.py
@@ -1,9 +1,12 @@
 import httpx
 from typing import Dict, Any, Optional, Deque
-from datetime import datetime
+from datetime import datetime, timedelta
 import logging
 import asyncio
 import time
+import json
+import os
+from pathlib import Path
 from collections import deque
 from app.core.config import settings
 
@@ -65,6 +68,9 @@ class APICallMonitor:
 
 class KoreaInvestmentAPI:
     """한국투자증권 API 클라이언트 (안전한 재시도 및 쓰로틀링 적용)"""
+
+    # 토큰 캐시 파일 경로 — 사용자 홈 디렉토리 하위에 저장 (/tmp는 보안 취약)
+    TOKEN_CACHE_FILE = Path.home() / ".cache" / "auto-stock" / "kis_token_cache.json"
     
     def __init__(self):
         self.base_url = settings.KOREA_INVESTMENT_API_BASE_URL
@@ -85,42 +91,148 @@ class KoreaInvestmentAPI:
         # 동시 요청 제한 (세마포어)
         self.semaphore = asyncio.Semaphore(settings.API_MAX_CONCURRENT_REQUESTS)
         
+        # 토큰 발급 Lock (중복 발급 방지)
+        self._token_lock = asyncio.Lock()
+        
         # 모니터링
         self.monitor = APICallMonitor(window_size=settings.API_MONITORING_WINDOW)
+
+        # 시작 시 설정 로깅 (키 마스킹)
+        logger.info(f"🔧 KIS API 초기화: mode={settings.KIS_MODE}, "
+                     f"base_url={self.base_url}, "
+                     f"app_key={self.app_key[:6]}..., "
+                     f"account={self.account_number[:4]}****{self.account_number[-2:]}")
+
+        # 캐시된 토큰 로드
+        self._load_token_from_cache()
+    
+    def _load_token_from_cache(self):
+        """파일에서 토큰 로드 (앱 시작 시 동기 호출)"""
+        try:
+            cache_file = Path(self.TOKEN_CACHE_FILE)
+            if cache_file.exists():
+                with open(cache_file, 'r') as f:
+                    cache = json.load(f)
+                    self.access_token = cache.get('access_token')
+                    expires_str = cache.get('expires_at')
+                    if expires_str:
+                        self.token_expires_at = datetime.fromisoformat(expires_str)
+                        if self.access_token and datetime.now() < self.token_expires_at:
+                            remaining = (self.token_expires_at - datetime.now()).total_seconds() / 3600
+                            logger.info(f"💾 캐시 파일에서 토큰 로드 성공 (남은 시간: {remaining:.1f}시간)")
+                        else:
+                            logger.info("💾 캐시 파일의 토큰이 만료됨")
+                            self.access_token = None
+                            self.token_expires_at = None
+        except Exception as e:
+            logger.warning(f"⚠️ 토큰 캐시 파일 로드 실패: {e}")
+
+    def _write_token_file(self):
+        """토큰을 파일에 동기 저장 (asyncio.to_thread 내부에서 실행)"""
+        cache_file = Path(self.TOKEN_CACHE_FILE)
+        cache_file.parent.mkdir(parents=True, exist_ok=True)
+        cache = {
+            'access_token': self.access_token,
+            'expires_at': self.token_expires_at.isoformat() if self.token_expires_at else None,
+        }
+        with open(cache_file, 'w') as f:
+            json.dump(cache, f)
+        # 소유자만 읽기/쓰기 가능하도록 퍼미션 설정 (보안)
+        os.chmod(cache_file, 0o600)
+        logger.debug("💾 토큰 캐시 파일 저장 완료")
+
+    async def _save_token_to_cache(self):
+        """토큰을 파일에 비동기 저장 (이벤트 루프 블로킹 방지)"""
+        try:
+            await asyncio.to_thread(self._write_token_file)
+        except Exception as e:
+            logger.warning(f"⚠️ 토큰 캐시 파일 저장 실패: {e}")
     
     async def _get_access_token(self) -> str:
-        """접근 토큰 발급"""
+        """접근 토큰 발급 (Lock으로 중복 발급 방지)"""
+        # 캐시된 토큰이 유효하면 재사용 (23시간 유효)
         if self.access_token and self.token_expires_at and datetime.now() < self.token_expires_at:
+            remaining = (self.token_expires_at - datetime.now()).total_seconds() / 3600
+            logger.info(f"✅ 캐시된 토큰 재사용 (남은 시간: {remaining:.1f}시간)")
             return self.access_token
         
-        async with httpx.AsyncClient() as client:
-            response = await client.post(
-                f"{self.base_url}/oauth2/tokenP",
-                json={
-                    "grant_type": "client_credentials",
-                    "appkey": self.app_key,
-                    "appsecret": self.app_secret
-                }
-            )
-            
-            if response.status_code == 200:
-                data = response.json()
-                self.access_token = data["access_token"]
-                # 토큰 만료 시간 설정 (일반적으로 24시간)
-                from datetime import timedelta
-                self.token_expires_at = datetime.now() + timedelta(hours=23)
+        # 🔒 Lock 획득 - 동시 요청 시 하나만 토큰 발급
+        async with self._token_lock:
+            # Lock 대기 중 다른 요청이 토큰 발급했을 수 있으므로 재확인
+            if self.access_token and self.token_expires_at and datetime.now() < self.token_expires_at:
+                remaining = (self.token_expires_at - datetime.now()).total_seconds() / 3600
+                logger.info(f"✅ 대기 중 토큰 발급됨, 재사용 (남은 시간: {remaining:.1f}시간)")
                 return self.access_token
-            else:
-                raise Exception(f"Failed to get access token: {response.text}")
+            
+            # 토큰 발급 시도 전에 마지막 시도 시간 확인 (1분 제한 대응)
+            if hasattr(self, '_last_token_request_time'):
+                elapsed = (datetime.now() - self._last_token_request_time).total_seconds()
+                if elapsed < 70:  # 70초 대기 (여유있게)
+                    # 기존 토큰이 있으면 계속 사용
+                    if self.access_token:
+                        logger.warning(f"⏳ 토큰 발급 1분 제한 ({elapsed:.0f}초 경과) - 기존 토큰 재사용")
+                        # 만료 시간 연장 (추가 1시간)
+                        self.token_expires_at = datetime.now() + timedelta(hours=1)
+                        return self.access_token
+                    
+                    wait_time = 70 - elapsed
+                    logger.warning(f"⏳ 토큰 발급 1분 제한: {wait_time:.1f}초 대기 중...")
+                    await asyncio.sleep(wait_time + 1)
+            
+            logger.info("🔑 새로운 토큰 발급 요청...")
+            self._last_token_request_time = datetime.now()
+        
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    f"{self.base_url}/oauth2/tokenP",
+                    json={
+                        "grant_type": "client_credentials",
+                        "appkey": self.app_key,
+                        "appsecret": self.app_secret
+                    },
+                    timeout=30.0
+                )
+                
+                if response.status_code == 200:
+                    data = response.json()
+                    self.access_token = data["access_token"]
+                    # 토큰 만료 시간 설정 (일반적으로 24시간)
+                    self.token_expires_at = datetime.now() + timedelta(hours=23)
+                    
+                    # 파일에 저장 (비동기)
+                    await self._save_token_to_cache()
+                    
+                    logger.info(f"✅ 새 토큰 발급 완료 (만료: {self.token_expires_at.strftime('%Y-%m-%d %H:%M')})")
+                    return self.access_token
+                else:
+                    error_msg = response.text
+                    logger.error(f"❌ 토큰 발급 실패: {response.status_code} - {error_msg}")
+                    
+                    # 토큰 발급 실패 시에도 기존 토큰이 있다면 계속 사용 시도
+                    if self.access_token:
+                        logger.warning(f"⚠️ 토큰 발급 실패했지만 기존 토큰 재사용 시도")
+                        # 만료 시간 연장
+                        self.token_expires_at = datetime.now() + timedelta(hours=1)
+                        return self.access_token
+                    raise Exception(f"Failed to get access token: {error_msg}")
+            except Exception as e:
+                logger.error(f"❌ 토큰 요청 중 오류: {e}")
+                # 기존 토큰이 있으면 사용
+                if self.access_token:
+                    logger.warning(f"⚠️ 토큰 요청 실패, 기존 토큰 재사용")
+                    self.token_expires_at = datetime.now() + timedelta(hours=1)
+                    return self.access_token
+                raise
     
-    async def _make_request(self, method: str, endpoint: str, tr_id: str, **kwargs) -> Dict[str, Any]:
+    async def _make_request(self, method: str, endpoint: str, tr_id: str, extra_headers: Optional[Dict[str, str]] = None, **kwargs) -> (Dict[str, Any], Any):
         """API 요청 실행 (안전한 재시도 + 쓰로틀링 + 모니터링)"""
         
         # 동시 요청 수 제한 (세마포어)
         async with self.semaphore:
-            return await self._make_request_with_retry(method, endpoint, tr_id, **kwargs)
+            return await self._make_request_with_retry(method, endpoint, tr_id, extra_headers=extra_headers, **kwargs)
     
-    async def _make_request_with_retry(self, method: str, endpoint: str, tr_id: str, **kwargs) -> Dict[str, Any]:
+    async def _make_request_with_retry(self, method: str, endpoint: str, tr_id: str, extra_headers: Optional[Dict[str, str]] = None, **kwargs) -> (Dict[str, Any], Any):
         """재시도 로직을 포함한 실제 요청 실행"""
         start_time = time.time()
         retry_count = 0
@@ -146,6 +258,8 @@ class KoreaInvestmentAPI:
                     "appsecret": self.app_secret,
                     "tr_id": tr_id,
                 }
+                if extra_headers:
+                    headers.update(extra_headers)
                 
                 # 타임아웃 설정
                 timeout = httpx.Timeout(self.timeout, connect=10.0)
@@ -170,7 +284,7 @@ class KoreaInvestmentAPI:
                                 f"(임계값: {settings.API_ERROR_THRESHOLD:.1%})"
                             )
                         
-                        return response.json()
+                        return response.json(), response.headers
                     
                     # API 호출 제한 초과 (429) 또는 서버 오류 (5xx)
                     elif response.status_code in [429, 500, 502, 503, 504]:
@@ -199,8 +313,12 @@ class KoreaInvestmentAPI:
                         
                         error_msg = f"API 클라이언트 오류 (재시도 안함): {response.status_code} - {response.text}"
                         logger.error(f"❌ {error_msg}")
-                        raise Exception(error_msg)
-                    
+                        # 에러 응답도 json과 headers 튜플로 반환 시도
+                        try:
+                            return response.json(), response.headers
+                        except Exception:
+                            return {"rt_cd": str(response.status_code), "msg1": error_msg, "output": None}, None
+
                     # 기타 오류
                     else:
                         duration = time.time() - start_time
@@ -242,7 +360,7 @@ class KoreaInvestmentAPI:
     async def get_current_price(self, stock_code: str) -> Dict[str, Any]:
         """현재가 조회"""
         try:
-            result = await self._make_request(
+            result, _ = await self._make_request(
                 "GET",
                 "/uapi/domestic-stock/v1/quotations/inquire-price",
                 "FHKST01010100",
@@ -256,39 +374,292 @@ class KoreaInvestmentAPI:
             logger.error(f"Error fetching price for {stock_code}: {e}")
             raise
     
-    async def get_daily_chart(self, stock_code: str, period: str = "D") -> Dict[str, Any]:
-        """일봉/주봉/월봉 조회
+    async def get_daily_chart(self, stock_code: str, period: str = "D", limit: int = 240) -> Dict[str, Any]:
+        """일봉/주봉/월봉 조회 (페이지네이션 지원으로 최대 240개까지 조회)"""
+        all_output2 = []
         
-        KIS API는 기본적으로 최근 30~100개 데이터를 반환
-        더 많은 데이터가 필요하면 반복 호출 필요 (페이지네이션 없음)
-        """
+        # 1. 첫 요청
+        params = {
+            "FID_COND_MRKT_DIV_CODE": "J",
+            "FID_INPUT_ISCD": stock_code,
+            "FID_PERIOD_DIV_CODE": period,
+            "FID_ORG_ADJ_PRC": "0"  # 0: 수정주가, 1: 원주가
+        }
         try:
-            result = await self._make_request(
+            result, headers = await self._make_request(
                 "GET",
                 "/uapi/domestic-stock/v1/quotations/inquire-daily-price",
                 "FHKST01010400",
+                params=params
+            )
+
+            # FHKST01010400은 'output' (배열) 또는 'output2' (배열)로 데이터를 반환
+            # 실전/모의투자 환경에 따라 키 이름이 다를 수 있음
+            data_key = 'output2' if isinstance(result.get('output2'), list) and result.get('output2') else \
+                       'output' if isinstance(result.get('output'), list) and result.get('output') else None
+
+            if not result or result.get('rt_cd') != '0' or data_key is None:
+                logger.warning(f"No chart data for {stock_code}: {result.get('msg1', 'Unknown')}")
+                return result
+
+            all_output2.extend(result.get(data_key, []))
+            tr_cont = headers.get('tr_cont')
+
+            # 2. 연속 조회 (필요 시)
+            while tr_cont in ('F', 'M') and len(all_output2) < limit:
+                await asyncio.sleep(self.min_request_interval + 0.1) # Rate limit
+                extra_headers = {'tr_cont': 'Y'}
+
+                result_cont, headers_cont = await self._make_request(
+                    "GET",
+                    "/uapi/domestic-stock/v1/quotations/inquire-daily-price",
+                    "FHKST01010400",
+                    params=params,
+                    extra_headers=extra_headers
+                )
+
+                if result_cont and result_cont.get('rt_cd') == '0':
+                    cont_key = 'output2' if isinstance(result_cont.get('output2'), list) else 'output'
+                    all_output2.extend(result_cont.get(cont_key, []))
+                
+                tr_cont = headers_cont.get('tr_cont') if headers_cont else None
+
+            # 3. 최종 결과 조합
+            final_result = result # 첫 페이지 응답을 기반으로 조합
+            final_result['output2'] = all_output2
+            final_result['msg1'] = f"OK (fetched {len(all_output2)} data points)"
+            
+            logger.info(f"✅ Fetched {len(all_output2)} chart data points for {stock_code}")
+            return final_result
+
+        except Exception as e:
+            logger.error(f"Error fetching paginated chart for {stock_code}: {e}")
+            raise
+
+    async def get_overseas_price(self, symbol: str, exchange_code: str = "NASD") -> Dict[str, Any]:
+        """해외주식 현재가 조회 (NASD, NYSE, AMEX)"""
+        try:
+            # 거래소 코드 보정
+            exch_map = {"NASD": "NAS", "NYSE": "NYS", "AMEX": "AMS"}
+            formatted_exchange = exch_map.get(exchange_code.upper(), exchange_code.upper())
+
+            # 모의투자 여부에 따라 TR_ID가 다를 수 있는지 확인 필요하나, 
+            # 시세 조회는 실전/모의 공통인 경우가 많음 (HHDFS00000300)
+            
+            result, _ = await self._make_request(
+                "GET",
+                "/uapi/overseas-price/v1/quotations/price",
+                "HHDFS00000300",
                 params={
-                    "FID_COND_MRKT_DIV_CODE": "J",
-                    "FID_INPUT_ISCD": stock_code,
-                    "FID_PERIOD_DIV_CODE": period,
-                    "FID_ORG_ADJ_PRC": "0"  # 0: 수정주가, 1: 원주가
+                    "AUTH": "",
+                    "EXCD": exchange_code.upper(), # NASD, NYSE, AMEX
+                    "SYMB": symbol.upper()
                 }
             )
             return result
         except Exception as e:
-            logger.error(f"Error fetching chart for {stock_code}: {e}")
+            logger.error(f"Error fetching overseas price for {symbol}: {e}")
             raise
-    
+
+    async def get_minute_chart(
+        self,
+        stock_code: str,
+        ref_time: str = "",
+        include_past: bool = True,
+    ) -> Dict[str, Any]:
+        """국내주식 분봉차트 조회 (FHKST03010200)
+
+        KIS API: /uapi/domestic-stock/v1/quotations/inquire-time-itemchartprice
+        한 번 호출에 최대 30개 분봉 반환. 전체 장 데이터는 여러 번 호출 필요.
+
+        Args:
+            stock_code: 종목코드 (e.g. "005930")
+            ref_time: 조회 기준 시간 (HHMMSS). 빈 문자열이면 현재 시간
+            include_past: True = 과거 데이터 포함 (Y), False = 당일만 (N)
+
+        Returns:
+            {
+              "output1": { 현재가 요약 },
+              "output2": [
+                {
+                  "stck_bsop_date": "20260222",   # 날짜 YYYYMMDD
+                  "stck_cntg_hour": "091500",      # 시간 HHMMSS
+                  "stck_prpr":  "71800",            # 종가(현재가)
+                  "stck_oprc":  "71500",            # 시가
+                  "stck_hgpr":  "72000",            # 고가
+                  "stck_lwpr":  "71400",            # 저가
+                  "cntg_vol":   "12345",            # 분봉 거래량
+                  "acml_vol":   "987654",           # 누적 거래량
+                  "acml_tr_pbmn": "70896123456",    # 누적 거래대금(원)
+                }, ...
+              ]
+            }
+        """
+        try:
+            if not ref_time:
+                from datetime import datetime
+                import pytz
+                kst = pytz.timezone("Asia/Seoul")
+                ref_time = datetime.now(kst).strftime("%H%M%S")
+
+            params = {
+                "FID_ETC_CLS_CODE": "",
+                "FID_INPUT_ISCD": stock_code,
+                "FID_INPUT_HOUR_1": ref_time,
+                "FID_PW_DATA_INCU_YN": "Y" if include_past else "N",
+            }
+            result, _ = await self._make_request(
+                "GET",
+                "/uapi/domestic-stock/v1/quotations/inquire-time-itemchartprice",
+                "FHKST03010200",
+                params=params,
+            )
+            return result
+        except Exception as e:
+            logger.error(f"Error fetching minute chart for {stock_code}: {e}")
+            raise
+
+    async def get_minute_chart_full_day(
+        self,
+        stock_code: str,
+        market_open: str = "090000",
+    ) -> list:
+        """당일 전체 분봉 데이터 수집 (여러 번 호출 집계)
+
+        09:00부터 현재까지의 모든 1분봉을 순서대로 반환.
+        한 번 호출에 30개씩 → 최대 ~13회 호출 필요 (390분/30).
+        시간 역순 데이터를 정순으로 변환해서 반환.
+
+        Returns:
+            List[dict] — output2 레코드 목록 (오래된 것 → 최신 순)
+        """
+        from datetime import datetime
+        import pytz
+        kst = pytz.timezone("Asia/Seoul")
+        now_str = datetime.now(kst).strftime("%H%M%S")
+
+        all_candles: list = []
+        ref = now_str
+        seen_times: set = set()
+
+        for _ in range(15):  # 최대 15회 (450분, 여유 있게)
+            try:
+                result = await self.get_minute_chart(stock_code, ref_time=ref)
+            except Exception as e:
+                logger.warning(f"Minute chart fetch failed for {stock_code} at {ref}: {e}")
+                break
+
+            candles = result.get("output2") if isinstance(result.get("output2"), list) else []
+            if not candles:
+                break
+
+            new_added = 0
+            for c in candles:
+                t = c.get("stck_cntg_hour", "")
+                if t and t not in seen_times:
+                    seen_times.add(t)
+                    all_candles.append(c)
+                    new_added += 1
+
+            # 가장 오래된 시간 확인
+            times = [c.get("stck_cntg_hour", "999999") for c in candles if c.get("stck_cntg_hour")]
+            oldest = min(times) if times else "000000"
+
+            if oldest <= market_open or new_added == 0:
+                break
+
+            ref = oldest
+            await asyncio.sleep(self.min_request_interval + 0.05)
+
+        # 오래된 것 → 최신 순으로 정렬
+        all_candles.sort(key=lambda c: c.get("stck_cntg_hour", ""))
+        return all_candles
+
+    async def get_overseas_daily_chart(self, symbol: str, exchange_code: str = "NASD", period: str = "D") -> Dict[str, Any]:
+        """해외주식 차트 조회"""
+        try:
+            # 기간 코드: O(일), P(주), Q(월) - KIS 해외주식 문서 기준
+            # 또는 0(일), 1(주), 2(월) 
+            gubn = "0"
+            if period == "W": gubn = "1"
+            elif period == "M": gubn = "2"
+
+            result, _ = await self._make_request(
+                "GET",
+                "/uapi/overseas-price/v1/quotations/dailyprice",
+                "HHDFS76240000",
+                params={
+                    "AUTH": "",
+                    "EXCD": exchange_code.upper(),
+                    "SYMB": symbol.upper(),
+                    "GUBN": gubn,
+                    "BYMD": "",
+                    "MODP": "1"
+                }
+            )
+            return result
+        except Exception as e:
+            logger.error(f"Error fetching overseas chart for {symbol}: {e}")
+            raise
+
+    async def place_overseas_order(
+        self,
+        symbol: str, 
+        order_type: str, # "BUY" or "SELL"
+        quantity: int,
+        price: float, # 해외주식은 지정가(Limit)가 기본
+        exchange_code: str = "NASD"
+    ) -> Dict[str, Any]:
+        """해외주식 주문 (미국주식 기준)"""
+        try:
+            account_number_prefix = self.account_number[:8]
+            account_number_suffix = self.account_number[8:]
+            
+            # 모의/실전 구분
+            is_virtual = "vts" in self.base_url.lower()
+            
+            # TR_ID 설정 (미국 매수/매도)
+            if order_type == "BUY":
+                tr_id = "VTTT1002U" if is_virtual else "TTTT1002U" # 미국 매수
+            else:
+                tr_id = "VTTT1006U" if is_virtual else "TTTT1006U" # 미국 매도
+            
+            # 해외주식 주문 (미국)
+            # OVRS_EXCG_CD: NASD, NYSE, AMEX
+            result, _ = await self._make_request(
+                "POST",
+                "/uapi/overseas-stock/v1/trading/order",
+                tr_id,
+                json={
+                    "CANO": account_number_prefix,
+                    "ACNT_PRDT_CD": account_number_suffix,
+                    "OVRS_EXCG_CD": exchange_code.upper(),
+                    "PDNO": symbol.upper(),
+                    "ORD_QTY": str(quantity),
+                    "OVRS_ORD_UNPR": str(price),
+                    "ORD_SVR_DVSN_CD": "0",
+                    "ORD_DVSN": "00" # 00: 지정가
+                }
+            )
+            return result
+        except Exception as e:
+            logger.error(f"Error placing overseas order: {e}")
+            raise
+
     async def get_balance(self) -> Dict[str, Any]:
         """계좌 잔고 조회"""
         try:
             account_number_prefix = self.account_number[:8]
             account_number_suffix = self.account_number[8:]
             
-            result = await self._make_request(
+            # 모의투자 환경 확인 (URL에 'vts' 포함 여부로 판단)
+            is_virtual = "vts" in self.base_url.lower()
+            tr_id = "VTTC8434R" if is_virtual else "TTTC8434R"
+            
+            result, _ = await self._make_request(
                 "GET",
                 "/uapi/domestic-stock/v1/trading/inquire-balance",
-                "TTTC8434R",
+                tr_id,
                 params={
                     "CANO": account_number_prefix,
                     "ACNT_PRDT_CD": account_number_suffix,
@@ -303,6 +674,10 @@ class KoreaInvestmentAPI:
                     "CTX_AREA_NK100": ""
                 }
             )
+            logger.info(f"📋 Balance API Full Response: {result}")
+            logger.info(f"📋 Balance API Keys: {result.keys()}")
+            if result.get('rt_cd') != '0':
+                logger.error(f"❌ Balance API error - rt_cd={result.get('rt_cd')}, msg1={result.get('msg1')}")
             return result
         except Exception as e:
             logger.error(f"Error fetching balance: {e}")
@@ -317,20 +692,35 @@ class KoreaInvestmentAPI:
     ) -> Dict[str, Any]:
         """주문 실행"""
         try:
+            # 환경 설정 확인
+            if not self.app_key or not self.app_secret or not self.account_number:
+                error_msg = f"KIS API 설정 누락: app_key={bool(self.app_key)}, secret={bool(self.app_secret)}, account={bool(self.account_number)}"
+                logger.error(error_msg)
+                return {
+                    "rt_cd": "-1",
+                    "msg1": error_msg,
+                    "odno": None
+                }
+            
             account_number_prefix = self.account_number[:8]
             account_number_suffix = self.account_number[8:]
             
-            # 매수/매도 구분
+            # 모의투자 환경 확인
+            is_virtual = "vts" in self.base_url.lower()
+            
+            # 매수/매도 구분 (모의투자는 V 접두사)
             if order_type == "BUY":
-                tr_id = "TTTC0802U"  # 현금 매수
+                tr_id = "VTTC0802U" if is_virtual else "TTTC0802U"  # 현금 매수
             else:
-                tr_id = "TTTC0801U"  # 현금 매도
+                tr_id = "VTTC0801U" if is_virtual else "TTTC0801U"  # 현금 매도
             
             # 주문 유형 (00: 지정가, 01: 시장가)
             order_dvsn = "01" if price is None else "00"
             order_price = "0" if price is None else str(int(price))
             
-            result = await self._make_request(
+            logger.info(f"📤 주문 요청: {order_type} {stock_code} {quantity}주 @{order_price}원 (tr_id={tr_id}, is_virtual={is_virtual})")
+            
+            result, _ = await self._make_request(
                 "POST",
                 "/uapi/domestic-stock/v1/trading/order-cash",
                 tr_id,
@@ -343,10 +733,16 @@ class KoreaInvestmentAPI:
                     "ORD_UNPR": order_price
                 }
             )
+            
+            logger.info(f"📥 주문 응답: rt_cd={result.get('rt_cd')}, msg1={result.get('msg1')}, odno={result.get('odno')}")
             return result
         except Exception as e:
-            logger.error(f"Error placing order: {e}")
-            raise
+            logger.error(f"❌ 주문 실행 오류: {e}", exc_info=True)
+            return {
+                "rt_cd": "-1",
+                "msg1": str(e),
+                "odno": None
+            }
     
     async def cancel_order(self, order_id: str, quantity: int) -> Dict[str, Any]:
         """주문 취소"""
@@ -354,10 +750,14 @@ class KoreaInvestmentAPI:
             account_number_prefix = self.account_number[:8]
             account_number_suffix = self.account_number[8:]
             
-            result = await self._make_request(
+            # 모의투자 환경 확인
+            is_virtual = "vts" in self.base_url.lower()
+            tr_id = "VTTC0803U" if is_virtual else "TTTC0803U"
+            
+            result, _ = await self._make_request(
                 "POST",
                 "/uapi/domestic-stock/v1/trading/order-rvsecncl",
-                "TTTC0803U",
+                tr_id,
                 json={
                     "CANO": account_number_prefix,
                     "ACNT_PRDT_CD": account_number_suffix,
@@ -383,7 +783,7 @@ class KoreaInvestmentAPI:
     ) -> Dict[str, Any]:
         """조건 검색으로 종목 조회"""
         try:
-            result = await self._make_request(
+            result, _ = await self._make_request(
                 "GET",
                 "/uapi/domestic-stock/v1/quotations/inquire-search",
                 "HHKST03900300",
@@ -410,7 +810,7 @@ class KoreaInvestmentAPI:
         """전체 종목 리스트 조회"""
         try:
             # 거래대금 상위 종목 조회
-            result = await self._make_request(
+            result, _ = await self._make_request(
                 "GET",
                 "/uapi/domestic-stock/v1/quotations/volume-rank",
                 "FHPST01710000",
@@ -437,6 +837,32 @@ class KoreaInvestmentAPI:
         """거래량 순위 조회 (get_stock_list와 동일하지만 명시적 이름)"""
         return await self.get_stock_list(market)
     
+    async def get_orderbook(self, stock_code: str) -> Dict[str, Any]:
+        """호가 정보 조회 (매수/매도 호가 10단계)"""
+        try:
+            result, _ = await self._make_request(
+                "GET",
+                "/uapi/domestic-stock/v1/quotations/inquire-asking-price-exp-ccn",
+                "FHKST01010200",
+                params={
+                    "FID_COND_MRKT_DIV_CODE": "J",
+                    "FID_INPUT_ISCD": stock_code
+                }
+            )
+            
+            # 디버깅용 로그
+            logger.info(f"📊 Orderbook raw response for {stock_code}:")
+            logger.info(f"  rt_cd: {result.get('rt_cd')}, msg1: {result.get('msg1')}")
+            if result.get('output1'):
+                logger.info(f"  output1 keys: {list(result['output1'].keys())[:10]}")
+            if result.get('output2'):
+                logger.info(f"  output2 keys: {list(result['output2'].keys())[:10]}")
+            
+            return result
+        except Exception as e:
+            logger.error(f"Error fetching orderbook for {stock_code}: {e}")
+            raise
+    
     def get_monitor_stats(self) -> Dict[str, Any]:
         """API 호출 모니터링 통계 반환"""
         return self.monitor.get_stats()
diff --git a/backend/app/services/loss_tracker.py b/backend/app/services/loss_tracker.py
new file mode 100644
index 0000000..c58406f
--- /dev/null
+++ b/backend/app/services/loss_tracker.py
@@ -0,0 +1,150 @@
+"""
+연속 손실 추적 - CLAUDE.md 섹션 7.4
+
+동일 종목에서 3회 이상 연속 손실 시 30거래일 동안 신규 진입 금지.
+재시작 후에도 ban 상태 유지: DB(stock_bans 테이블) 영속화.
+"""
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class ConsecutiveLossTracker:
+    """종목별 연속 손실 추적 및 쿨링오프 관리"""
+
+    def __init__(self, ban_count: int = 3, ban_calendar_days: int = 42):
+        """
+        Args:
+            ban_count: 연속 손실 횟수 임계값 (기본 3)
+            ban_calendar_days: 금지 기간 (30거래일 ≈ 42캘린더일)
+        """
+        self.ban_count = ban_count
+        self.ban_calendar_days = ban_calendar_days
+        # {stock_code: {"consecutive_losses": int, "ban_until": datetime|None}}
+        self._tracker: Dict[str, dict] = {}
+
+    def record_trade_result(self, stock_code: str, is_loss: bool):
+        """매매 결과 인메모리 기록 (DB 저장은 save_to_db 별도 호출)
+
+        Args:
+            stock_code: 종목코드
+            is_loss: 손실 여부
+        """
+        if stock_code not in self._tracker:
+            self._tracker[stock_code] = {"consecutive_losses": 0, "ban_until": None}
+
+        entry = self._tracker[stock_code]
+        if is_loss:
+            entry["consecutive_losses"] += 1
+            if entry["consecutive_losses"] >= self.ban_count:
+                entry["ban_until"] = datetime.now() + timedelta(days=self.ban_calendar_days)
+                logger.warning(
+                    f"{stock_code}: {entry['consecutive_losses']}회 연속 손실 → "
+                    f"{entry['ban_until'].strftime('%Y-%m-%d')}까지 진입 금지"
+                )
+        else:
+            entry["consecutive_losses"] = 0
+            entry["ban_until"] = None
+
+    async def save_to_db(self, db, stock_code: str):
+        """인메모리 상태를 DB에 영속화 (record_trade_result 후 호출)"""
+        try:
+            from sqlalchemy import select
+            from app.models.models import StockBan
+
+            entry = self._tracker.get(stock_code)
+            if entry is None:
+                return
+
+            result = await db.execute(select(StockBan).where(StockBan.stock_code == stock_code))
+            record = result.scalar_one_or_none()
+
+            if record is None:
+                record = StockBan(
+                    stock_code=stock_code,
+                    consecutive_losses=entry["consecutive_losses"],
+                    ban_until=entry["ban_until"],
+                )
+                db.add(record)
+            else:
+                record.consecutive_losses = entry["consecutive_losses"]
+                record.ban_until = entry["ban_until"]
+                record.updated_at = datetime.utcnow()
+
+            await db.commit()
+            logger.debug(f"loss_tracker DB 저장 완료: {stock_code}")
+        except Exception as e:
+            logger.error(f"loss_tracker DB 저장 실패 ({stock_code}): {e}")
+
+    async def load_from_db(self, db):
+        """앱 시작 시 DB에서 ban 상태 복원"""
+        try:
+            from sqlalchemy import select
+            from app.models.models import StockBan
+
+            result = await db.execute(select(StockBan))
+            records = result.scalars().all()
+
+            now = datetime.now()
+            loaded = 0
+            for rec in records:
+                # 만료된 ban은 초기화
+                ban_until = rec.ban_until
+                if ban_until and now >= ban_until:
+                    ban_until = None
+                    consecutive_losses = 0
+                else:
+                    consecutive_losses = rec.consecutive_losses
+
+                self._tracker[rec.stock_code] = {
+                    "consecutive_losses": consecutive_losses,
+                    "ban_until": ban_until,
+                }
+                if ban_until:
+                    loaded += 1
+                    logger.info(
+                        f"ban 복원: {rec.stock_code} → {ban_until.strftime('%Y-%m-%d')}까지 진입 금지"
+                    )
+
+            logger.info(f"loss_tracker DB 로드 완료: {len(records)}건 중 {loaded}건 활성 ban")
+        except Exception as e:
+            logger.error(f"loss_tracker DB 로드 실패: {e}")
+
+    def is_banned(self, stock_code: str) -> bool:
+        """해당 종목이 진입 금지 상태인지 확인"""
+        entry = self._tracker.get(stock_code)
+        if not entry or not entry["ban_until"]:
+            return False
+        if datetime.now() >= entry["ban_until"]:
+            # 금지 기간 만료 → 리셋
+            entry["consecutive_losses"] = 0
+            entry["ban_until"] = None
+            return False
+        return True
+
+    def get_ban_info(self, stock_code: str) -> dict:
+        """종목의 연속 손실 및 금지 정보 조회"""
+        entry = self._tracker.get(stock_code, {"consecutive_losses": 0, "ban_until": None})
+        return {
+            "stock_code": stock_code,
+            "consecutive_losses": entry["consecutive_losses"],
+            "is_banned": self.is_banned(stock_code),
+            "ban_until": entry["ban_until"].isoformat() if entry["ban_until"] else None,
+        }
+
+
+# 싱글톤 인스턴스 — settings에서 ban_count 주입
+def _create_loss_tracker() -> ConsecutiveLossTracker:
+    try:
+        from app.core.config import settings
+        return ConsecutiveLossTracker(
+            ban_count=settings.CONSECUTIVE_LOSS_BAN_COUNT,
+            ban_calendar_days=42,  # 30거래일 ≈ 42캘린더일
+        )
+    except Exception:
+        return ConsecutiveLossTracker()
+
+
+loss_tracker = _create_loss_tracker()
diff --git a/backend/app/services/mdd_manager.py b/backend/app/services/mdd_manager.py
new file mode 100644
index 0000000..fdfbb93
--- /dev/null
+++ b/backend/app/services/mdd_manager.py
@@ -0,0 +1,80 @@
+"""
+MDD(Maximum Drawdown) 관리 - CLAUDE.md 섹션 6.3
+
+- 포트폴리오 최고점 대비 하락률 추적
+- -10% 돌파 시: 신규 진입 중단 + 기존 포지션 30% 축소
+- -20% 돌파 시: 전체 포지션 50% 강제 축소 (레버리지/인버스 우선)
+"""
+import asyncio
+import logging
+from typing import Dict
+
+logger = logging.getLogger(__name__)
+
+
+class MDDManager:
+    """포트폴리오 MDD 관리자 (싱글톤으로 사용)"""
+
+    def __init__(self):
+        self.peak_balance: float = 0.0
+        self.is_paused: bool = False
+        self.reduction_applied: str = None  # None, "10pct", "20pct"
+        self._lock = asyncio.Lock()  # 스케줄러-sync 동시 접근 방지
+
+    async def update(self, current_balance: float) -> Dict:
+        """MDD 업데이트 및 필요한 조치 반환 (thread-safe)
+
+        Returns:
+            {"action": "NONE"/"REDUCE_AND_PAUSE"/"FORCE_REDUCE",
+             "drawdown": float, ...}
+        """
+        async with self._lock:
+            if current_balance > self.peak_balance:
+                self.peak_balance = current_balance
+                self.is_paused = False
+                self.reduction_applied = None
+
+            if self.peak_balance <= 0:
+                return {"action": "NONE", "drawdown": 0.0}
+
+            drawdown_pct = ((current_balance - self.peak_balance) / self.peak_balance) * 100
+
+            # -20% 돌파: 50% 강제 축소
+            if drawdown_pct <= -20 and self.reduction_applied != "20pct":
+                self.is_paused = True
+                self.reduction_applied = "20pct"
+                logger.warning(f"MDD {drawdown_pct:.1f}% - 50% 강제 축소 + 신규진입 중단")
+                return {
+                    "action": "FORCE_REDUCE",
+                    "drawdown": drawdown_pct,
+                    "reduce_pct": 0.50,
+                    "prioritize_leverage": True,
+                }
+
+            # -10% 돌파: 30% 축소 + 신규진입 중단
+            if drawdown_pct <= -10 and self.reduction_applied is None:
+                self.is_paused = True
+                self.reduction_applied = "10pct"
+                logger.warning(f"MDD {drawdown_pct:.1f}% - 30% 축소 + 신규진입 중단")
+                return {
+                    "action": "REDUCE_AND_PAUSE",
+                    "drawdown": drawdown_pct,
+                    "reduce_pct": 0.30,
+                }
+
+            return {"action": "NONE", "drawdown": drawdown_pct}
+
+    async def can_open_new_position(self) -> bool:
+        """신규 포지션 진입 가능 여부 (thread-safe)"""
+        async with self._lock:
+            return not self.is_paused
+
+    def reset(self):
+        """MDD 상태 리셋 (수동 복구 시) — 동기 메서드, 단독 호출 시에만 사용"""
+        self.is_paused = False
+        self.reduction_applied = None
+        logger.info("MDD 관리자 리셋")
+
+
+# 싱글톤 인스턴스
+mdd_manager = MDDManager()
diff --git a/backend/app/services/mean_reversion_strategy.py b/backend/app/services/mean_reversion_strategy.py
new file mode 100644
index 0000000..f2e1686
--- /dev/null
+++ b/backend/app/services/mean_reversion_strategy.py
@@ -0,0 +1,340 @@
+"""
+RSI + 볼린저 밴드 평균회귀 전략 (CLAUDE.md 섹션 7.1-7.5)
+
+일봉 기준, 전체 자본의 최대 30% 이내에서만 운용.
+"""
+import logging
+from typing import Optional, Dict, List, Tuple
+from dataclasses import dataclass
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+
+class MarketRegime(Enum):
+    BULL = "bull"
+    BEAR = "bear"
+
+
+@dataclass
+class ExitSignal:
+    action: str        # "SELL_PARTIAL", "SELL_ALL"
+    reason: str
+    sell_pct: float    # 0.5 = 50%, 1.0 = 전량
+
+
+def calculate_atr(highs: List[float], lows: List[float], closes: List[float], period: int = 14) -> Optional[float]:
+    """ATR(Average True Range) 계산
+
+    TR = max(H-L, |H-Cprev|, |L-Cprev|)
+    ATR = SMA(TR, period)
+    """
+    if len(highs) < period + 1 or len(lows) < period + 1 or len(closes) < period + 1:
+        return None
+
+    true_ranges = []
+    for i in range(1, len(highs)):
+        h, l, c_prev = highs[i], lows[i], closes[i - 1]
+        tr = max(h - l, abs(h - c_prev), abs(l - c_prev))
+        true_ranges.append(tr)
+
+    if len(true_ranges) < period:
+        return None
+    return sum(true_ranges[-period:]) / period
+
+
+def calculate_adx(highs: List[float], lows: List[float], closes: List[float], period: int = 14) -> Optional[float]:
+    """Wilder's ADX(Average Directional Index) 계산 — 추세 강도 지표
+
+    알고리즘:
+    1. TR = max(H-L, |H-Cprev|, |L-Cprev|)
+    2. +DM = H-Hprev if (H-Hprev) > (Lprev-L) and > 0, else 0
+    3. -DM = Lprev-L if (Lprev-L) > (H-Hprev) and > 0, else 0
+    4. Wilder 평활: ATR14 = ATR14_prev - ATR14_prev/14 + TR (초기값은 14일 합산)
+    5. +DI14 = 100 × (+DM14 / ATR14), -DI14 동일
+    6. DX = 100 × |+DI14 - -DI14| / (+DI14 + -DI14)
+    7. ADX = DX의 Wilder 평활
+
+    해석 (평균회귀 전략):
+    - ADX < 20: 횡보장 → 평균회귀 유리
+    - ADX 20~30: 중간 추세 → 조건부 허용
+    - ADX > 30: 강한 추세 → 평균회귀 위험 (진입 차단)
+    """
+    n = len(highs)
+    # 최소 2*period + 1개 필요 (초기 평활 + ADX 평활)
+    if n < period * 2 + 1:
+        return None
+
+    trs: List[float] = []
+    plus_dms: List[float] = []
+    minus_dms: List[float] = []
+
+    for i in range(1, n):
+        h, l, c_prev = highs[i], lows[i], closes[i - 1]
+        h_prev, l_prev = highs[i - 1], lows[i - 1]
+
+        tr = max(h - l, abs(h - c_prev), abs(l - c_prev))
+        up_move = h - h_prev
+        down_move = l_prev - l
+
+        plus_dm = up_move if up_move > down_move and up_move > 0 else 0.0
+        minus_dm = down_move if down_move > up_move and down_move > 0 else 0.0
+
+        trs.append(tr)
+        plus_dms.append(plus_dm)
+        minus_dms.append(minus_dm)
+
+    def _wilder_smooth(values: List[float]) -> List[float]:
+        """Wilder 평활: 초기값 = 첫 period개 합산, 이후 재귀 평활."""
+        smoothed = [sum(values[:period])]
+        for v in values[period:]:
+            smoothed.append(smoothed[-1] - smoothed[-1] / period + v)
+        return smoothed
+
+    atr_s = _wilder_smooth(trs)
+    plus_dm_s = _wilder_smooth(plus_dms)
+    minus_dm_s = _wilder_smooth(minus_dms)
+
+    dxs: List[float] = []
+    for atr_v, p_dm, m_dm in zip(atr_s, plus_dm_s, minus_dm_s):
+        if atr_v == 0:
+            dxs.append(0.0)
+            continue
+        plus_di = 100.0 * p_dm / atr_v
+        minus_di = 100.0 * m_dm / atr_v
+        di_sum = plus_di + minus_di
+        dxs.append(100.0 * abs(plus_di - minus_di) / di_sum if di_sum else 0.0)
+
+    if len(dxs) < period:
+        return None
+
+    adx_s = _wilder_smooth(dxs)
+    return round(adx_s[-1], 2)
+
+
+def detect_market_regime(index_closes: List[float]) -> MarketRegime:
+    """섹션 7.1: 200일 MA + 기울기로 상승장/하락장 판별
+
+    상승장(Bull): 지수 > MA200 AND MA200 기울기 양(+)
+    하락장(Bear): 그 외
+    """
+    if len(index_closes) < 205:
+        return MarketRegime.BEAR  # 데이터 부족 시 보수적
+
+    ma200_current = sum(index_closes[-200:]) / 200
+    ma200_5d_ago = sum(index_closes[-205:-5]) / 200
+    slope_positive = ma200_current > ma200_5d_ago
+
+    is_bull = index_closes[-1] > ma200_current and slope_positive
+    return MarketRegime.BULL if is_bull else MarketRegime.BEAR
+
+
+def calculate_rsi(closes: List[float], period: int = 14) -> Optional[float]:
+    """RSI(Relative Strength Index) 계산"""
+    if len(closes) < period + 1:
+        return None
+
+    gains, losses = [], []
+    for i in range(-period, 0):
+        diff = closes[i] - closes[i - 1]
+        gains.append(max(diff, 0))
+        losses.append(max(-diff, 0))
+
+    avg_gain = sum(gains) / period
+    avg_loss = sum(losses) / period
+    if avg_loss == 0:
+        return 100.0
+    rs = avg_gain / avg_loss
+    return 100 - (100 / (1 + rs))
+
+
+def calculate_bollinger(closes: List[float], period: int = 20) -> Optional[Tuple[float, float, float]]:
+    """볼린저 밴드 (20일, 2σ) 계산
+
+    Returns: (upper, middle, lower)
+    """
+    if len(closes) < period:
+        return None
+    window = closes[-period:]
+    middle = sum(window) / period
+    variance = sum((p - middle) ** 2 for p in window) / period
+    std = variance ** 0.5
+    return (middle + 2 * std, middle, middle - 2 * std)
+
+
+def is_reversal_candle(opens: List[float], highs: List[float],
+                       lows: List[float], closes: List[float]) -> bool:
+    """하락장 매수 조건용 되돌림 캔들 감지 (섹션 7.2)
+
+    양봉 또는 긴 하단 꼬리(하단 그림자 > 2× 몸통)
+    """
+    if not closes:
+        return False
+    o, h, l, c = opens[-1], highs[-1], lows[-1], closes[-1]
+    body = abs(c - o)
+    lower_shadow = min(o, c) - l
+    is_bullish = c > o
+    has_long_lower_shadow = lower_shadow > 2 * max(body, 0.01)
+    return is_bullish or has_long_lower_shadow
+
+
+def check_buy_signal(
+    regime: MarketRegime,
+    rsi: float,
+    close: float,
+    bb_upper: float,
+    bb_middle: float,
+    bb_lower: float,
+    avg_volume_20d: float,
+    current_volume: int,
+    prev_volume: int,
+    is_reversal: bool = False,
+) -> Optional[Dict]:
+    """섹션 7.2: 매수 조건 판별
+
+    Bull: RSI(14) ≤ 25 (과매도) OR 거래량 ≥ 20일평균×200%, 종가가 BB 하단선 -3% ~ +1.5% 구간
+    Bear: RSI(14) ≤ 35 (과매도), 종가 ≤ BB 하단선, 되돌림 캔들 출현, 전일 대비 거래량 증가
+
+    공통: 거래대금 ≥ 20일 평균
+    """
+    if current_volume < avg_volume_20d:
+        return None
+
+    if regime == MarketRegime.BULL:
+        rsi_ok = rsi <= 25
+        vol_ok = current_volume >= avg_volume_20d * 2  # 거래량 20일평균 200% 이상
+        if rsi_ok or vol_ok:
+            bb_low_minus = bb_lower * 0.97   # -3%
+            bb_low_plus = bb_lower * 1.015   # +1.5%
+            if bb_low_minus <= close <= bb_low_plus:
+                trigger = f"RSI({rsi:.1f})<=25" if rsi_ok else f"거래량({current_volume / avg_volume_20d * 100:.0f}%>=200%)"
+                return {
+                    "signal": "BUY",
+                    "strategy": "MEAN_REVERSION_BULL",
+                    "split_plan": [0.50, 0.50],  # 2회 분할 매수
+                    "description": f"{trigger} + BB 하단 -3%~+1.5% (상승장 과매도)",
+                }
+
+    elif regime == MarketRegime.BEAR:
+        if rsi <= 35:  # 40 → 35: 더 낮은 가격에서 진입
+            # 하락장 진입 필터: 거래량 전일 대비 증가 확인 (매수세 유입)
+            if close <= bb_lower and is_reversal and current_volume > prev_volume:
+                return {
+                    "signal": "BUY",
+                    "strategy": "MEAN_REVERSION_BEAR",
+                    "split_plan": [0.30, 0.30, 0.40],  # 3회 분할 매수
+                    "description": f"RSI({rsi:.1f})<=35 + BB 하단 + 되돌림 + 거래량↑ (하락장 과매도)",
+                }
+
+    return None
+
+
+def check_exit_signal(
+    regime: MarketRegime,
+    rsi: float,
+    close: float,
+    bb_upper: float,
+    bb_middle: float,
+    bb_lower: float,
+    entry_price: float,
+    atr: float,
+    lowest_since_entry: float,
+    remaining_pct: float,
+) -> Optional[ExitSignal]:
+    """섹션 7.3 + 7.4: 청산 조건
+
+    손절: min(최저가 - 2.5×ATR, 진입가 - 8%) 중 높은 값(타이트한 것)
+    1차 익절: Bull 30% (트렌드 팔로잉), Bear 50% (리스크 관리)
+    2차 익절(전량): RSI ≥ 60 진입 + 종가 ≥ BB 상단선 근처
+    """
+    # 손절 체크 (섹션 7.4)
+    atr_stop = lowest_since_entry - 2.5 * atr
+    pct_stop = entry_price * 0.92  # -8%
+    stop_price = max(atr_stop, pct_stop)  # 높은 값 = 타이트한 손절
+
+    if close <= stop_price:
+        return ExitSignal(
+            action="SELL_ALL",
+            reason=f"손절 (close={close:.0f} <= stop={stop_price:.0f}, ATR={atr:.0f})",
+            sell_pct=1.0,
+        )
+
+    # 1차 익절: 시장 상태별 비중 조정 (RSI 45~50 회복 + BB 중앙선 상회)
+    if regime == MarketRegime.BULL:
+        # 상승장: 30% 익절 (트렌드 팔로잉)
+        if remaining_pct > 0.7 and 45 <= rsi <= 50 and close > bb_middle:
+            return ExitSignal(
+                action="SELL_PARTIAL",
+                reason=f"1차 익절(Bull 30%): RSI({rsi:.1f}) 45-50 회복 + BB중앙({bb_middle:.0f}) 상회",
+                sell_pct=0.30,
+            )
+    else:
+        # 하락장: 50% 익절 (리스크 관리)
+        if remaining_pct > 0.5 and 45 <= rsi <= 50 and close > bb_middle:
+            return ExitSignal(
+                action="SELL_PARTIAL",
+                reason=f"1차 익절(Bear 50%): RSI({rsi:.1f}) 45-50 회복 + BB중앙({bb_middle:.0f}) 상회",
+                sell_pct=0.50,
+            )
+
+    # 2차 익절: 전량 매도 (RSI ≥ 60 진입 + BB 상단선 근처)
+    threshold = 0.7 if regime == MarketRegime.BULL else 0.5
+    if remaining_pct <= threshold and rsi >= 60:
+        if close >= bb_upper * 0.99:
+            return ExitSignal(
+                action="SELL_ALL",
+                reason=f"2차 익절: RSI({rsi:.1f})>=60 진입 + BB상단({bb_upper:.0f}) 도달",
+                sell_pct=1.0,
+            )
+
+    return None
+
+
+def calculate_position_size(
+    total_assets: float,
+    available_cash: float,
+    current_strategy_allocation: float,
+    regime: MarketRegime,
+    max_per_position: float = 0.04,
+    max_strategy_capital_bull: float = 0.70,
+    max_strategy_capital_bear: float = 0.30,
+) -> float:
+    """섹션 6.1 + 7.5: 포지션 사이징 (시장 상태별 동적 배분)
+
+    - 1종목당 최대 3-4% (max_per_position)
+    - 상승장(Bull): 전략 전체 최대 70% 운용 (공격적)
+    - 하락장(Bear): 전략 전체 최대 30% 운용 (보수적)
+    """
+    # 시장 상태에 따라 최대 자본 비중 결정
+    max_strategy_capital = max_strategy_capital_bull if regime == MarketRegime.BULL else max_strategy_capital_bear
+
+    max_by_position = total_assets * max_per_position
+    remaining_budget = (total_assets * max_strategy_capital) - current_strategy_allocation
+    return max(0, min(max_by_position, remaining_budget, available_cash))
+
+
+def check_h1_breakout_with_ma5(
+    h1_closes: List[float],
+    h1_current_close: float,
+) -> bool:
+    """섹션 7.5: 60분봉 5일선 돌파 확인 (가짜 반등 필터)
+
+    60분봉 기준 5일(120시간 = 5일×24시간) 이동평균선 상향 돌파 여부 확인
+    실제로는 5일 분량의 60분봉 데이터가 필요: 5일 × 6.5시간(장 운영) = 약 30~40개 봉
+
+    Args:
+        h1_closes: 60분봉 종가 리스트 (최소 5개 이상)
+        h1_current_close: 현재 60분봉 종가
+
+    Returns:
+        True: 5일선 상향 돌파, False: 미돌파
+
+    Note:
+        - 60분봉 데이터가 충분하지 않으면 False 반환 (보수적)
+        - 복합 타임프레임 전략에서 선택적으로 사용
+    """
+    if len(h1_closes) < 5:
+        return False  # 데이터 부족 시 보수적 대응
+
+    ma5 = sum(h1_closes[-5:]) / 5
+    return h1_current_close > ma5
diff --git a/backend/app/services/ml_ensemble.py b/backend/app/services/ml_ensemble.py
new file mode 100644
index 0000000..d0a6bad
--- /dev/null
+++ b/backend/app/services/ml_ensemble.py
@@ -0,0 +1,560 @@
+"""
+ML 앙상블 모델 서비스
+
+3개 모델을 결합하여 주식 매수/매도 신호를 예측합니다:
+- LightGBM (40%): 탭뷸러 피처 기반 분류
+- PyTorch LSTM (35%): 시계열 패턴 학습
+- Random Forest (25%): 피처 조합 기반 분류
+
+앙상블 스코어: 0~100 (높을수록 매수 신호 강함)
+"""
+
+import logging
+import os
+from pathlib import Path
+from typing import Dict, Any, Optional, Tuple
+
+import numpy as np
+import joblib
+
+from app.services.feature_engineering import (
+    FEATURE_COLUMNS,
+    LSTM_SEQUENCE_FEATURES,
+    extract_single_features,
+    chart_data_to_dataframe,
+    extract_features,
+    prepare_training_data,
+)
+
+logger = logging.getLogger(__name__)
+
+# 모델 저장 디렉토리
+MODEL_DIR = Path(__file__).parent.parent.parent / "models" / "ensemble"
+
+
+# ─── PyTorch LSTM 모델 정의 ───
+
+def _get_torch():
+    """PyTorch lazy import"""
+    try:
+        import torch
+        import torch.nn as nn
+        return torch, nn
+    except ImportError:
+        return None, None
+
+
+class StockLSTM:
+    """PyTorch LSTM 모델 래퍼"""
+
+    def __init__(self, input_size: int = 5, hidden_size: int = 64, num_layers: int = 2,
+                 num_classes: int = 3, dropout: float = 0.3):
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.num_layers = num_layers
+        self.num_classes = num_classes
+        self.dropout = dropout
+        self.model = None
+        self.device = None
+        self._build()
+
+    def _build(self):
+        torch, nn = _get_torch()
+        if torch is None:
+            logger.warning("PyTorch not available, LSTM model disabled")
+            return
+
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+        class LSTMNet(nn.Module):
+            def __init__(self_, input_size, hidden_size, num_layers, num_classes, dropout):
+                super().__init__()
+                self_.lstm = nn.LSTM(
+                    input_size=input_size,
+                    hidden_size=hidden_size,
+                    num_layers=num_layers,
+                    batch_first=True,
+                    dropout=dropout if num_layers > 1 else 0,
+                )
+                self_.fc1 = nn.Linear(hidden_size, 32)
+                self_.relu = nn.ReLU()
+                self_.drop = nn.Dropout(dropout)
+                self_.fc2 = nn.Linear(32, num_classes)
+
+            def forward(self_, x):
+                out, _ = self_.lstm(x)
+                out = out[:, -1, :]  # 마지막 타임스텝
+                out = self_.drop(self_.relu(self_.fc1(out)))
+                out = self_.fc2(out)
+                return out
+
+        self.model = LSTMNet(
+            self.input_size, self.hidden_size, self.num_layers,
+            self.num_classes, self.dropout,
+        ).to(self.device)
+
+    def train_model(self, X_seq: np.ndarray, y: np.ndarray,
+                    epochs: int = 50, lr: float = 0.001, batch_size: int = 32) -> Dict[str, float]:
+        """LSTM 모델 학습"""
+        torch, nn = _get_torch()
+        if torch is None or self.model is None:
+            return {"error": "PyTorch not available"}
+
+        from torch.utils.data import TensorDataset, DataLoader
+
+        # 시퀀스 피처 정규화 (채널별)
+        self.seq_mean = X_seq.mean(axis=(0, 1))
+        self.seq_std = X_seq.std(axis=(0, 1)) + 1e-8
+        X_norm = (X_seq - self.seq_mean) / self.seq_std
+
+        X_tensor = torch.FloatTensor(X_norm).to(self.device)
+        y_tensor = torch.LongTensor(y).to(self.device)
+
+        dataset = TensorDataset(X_tensor, y_tensor)
+        loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
+
+        criterion = nn.CrossEntropyLoss()
+        optimizer = torch.optim.Adam(self.model.parameters(), lr=lr)
+
+        self.model.train()
+        best_loss = float("inf")
+
+        for epoch in range(epochs):
+            total_loss = 0.0
+            correct = 0
+            total = 0
+            for X_batch, y_batch in loader:
+                optimizer.zero_grad()
+                outputs = self.model(X_batch)
+                loss = criterion(outputs, y_batch)
+                loss.backward()
+                optimizer.step()
+
+                total_loss += loss.item() * len(y_batch)
+                _, predicted = torch.max(outputs, 1)
+                correct += (predicted == y_batch).sum().item()
+                total += len(y_batch)
+
+            avg_loss = total_loss / total
+            accuracy = correct / total
+            if avg_loss < best_loss:
+                best_loss = avg_loss
+
+            if (epoch + 1) % 10 == 0:
+                logger.info(f"LSTM Epoch [{epoch+1}/{epochs}] Loss: {avg_loss:.4f} Acc: {accuracy:.4f}")
+
+        return {"final_loss": best_loss, "final_accuracy": accuracy}
+
+    def predict_proba(self, X_seq: np.ndarray) -> np.ndarray:
+        """예측 확률 반환 (N, 3)"""
+        torch, nn = _get_torch()
+        if torch is None or self.model is None:
+            return np.full((len(X_seq), 3), 1.0 / 3)
+
+        self.model.eval()
+        X_norm = (X_seq - self.seq_mean) / self.seq_std
+        X_tensor = torch.FloatTensor(X_norm).to(self.device)
+
+        with torch.no_grad():
+            outputs = self.model(X_tensor)
+            probs = torch.softmax(outputs, dim=1).cpu().numpy()
+        return probs
+
+    def save(self, path: Path):
+        torch, _ = _get_torch()
+        if torch is None or self.model is None:
+            return
+        torch.save({
+            "model_state": self.model.state_dict(),
+            "seq_mean": self.seq_mean,
+            "seq_std": self.seq_std,
+            "config": {
+                "input_size": self.input_size,
+                "hidden_size": self.hidden_size,
+                "num_layers": self.num_layers,
+                "num_classes": self.num_classes,
+                "dropout": self.dropout,
+            },
+        }, path)
+
+    def load(self, path: Path) -> bool:
+        torch, _ = _get_torch()
+        if torch is None:
+            return False
+        try:
+            checkpoint = torch.load(path, map_location=self.device, weights_only=False)
+            self.model.load_state_dict(checkpoint["model_state"])
+            self.seq_mean = checkpoint["seq_mean"]
+            self.seq_std = checkpoint["seq_std"]
+            self.model.eval()
+            return True
+        except Exception as e:
+            logger.error(f"Failed to load LSTM model: {e}")
+            return False
+
+
+# ─── 앙상블 모델 클래스 ───
+
+class MLEnsemble:
+    """3개 모델(LightGBM + LSTM + RF)을 앙상블하여 주식 매수/매도 예측"""
+
+    def __init__(self, model_dir: Path = MODEL_DIR,
+                 weights: Tuple[float, float, float] = (0.40, 0.35, 0.25)):
+        self.model_dir = model_dir
+        self.weights = weights  # (lgbm, lstm, rf)
+
+        self.lgbm_model = None
+        self.lstm_model = None
+        self.rf_model = None
+        self.scaler = None  # tabular feature scaler
+
+        self.is_trained = False
+        self.training_metrics: Dict[str, Any] = {}
+
+    def _ensure_dir(self):
+        self.model_dir.mkdir(parents=True, exist_ok=True)
+
+    def train(self, X_tabular: np.ndarray, X_seq: np.ndarray, y: np.ndarray) -> Dict[str, Any]:
+        """전체 앙상블 학습
+
+        Args:
+            X_tabular: (N, 20) 탭뷸러 피처
+            X_seq: (N, 60, 5) LSTM 시퀀스
+            y: (N,) 레이블 (0=DOWN, 1=HOLD, 2=UP)
+
+        Returns:
+            학습 메트릭
+        """
+        self._ensure_dir()
+        metrics = {}
+
+        if len(X_tabular) < 50:
+            return {"error": f"학습 데이터 부족: {len(X_tabular)}개 (최소 50개 필요)"}
+
+        logger.info(f"앙상블 학습 시작: {len(X_tabular)}개 샘플, 클래스 분포: {np.bincount(y)}")
+
+        # 탭뷸러 피처 스케일링
+        from sklearn.preprocessing import StandardScaler
+        self.scaler = StandardScaler()
+        X_scaled = self.scaler.fit_transform(X_tabular)
+
+        # 학습/검증 분리 (시계열이므로 뒤쪽 20%를 검증으로)
+        split_idx = int(len(X_scaled) * 0.8)
+        X_train, X_val = X_scaled[:split_idx], X_scaled[split_idx:]
+        y_train, y_val = y[:split_idx], y[split_idx:]
+        X_seq_train, X_seq_val = X_seq[:split_idx], X_seq[split_idx:]
+
+        # 1. LightGBM
+        logger.info(">>> LightGBM 학습 중...")
+        try:
+            import lightgbm as lgb
+            self.lgbm_model = lgb.LGBMClassifier(
+                n_estimators=200,
+                max_depth=6,
+                learning_rate=0.05,
+                num_leaves=31,
+                min_child_samples=10,
+                subsample=0.8,
+                colsample_bytree=0.8,
+                reg_alpha=0.1,
+                reg_lambda=0.1,
+                random_state=42,
+                verbose=-1,
+                num_class=3,
+                objective="multiclass",
+            )
+            self.lgbm_model.fit(
+                X_train, y_train,
+                eval_set=[(X_val, y_val)],
+            )
+            lgbm_val_pred = self.lgbm_model.predict(X_val)
+            lgbm_acc = np.mean(lgbm_val_pred == y_val)
+            metrics["lgbm_accuracy"] = float(lgbm_acc)
+            logger.info(f"LightGBM 검증 정확도: {lgbm_acc:.4f}")
+
+            # 피처 중요도
+            importance = self.lgbm_model.feature_importances_
+            top_features = sorted(
+                zip(FEATURE_COLUMNS, importance),
+                key=lambda x: x[1], reverse=True
+            )[:5]
+            metrics["lgbm_top_features"] = [
+                {"name": name, "importance": int(imp)} for name, imp in top_features
+            ]
+        except Exception as e:
+            logger.error(f"LightGBM 학습 실패: {e}")
+            metrics["lgbm_error"] = str(e)
+
+        # 2. PyTorch LSTM
+        logger.info(">>> PyTorch LSTM 학습 중...")
+        try:
+            self.lstm_model = StockLSTM(
+                input_size=len(LSTM_SEQUENCE_FEATURES),
+                hidden_size=64,
+                num_layers=2,
+                num_classes=3,
+                dropout=0.3,
+            )
+            lstm_metrics = self.lstm_model.train_model(
+                X_seq_train, y_train,
+                epochs=50, lr=0.001, batch_size=32,
+            )
+            # 검증
+            lstm_val_probs = self.lstm_model.predict_proba(X_seq_val)
+            lstm_val_pred = np.argmax(lstm_val_probs, axis=1)
+            lstm_acc = np.mean(lstm_val_pred == y_val)
+            metrics["lstm_accuracy"] = float(lstm_acc)
+            metrics["lstm_training"] = lstm_metrics
+            logger.info(f"LSTM 검증 정확도: {lstm_acc:.4f}")
+        except Exception as e:
+            logger.error(f"LSTM 학습 실패: {e}")
+            metrics["lstm_error"] = str(e)
+
+        # 3. Random Forest
+        logger.info(">>> Random Forest 학습 중...")
+        try:
+            from sklearn.ensemble import RandomForestClassifier
+            self.rf_model = RandomForestClassifier(
+                n_estimators=100,
+                max_depth=8,
+                min_samples_split=10,
+                min_samples_leaf=5,
+                random_state=42,
+                n_jobs=-1,
+            )
+            self.rf_model.fit(X_train, y_train)
+            rf_val_pred = self.rf_model.predict(X_val)
+            rf_acc = np.mean(rf_val_pred == y_val)
+            metrics["rf_accuracy"] = float(rf_acc)
+            logger.info(f"Random Forest 검증 정확도: {rf_acc:.4f}")
+        except Exception as e:
+            logger.error(f"Random Forest 학습 실패: {e}")
+            metrics["rf_error"] = str(e)
+
+        # 앙상블 검증
+        ensemble_probs = self._ensemble_predict_proba(X_val, X_seq_val)
+        if ensemble_probs is not None:
+            ensemble_pred = np.argmax(ensemble_probs, axis=1)
+            ensemble_acc = np.mean(ensemble_pred == y_val)
+            metrics["ensemble_accuracy"] = float(ensemble_acc)
+            logger.info(f"앙상블 검증 정확도: {ensemble_acc:.4f}")
+
+        # 모델 저장
+        self._save_models()
+        self.is_trained = True
+        self.training_metrics = metrics
+
+        logger.info(f"앙상블 학습 완료: {metrics}")
+        return metrics
+
+    def _ensemble_predict_proba(self, X_tabular: np.ndarray, X_seq: np.ndarray) -> Optional[np.ndarray]:
+        """3개 모델의 가중 평균 확률"""
+        probs_list = []
+        weights_list = []
+
+        # LightGBM
+        if self.lgbm_model is not None:
+            try:
+                lgbm_probs = self.lgbm_model.predict_proba(X_tabular)
+                probs_list.append(lgbm_probs)
+                weights_list.append(self.weights[0])
+            except Exception:
+                pass
+
+        # LSTM
+        if self.lstm_model is not None and self.lstm_model.model is not None:
+            try:
+                lstm_probs = self.lstm_model.predict_proba(X_seq)
+                probs_list.append(lstm_probs)
+                weights_list.append(self.weights[1])
+            except Exception:
+                pass
+
+        # RF
+        if self.rf_model is not None:
+            try:
+                rf_probs = self.rf_model.predict_proba(X_tabular)
+                probs_list.append(rf_probs)
+                weights_list.append(self.weights[2])
+            except Exception:
+                pass
+
+        if not probs_list:
+            return None
+
+        # 가중 평균
+        total_weight = sum(weights_list)
+        weighted_probs = sum(
+            p * (w / total_weight) for p, w in zip(probs_list, weights_list)
+        )
+        return weighted_probs
+
+    def predict(self, chart_data: list) -> Dict[str, Any]:
+        """단일 종목 예측.
+
+        Args:
+            chart_data: KIS API 차트 데이터 (최신순)
+
+        Returns:
+            {
+                "ensemble_score": int (0~100),
+                "confidence": float (0~1),
+                "signal": str ("BUY"/"HOLD"/"SELL"),
+                "model_scores": {"lgbm": ..., "lstm": ..., "rf": ...},
+                "probabilities": {"up": ..., "hold": ..., "down": ...}
+            }
+        """
+        if not self.is_trained:
+            return {"error": "모델이 학습되지 않았습니다", "ensemble_score": 50, "confidence": 0.0, "signal": "HOLD"}
+
+        tabular, sequence = extract_single_features(chart_data)
+        if tabular is None or sequence is None:
+            return {"error": "피처 추출 실패 (데이터 부족)", "ensemble_score": 50, "confidence": 0.0, "signal": "HOLD"}
+
+        # 스케일링
+        tabular_scaled = self.scaler.transform(tabular.reshape(1, -1))
+        sequence_batch = sequence.reshape(1, 60, len(LSTM_SEQUENCE_FEATURES))
+
+        # 앙상블 예측
+        probs = self._ensemble_predict_proba(tabular_scaled, sequence_batch)
+        if probs is None:
+            return {"error": "모든 모델 예측 실패", "ensemble_score": 50, "confidence": 0.0, "signal": "HOLD"}
+
+        prob_down, prob_hold, prob_up = probs[0]
+
+        # 앙상블 스코어: UP 확률 기반 (0~100)
+        ensemble_score = int(prob_up * 100)
+
+        # 신뢰도: 최고 확률과 나머지의 차이
+        max_prob = max(prob_down, prob_hold, prob_up)
+        confidence = float(max_prob)
+
+        # 신호 결정
+        if prob_up > prob_down and prob_up > prob_hold and prob_up > 0.4:
+            signal = "BUY"
+        elif prob_down > prob_up and prob_down > prob_hold and prob_down > 0.4:
+            signal = "SELL"
+        else:
+            signal = "HOLD"
+
+        # 개별 모델 스코어
+        model_scores = {}
+        if self.lgbm_model is not None:
+            try:
+                lp = self.lgbm_model.predict_proba(tabular_scaled)[0]
+                model_scores["lgbm"] = {"up": float(lp[2]), "hold": float(lp[1]), "down": float(lp[0])}
+            except Exception:
+                pass
+        if self.lstm_model is not None and self.lstm_model.model is not None:
+            try:
+                lp = self.lstm_model.predict_proba(sequence_batch)[0]
+                model_scores["lstm"] = {"up": float(lp[2]), "hold": float(lp[1]), "down": float(lp[0])}
+            except Exception:
+                pass
+        if self.rf_model is not None:
+            try:
+                lp = self.rf_model.predict_proba(tabular_scaled)[0]
+                model_scores["rf"] = {"up": float(lp[2]), "hold": float(lp[1]), "down": float(lp[0])}
+            except Exception:
+                pass
+
+        return {
+            "ensemble_score": ensemble_score,
+            "confidence": round(confidence, 4),
+            "signal": signal,
+            "model_scores": model_scores,
+            "probabilities": {
+                "up": round(float(prob_up), 4),
+                "hold": round(float(prob_hold), 4),
+                "down": round(float(prob_down), 4),
+            },
+        }
+
+    def _save_models(self):
+        """모델 파일 저장"""
+        self._ensure_dir()
+
+        if self.lgbm_model is not None:
+            joblib.dump(self.lgbm_model, self.model_dir / "lgbm_model.pkl")
+        if self.rf_model is not None:
+            joblib.dump(self.rf_model, self.model_dir / "rf_model.pkl")
+        if self.lstm_model is not None:
+            self.lstm_model.save(self.model_dir / "lstm_model.pt")
+        if self.scaler is not None:
+            joblib.dump(self.scaler, self.model_dir / "scaler.pkl")
+
+        # 메트릭 저장
+        import json
+        with open(self.model_dir / "metrics.json", "w") as f:
+            json.dump(self.training_metrics, f, indent=2, ensure_ascii=False, default=str)
+
+        logger.info(f"모델 저장 완료: {self.model_dir}")
+
+    def load_models(self) -> bool:
+        """저장된 모델 로드"""
+        try:
+            scaler_path = self.model_dir / "scaler.pkl"
+            if not scaler_path.exists():
+                logger.warning("저장된 앙상블 모델이 없습니다")
+                return False
+
+            self.scaler = joblib.load(scaler_path)
+
+            lgbm_path = self.model_dir / "lgbm_model.pkl"
+            if lgbm_path.exists():
+                self.lgbm_model = joblib.load(lgbm_path)
+
+            rf_path = self.model_dir / "rf_model.pkl"
+            if rf_path.exists():
+                self.rf_model = joblib.load(rf_path)
+
+            lstm_path = self.model_dir / "lstm_model.pt"
+            if lstm_path.exists():
+                self.lstm_model = StockLSTM(
+                    input_size=len(LSTM_SEQUENCE_FEATURES),
+                    hidden_size=64, num_layers=2, num_classes=3, dropout=0.3,
+                )
+                self.lstm_model.load(lstm_path)
+
+            # 메트릭 로드
+            metrics_path = self.model_dir / "metrics.json"
+            if metrics_path.exists():
+                import json
+                with open(metrics_path) as f:
+                    self.training_metrics = json.load(f)
+
+            self.is_trained = True
+            logger.info("앙상블 모델 로드 완료")
+            return True
+
+        except Exception as e:
+            logger.error(f"앙상블 모델 로드 실패: {e}")
+            return False
+
+    def get_status(self) -> Dict[str, Any]:
+        """모델 상태 조회"""
+        return {
+            "is_trained": self.is_trained,
+            "models": {
+                "lgbm": self.lgbm_model is not None,
+                "lstm": self.lstm_model is not None and self.lstm_model.model is not None,
+                "rf": self.rf_model is not None,
+            },
+            "weights": {"lgbm": self.weights[0], "lstm": self.weights[1], "rf": self.weights[2]},
+            "metrics": self.training_metrics,
+            "model_dir": str(self.model_dir),
+        }
+
+
+# ─── 싱글톤 인스턴스 ───
+
+_ensemble_instance: Optional[MLEnsemble] = None
+
+
+def get_ensemble() -> MLEnsemble:
+    """앙상블 모델 싱글톤 인스턴스 반환"""
+    global _ensemble_instance
+    if _ensemble_instance is None:
+        _ensemble_instance = MLEnsemble()
+        _ensemble_instance.load_models()
+    return _ensemble_instance
diff --git a/backend/app/services/tensorflow_predictor.py b/backend/app/services/tensorflow_predictor.py
new file mode 100644
index 0000000..75ca2f1
--- /dev/null
+++ b/backend/app/services/tensorflow_predictor.py
@@ -0,0 +1,108 @@
+import logging
+from typing import List, Dict, Any, Optional
+
+import numpy as np
+
+from app.services.korea_investment_api import korea_investment_api
+
+logger = logging.getLogger(__name__)
+
+
+class TensorFlowNotAvailable(Exception):
+    pass
+
+
+class TensorFlowPredictor:
+    """Lightweight wrapper around a Keras model + scaler.
+
+    - Lazily attempts to import TensorFlow/Keras and load model files.
+    - If TensorFlow or model/scaler files are missing, raises TensorFlowNotAvailable
+      so callers can handle gracefully (e.g., return 503 or a friendly message).
+    - Fetches recent daily closes from KIS API.
+    """
+
+    def __init__(self, model_path: str = "models/lstm_model.h5", scaler_path: str = "models/scaler.pkl", time_steps: int = 60):
+        self.model_path = model_path
+        self.scaler_path = scaler_path
+        self.time_steps = time_steps
+
+        try:
+            # Local import to avoid hard dependency when not installed
+            import tensorflow as tf  # noqa: F401
+            from tensorflow import keras  # noqa: F401
+            import joblib  # noqa: F401
+        except Exception as e:
+            logger.warning(f"TensorFlow or joblib not available: {e}")
+            raise TensorFlowNotAvailable("TensorFlow/joblib not installed in backend environment")
+
+        # Load resources
+        try:
+            from tensorflow import keras
+            import joblib
+
+            self.model = keras.models.load_model(self.model_path)
+            self.scaler = joblib.load(self.scaler_path)
+        except Exception as e:
+            logger.warning(f"Failed to load TF model/scaler: {e}")
+            raise TensorFlowNotAvailable(f"Model or scaler not found: {e}")
+
+    async def fetch_kis_closes(self, stock_code: str, days: int = 60) -> np.ndarray:
+        """Fetch recent daily closes from KIS. Returns array oldest→latest.
+        Uses korea_investment_api.get_daily_chart(stock_code, "D").
+        """
+        try:
+            resp = await korea_investment_api.get_daily_chart(stock_code, "D")
+            output = resp.get("output") or []
+            if not output:
+                raise RuntimeError("empty_chart")
+            # KIS usually returns newest first; reverse to chronological
+            closes_desc = [float(item.get("stck_clpr", 0) or 0) for item in output]
+            closes = list(reversed(closes_desc))
+            arr = np.array(closes[-days:], dtype=float)
+            if arr.size < days:
+                # If fewer than requested, still return what's available
+                logger.info(f"{stock_code}: only {arr.size} closes available (requested {days})")
+            return arr
+        except Exception as e:
+            logger.error(f"Failed to fetch KIS closes for {stock_code}: {e}")
+            raise
+
+    async def predict_stock(self, stock_code: str) -> Dict[str, Any]:
+        """Return prediction dict with expected_return and simple signal."""
+        try:
+            prices = await self.fetch_kis_closes(stock_code, days=self.time_steps)
+            if prices.size == 0:
+                raise RuntimeError("no_price_data")
+
+            # Normalize and shape for LSTM (1, time_steps, 1)
+            scaled = self.scaler.transform(prices.reshape(-1, 1))
+            if scaled.shape[0] < self.time_steps:
+                # Pad at the front if needed
+                pad = np.repeat(scaled[0:1], self.time_steps - scaled.shape[0], axis=0)
+                scaled = np.vstack([pad, scaled])
+            X_input = scaled[-self.time_steps:].reshape(1, self.time_steps, 1)
+
+            # Predict
+            predicted_scaled = self.model.predict(X_input, verbose=0)
+            predicted_price = float(self.scaler.inverse_transform(predicted_scaled)[0][0])
+            current_price = float(prices[-1])
+
+            expected_return = ((predicted_price - current_price) / current_price * 100.0) if current_price > 0 else 0.0
+            signal = "BUY" if predicted_price > current_price * 1.02 else "HOLD"
+
+            return {
+                "stock_code": stock_code,
+                "current_price": current_price,
+                "predicted_price": predicted_price,
+                "expected_return": expected_return,
+                "signal": signal,
+            }
+        except TensorFlowNotAvailable:
+            raise
+        except Exception as e:
+            logger.error(f"Prediction failed for {stock_code}: {e}")
+            # Degrade gracefully
+            return {
+                "stock_code": stock_code,
+                "error": str(e),
+            }
diff --git a/backend/app/services/watchlist.py b/backend/app/services/watchlist.py
new file mode 100644
index 0000000..a8e3a76
--- /dev/null
+++ b/backend/app/services/watchlist.py
@@ -0,0 +1,63 @@
+"""
+분석종목(Watchlist) 관리 공용 서비스
+
+아침 배치(batch_daily_analysis)와 장중 배치(batch_intraday_analysis)가 공유하는
+초기화 함수. 각 배치 스크립트가 자신의 AsyncSession을 전달해 사용한다.
+"""
+from datetime import datetime, date
+import logging
+
+from sqlalchemy import select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.models import WatchlistStock, StockAnalysis
+
+logger = logging.getLogger(__name__)
+
+# 분석종목 관련 상수
+WATCHLIST_INIT_SIZE: int = 50    # 아침 배치 초기화 종목 수
+WATCHLIST_MAX_SIZE: int = 100    # 최대 관리 종목 수
+WATCHLIST_ENTRY_SCORE: int = 60  # 장중 신규 진입 기준 점수
+WATCHLIST_EXIT_SCORE: int = 20   # 장중 제거 기준 점수
+
+
+async def initialize_watchlist(session: AsyncSession, analysis_date: date) -> int:
+    """아침 배치 완료 후 분석종목 초기화.
+
+    기존 활성 종목을 전부 비활성화하고,
+    오늘 stock_analysis score 상위 WATCHLIST_INIT_SIZE 개로 새로 채운다.
+
+    Returns: 추가된 종목 수
+    """
+    now = datetime.now()
+
+    # 1. 기존 활성 종목 전부 비활성화
+    await session.execute(
+        update(WatchlistStock)
+        .where(WatchlistStock.is_active == True)
+        .values(is_active=False, removed_at=now, removed_reason="daily_reset")
+    )
+
+    # 2. 오늘 score 상위 N개 조회
+    result = await session.execute(
+        select(StockAnalysis.stock_code, StockAnalysis.stock_name, StockAnalysis.score)
+        .where(StockAnalysis.analysis_date == analysis_date)
+        .order_by(StockAnalysis.score.desc())
+        .limit(WATCHLIST_INIT_SIZE)
+    )
+    top_stocks = result.all()
+
+    # 3. 신규 활성 종목 등록
+    for row in top_stocks:
+        session.add(WatchlistStock(
+            stock_code=row.stock_code,
+            stock_name=row.stock_name,
+            added_at=now,
+            added_reason="morning_batch",
+            score_at_add=row.score,
+            is_active=True,
+        ))
+
+    await session.commit()
+    logger.info(f"📋 분석종목 초기화 완료: {len(top_stocks)}개 (기준일: {analysis_date})")
+    return len(top_stocks)
diff --git a/backend/app/services/websocket_manager.py b/backend/app/services/websocket_manager.py
index 5a57a60..f52a55a 100644
--- a/backend/app/services/websocket_manager.py
+++ b/backend/app/services/websocket_manager.py
@@ -1,6 +1,6 @@
 from typing import Dict, List
 from fastapi import WebSocket
-import json
+from app.core.json_helpers import _dumps
 import logging
 
 logger = logging.getLogger(__name__)
@@ -47,7 +47,7 @@ class WebSocketManager:
     
     async def broadcast_json(self, data: dict):
         """JSON 데이터를 모든 클라이언트에게 브로드캐스트"""
-        message = json.dumps(data)
+        message = _dumps(data)
         await self.broadcast(message)
     
     async def send_market_update(self, stock_code: str, data: dict):
diff --git a/backend/batch_daily_analysis.py b/backend/batch_daily_analysis.py
index ddf7929..f35e09c 100644
--- a/backend/batch_daily_analysis.py
+++ b/backend/batch_daily_analysis.py
@@ -6,7 +6,6 @@
 - 기술적 지표 계산
 - 매매 신호 생성
 - DB 저장
-
 실행: python batch_daily_analysis.py
 Cron: 0 9 * * 1-5 cd /path/to/auto-stock/backend && python batch_daily_analysis.py
 """
@@ -19,14 +18,14 @@ from pathlib import Path
 # 프로젝트 루트를 Python 경로에 추가
 sys.path.insert(0, str(Path(__file__).parent))
 
-from sqlalchemy import select, delete
+from sqlalchemy import delete
 from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
 from sqlalchemy.orm import sessionmaker
 
 from app.core.config import settings
 from app.models.models import StockAnalysis
-from app.services.korea_investment_api import KoreaInvestmentAPI
-from app.api.endpoints.recommendations import analyze_stock_with_indicators
+from app.services.korea_investment_api import KoreaInvestmentAPI, korea_investment_api
+from app.api.endpoints.recommendations import analyze_stock_for_batch
 import logging
 
 logging.basicConfig(
@@ -37,8 +36,13 @@ logger = logging.getLogger(__name__)
 
 
 # 데이터베이스 연결
+# SQLAlchemy asyncpg 드라이버 사용 (postgresql+asyncpg://)
+database_url = settings.DATABASE_URL
+if database_url.startswith("postgresql://"):
+    database_url = database_url.replace("postgresql://", "postgresql+asyncpg://", 1)
+
 engine = create_async_engine(
-    settings.DATABASE_URL,
+    database_url,
     echo=False,
     pool_pre_ping=True,
     pool_size=10,
@@ -52,159 +56,214 @@ AsyncSessionLocal = sessionmaker(
 )
 
 
-async def get_all_tradable_stocks() -> list[tuple[str, str]]:
-    """거래 가능한 전체 종목 조회 (안전한 재시도 적용)"""
-    kis_api = KoreaInvestmentAPI()
-    
-    logger.info("Fetching all tradable stocks from KIS API...")
-    
-    stocks = []
-    
-    # KOSPI 상위 종목 조회
+async def get_all_tradable_stocks(kis_api: KoreaInvestmentAPI, limit: int = 500) -> list[tuple[str, str]]:
+    """시가총액 상위 종목 조회 (pykrx 사용)
+
+    Args:
+        kis_api: KIS API 인스턴스 (호환성 유지용, 미사용)
+        limit: 조회할 종목 수 (기본 500개)
+
+    Returns:
+        [(stock_code, stock_name), ...] 시가총액 상위 종목 리스트
+    """
+    logger.info(f"Fetching top {limit} stocks by market cap from pykrx...")
+
     try:
-        # 재시도 로직이 내장되어 있으므로 sleep 제거 (쓰로틀링은 자동 적용)
-        kospi_result = await kis_api.get_volume_rank("J")
-        if kospi_result and kospi_result.get("output"):
-            for item in kospi_result["output"]:
-                stocks.append((
-                    item["mksc_shrn_iscd"],
-                    item["hts_kor_isnm"]
-                ))
-        logger.info(f"✅ Found {len(stocks)} KOSPI stocks")
+        from pykrx import stock as pykrx_stock
+        import pandas as pd
+
+        today = datetime.now().strftime("%Y%m%d")
+        stocks_with_cap = []
+
+        # ETF/특수 종목 제외 키워드
+        SKIP_KEYWORDS = [
+            "ETF", "레버리지", "인버스", "KODEX", "TIGER", "ARIRANG",
+            "KBSTAR", "HANARO", "SOL", "ACE", "KOSEF", "KINDEX",
+            "선물", "스팩", "리츠", "SPAC",
+        ]
+
+        # KOSPI + KOSDAQ 전체 종목 조회
+        for market in ["KOSPI", "KOSDAQ"]:
+            try:
+                # 시장 전체의 시가총액 데이터를 한 번에 조회 (최적화)
+                cap_df = pykrx_stock.get_market_cap_by_ticker(today, market=market)
+                logger.info(f"  {market}: {len(cap_df)}개 종목 시가총액 조회")
+
+                for ticker in cap_df.index:
+                    try:
+                        name = pykrx_stock.get_market_ticker_name(ticker)
+
+                        # ETF/특수 종목 필터링
+                        if any(k in name for k in SKIP_KEYWORDS):
+                            continue
+
+                        market_cap = cap_df.loc[ticker, "시가총액"]
+                        stocks_with_cap.append((ticker, name, market_cap))
+
+                    except Exception as e:
+                        logger.debug(f"  Skip {ticker}: {e}")
+                        continue
+
+            except Exception as e:
+                logger.error(f"❌ Failed to fetch {market} stocks: {e}")
+
+        # 시가총액 기준 내림차순 정렬
+        stocks_with_cap.sort(key=lambda x: x[2], reverse=True)
+
+        # 상위 N개 선택 (시가총액 제외)
+        top_stocks = [(code, name) for code, name, _ in stocks_with_cap[:limit]]
+
+        logger.info(f"✅ Selected top {len(top_stocks)} stocks by market cap")
+        if top_stocks:
+            kospi_count = sum(1 for c, _ in top_stocks if c.startswith(('0', '1', '2', '3', '4', '5')))
+            kosdaq_count = len(top_stocks) - kospi_count
+            logger.info(f"   KOSPI: {kospi_count} stocks")
+            logger.info(f"   KOSDAQ: {kosdaq_count} stocks")
+
+        return top_stocks
+
     except Exception as e:
-        logger.error(f"❌ Failed to fetch KOSPI stocks: {e}")
-    
-    # KOSDAQ 상위 종목 조회
-    try:
-        kosdaq_result = await kis_api.get_volume_rank("Q")
-        if kosdaq_result and kosdaq_result.get("output"):
-            kospi_count = len(stocks)
-            for item in kosdaq_result["output"]:
-                stocks.append((
-                    item["mksc_shrn_iscd"],
-                    item["hts_kor_isnm"]
-                ))
-            logger.info(f"✅ Found {len(stocks) - kospi_count} KOSDAQ stocks")
-    except Exception as e:
-        logger.error(f"❌ Failed to fetch KOSDAQ stocks: {e}")
-    
-    logger.info(f"📊 Total tradable stocks: {len(stocks)}")
-    return stocks
+        logger.error(f"❌ Failed to fetch stocks by market cap: {e}", exc_info=True)
+        logger.warning("⚠️ Falling back to empty list")
+        return []
 
 
 async def analyze_and_save_stock(
-    session: AsyncSession,
     stock_code: str,
     stock_name: str,
     analysis_date: datetime
-) -> bool:
-    """종목 분석 후 DB 저장"""
+) -> str:
+    """종목 분석 후 DB 저장 (독립 세션 사용 — 동시 처리 안전)
+
+    ATR은 analyze_stock() 내부에서 이미 계산되어 result.atr_14에 포함됨.
+    이중 API 호출 없음.
+
+    Returns: "ok" | "no_chart" | "price_filter" | "error"
+    """
     try:
-        # 종목 분석 (기존 함수 재사용)
-        result = await analyze_stock_with_indicators(stock_code, stock_name)
-        
+        # 배치 전용 함수 사용 (거래량/점수 필터 없이 전 종목 지표 저장)
+        result = await analyze_stock_for_batch(stock_code, stock_name)
+
         if not result:
-            logger.warning(f"No analysis result for {stock_code}")
-            return False
-        
-        # DB에 저장
-        analysis = StockAnalysis(
-            stock_code=stock_code,
-            stock_name=stock_name,
-            analysis_date=analysis_date,
-            current_price=result.current_price,
-            change_rate=result.change_rate,
-            volume=result.volume,
-            rsi=result.rsi,
-            ma5=result.ma5,
-            ma20=result.ma20,
-            ma60=result.ma60,
-            stochastic_k=result.stochastic_k,
-            stochastic_d=result.stochastic_d,
-            bollinger_upper=result.bollinger_upper,
-            bollinger_lower=result.bollinger_lower,
-            bollinger_middle=result.bollinger_middle,
-            signals=result.signals,
-            score=result.score
-        )
-        
-        session.add(analysis)
-        await session.commit()
-        
-        logger.info(f"✅ Saved analysis for {stock_code} ({stock_name}): score={result.score}")
-        return True
-        
+            # for_batch=True 에서 None = 차트 데이터 없음 or 가격 0 등 실제 오류
+            logger.info(f"차트없음 {stock_code} ({stock_name}): KIS API 차트 데이터 없음")
+            return "no_chart"
+
+        # 5,000원 이하 저가주 제외 (CLAUDE.md 6.4)
+        if result.current_price and result.current_price < 5000:
+            logger.info(f"가격필터 {stock_code} ({stock_name}): {result.current_price:.0f}원 < 5,000원")
+            return "price_filter"
+
+        async with AsyncSessionLocal() as session:
+            # 이미 오늘 분석된 종목이면 삭제 후 재삽입 (중복 방지)
+            await session.execute(
+                delete(StockAnalysis).where(
+                    StockAnalysis.stock_code == stock_code,
+                    StockAnalysis.analysis_date == analysis_date,
+                )
+            )
+            analysis = StockAnalysis(
+                stock_code=stock_code,
+                stock_name=stock_name,
+                analysis_date=analysis_date,
+                current_price=result.current_price,
+                change_rate=result.change_rate,
+                volume=result.volume,
+                rsi=result.rsi,
+                ma5=result.ma5,
+                ma20=result.ma20,
+                ma60=result.ma60,
+                stochastic_k=result.stochastic_k,
+                stochastic_d=result.stochastic_d,
+                bollinger_upper=result.bollinger_upper,
+                bollinger_lower=result.bollinger_lower,
+                bollinger_middle=result.bollinger_middle,
+                signals=result.signals,
+                score=result.score,
+                ml_score=result.ml_score,
+                ml_confidence=result.ml_confidence,
+                ml_signal=result.ml_signal,
+                atr_14=result.atr_14,
+                adx_14=result.adx_14,
+            )
+            session.add(analysis)
+            await session.commit()
+
+        ml_info = f", ml_score={result.ml_score}" if result.ml_score is not None else ""
+        logger.info(f"✅ Saved analysis for {stock_code} ({stock_name}): score={result.score}{ml_info}")
+        return "ok"
     except Exception as e:
         logger.error(f"❌ Failed to analyze {stock_code}: {e}")
-        await session.rollback()
-        return False
+        return "error"
 
 
 async def batch_analyze_all_stocks(limit: int = None):
-    """전체 종목 배치 분석 (안전한 재시도 및 쓰로틀링 적용)"""
+    """전체 종목 배치 분석 (동시 처리 + 이중 API 호출 제거로 고속화)
+
+    변경 사항:
+    - 순차 처리(+3초 sleep) → asyncio.gather() 동시 처리 (BATCH_CONCURRENCY 종목 병렬)
+    - 이중 API 호출 제거: ATR이 analyze_stock() 내부에서 계산됨
+    - 각 종목별 독립 세션 사용 (동시 처리 안전)
+    - KIS API 내부 세마포어(API_MAX_CONCURRENT_REQUESTS)가 자체적으로 속도 제어
+    """
     start_time = datetime.now()
     analysis_date = date.today()
-    
+
+    # 동시 처리 종목 수 (KIS API 내부 세마포어로 실제 API 호출은 추가 제어됨)
+    BATCH_CONCURRENCY = 5
+
     logger.info(f"🚀 Starting daily batch analysis for {analysis_date}")
-    logger.info(f"⚙️  Rate Limiting: {settings.API_MIN_REQUEST_INTERVAL}초 간격, 최대 재시도 {settings.API_MAX_RETRIES}회")
-    
-    # KIS API 인스턴스
+    logger.info(f"⚙️  동시 처리: {BATCH_CONCURRENCY}종목, API 세마포어: {settings.API_MAX_CONCURRENT_REQUESTS}req")
+
+    # KIS API 인스턴스 (종목 목록 조회용)
     kis_api = KoreaInvestmentAPI()
-    
-    async with AsyncSessionLocal() as session:
-        # 1. 오늘 날짜 기존 데이터 삭제
-        logger.info("🗑️  Deleting old analysis data...")
-        await session.execute(
-            delete(StockAnalysis).where(
-                StockAnalysis.analysis_date >= analysis_date
-            )
-        )
-        await session.commit()
-        logger.info("✅ Old data deleted")
-        
-        # 2. 전체 종목 조회
-        all_stocks = await get_all_tradable_stocks()
-        
-        if limit:
-            all_stocks = all_stocks[:limit]
-            logger.info(f"🧪 Limited to {limit} stocks for testing")
-        
-        # 3. 배치 처리 (쓰로틀링은 KIS API 클래스에서 자동 처리)
-        success_count = 0
-        fail_count = 0
-        
-        for i, (stock_code, stock_name) in enumerate(all_stocks, 1):
-            logger.info(f"[{i}/{len(all_stocks)}] Analyzing {stock_code} ({stock_name})...")
-            
-            success = await analyze_and_save_stock(
-                session,
-                stock_code,
-                stock_name,
-                analysis_date
-            )
-            
-            if success:
-                success_count += 1
-            else:
-                fail_count += 1
-            
-            # 30개마다 통계 출력
-            if i % 30 == 0:
-                kis_api.log_monitor_stats()
-    
+
+    # 1. 시가총액 상위 500개 종목 조회 (ETF/특수 종목 자동 제외)
+    market_cap_limit = 500
+    all_stocks = await get_all_tradable_stocks(kis_api, limit=market_cap_limit)
+    logger.info(f"📊 시가총액 상위 {len(all_stocks)}개 종목 선정 완료")
+
+    # 테스트용 추가 제한 (옵션)
+    filtered_stocks = all_stocks
+    if limit:
+        filtered_stocks = all_stocks[:limit]
+        logger.info(f"🧪 테스트 모드: {limit}개 종목으로 제한")
+
+    # 2. 동시 처리 (세마포어로 동시 처리 종목 수 제한)
+    semaphore = asyncio.Semaphore(BATCH_CONCURRENCY)
+    total = len(filtered_stocks)
+
+    async def analyze_one(i: int, stock_code: str, stock_name: str) -> bool:
+        async with semaphore:
+            logger.info(f"[{i}/{total}] Analyzing {stock_code} ({stock_name})...")
+            return await analyze_and_save_stock(stock_code, stock_name, analysis_date)
+
+    tasks = [
+        analyze_one(i, code, name)
+        for i, (code, name) in enumerate(filtered_stocks, 1)
+    ]
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+
+    success_count    = sum(1 for r in results if r == "ok")
+    no_chart_count   = sum(1 for r in results if r == "no_chart")
+    price_filter_count = sum(1 for r in results if r == "price_filter")
+    error_count      = sum(1 for r in results if r == "error" or isinstance(r, Exception))
+
     # 4. 결과 요약 및 최종 통계
     end_time = datetime.now()
     duration = (end_time - start_time).total_seconds()
-    
+
     logger.info("=" * 60)
     logger.info(f"✅ Batch analysis completed!")
-    logger.info(f"📊 Success: {success_count} / Total: {len(all_stocks)}")
-    logger.info(f"❌ Failed: {fail_count}")
+    logger.info(f"📊 성공: {success_count} / 전체: {len(all_stocks)}")
+    logger.info(f"   ├─ 차트없음: {no_chart_count}건 (거래정지·신규상장·특수종목)")
+    logger.info(f"   ├─ 가격필터: {price_filter_count}건 (5,000원 미만)")
+    logger.info(f"   └─ 오류:     {error_count}건")
     logger.info(f"⏱️  Duration: {duration:.1f} seconds ({duration/60:.1f} minutes)")
     logger.info(f"📅 Analysis Date: {analysis_date}")
-    
-    # API 통계 출력
-    stats = kis_api.get_monitor_stats()
+
+    # API 통계 출력 (싱글톤 인스턴스 기준)
+    stats = korea_investment_api.get_monitor_stats()
     logger.info(f"📡 API 통계:")
     logger.info(f"   - 총 호출: {stats['total_calls']}건")
     logger.info(f"   - 오류: {stats['total_errors']}건 ({stats['error_rate']:.1%})")
@@ -212,6 +271,15 @@ async def batch_analyze_all_stocks(limit: int = None):
     logger.info(f"   - 평균 응답 시간: {stats['avg_duration']:.2f}초")
     logger.info("=" * 60)
 
+    # 분석종목(watchlist) 초기화 — score 상위 50개로 장중 미니배치 대상 설정
+    try:
+        from app.services.watchlist import initialize_watchlist
+        async with AsyncSessionLocal() as session:
+            count = await initialize_watchlist(session, analysis_date)
+            logger.info(f"📋 분석종목 초기화 완료: {count}개 → 장중 미니배치 준비")
+    except Exception as e:
+        logger.warning(f"⚠️ 분석종목 초기화 실패 (non-critical): {e}")
+
 
 async def main():
     """메인 실행 함수"""
diff --git a/backend/batch_intraday_analysis.py b/backend/batch_intraday_analysis.py
new file mode 100644
index 0000000..07e28c5
--- /dev/null
+++ b/backend/batch_intraday_analysis.py
@@ -0,0 +1,316 @@
+"""
+장중 미니배치: 매 10분마다 실행 (평일 09:00~15:30 KST)
+
+[흐름]
+1. 아침 배치(batch_daily_analysis.py)가 분석종목(watchlist)을 score 상위 50개로 초기화
+2. 장중 미니배치는 분석종목만 재분석하여 최신 지표로 stock_analysis 갱신
+3. 분석 결과를 watchlist_history에 시계열로 누적 저장
+4. score 기준으로 분석종목 진입(≥60) / 제거(<20) 자동 관리
+
+실행: python batch_intraday_analysis.py
+Cron: */10 9-15 * * 1-5 docker exec autostock-backend python /app/batch_intraday_analysis.py >> /logs/batch_intraday.log 2>&1
+"""
+
+import asyncio
+import sys
+from datetime import datetime, date
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+from sqlalchemy import select, delete, update, func
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker
+import logging
+
+from app.core.config import settings
+from app.core.market_schedule import is_market_open
+from app.models.models import StockAnalysis, WatchlistStock, WatchlistHistory
+from app.api.endpoints.recommendations import analyze_stock_for_batch
+from app.services.watchlist import (
+    WATCHLIST_MAX_SIZE,
+    WATCHLIST_ENTRY_SCORE,
+    WATCHLIST_EXIT_SCORE,
+)
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# 동시 처리 종목 수 (KIS API 세마포어가 추가로 속도 제어)
+BATCH_CONCURRENCY = 5
+
+# DB 연결
+database_url = settings.DATABASE_URL
+if database_url.startswith("postgresql://"):
+    database_url = database_url.replace("postgresql://", "postgresql+asyncpg://", 1)
+
+engine = create_async_engine(
+    database_url,
+    echo=False,
+    pool_pre_ping=True,
+    pool_size=5,
+    max_overflow=10,
+)
+
+AsyncSessionLocal = sessionmaker(
+    engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+)
+
+
+async def get_active_watchlist() -> list[tuple[str, str]]:
+    """현재 활성 분석종목 목록 조회."""
+    async with AsyncSessionLocal() as session:
+        result = await session.execute(
+            select(WatchlistStock.stock_code, WatchlistStock.stock_name)
+            .where(WatchlistStock.is_active == True)
+        )
+        rows = result.all()
+
+    if not rows:
+        logger.warning(
+            "⚠️ 분석종목이 없습니다. "
+            "아침 배치(batch_daily_analysis.py)가 먼저 실행되었는지 확인하세요."
+        )
+    else:
+        logger.info(f"📋 분석종목 {len(rows)}개 대상")
+    return [(row.stock_code, row.stock_name) for row in rows]
+
+
+async def analyze_update_and_manage(
+    stock_code: str,
+    stock_name: str,
+    analysis_date: date,
+) -> tuple[bool, int | None]:
+    """종목 재분석 → stock_analysis 갱신 → watchlist_history 저장 → watchlist 관리.
+
+    Returns: (success, score)
+    """
+    try:
+        result = await analyze_stock_for_batch(stock_code, stock_name)
+        if not result:
+            logger.info(f"No result for {stock_code} (chart/price issue)")
+            return False, None
+
+        # 5,000원 이하 저가주 → watchlist에서도 제거
+        if result.current_price and result.current_price < 5000:
+            logger.debug(f"Skip {stock_code}: price={result.current_price:.0f}원 < 5,000원")
+            async with AsyncSessionLocal() as session:
+                await session.execute(
+                    update(WatchlistStock)
+                    .where(
+                        WatchlistStock.stock_code == stock_code,
+                        WatchlistStock.is_active == True,
+                    )
+                    .values(
+                        is_active=False,
+                        removed_at=datetime.now(),
+                        removed_reason="price_filter",
+                    )
+                )
+                await session.commit()
+            return False, None
+
+        now = datetime.now()
+        score = result.score
+
+        async with AsyncSessionLocal() as session:
+            # 1. stock_analysis 갱신 (DELETE + INSERT)
+            await session.execute(
+                delete(StockAnalysis).where(
+                    StockAnalysis.stock_code == stock_code,
+                    StockAnalysis.analysis_date == analysis_date,
+                )
+            )
+            session.add(StockAnalysis(
+                stock_code=stock_code,
+                stock_name=stock_name,
+                analysis_date=analysis_date,
+                current_price=result.current_price,
+                change_rate=result.change_rate,
+                volume=result.volume,
+                rsi=result.rsi,
+                ma5=result.ma5,
+                ma20=result.ma20,
+                ma60=result.ma60,
+                stochastic_k=result.stochastic_k,
+                stochastic_d=result.stochastic_d,
+                bollinger_upper=result.bollinger_upper,
+                bollinger_lower=result.bollinger_lower,
+                bollinger_middle=result.bollinger_middle,
+                signals=result.signals,
+                score=score,
+                ml_score=result.ml_score,
+                ml_confidence=result.ml_confidence,
+                ml_signal=result.ml_signal,
+                atr_14=result.atr_14,
+                adx_14=result.adx_14,
+            ))
+
+            # 2. watchlist_history 시계열 기록
+            session.add(WatchlistHistory(
+                stock_code=stock_code,
+                stock_name=stock_name,
+                recorded_at=now,
+                score=score,
+                current_price=result.current_price,
+                change_rate=result.change_rate,
+                rsi=result.rsi,
+                signals=result.signals,
+            ))
+
+            # 3. score가 기준 이하면 분석종목에서 제거
+            if score is not None and score < WATCHLIST_EXIT_SCORE:
+                await session.execute(
+                    update(WatchlistStock)
+                    .where(
+                        WatchlistStock.stock_code == stock_code,
+                        WatchlistStock.is_active == True,
+                    )
+                    .values(
+                        is_active=False,
+                        removed_at=now,
+                        removed_reason="score_drop",
+                    )
+                )
+                logger.info(
+                    f"🚫 {stock_code} ({stock_name}) 분석종목 제거: "
+                    f"score={score} < {WATCHLIST_EXIT_SCORE}"
+                )
+
+            await session.commit()
+
+        logger.info(f"✅ {stock_code} ({stock_name}): score={score}")
+        return True, score
+
+    except Exception as e:
+        logger.error(f"❌ Failed {stock_code}: {e}")
+        return False, None
+
+
+async def refresh_watchlist(analysis_date: date, current_codes: set[str]) -> int:
+    """분석종목에 없는 고점수 종목을 신규 추가.
+
+    Args:
+        analysis_date: 오늘 날짜 (stock_analysis 기준)
+        current_codes: 이번 배치 시작 시점의 watchlist 코드 집합
+
+    Returns: 추가된 종목 수
+    """
+    async with AsyncSessionLocal() as session:
+        # 현재 활성 종목 수 확인
+        count_result = await session.execute(
+            select(func.count())
+            .select_from(WatchlistStock)
+            .where(WatchlistStock.is_active == True)
+        )
+        active_count = count_result.scalar() or 0
+
+        slots = WATCHLIST_MAX_SIZE - active_count
+        if slots <= 0:
+            logger.debug(f"Watchlist 최대치 도달 ({active_count}/{WATCHLIST_MAX_SIZE})")
+            return 0
+
+        # stock_analysis에서 고점수 종목 중 현재 watchlist에 없는 것 조회
+        exclude_codes = list(current_codes) if current_codes else ["__none__"]
+        result = await session.execute(
+            select(
+                StockAnalysis.stock_code,
+                StockAnalysis.stock_name,
+                StockAnalysis.score,
+            )
+            .where(
+                StockAnalysis.analysis_date == analysis_date,
+                StockAnalysis.score >= WATCHLIST_ENTRY_SCORE,
+                StockAnalysis.stock_code.notin_(exclude_codes),
+            )
+            .order_by(StockAnalysis.score.desc())
+            .limit(slots)
+        )
+        candidates = result.all()
+
+        if not candidates:
+            return 0
+
+        now = datetime.now()
+        for row in candidates:
+            session.add(WatchlistStock(
+                stock_code=row.stock_code,
+                stock_name=row.stock_name,
+                added_at=now,
+                added_reason="score_rise",
+                score_at_add=row.score,
+                is_active=True,
+            ))
+
+        await session.commit()
+        logger.info(
+            f"➕ 분석종목 {len(candidates)}개 신규 추가 "
+            f"(score ≥ {WATCHLIST_ENTRY_SCORE}, 현재 {active_count + len(candidates)}개)"
+        )
+        return len(candidates)
+
+
+async def main():
+    """장중 미니배치 메인"""
+    # 장중(09:00~15:30 KST 평일)이 아니면 즉시 종료
+    if not is_market_open():
+        logger.info("📴 장중이 아닙니다 (09:00~15:30 평일). 종료합니다.")
+        return
+
+    start_time = datetime.now()
+    analysis_date = date.today()
+    logger.info(
+        f"⚡ [Intraday] {start_time.strftime('%H:%M:%S')} 시작 — "
+        f"분석종목 재분석 (진입≥{WATCHLIST_ENTRY_SCORE}, 제거<{WATCHLIST_EXIT_SCORE})"
+    )
+
+    # 활성 분석종목 조회
+    active_stocks = await get_active_watchlist()
+    if not active_stocks:
+        return
+
+    # 이번 배치 시작 시점의 코드 집합 (신규 추가 시 중복 방지용)
+    current_codes = {code for code, _ in active_stocks}
+    total = len(active_stocks)
+
+    # 병렬 재분석
+    semaphore = asyncio.Semaphore(BATCH_CONCURRENCY)
+
+    async def analyze_one(i: int, code: str, name: str) -> tuple[bool, int | None]:
+        async with semaphore:
+            logger.info(f"[{i}/{total}] {code} ({name})")
+            return await analyze_update_and_manage(code, name, analysis_date)
+
+    tasks = [
+        analyze_one(i, code, name)
+        for i, (code, name) in enumerate(active_stocks, 1)
+    ]
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+
+    success = sum(1 for r in results if isinstance(r, tuple) and r[0] is True)
+    removed = sum(
+        1 for r in results
+        if isinstance(r, tuple) and r[0] is True
+        and r[1] is not None and r[1] < WATCHLIST_EXIT_SCORE
+    )
+    fail = sum(1 for r in results if isinstance(r, tuple) and r[0] is False)
+    error = sum(1 for r in results if isinstance(r, Exception))
+
+    # 고점수 신규 종목 추가
+    added = await refresh_watchlist(analysis_date, current_codes)
+
+    duration = (datetime.now() - start_time).total_seconds()
+    logger.info(
+        f"✅ [Intraday] 완료: {success}/{total} 성공, "
+        f"{removed} 제거, +{added} 신규, "
+        f"{fail} 실패, {error} 오류 — {duration:.1f}초"
+    )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/backend/cleanup_portfolio.py b/backend/cleanup_portfolio.py
new file mode 100644
index 0000000..d62a0a5
--- /dev/null
+++ b/backend/cleanup_portfolio.py
@@ -0,0 +1,52 @@
+"""포트폴리오 수량 0인 종목 정리 스크립트"""
+import asyncio
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+from sqlalchemy import select, delete
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker
+from app.core.config import settings
+from app.models.models import Portfolio
+
+async def cleanup():
+    # asyncpg 드라이버 사용
+    database_url = settings.DATABASE_URL
+    if database_url.startswith("postgresql://"):
+        database_url = database_url.replace("postgresql://", "postgresql+asyncpg://", 1)
+    
+    engine = create_async_engine(database_url)
+    AsyncSessionLocal = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+    
+    async with AsyncSessionLocal() as session:
+        # 수량 0인 종목 조회
+        result = await session.execute(
+            select(Portfolio).where(Portfolio.quantity == 0)
+        )
+        zero_qty = result.scalars().all()
+        
+        print(f"수량 0인 종목: {len(zero_qty)}개")
+        for p in zero_qty:
+            print(f"  - {p.stock_name}({p.stock_code}): {p.quantity}주")
+        
+        if zero_qty:
+            # 삭제
+            await session.execute(
+                delete(Portfolio).where(Portfolio.quantity == 0)
+            )
+            await session.commit()
+            print(f"\n✅ {len(zero_qty)}개 종목 삭제 완료")
+        else:
+            print("\n정리할 종목이 없습니다.")
+        
+        # 최종 포트폴리오 확인
+        result = await session.execute(select(Portfolio))
+        all_portfolio = result.scalars().all()
+        print(f"\n현재 포트폴리오: {len(all_portfolio)}개")
+        for p in all_portfolio:
+            print(f"  - {p.stock_name}({p.stock_code}): {p.quantity}주")
+
+if __name__ == "__main__":
+    asyncio.run(cleanup())
diff --git a/backend/clear_test_data.py b/backend/clear_test_data.py
new file mode 100644
index 0000000..29db8e3
--- /dev/null
+++ b/backend/clear_test_data.py
@@ -0,0 +1,58 @@
+"""
+테스트 데이터 삭제 스크립트
+재시작 시 오래된 테스트 데이터를 자동으로 삭제합니다.
+"""
+
+import asyncio
+import logging
+from sqlalchemy import delete, select
+from datetime import date, timedelta
+
+from app.core.database import AsyncSessionLocal
+from app.models.models import StockAnalysis, TradeHistory, Portfolio
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+async def clear_test_data():
+    """테스트 데이터 및 오래된 분석 데이터 삭제"""
+    async with AsyncSessionLocal() as session:
+        try:
+            # 1. 오래된 stock_analysis 데이터 삭제 (7일 이전)
+            cutoff_date = date.today() - timedelta(days=7)
+            result = await session.execute(
+                delete(StockAnalysis).where(StockAnalysis.analysis_date < cutoff_date)
+            )
+            deleted_analysis = result.rowcount
+            logger.info(f"🗑️ Deleted {deleted_analysis} old stock_analysis records (before {cutoff_date})")
+            
+            # 2. PENDING/FAILED 상태의 오래된 거래 내역 삭제 (1일 이전)
+            cutoff_datetime = date.today() - timedelta(days=1)
+            result = await session.execute(
+                delete(TradeHistory).where(
+                    TradeHistory.status.in_(['PENDING', 'FAILED']),
+                    TradeHistory.created_at < cutoff_datetime
+                )
+            )
+            deleted_trades = result.rowcount
+            logger.info(f"🗑️ Deleted {deleted_trades} old PENDING/FAILED trade records")
+            
+            # 3. 수량이 0인 포트폴리오 항목 삭제
+            result = await session.execute(
+                delete(Portfolio).where(Portfolio.quantity <= 0)
+            )
+            deleted_portfolio = result.rowcount
+            logger.info(f"🗑️ Deleted {deleted_portfolio} empty portfolio records")
+            
+            await session.commit()
+            logger.info("✅ Test data cleanup completed successfully!")
+            
+        except Exception as e:
+            logger.error(f"❌ Error during test data cleanup: {e}")
+            await session.rollback()
+            raise
+
+
+if __name__ == "__main__":
+    asyncio.run(clear_test_data())
diff --git a/backend/collect_krx_data.py b/backend/collect_krx_data.py
new file mode 100644
index 0000000..2fae511
--- /dev/null
+++ b/backend/collect_krx_data.py
@@ -0,0 +1,323 @@
+"""
+KRX 히스토리컬 데이터 수집 스크립트
+
+pykrx를 사용하여 KOSPI/KOSDAQ 종목의 일봉 OHLCV 데이터를 DB에 저장합니다.
+
+사용법:
+    python collect_krx_data.py                          # 전체 수집 (10년, 주요 200종목)
+    python collect_krx_data.py --limit 5 --start-date 20240101  # 테스트 (5종목, 2024년~)
+    python collect_krx_data.py --update                 # 증분 업데이트 (마지막 저장일 이후)
+    python collect_krx_data.py --market kospi            # KOSPI만
+"""
+
+import argparse
+import asyncio
+import logging
+import sys
+import time
+from datetime import date, datetime, timedelta
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from pykrx import stock as pykrx_stock
+
+# 프로젝트 루트를 Python 경로에 추가
+sys.path.insert(0, str(Path(__file__).parent))
+
+from sqlalchemy import text
+from sqlalchemy.dialects.postgresql import insert as pg_insert
+
+from app.core.database import AsyncSessionLocal, engine, Base
+from app.models.models import StockDailyPrice
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+# ETF/특수 종목 제외 키워드
+SKIP_KEYWORDS = [
+    "ETF", "레버리지", "인버스", "KODEX", "TIGER", "ARIRANG",
+    "KBSTAR", "HANARO", "SOL", "ACE", "KOSEF", "KINDEX",
+    "선물", "스팩", "리츠", "SPAC",
+]
+
+
+def get_stock_list(market: str = "all", limit: int = 0) -> list:
+    """pykrx로 종목 목록 조회
+
+    Args:
+        market: "kospi", "kosdaq", "all"
+        limit: 0이면 전체, N이면 상위 N개
+
+    Returns:
+        [(stock_code, stock_name), ...]
+    """
+    today = datetime.now().strftime("%Y%m%d")
+    stocks = []
+
+    markets = []
+    if market in ("kospi", "all"):
+        markets.append("KOSPI")
+    if market in ("kosdaq", "all"):
+        markets.append("KOSDAQ")
+
+    for mkt in markets:
+        try:
+            tickers = pykrx_stock.get_market_ticker_list(today, market=mkt)
+            for ticker in tickers:
+                name = pykrx_stock.get_market_ticker_name(ticker)
+                if any(k in name for k in SKIP_KEYWORDS):
+                    continue
+                stocks.append((ticker, name))
+            logger.info(f"{mkt}: {len(tickers)}개 조회, 필터링 후 {len(stocks)}개")
+        except Exception as e:
+            logger.error(f"{mkt} 종목 목록 조회 실패: {e}")
+
+    # 중복 제거
+    seen = set()
+    unique = []
+    for code, name in stocks:
+        if code not in seen:
+            seen.add(code)
+            unique.append((code, name))
+
+    if limit > 0:
+        unique = unique[:limit]
+
+    logger.info(f"총 {len(unique)}개 종목 선정")
+    return unique
+
+
+def fetch_ohlcv(stock_code: str, start_date: str, end_date: str) -> pd.DataFrame:
+    """pykrx로 일봉 OHLCV 데이터 조회
+
+    Returns:
+        DataFrame with columns: date, open, high, low, close, volume, change_rate, market_cap
+    """
+    try:
+        df = pykrx_stock.get_market_ohlcv_by_date(
+            start_date, end_date, stock_code, adjusted=True
+        )
+        if df.empty:
+            return pd.DataFrame()
+
+        # 시가총액 조회
+        try:
+            cap_df = pykrx_stock.get_market_cap_by_date(start_date, end_date, stock_code)
+            if not cap_df.empty:
+                df["시가총액"] = cap_df["시가총액"]
+        except Exception:
+            df["시가총액"] = None
+
+        df = df.reset_index()
+        df.columns = [c.replace("날짜", "date") for c in df.columns]
+
+        result = pd.DataFrame({
+            "date": df.iloc[:, 0],  # 날짜
+            "open": df["시가"].astype(int),
+            "high": df["고가"].astype(int),
+            "low": df["저가"].astype(int),
+            "close": df["종가"].astype(int),
+            "volume": df["거래량"].astype(int),
+            "change_rate": df["등락률"] / 100.0 if "등락률" in df.columns else 0,
+            "market_cap": df.get("시가총액"),
+        })
+
+        # 거래량 0인 날 제거 (거래정지일)
+        result = result[result["volume"] > 0].reset_index(drop=True)
+        return result
+
+    except Exception as e:
+        logger.error(f"{stock_code} OHLCV 조회 실패: {e}")
+        return pd.DataFrame()
+
+
+async def create_tables():
+    """DB 테이블 생성"""
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    logger.info("DB 테이블 확인/생성 완료")
+
+
+async def get_last_trade_date(session, stock_code: str) -> date | None:
+    """특정 종목의 DB 내 마지막 거래일 조회"""
+    result = await session.execute(
+        text(
+            "SELECT MAX(trade_date) FROM stock_daily_prices WHERE stock_code = :code"
+        ),
+        {"code": stock_code},
+    )
+    row = result.scalar()
+    return row
+
+
+async def upsert_daily_prices(session, stock_code: str, stock_name: str, df: pd.DataFrame):
+    """DB에 일봉 데이터 upsert (중복 시 업데이트)"""
+    if df.empty:
+        return 0
+
+    records = []
+    for _, row in df.iterrows():
+        trade_date = row["date"]
+        if isinstance(trade_date, pd.Timestamp):
+            trade_date = trade_date.date()
+
+        record = {
+            "stock_code": stock_code,
+            "stock_name": stock_name,
+            "trade_date": trade_date,
+            "open_price": int(row["open"]),
+            "high_price": int(row["high"]),
+            "low_price": int(row["low"]),
+            "close_price": int(row["close"]),
+            "volume": int(row["volume"]),
+            "change_rate": float(row["change_rate"]) if pd.notna(row["change_rate"]) else None,
+            "market_cap": int(row["market_cap"]) if pd.notna(row.get("market_cap")) else None,
+        }
+        records.append(record)
+
+    # PostgreSQL ON CONFLICT upsert (batch)
+    batch_size = 500
+    inserted = 0
+    for i in range(0, len(records), batch_size):
+        batch = records[i:i + batch_size]
+        stmt = pg_insert(StockDailyPrice).values(batch)
+        stmt = stmt.on_conflict_do_update(
+            constraint="uq_stock_daily",
+            set_={
+                "stock_name": stmt.excluded.stock_name,
+                "open_price": stmt.excluded.open_price,
+                "high_price": stmt.excluded.high_price,
+                "low_price": stmt.excluded.low_price,
+                "close_price": stmt.excluded.close_price,
+                "volume": stmt.excluded.volume,
+                "change_rate": stmt.excluded.change_rate,
+                "market_cap": stmt.excluded.market_cap,
+            },
+        )
+        await session.execute(stmt)
+        inserted += len(batch)
+
+    await session.commit()
+    return inserted
+
+
+async def collect_all(
+    market: str = "all",
+    limit: int = 0,
+    start_date: str = "20160101",
+    update_mode: bool = False,
+):
+    """메인 수집 로직"""
+    await create_tables()
+
+    end_date = datetime.now().strftime("%Y%m%d")
+
+    # 종목 목록
+    stock_list = get_stock_list(market=market, limit=limit)
+    if not stock_list:
+        logger.error("종목 목록이 비어있습니다")
+        return
+
+    total = len(stock_list)
+    total_inserted = 0
+    success_count = 0
+    fail_count = 0
+
+    async with AsyncSessionLocal() as session:
+        for i, (stock_code, stock_name) in enumerate(stock_list):
+            try:
+                actual_start = start_date
+
+                if update_mode:
+                    last_date = await get_last_trade_date(session, stock_code)
+                    if last_date:
+                        # 마지막 저장일 다음 날부터
+                        next_day = last_date + timedelta(days=1)
+                        actual_start = next_day.strftime("%Y%m%d")
+                        if next_day >= date.today():
+                            logger.info(f"[{i+1}/{total}] {stock_code} ({stock_name}): 이미 최신")
+                            success_count += 1
+                            continue
+
+                logger.info(
+                    f"[{i+1}/{total}] {stock_code} ({stock_name}): "
+                    f"{actual_start} ~ {end_date} 수집 중..."
+                )
+
+                df = fetch_ohlcv(stock_code, actual_start, end_date)
+                if df.empty:
+                    logger.warning(f"  {stock_code}: 데이터 없음")
+                    fail_count += 1
+                    continue
+
+                count = await upsert_daily_prices(session, stock_code, stock_name, df)
+                total_inserted += count
+                success_count += 1
+                logger.info(f"  {stock_code}: {count}개 행 저장 (총 {len(df)}일)")
+
+            except Exception as e:
+                logger.error(f"  {stock_code} ({stock_name}) 실패: {e}")
+                fail_count += 1
+                # 에러 시에도 계속 진행
+                try:
+                    await session.rollback()
+                except Exception:
+                    pass
+
+            # pykrx rate limit 방지
+            time.sleep(0.5)
+
+    logger.info("=" * 60)
+    logger.info(f"수집 완료!")
+    logger.info(f"  성공: {success_count}/{total}")
+    logger.info(f"  실패: {fail_count}/{total}")
+    logger.info(f"  총 저장 행: {total_inserted:,}")
+    logger.info("=" * 60)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="KRX 히스토리컬 데이터 수집")
+    parser.add_argument(
+        "--market",
+        choices=["kospi", "kosdaq", "all"],
+        default="all",
+        help="수집 시장 (기본: all)",
+    )
+    parser.add_argument(
+        "--limit", type=int, default=0, help="종목 수 제한 (0=전체, 테스트용)"
+    )
+    parser.add_argument(
+        "--start-date",
+        default="20160101",
+        help="수집 시작일 YYYYMMDD (기본: 20160101)",
+    )
+    parser.add_argument(
+        "--update",
+        action="store_true",
+        help="증분 업데이트 모드 (마지막 저장일 이후만 수집)",
+    )
+    args = parser.parse_args()
+
+    logger.info(f"KRX 데이터 수집 시작")
+    logger.info(f"  시장: {args.market}")
+    logger.info(f"  종목 제한: {'전체' if args.limit == 0 else args.limit}")
+    logger.info(f"  시작일: {args.start_date}")
+    logger.info(f"  증분 모드: {args.update}")
+
+    start_time = time.time()
+    asyncio.run(collect_all(
+        market=args.market,
+        limit=args.limit,
+        start_date=args.start_date,
+        update_mode=args.update,
+    ))
+    elapsed = time.time() - start_time
+    logger.info(f"총 소요시간: {elapsed:.1f}초 ({elapsed/60:.1f}분)")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/backend/diagnose_autotrade.py b/backend/diagnose_autotrade.py
new file mode 100644
index 0000000..48bf63e
--- /dev/null
+++ b/backend/diagnose_autotrade.py
@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""자동매매 진단 스크립트"""
+
+import sys
+import os
+sys.path.insert(0, '/app')
+
+from datetime import datetime
+import pytz
+
+# 1. 현재 시간 확인
+KST = pytz.timezone('Asia/Seoul')
+now = datetime.now(KST)
+print(f"🕐 현재 시간 (KST): {now.strftime('%Y-%m-%d %H:%M:%S %A')}")
+print(f"   요일: {now.weekday()} (0=월, 6=일)")
+current_minutes = now.hour * 60 + now.minute
+print(f"   시간(분): {current_minutes} (장시간: 540-930)")
+
+# 2. 장 운영 시간 체크
+from app.core.market_schedule import is_market_open
+market_status = is_market_open()
+print(f"\n📊 장 운영 상태: {'✅ OPEN (자동매매 가능)' if market_status else '❌ CLOSED (자동매매 중단)'}")
+
+# 3. 설정 확인
+from app.core.config import settings
+print(f"\n⚙️ 자동매매 설정:")
+print(f"   AUTO_TRADE_ENABLED: {settings.AUTO_TRADE_ENABLED}")
+print(f"   STOP_LOSS_PERCENT: {settings.STOP_LOSS_PERCENT}%")
+print(f"   TAKE_PROFIT_PERCENT: {settings.TAKE_PROFIT_PERCENT}%")
+print(f"   MAX_DAILY_TRADES: {settings.MAX_DAILY_TRADES}")
+print(f"   TREND_FILTER_ENABLED: {settings.TREND_FILTER_ENABLED}")
+
+# 4. API 키 확인
+print(f"\n🔑 API 인증 정보:")
+print(f"   KIS_APP_KEY: {'✅ 설정됨' if settings.KOREA_INVESTMENT_APP_KEY else '❌ 미설정'}")
+print(f"   KIS_APP_SECRET: {'✅ 설정됨' if settings.KOREA_INVESTMENT_APP_SECRET else '❌ 미설정'}")
+print(f"   KIS_ACCOUNT_NO: {'✅ 설정됨' if settings.KOREA_INVESTMENT_ACCOUNT_NUMBER else '❌ 미설정'}")
+
+# 5. 자동매매 가능 여부 최종 판단
+can_trade = market_status and settings.AUTO_TRADE_ENABLED
+print(f"\n🎯 최종 판단: {'✅ 자동매매 실행 가능' if can_trade else '❌ 자동매매 실행 불가'}")
+
+if not can_trade:
+    reasons = []
+    if not market_status:
+        reasons.append("- 장 마감 시간입니다")
+    if not settings.AUTO_TRADE_ENABLED:
+        reasons.append("- AUTO_TRADE_ENABLED가 False입니다")
+    if not settings.KOREA_INVESTMENT_APP_KEY:
+        reasons.append("- KIS API 인증 정보가 없습니다")
+    
+    print("\n⚠️ 자동매매 불가 원인:")
+    for r in reasons:
+        print(f"   {r}")
+
+# 6. 데이터베이스 연결 확인
+print(f"\n💾 데이터베이스:")
+try:
+    from sqlalchemy import create_engine, text
+    engine = create_engine(settings.DATABASE_URL.replace('+asyncpg', ''))
+    with engine.connect() as conn:
+        result = conn.execute(text("SELECT COUNT(*) FROM portfolio"))
+        portfolio_count = result.scalar()
+        print(f"   ✅ 연결 성공")
+        print(f"   포트폴리오 종목 수: {portfolio_count}")
+except Exception as e:
+    print(f"   ❌ 연결 실패: {e}")
+
+print("\n" + "="*60)
diff --git a/backend/fix_trade_history.py b/backend/fix_trade_history.py
new file mode 100644
index 0000000..2a11dd4
--- /dev/null
+++ b/backend/fix_trade_history.py
@@ -0,0 +1,62 @@
+import asyncio
+from app.core.database import AsyncSessionLocal
+from app.models.models import TradeHistory, Portfolio
+from sqlalchemy import select, and_
+
+async def fix_trade_history():
+    """잘못된 거래 내역 수정"""
+    async with AsyncSessionLocal() as db:
+        # 현대ADM 포트폴리오 확인
+        result = await db.execute(
+            select(Portfolio).where(Portfolio.stock_code == "187660")
+        )
+        portfolio = result.scalar_one_or_none()
+        
+        if portfolio:
+            actual_qty = portfolio.quantity
+            print(f"✅ 실제 보유 수량: {actual_qty}주")
+        else:
+            print("❌ 포트폴리오에 현대ADM 없음")
+            return
+        
+        # 현대ADM 거래 내역 조회
+        result = await db.execute(
+            select(TradeHistory)
+            .where(
+                and_(
+                    TradeHistory.stock_code == "187660",
+                    TradeHistory.order_type == "BUY",
+                    TradeHistory.status.in_(["COMPLETED", "EXECUTED"])
+                )
+            )
+            .order_by(TradeHistory.created_at)
+        )
+        trades = result.scalars().all()
+        
+        print(f"\n📋 DB 거래 내역: {len(trades)}건")
+        total_db_qty = sum(t.executed_quantity or t.order_quantity for t in trades)
+        print(f"📊 DB 총 매수량: {total_db_qty}주")
+        print(f"📊 실제 보유량: {actual_qty}주")
+        print(f"⚠️  차이: {total_db_qty - actual_qty}주")
+        
+        # 가장 최근 거래만 남기고 나머지 삭제
+        if len(trades) > 1:
+            print(f"\n🗑️  중복 거래 내역 삭제:")
+            for trade in trades[:-1]:  # 마지막 거래 제외하고 삭제
+                print(f"   - ID {trade.id}: {trade.order_quantity}주 (생성: {trade.created_at})")
+                await db.delete(trade)
+            
+            # 마지막 거래의 수량을 실제 보유량으로 수정
+            last_trade = trades[-1]
+            print(f"\n✏️  마지막 거래 수량 수정:")
+            print(f"   - ID {last_trade.id}: {last_trade.order_quantity}주 → {actual_qty}주")
+            last_trade.executed_quantity = actual_qty
+            last_trade.order_quantity = actual_qty
+            
+            await db.commit()
+            print(f"\n✅ 수정 완료!")
+        else:
+            print("\n✅ 중복 없음")
+
+if __name__ == "__main__":
+    asyncio.run(fix_trade_history())
diff --git a/backend/force_sync_portfolio.py b/backend/force_sync_portfolio.py
new file mode 100644
index 0000000..bcdf78e
--- /dev/null
+++ b/backend/force_sync_portfolio.py
@@ -0,0 +1,45 @@
+"""포트폴리오 강제 동기화 스크립트"""
+import asyncio
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+from app.api.endpoints.portfolio import sync_portfolio, portfolio_cache
+from app.core.database import get_db
+
+async def force_sync():
+    print("🔄 포트폴리오 강제 동기화 시작...")
+    
+    # 캐시 초기화
+    portfolio_cache.holdings = []
+    portfolio_cache.summary = None
+    portfolio_cache.last_synced = None
+    portfolio_cache.change_flag = True
+    
+    print("✅ 캐시 초기화 완료")
+    
+    # DB 세션 생성
+    from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+    from sqlalchemy.orm import sessionmaker
+    from app.core.config import settings
+    
+    database_url = settings.DATABASE_URL
+    if database_url.startswith("postgresql://"):
+        database_url = database_url.replace("postgresql://", "postgresql+asyncpg://", 1)
+    
+    engine = create_async_engine(database_url)
+    AsyncSessionLocal = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+    
+    async with AsyncSessionLocal() as session:
+        try:
+            result = await sync_portfolio(session, force=True)
+            print(f"✅ 동기화 완료: {result}")
+            print(f"📊 보유 종목: {len(portfolio_cache.holdings)}개")
+            for h in portfolio_cache.holdings:
+                print(f"  - {h.stock_name}({h.stock_code}): {h.quantity}주")
+        except Exception as e:
+            print(f"❌ 동기화 실패: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(force_sync())
diff --git a/backend/migrations/add_ml_ensemble_columns.sql b/backend/migrations/add_ml_ensemble_columns.sql
new file mode 100644
index 0000000..f1ffcfd
--- /dev/null
+++ b/backend/migrations/add_ml_ensemble_columns.sql
@@ -0,0 +1,6 @@
+-- ML 앙상블 스코어 컬럼 추가 (stock_analysis 테이블)
+-- 실행: psql -d autostock_db -f migrations/add_ml_ensemble_columns.sql
+
+ALTER TABLE stock_analysis ADD COLUMN IF NOT EXISTS ml_score INTEGER;
+ALTER TABLE stock_analysis ADD COLUMN IF NOT EXISTS ml_confidence NUMERIC(5, 4);
+ALTER TABLE stock_analysis ADD COLUMN IF NOT EXISTS ml_signal VARCHAR(10);
diff --git a/backend/migrations/add_risk_management.sql b/backend/migrations/add_risk_management.sql
new file mode 100644
index 0000000..2882a35
--- /dev/null
+++ b/backend/migrations/add_risk_management.sql
@@ -0,0 +1,39 @@
+-- 🔥 리스크 관리 기능 추가를 위한 DB 마이그레이션
+
+-- 1. trading_sessions 테이블 생성 (일일 리스크 관리)
+CREATE TABLE IF NOT EXISTS trading_sessions (
+    id SERIAL PRIMARY KEY,
+    session_date DATE NOT NULL UNIQUE,
+    consecutive_losses INTEGER DEFAULT 0,
+    consecutive_wins INTEGER DEFAULT 0,
+    daily_profit_loss NUMERIC(15, 2) DEFAULT 0,
+    daily_trades_count INTEGER DEFAULT 0,
+    is_paused BOOLEAN DEFAULT FALSE,
+    pause_reason VARCHAR(200),
+    starting_balance NUMERIC(15, 2),
+    ending_balance NUMERIC(15, 2),
+    peak_balance NUMERIC(15, 2),
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX idx_trading_sessions_date ON trading_sessions(session_date);
+
+-- 2. trade_history 테이블에 리스크 관리 필드 추가
+ALTER TABLE trade_history 
+ADD COLUMN IF NOT EXISTS entry_trade_id INTEGER,
+ADD COLUMN IF NOT EXISTS slippage NUMERIC(15, 2),
+ADD COLUMN IF NOT EXISTS commission NUMERIC(15, 2),
+ADD COLUMN IF NOT EXISTS net_profit_loss NUMERIC(15, 2),
+ADD COLUMN IF NOT EXISTS profit_loss_rate NUMERIC(10, 4);
+
+-- 3. 기존 데이터에 대한 기본값 설정 (선택적)
+-- 기존 매도 거래에 대해 profit_loss_rate 계산 (매수 거래와 페어링 필요)
+-- 이 부분은 실제 데이터에 맞게 커스터마이징 필요
+
+COMMENT ON TABLE trading_sessions IS '일일 트레이딩 세션 관리 - 연속 손실 추적 및 리스크 제한';
+COMMENT ON COLUMN trade_history.entry_trade_id IS '매도 시 연결된 매수 거래 ID';
+COMMENT ON COLUMN trade_history.slippage IS '슬리피지 (체결가 - 주문가)';
+COMMENT ON COLUMN trade_history.commission IS '수수료';
+COMMENT ON COLUMN trade_history.net_profit_loss IS '수수료 차감 후 순손익';
+COMMENT ON COLUMN trade_history.profit_loss_rate IS '수익률 (%)';
diff --git a/backend/migrations/add_trade_history_columns.sql b/backend/migrations/add_trade_history_columns.sql
new file mode 100644
index 0000000..73c2ae3
--- /dev/null
+++ b/backend/migrations/add_trade_history_columns.sql
@@ -0,0 +1,11 @@
+-- 거래 이력 테이블에 새로운 컬럼 추가
+ALTER TABLE trade_history 
+ADD COLUMN IF NOT EXISTS total_amount NUMERIC(15, 2),
+ADD COLUMN IF NOT EXISTS entry_reason TEXT,
+ADD COLUMN IF NOT EXISTS exit_reason TEXT,
+ADD COLUMN IF NOT EXISTS signals JSONB;
+
+-- 기존 데이터에 대한 total_amount 계산
+UPDATE trade_history 
+SET total_amount = executed_price * executed_quantity 
+WHERE total_amount IS NULL AND executed_price IS NOT NULL AND executed_quantity IS NOT NULL;
diff --git a/backend/prefetch_token.py b/backend/prefetch_token.py
new file mode 100644
index 0000000..8eef0cd
--- /dev/null
+++ b/backend/prefetch_token.py
@@ -0,0 +1,48 @@
+"""
+KIS API 토큰 선제 발급 스크립트
+
+매일 오전 6시에 실행하여 토큰을 미리 발급·캐시함으로써
+장 시작 전(8:50 배치, 자동매매)의 불필요한 토큰 발급 지연을 방지한다.
+
+토큰 유효기간: 23시간 (6시 발급 → 다음날 5시까지 유효)
+Cron: 0 6 * * 1-5 docker exec autostock-backend python /app/prefetch_token.py >> /logs/token_prefetch.log 2>&1
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+from datetime import datetime
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+import logging
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+async def main():
+    from app.services.korea_investment_api import KoreaInvestmentAPI
+
+    logger.info(f"🔑 [{datetime.now().strftime('%H:%M:%S')}] 토큰 선제 발급 시작")
+
+    api = KoreaInvestmentAPI()
+
+    # 캐시된 토큰이 있어도 강제 재발급 (토큰 만료 임박 방지)
+    api.access_token = None
+    api.token_expires_at = None
+
+    try:
+        token = await api._get_access_token()
+        expires = api.token_expires_at.strftime('%Y-%m-%d %H:%M') if api.token_expires_at else "unknown"
+        logger.info(f"✅ 토큰 발급 완료 — 만료: {expires}")
+    except Exception as e:
+        logger.error(f"❌ 토큰 발급 실패: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/backend/requirements.txt b/backend/requirements.txt
index 9449ebb..da5cfcf 100644
--- a/backend/requirements.txt
+++ b/backend/requirements.txt
@@ -4,21 +4,30 @@ pydantic>=2.5.0
 pydantic-settings>=2.1.0
 sqlalchemy>=2.0.36
 asyncpg>=0.30.0
+psycopg2-binary>=2.9.9
 alembic>=1.14.0
 greenlet>=3.0.0
 redis==5.0.1
 aio-pika==9.3.1
 websockets==12.0
-httpx==0.25.2
+httpx>=0.27.1
 python-jose[cryptography]==3.3.0
 passlib[bcrypt]==1.7.4
-python-multipart==0.0.6
-anthropic==0.7.8
+python-multipart>=0.0.9
+anthropic>=0.18.0
 pandas>=2.2.0
 numpy>=1.26.0
 ta==0.11.0
 python-dotenv==1.0.0
+pytz>=2024.1
 celery==5.3.4
 pytest==7.4.3
 pytest-asyncio==0.21.1
 feedparser==6.0.11
+joblib>=1.3.0
+pytz
+# ML Ensemble
+torch>=2.1.0
+lightgbm>=4.1.0
+scikit-learn>=1.3.0
+pykrx>=1.0.44
diff --git a/backend/trading_rules_config.json b/backend/trading_rules_config.json
index 2330c85..81c17be 100644
--- a/backend/trading_rules_config.json
+++ b/backend/trading_rules_config.json
@@ -3,134 +3,83 @@
     "min_cash_reserve_ratio": 0.2,
     "max_cash_reserve_ratio": 0.3,
     "min_cash_reserve_amount": 1000000,
-    "max_holdings_count": 5,
-    "max_position_size_ratio": 0.25,
-    "min_position_size_ratio": 0.05,
+    "max_holdings_count": 20,
+    "max_position_size_ratio": 0.04,
+    "min_position_size_ratio": 0.02,
     "max_sector_concentration": 0.4,
+    "leverage_etf_max_ratio": 0.20,
+    "mean_reversion_max_capital": 0.30,
     "rebalance_threshold": 0.1
   },
   "risk_management": {
     "max_daily_loss": 0.03,
     "max_daily_trades": 10,
-    "max_loss_per_trade": 0.05,
+    "max_loss_per_trade": 0.08,
+    "stop_loss_low_vol": -6.0,
+    "stop_loss_high_vol": -10.0,
+    "atr_stop_multiplier": 2.5,
+    "atr_trailing_multiplier": 1.5,
     "trailing_stop_loss": 0.02,
-    "daily_profit_target": 0.05
+    "daily_profit_target": 0.05,
+    "mdd_pause_threshold": -10,
+    "mdd_force_threshold": -20,
+    "consecutive_loss_ban_count": 3,
+    "consecutive_loss_ban_days": 30,
+    "overheat_filter": {
+      "enabled": true,
+      "max_gain_3day": 15.0,
+      "max_gain_5day": 20.0,
+      "max_gain_10day": 30.0,
+      "max_disparity_20ma": 108.0
+    },
+    "bear_market_filter": {
+      "enabled": true,
+      "description": "코스피 200일 MA 기반 하락장 방어 전략 (섹션 7.1)",
+      "conditions": {
+        "bull": "코스피 > MA200 AND MA200 기울기 양(+)",
+        "bear": "위 조건 미충족"
+      },
+      "bearish_actions": {
+        "min_score": 5,
+        "max_trades_per_day": 3,
+        "position_multiplier": 0.5
+      },
+      "strong_bearish_actions": {
+        "min_score": 8,
+        "max_trades_per_day": 1,
+        "position_multiplier": 0.1
+      }
+    }
   },
   "rules": [
     {
-      "name": "RSI 과매도 반등 전략",
-      "description": "RSI가 30 이하로 과매도 상태이고, 거래량이 평균의 150% 이상일 때 매수",
-      "rule_type": "buy",
+      "name": "RSI+볼린저 평균회귀",
+      "description": "RSI 과매도 + 볼린저 하단 평균회귀 전략 (CLAUDE.md 섹션 7)",
+      "rule_type": "MEAN_REVERSION",
       "is_active": true,
       "priority": 1,
       "conditions": {
-        "rsi_threshold": 30,
-        "volume_multiplier": 1.5,
-        "ma_proximity": 0.03,
-        "trend": "down"
+        "rsi_bull_max": 25,
+        "rsi_bear_max": 35,
+        "bb_proximity_pct": 1.0,
+        "min_price_krw": 5000,
+        "min_price_usd": 4.0,
+        "min_volume_vs_avg": 1.0
       },
       "actions": {
         "action_type": "buy",
         "position_sizing": {
           "method": "fixed_ratio",
-          "target_ratio": 0.15,
-          "min_amount": 500000
+          "target_ratio": 0.04
         },
+        "stop_loss_atr_mult": 2.5,
+        "stop_loss_max_pct": -8.0,
         "take_profit": 5.0,
-        "stop_loss": 3.0
-      }
-    },
-    {
-      "name": "골든크로스 추세 추종",
-      "description": "20일선이 60일선을 상향 돌파하고 상승 추세가 확인될 때 매수",
-      "rule_type": "buy",
-      "is_active": true,
-      "priority": 2,
-      "conditions": {
-        "sma_short": 20,
-        "sma_long": 60,
-        "macd_signal": "positive",
-        "volume_trend": "increasing"
-      },
-      "actions": {
-        "action_type": "buy",
-        "position_sizing": {
-          "method": "fixed_ratio",
-          "target_ratio": 0.2,
-          "min_amount": 1000000
-        },
-        "take_profit": 10.0,
-        "stop_loss": 5.0
-      }
-    },
-    {
-      "name": "지지선 반등 전략",
-      "description": "주요 지지선에서 반등하고 긍정적인 뉴스나 이벤트가 있을 때 매수",
-      "rule_type": "buy",
-      "is_active": true,
-      "priority": 3,
-      "conditions": {
-        "support_level": "recent_low",
-        "bb_position": "lower_20",
-        "rsi_trend": "rising",
-        "volume_increase": true
-      },
-      "actions": {
-        "action_type": "buy",
-        "position_sizing": {
-          "method": "fixed_ratio",
-          "target_ratio": 0.15,
-          "min_amount": 500000
-        },
-        "take_profit": 7.0,
-        "stop_loss": 4.0
-      }
-    },
-    {
-      "name": "박스권 돌파 전략",
-      "description": "박스권 상단을 강한 거래량과 함께 돌파할 때 매수",
-      "rule_type": "buy",
-      "is_active": true,
-      "priority": 4,
-      "conditions": {
-        "breakout_period": 20,
-        "volume_multiplier": 2.0,
-        "rsi_max": 70,
-        "trend": "up"
-      },
-      "actions": {
-        "action_type": "buy",
-        "position_sizing": {
-          "method": "fixed_ratio",
-          "target_ratio": 0.2,
-          "min_amount": 1000000
-        },
-        "take_profit": 15.0,
-        "stop_loss": 5.0
-      }
-    },
-    {
-      "name": "모멘텀 추세 전략",
-      "description": "강한 상승 모멘텀이 지속되고 있을 때 추가 매수",
-      "rule_type": "buy",
-      "is_active": false,
-      "priority": 5,
-      "conditions": {
-        "consecutive_up_days": 3,
-        "volume_trend": "increasing",
-        "macd_histogram": "increasing",
-        "rsi_min": 50,
-        "rsi_max": 70
-      },
-      "actions": {
-        "action_type": "buy",
-        "position_sizing": {
-          "method": "fixed_ratio",
-          "target_ratio": 0.15,
-          "min_amount": 500000
-        },
-        "take_profit": 12.0,
-        "stop_loss": 4.0
+        "stop_loss": 6.0,
+        "exit_1_rsi": 50,
+        "exit_1_pct": 0.50,
+        "exit_2_rsi_min": 60,
+        "exit_2_rsi_max": 70
       }
     }
   ]
diff --git a/backend/train_ensemble.py b/backend/train_ensemble.py
new file mode 100644
index 0000000..56fd9d9
--- /dev/null
+++ b/backend/train_ensemble.py
@@ -0,0 +1,306 @@
+"""
+앙상블 모델 학습 스크립트
+
+데이터 소스를 선택하여 LightGBM + PyTorch LSTM + Random Forest 앙상블 모델을 학습합니다.
+- DB 모드(기본): stock_daily_prices 테이블의 KRX 히스토리컬 데이터 사용
+- API 모드: KIS API에서 실시간 차트 데이터 수집
+
+사용법:
+    python train_ensemble.py                        # DB 기반 전체 학습
+    python train_ensemble.py --source db --limit 20 # DB에서 20종목
+    python train_ensemble.py --source api --test    # KIS API로 10종목 (기존 방식)
+    python train_ensemble.py --min-days 500         # 최소 500일 데이터 있는 종목만
+"""
+
+import asyncio
+import sys
+import argparse
+import logging
+from pathlib import Path
+from datetime import datetime
+
+import numpy as np
+import pandas as pd
+
+# 프로젝트 루트를 Python 경로에 추가
+sys.path.insert(0, str(Path(__file__).parent))
+
+from app.services.feature_engineering import (
+    chart_data_to_dataframe,
+    db_data_to_dataframe,
+    extract_features,
+    prepare_training_data,
+)
+from app.services.ml_ensemble import MLEnsemble
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+# ─── DB 기반 데이터 수집 ───
+
+async def collect_training_data_from_db(limit: int = 200, min_days: int = 200) -> tuple:
+    """DB의 stock_daily_prices에서 학습 데이터 수집
+
+    Args:
+        limit: 최대 종목 수
+        min_days: 최소 데이터 일수 (이보다 적으면 제외)
+
+    Returns:
+        (X_tabular, X_seq, y)
+    """
+    from sqlalchemy import text
+    from app.core.database import AsyncSessionLocal
+
+    all_X_tabular = []
+    all_X_seq = []
+    all_y = []
+
+    async with AsyncSessionLocal() as session:
+        # 충분한 데이터가 있는 종목 조회
+        result = await session.execute(
+            text("""
+                SELECT stock_code, stock_name, COUNT(*) as cnt
+                FROM stock_daily_prices
+                GROUP BY stock_code, stock_name
+                HAVING COUNT(*) >= :min_days
+                ORDER BY cnt DESC
+                LIMIT :limit
+            """),
+            {"min_days": min_days, "limit": limit},
+        )
+        stock_list = [(row[0], row[1], row[2]) for row in result.fetchall()]
+
+        if not stock_list:
+            logger.error(f"DB에 {min_days}일 이상 데이터가 있는 종목이 없습니다")
+            logger.error("먼저 python collect_krx_data.py 를 실행하세요")
+            return np.array([]), np.array([]), np.array([])
+
+        logger.info(f"DB에서 {len(stock_list)}개 종목 조회 (최소 {min_days}일)")
+
+        for i, (stock_code, stock_name, day_count) in enumerate(stock_list):
+            logger.info(f"[{i+1}/{len(stock_list)}] {stock_code} ({stock_name}): {day_count}일 데이터")
+
+            try:
+                # DB에서 OHLCV 조회
+                rows = await session.execute(
+                    text("""
+                        SELECT trade_date, open_price, high_price, low_price,
+                               close_price, volume
+                        FROM stock_daily_prices
+                        WHERE stock_code = :code
+                        ORDER BY trade_date ASC
+                    """),
+                    {"code": stock_code},
+                )
+                data = [
+                    {
+                        "trade_date": r[0],
+                        "open_price": r[1],
+                        "high_price": r[2],
+                        "low_price": r[3],
+                        "close_price": r[4],
+                        "volume": r[5],
+                    }
+                    for r in rows.fetchall()
+                ]
+
+                if len(data) < min_days:
+                    continue
+
+                # DataFrame 변환 및 피처 추출
+                df = db_data_to_dataframe(data)
+                features_df = extract_features(df)
+
+                # 학습 데이터 준비
+                X_tab, X_seq, y, indices = prepare_training_data(
+                    df, features_df,
+                    forecast_days=3,
+                    up_threshold=0.015,
+                    down_threshold=-0.015,
+                )
+
+                if len(X_tab) == 0:
+                    logger.warning(f"  {stock_code}: 유효 샘플 없음")
+                    continue
+
+                all_X_tabular.append(X_tab)
+                all_X_seq.append(X_seq)
+                all_y.append(y)
+
+                logger.info(
+                    f"  {stock_code}: {len(X_tab)}개 샘플 "
+                    f"(UP:{np.sum(y==2)} HOLD:{np.sum(y==1)} DOWN:{np.sum(y==0)})"
+                )
+
+            except Exception as e:
+                logger.error(f"  {stock_code} 처리 실패: {e}")
+
+    if not all_X_tabular:
+        return np.array([]), np.array([]), np.array([])
+
+    X_tabular = np.vstack(all_X_tabular)
+    X_seq = np.vstack(all_X_seq)
+    y = np.concatenate(all_y)
+
+    return X_tabular, X_seq, y
+
+
+# ─── KIS API 기반 데이터 수집 (기존 방식) ───
+
+async def collect_training_data_from_api(stock_list: list, kis_api) -> tuple:
+    """여러 종목의 차트 데이터를 KIS API에서 수집하여 학습 데이터로 변환"""
+    all_X_tabular = []
+    all_X_seq = []
+    all_y = []
+
+    for i, (stock_code, stock_name) in enumerate(stock_list):
+        logger.info(f"[{i+1}/{len(stock_list)}] 데이터 수집: {stock_code} ({stock_name})")
+
+        try:
+            chart_resp = await kis_api.get_daily_chart(stock_code, "D")
+            chart_data = chart_resp.get("output", [])
+
+            if not chart_data or len(chart_data) < 80:
+                logger.warning(f"  {stock_code}: 데이터 부족 ({len(chart_data) if chart_data else 0}일)")
+                continue
+
+            df = chart_data_to_dataframe(chart_data)
+            features_df = extract_features(df)
+
+            X_tab, X_seq, y, indices = prepare_training_data(
+                df, features_df,
+                forecast_days=3,
+                up_threshold=0.015,
+                down_threshold=-0.015,
+            )
+
+            if len(X_tab) == 0:
+                logger.warning(f"  {stock_code}: 유효 샘플 없음")
+                continue
+
+            all_X_tabular.append(X_tab)
+            all_X_seq.append(X_seq)
+            all_y.append(y)
+
+            logger.info(f"  {stock_code}: {len(X_tab)}개 샘플 (UP:{np.sum(y==2)} HOLD:{np.sum(y==1)} DOWN:{np.sum(y==0)})")
+
+        except Exception as e:
+            logger.error(f"  {stock_code} 수집 실패: {e}")
+
+        await asyncio.sleep(3)
+
+    if not all_X_tabular:
+        return np.array([]), np.array([]), np.array([])
+
+    X_tabular = np.vstack(all_X_tabular)
+    X_seq = np.vstack(all_X_seq)
+    y = np.concatenate(all_y)
+
+    return X_tabular, X_seq, y
+
+
+async def get_stock_list_from_api(kis_api, limit: int = 50) -> list:
+    """거래량 상위 종목 조회 (KIS API)"""
+    stocks = []
+
+    try:
+        kospi = await kis_api.get_volume_rank("J")
+        if kospi and kospi.get("output"):
+            for item in kospi["output"]:
+                name = item.get("hts_kor_isnm", "")
+                skip_keywords = ["ETF", "레버리지", "인버스", "KODEX", "선물", "TIGER", "ARIRANG"]
+                if any(k in name for k in skip_keywords):
+                    continue
+                stocks.append((item["mksc_shrn_iscd"], name))
+    except Exception as e:
+        logger.error(f"KOSPI 종목 조회 실패: {e}")
+
+    await asyncio.sleep(3)
+
+    try:
+        kosdaq = await kis_api.get_volume_rank("Q")
+        if kosdaq and kosdaq.get("output"):
+            for item in kosdaq["output"]:
+                name = item.get("hts_kor_isnm", "")
+                skip_keywords = ["ETF", "레버리지", "인버스", "KODEX", "선물", "TIGER", "ARIRANG"]
+                if any(k in name for k in skip_keywords):
+                    continue
+                stocks.append((item["mksc_shrn_iscd"], name))
+    except Exception as e:
+        logger.error(f"KOSDAQ 종목 조회 실패: {e}")
+
+    logger.info(f"총 {len(stocks)}개 종목 조회 완료")
+    return stocks[:limit]
+
+
+# ─── 메인 ───
+
+async def main():
+    parser = argparse.ArgumentParser(description="앙상블 모델 학습")
+    parser.add_argument("--source", choices=["db", "api"], default="db",
+                        help="데이터 소스 (기본: db)")
+    parser.add_argument("--limit", type=int, default=200,
+                        help="학습 종목 수 (기본: 200)")
+    parser.add_argument("--test", action="store_true",
+                        help="테스트 모드 (10종목)")
+    parser.add_argument("--min-days", type=int, default=200,
+                        help="DB 모드: 최소 데이터 일수 (기본: 200)")
+    args = parser.parse_args()
+
+    limit = 10 if args.test else args.limit
+    logger.info(f"데이터 소스: {args.source.upper()}")
+    logger.info(f"{'테스트 모드' if args.test else '전체 학습'}: {limit}개 종목")
+
+    start_time = datetime.now()
+
+    # 데이터 수집
+    if args.source == "db":
+        logger.info("=" * 60)
+        logger.info("DB(stock_daily_prices)에서 학습 데이터 수집 중...")
+        X_tabular, X_seq, y = await collect_training_data_from_db(
+            limit=limit, min_days=args.min_days
+        )
+    else:
+        # KIS API 모드
+        from app.services.korea_investment_api import KoreaInvestmentAPI
+        kis_api = KoreaInvestmentAPI()
+
+        stock_list = await get_stock_list_from_api(kis_api, limit=limit)
+        if not stock_list:
+            logger.error("종목 리스트를 가져올 수 없습니다")
+            return
+
+        logger.info("=" * 60)
+        logger.info("KIS API에서 학습 데이터 수집 중...")
+        X_tabular, X_seq, y = await collect_training_data_from_api(stock_list, kis_api)
+
+    if len(X_tabular) == 0:
+        logger.error("학습 데이터가 없습니다")
+        return
+
+    logger.info(f"총 학습 데이터: {len(X_tabular):,}개 샘플")
+    logger.info(f"  클래스 분포: UP={np.sum(y==2):,}, HOLD={np.sum(y==1):,}, DOWN={np.sum(y==0):,}")
+
+    # 앙상블 학습
+    logger.info("=" * 60)
+    logger.info("앙상블 모델 학습 중...")
+    ensemble = MLEnsemble()
+    metrics = ensemble.train(X_tabular, X_seq, y)
+
+    # 결과 출력
+    duration = (datetime.now() - start_time).total_seconds()
+    logger.info("=" * 60)
+    logger.info("학습 완료!")
+    logger.info(f"  소요 시간: {duration:.1f}초 ({duration/60:.1f}분)")
+    logger.info(f"  학습 결과:")
+    for key, value in metrics.items():
+        logger.info(f"    {key}: {value}")
+    logger.info("=" * 60)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/clear_test_data.sh b/clear_test_data.sh
new file mode 100755
index 0000000..69f479f
--- /dev/null
+++ b/clear_test_data.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+# 테스트 데이터 강제 삭제 스크립트
+
+echo "🗑️ Deleting all test data from stock_analysis table..."
+
+docker exec -i autostock-postgres psql -U stock_admin -d stock << EOF
+DELETE FROM stock_analysis;
+DELETE FROM trade_history WHERE status IN ('PENDING', 'FAILED');
+DELETE FROM portfolio WHERE quantity <= 0;
+SELECT 'Cleanup completed. Remaining stock_analysis records: ' || COUNT(*) FROM stock_analysis;
+EOF
+
+echo "✅ Test data cleanup completed!"
diff --git a/docker-compose.dev.yml b/docker-compose.dev.yml
index a87ce03..407acd5 100644
--- a/docker-compose.dev.yml
+++ b/docker-compose.dev.yml
@@ -1,13 +1,12 @@
-version: '3'
 
 services:
   postgres:
     image: postgres:15-alpine
     container_name: autostock-postgres
     environment:
-      POSTGRES_USER: ${POSTGRES_USER}
-      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
-      POSTGRES_DB: ${POSTGRES_DB}
+      POSTGRES_USER: ${POSTGRES_USER:-stock}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-stock1234}
+      POSTGRES_DB: ${POSTGRES_DB:-stock}
     volumes:
       - postgres_data:/var/lib/postgresql/data
       - ./docker/init-db.sql:/docker-entrypoint-initdb.d/init.sql
@@ -30,8 +29,8 @@ services:
     image: rabbitmq:3-management-alpine
     container_name: autostock-rabbitmq
     environment:
-      RABBITMQ_DEFAULT_USER: ${RABBITMQ_DEFAULT_USER}
-      RABBITMQ_DEFAULT_PASS: ${RABBITMQ_DEFAULT_PASS}
+      RABBITMQ_DEFAULT_USER: ${RABBITMQ_DEFAULT_USER:-guest}
+      RABBITMQ_DEFAULT_PASS: ${RABBITMQ_DEFAULT_PASS:-guest}
     ports:
       - "5672:5672"
       - "15672:15672"
@@ -40,6 +39,72 @@ services:
     networks:
       - autostock-network
 
+  backend:
+    build:
+      context: ./backend
+      dockerfile: Dockerfile
+    container_name: autostock-backend
+    volumes:
+      - ./backend:/app
+    ports:
+      - "8090:8000"
+    environment:
+      - DATABASE_URL=postgresql://${POSTGRES_USER:-stock}:${POSTGRES_PASSWORD:-stock1234}@postgres:5432/${POSTGRES_DB:-stock}
+      - REDIS_URL=redis://redis:6379/0
+      - RABBITMQ_URL=amqp://${RABBITMQ_DEFAULT_USER:-guest}:${RABBITMQ_DEFAULT_PASS:-guest}@rabbitmq:5672/
+      - KIS_MODE=${KIS_MODE:-virtual}
+      - KIS_VIRTUAL_APP_KEY=${KIS_VIRTUAL_APP_KEY}
+      - KIS_VIRTUAL_APP_SECRET=${KIS_VIRTUAL_APP_SECRET}
+      - KIS_VIRTUAL_ACCOUNT_NO=${KIS_VIRTUAL_ACCOUNT_NO}
+      - KIS_VIRTUAL_URL=${KIS_VIRTUAL_URL:-https://openapivts.koreainvestment.com:29443}
+      - KIS_REAL_APP_KEY=${KIS_REAL_APP_KEY}
+      - KIS_REAL_APP_SECRET=${KIS_REAL_APP_SECRET}
+      - KIS_REAL_ACCOUNT_NO=${KIS_REAL_ACCOUNT_NO}
+      - KIS_REAL_URL=${KIS_REAL_URL:-https://openapi.koreainvestment.com:9443}
+      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
+      - MCP_SERVER_URL=http://mcp-server:8001
+    command: uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload
+    depends_on:
+      - postgres
+      - redis
+      - rabbitmq
+    networks:
+      - autostock-network
+
+  mcp-server:
+    build:
+      context: ./mcp-server
+      dockerfile: Dockerfile
+    container_name: autostock-mcp-server
+    volumes:
+      - ./mcp-server:/app
+    ports:
+      - "8001:8001"
+    environment:
+      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
+      - LOG_LEVEL=debug
+      - DATABASE_URL=postgresql://${POSTGRES_USER:-stock}:${POSTGRES_PASSWORD:-stock1234}@postgres:5432/${POSTGRES_DB:-stock}
+    command: uvicorn main:app --host 0.0.0.0 --port 8001 --reload
+    networks:
+      - autostock-network
+
+  frontend:
+    image: node:20-alpine
+    container_name: autostock-frontend
+    working_dir: /app
+    volumes:
+      - ./frontend:/app
+      - /app/node_modules
+    ports:
+      - "3000:3000"
+    environment:
+      - VITE_API_TARGET=http://backend:8000
+    command: sh -c "npm install && npm run dev"
+    depends_on:
+      - backend
+    networks:
+      - autostock-network
+
 volumes:
   postgres_data:
   redis_data:
diff --git a/docker-compose.yml b/docker-compose.yml
index 1132e73..09029db 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1,5 +1,3 @@
-version: '3.8'
-
 services:
   # PostgreSQL Database
   postgres:
@@ -92,16 +90,21 @@ services:
       - DATABASE_URL=${DATABASE_URL}
       - REDIS_URL=${REDIS_URL}
       - RABBITMQ_URL=${RABBITMQ_URL}
-      - KOREA_INVESTMENT_APP_KEY=${KOREA_INVESTMENT_APP_KEY}
-      - KOREA_INVESTMENT_APP_SECRET=${KOREA_INVESTMENT_APP_SECRET}
-      - KOREA_INVESTMENT_ACCOUNT_NUMBER=${KOREA_INVESTMENT_ACCOUNT_NUMBER}
-      - KOREA_INVESTMENT_API_BASE_URL=${KOREA_INVESTMENT_API_BASE_URL}
+      - KIS_MODE=${KIS_MODE:-virtual}
+      - KIS_VIRTUAL_APP_KEY=${KIS_VIRTUAL_APP_KEY}
+      - KIS_VIRTUAL_APP_SECRET=${KIS_VIRTUAL_APP_SECRET}
+      - KIS_VIRTUAL_ACCOUNT_NO=${KIS_VIRTUAL_ACCOUNT_NO}
+      - KIS_VIRTUAL_URL=${KIS_VIRTUAL_URL:-https://openapivts.koreainvestment.com:29443}
+      - KIS_REAL_APP_KEY=${KIS_REAL_APP_KEY}
+      - KIS_REAL_APP_SECRET=${KIS_REAL_APP_SECRET}
+      - KIS_REAL_ACCOUNT_NO=${KIS_REAL_ACCOUNT_NO}
+      - KIS_REAL_URL=${KIS_REAL_URL:-https://openapi.koreainvestment.com:9443}
       - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
       - SECRET_KEY=${SECRET_KEY}
       - BACKEND_HOST=${BACKEND_HOST}
       - BACKEND_PORT=${BACKEND_PORT}
       - MCP_SERVER_URL=http://mcp-server:8001
-      - NEWS_API_KEY=${NEWS_API_KEY}
+      - NEWS_API_KEY=${NEWS_API_KEY:-}
       - LOG_LEVEL=${LOG_LEVEL}
     ports:
       - "8000:8000"
diff --git a/API_DOCS.md b/docs/API_DOCS.md
similarity index 100%
rename from API_DOCS.md
rename to docs/API_DOCS.md
diff --git a/API_SAFE_OPERATION.md b/docs/API_SAFE_OPERATION.md
similarity index 100%
rename from API_SAFE_OPERATION.md
rename to docs/API_SAFE_OPERATION.md
diff --git a/docs/BATCH_ANALYSIS_GUIDE.md b/docs/BATCH_ANALYSIS_GUIDE.md
new file mode 100644
index 0000000..50750c8
--- /dev/null
+++ b/docs/BATCH_ANALYSIS_GUIDE.md
@@ -0,0 +1,116 @@
+# 배치 분석 가이드
+
+## 개요
+매일 아침 장 시작 전에 전체 종목을 분석하여 DB에 캐시합니다.
+이를 통해 대시보드 첫 진입 시 빠른 로딩이 가능합니다.
+
+## 수동 실행
+
+### 테스트 (10개 종목만)
+```bash
+cd backend
+../.venv/bin/python batch_daily_analysis.py --test
+```
+
+### 제한된 개수 분석
+```bash
+cd backend
+../.venv/bin/python batch_daily_analysis.py --limit 30
+```
+
+### 전체 분석
+```bash
+cd backend
+../.venv/bin/python batch_daily_analysis.py
+```
+
+## 자동 실행 (Cron)
+
+### Cron Job 설정
+```bash
+./setup-cron.sh
+```
+
+이 스크립트는:
+- 매일 평일(월~금) 오전 8시 50분에 배치 분석 실행
+- 장 시작 전(9시) 데이터를 준비
+- 로그는 `logs/batch_analysis.log`에 저장
+
+### Cron Job 확인
+```bash
+crontab -l | grep batch_daily_analysis
+```
+
+### Cron Job 제거
+```bash
+crontab -e
+# 해당 라인 삭제 후 저장
+```
+
+## 로그 확인
+
+### 실시간 로그 보기
+```bash
+tail -f logs/batch_analysis.log
+```
+
+### 최근 로그 확인
+```bash
+tail -100 logs/batch_analysis.log
+```
+
+## 동작 방식
+
+1. **8:50 AM**: Cron이 배치 스크립트 실행
+2. **종목 조회**: KOSPI + KOSDAQ 거래량 상위 종목
+3. **기술적 분석**: 각 종목의 RSI, MA, 볼린저 밴드 등 계산
+4. **DB 저장**: `stock_analysis` 테이블에 저장
+5. **9:00 AM**: 장 시작
+6. **첫 진입**: DB에서 캐시된 데이터를 빠르게 로드 (1초 이내)
+
+## API 제한 대응
+
+한국투자증권 API는 다음 제한이 있습니다:
+- 토큰 발급: 1분에 1회
+- API 호출: 초당 2회 권장
+
+배치 스크립트는:
+- 각 종목 분석 후 2초 대기
+- API 에러 시 자동 재시도 (최대 3회)
+- 지수 백오프로 대기 시간 증가
+
+## 예상 소요 시간
+
+- 10개 종목: 약 30초
+- 30개 종목: 약 2분
+- 60개 종목 (전체): 약 4분
+
+## 문제 해결
+
+### Cron이 실행되지 않음
+```bash
+# Cron 데몬 상태 확인 (macOS)
+sudo launchctl list | grep cron
+
+# Cron 데몬 시작 (macOS)
+sudo launchctl start com.vix.cron
+```
+
+### API 토큰 에러
+로그에 "접근토큰 발급 잠시 후 다시 시도하세요" 메시지가 반복되면:
+- 배치 스크립트가 너무 빨리 실행됨
+- `batch_daily_analysis.py`의 `await asyncio.sleep(2)` 값을 3~5초로 증가
+
+### DB 연결 에러
+```bash
+# PostgreSQL 실행 확인
+pg_isready -h localhost -p 5432
+
+# 서비스 시작
+./start-all.sh
+```
+
+## 참고
+- 배치 분석은 선택사항입니다
+- 실행하지 않아도 첫 진입 시 실시간 분석이 자동으로 수행됩니다
+- 다만 실시간 분석은 10~30초 소요됩니다
diff --git a/BATCH_GUIDE.md b/docs/BATCH_GUIDE.md
similarity index 100%
rename from BATCH_GUIDE.md
rename to docs/BATCH_GUIDE.md
diff --git a/INSTALLATION.md b/docs/INSTALLATION.md
similarity index 100%
rename from INSTALLATION.md
rename to docs/INSTALLATION.md
diff --git a/PROJECT_STRUCTURE.md b/docs/PROJECT_STRUCTURE.md
similarity index 100%
rename from PROJECT_STRUCTURE.md
rename to docs/PROJECT_STRUCTURE.md
diff --git a/USER_GUIDE.md b/docs/USER_GUIDE.md
similarity index 100%
rename from USER_GUIDE.md
rename to docs/USER_GUIDE.md
diff --git a/backend/README.md b/docs/backend_guide.md
similarity index 100%
rename from backend/README.md
rename to docs/backend_guide.md
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 3bee811..eff4633 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -12,6 +12,7 @@
         "axios": "^1.6.2",
         "clsx": "^2.0.0",
         "date-fns": "^2.30.0",
+        "lightweight-charts": "^4.2.0",
         "lucide-react": "^0.294.0",
         "react": "^18.2.0",
         "react-dom": "^18.2.0",
@@ -21,8 +22,8 @@
       },
       "devDependencies": {
         "@types/node": "^24.10.0",
-        "@types/react": "^18.2.43",
-        "@types/react-dom": "^18.2.17",
+        "@types/react": "^18.3.26",
+        "@types/react-dom": "^18.3.7",
         "@typescript-eslint/eslint-plugin": "^6.14.0",
         "@typescript-eslint/parser": "^6.14.0",
         "@vitejs/plugin-react": "^4.2.1",
@@ -32,8 +33,8 @@
         "eslint-plugin-react-refresh": "^0.4.5",
         "postcss": "^8.4.32",
         "tailwindcss": "^3.3.6",
-        "typescript": "^5.2.2",
-        "vite": "^5.0.8"
+        "typescript": "^5.9.3",
+        "vite": "^7.2.2"
       }
     },
     "node_modules/@alloc/quick-lru": {
@@ -50,13 +51,13 @@
       }
     },
     "node_modules/@babel/code-frame": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
-      "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz",
+      "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-validator-identifier": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5",
         "js-tokens": "^4.0.0",
         "picocolors": "^1.1.1"
       },
@@ -65,9 +66,9 @@
       }
     },
     "node_modules/@babel/compat-data": {
-      "version": "7.28.5",
-      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.28.5.tgz",
-      "integrity": "sha512-6uFXyCayocRbqhZOB+6XcuZbkMNimwfVGFji8CTZnCzOHVGvDqzvitu1re2AU5LROliz7eQPhB8CpAMvnx9EjA==",
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz",
+      "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -75,21 +76,21 @@
       }
     },
     "node_modules/@babel/core": {
-      "version": "7.28.5",
-      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.5.tgz",
-      "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz",
+      "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.27.1",
-        "@babel/generator": "^7.28.5",
-        "@babel/helper-compilation-targets": "^7.27.2",
-        "@babel/helper-module-transforms": "^7.28.3",
-        "@babel/helpers": "^7.28.4",
-        "@babel/parser": "^7.28.5",
-        "@babel/template": "^7.27.2",
-        "@babel/traverse": "^7.28.5",
-        "@babel/types": "^7.28.5",
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-module-transforms": "^7.28.6",
+        "@babel/helpers": "^7.28.6",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/traverse": "^7.29.0",
+        "@babel/types": "^7.29.0",
         "@jridgewell/remapping": "^2.3.5",
         "convert-source-map": "^2.0.0",
         "debug": "^4.1.0",
@@ -116,14 +117,14 @@
       }
     },
     "node_modules/@babel/generator": {
-      "version": "7.28.5",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.5.tgz",
-      "integrity": "sha512-3EwLFhZ38J4VyIP6WNtt2kUdW9dokXA9Cr4IVIFHuCpZ3H8/YFOl5JjZHisrn1fATPBmKKqXzDFvh9fUwHz6CQ==",
+      "version": "7.29.1",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz",
+      "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/parser": "^7.28.5",
-        "@babel/types": "^7.28.5",
+        "@babel/parser": "^7.29.0",
+        "@babel/types": "^7.29.0",
         "@jridgewell/gen-mapping": "^0.3.12",
         "@jridgewell/trace-mapping": "^0.3.28",
         "jsesc": "^3.0.2"
@@ -133,13 +134,13 @@
       }
     },
     "node_modules/@babel/helper-compilation-targets": {
-      "version": "7.27.2",
-      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.2.tgz",
-      "integrity": "sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==",
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz",
+      "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/compat-data": "^7.27.2",
+        "@babel/compat-data": "^7.28.6",
         "@babel/helper-validator-option": "^7.27.1",
         "browserslist": "^4.24.0",
         "lru-cache": "^5.1.1",
@@ -170,29 +171,29 @@
       }
     },
     "node_modules/@babel/helper-module-imports": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz",
-      "integrity": "sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==",
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz",
+      "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/traverse": "^7.27.1",
-        "@babel/types": "^7.27.1"
+        "@babel/traverse": "^7.28.6",
+        "@babel/types": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-module-transforms": {
-      "version": "7.28.3",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.3.tgz",
-      "integrity": "sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw==",
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz",
+      "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-module-imports": "^7.27.1",
-        "@babel/helper-validator-identifier": "^7.27.1",
-        "@babel/traverse": "^7.28.3"
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/traverse": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -202,9 +203,9 @@
       }
     },
     "node_modules/@babel/helper-plugin-utils": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz",
-      "integrity": "sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==",
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz",
+      "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -242,27 +243,27 @@
       }
     },
     "node_modules/@babel/helpers": {
-      "version": "7.28.4",
-      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.4.tgz",
-      "integrity": "sha512-HFN59MmQXGHVyYadKLVumYsA9dBFun/ldYxipEjzA4196jpLZd8UjEEBLkbEkvfYreDqJhZxYAWFPtrfhNpj4w==",
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.6.tgz",
+      "integrity": "sha512-xOBvwq86HHdB7WUDTfKfT/Vuxh7gElQ+Sfti2Cy6yIWNW05P8iUslOVcZ4/sKbE+/jQaukQAdz/gf3724kYdqw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/template": "^7.27.2",
-        "@babel/types": "^7.28.4"
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/parser": {
-      "version": "7.28.5",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.5.tgz",
-      "integrity": "sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==",
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.0.tgz",
+      "integrity": "sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/types": "^7.28.5"
+        "@babel/types": "^7.29.0"
       },
       "bin": {
         "parser": "bin/babel-parser.js"
@@ -304,42 +305,42 @@
       }
     },
     "node_modules/@babel/runtime": {
-      "version": "7.28.4",
-      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.4.tgz",
-      "integrity": "sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==",
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.6.tgz",
+      "integrity": "sha512-05WQkdpL9COIMz4LjTxGpPNCdlpyimKppYNoJ5Di5EUObifl8t4tuLuUBBZEpoLYOmfvIWrsp9fCl0HoPRVTdA==",
       "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/template": {
-      "version": "7.27.2",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.2.tgz",
-      "integrity": "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==",
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz",
+      "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.27.1",
-        "@babel/parser": "^7.27.2",
-        "@babel/types": "^7.27.1"
+        "@babel/code-frame": "^7.28.6",
+        "@babel/parser": "^7.28.6",
+        "@babel/types": "^7.28.6"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/traverse": {
-      "version": "7.28.5",
-      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.5.tgz",
-      "integrity": "sha512-TCCj4t55U90khlYkVV/0TfkJkAkUg3jZFA3Neb7unZT8CPok7iiRfaX0F+WnqWqt7OxhOn0uBKXCw4lbL8W0aQ==",
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz",
+      "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.27.1",
-        "@babel/generator": "^7.28.5",
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
         "@babel/helper-globals": "^7.28.0",
-        "@babel/parser": "^7.28.5",
-        "@babel/template": "^7.27.2",
-        "@babel/types": "^7.28.5",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0",
         "debug": "^4.3.1"
       },
       "engines": {
@@ -347,9 +348,9 @@
       }
     },
     "node_modules/@babel/types": {
-      "version": "7.28.5",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.5.tgz",
-      "integrity": "sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==",
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz",
+      "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -361,9 +362,9 @@
       }
     },
     "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.3.tgz",
+      "integrity": "sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg==",
       "cpu": [
         "ppc64"
       ],
@@ -374,13 +375,13 @@
         "aix"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/android-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
-      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.3.tgz",
+      "integrity": "sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA==",
       "cpu": [
         "arm"
       ],
@@ -391,13 +392,13 @@
         "android"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/android-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
-      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.3.tgz",
+      "integrity": "sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==",
       "cpu": [
         "arm64"
       ],
@@ -408,13 +409,13 @@
         "android"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/android-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
-      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.3.tgz",
+      "integrity": "sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==",
       "cpu": [
         "x64"
       ],
@@ -425,13 +426,13 @@
         "android"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
-      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.3.tgz",
+      "integrity": "sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==",
       "cpu": [
         "arm64"
       ],
@@ -442,13 +443,13 @@
         "darwin"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/darwin-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
-      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.3.tgz",
+      "integrity": "sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==",
       "cpu": [
         "x64"
       ],
@@ -459,13 +460,13 @@
         "darwin"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
-      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.3.tgz",
+      "integrity": "sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==",
       "cpu": [
         "arm64"
       ],
@@ -476,13 +477,13 @@
         "freebsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
-      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.3.tgz",
+      "integrity": "sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA==",
       "cpu": [
         "x64"
       ],
@@ -493,13 +494,13 @@
         "freebsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
-      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.3.tgz",
+      "integrity": "sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==",
       "cpu": [
         "arm"
       ],
@@ -510,13 +511,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
-      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.3.tgz",
+      "integrity": "sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg==",
       "cpu": [
         "arm64"
       ],
@@ -527,13 +528,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
-      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.3.tgz",
+      "integrity": "sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==",
       "cpu": [
         "ia32"
       ],
@@ -544,13 +545,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-loong64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
-      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.3.tgz",
+      "integrity": "sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA==",
       "cpu": [
         "loong64"
       ],
@@ -561,13 +562,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
-      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.3.tgz",
+      "integrity": "sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==",
       "cpu": [
         "mips64el"
       ],
@@ -578,13 +579,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.3.tgz",
+      "integrity": "sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA==",
       "cpu": [
         "ppc64"
       ],
@@ -595,13 +596,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
-      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.3.tgz",
+      "integrity": "sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ==",
       "cpu": [
         "riscv64"
       ],
@@ -612,13 +613,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-s390x": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
-      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.3.tgz",
+      "integrity": "sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==",
       "cpu": [
         "s390x"
       ],
@@ -629,13 +630,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
-      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.3.tgz",
+      "integrity": "sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA==",
       "cpu": [
         "x64"
       ],
@@ -646,13 +647,30 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.3.tgz",
+      "integrity": "sha512-sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.3.tgz",
+      "integrity": "sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==",
       "cpu": [
         "x64"
       ],
@@ -663,13 +681,30 @@
         "netbsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.3.tgz",
+      "integrity": "sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.3.tgz",
+      "integrity": "sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ==",
       "cpu": [
         "x64"
       ],
@@ -680,13 +715,30 @@
         "openbsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.3.tgz",
+      "integrity": "sha512-NinAEgr/etERPTsZJ7aEZQvvg/A6IsZG/LgZy+81wON2huV7SrK3e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/sunos-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
-      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.3.tgz",
+      "integrity": "sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==",
       "cpu": [
         "x64"
       ],
@@ -697,13 +749,13 @@
         "sunos"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/win32-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
-      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.3.tgz",
+      "integrity": "sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==",
       "cpu": [
         "arm64"
       ],
@@ -714,13 +766,13 @@
         "win32"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/win32-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
-      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.3.tgz",
+      "integrity": "sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==",
       "cpu": [
         "ia32"
       ],
@@ -731,13 +783,13 @@
         "win32"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/win32-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
-      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.3.tgz",
+      "integrity": "sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==",
       "cpu": [
         "x64"
       ],
@@ -748,13 +800,13 @@
         "win32"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@eslint-community/eslint-utils": {
-      "version": "4.9.0",
-      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.0.tgz",
-      "integrity": "sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==",
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz",
+      "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -900,53 +952,6 @@
       "dev": true,
       "license": "BSD-3-Clause"
     },
-    "node_modules/@isaacs/cliui": {
-      "version": "8.0.2",
-      "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
-      "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "string-width": "^5.1.2",
-        "string-width-cjs": "npm:string-width@^4.2.0",
-        "strip-ansi": "^7.0.1",
-        "strip-ansi-cjs": "npm:strip-ansi@^6.0.1",
-        "wrap-ansi": "^8.1.0",
-        "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@isaacs/cliui/node_modules/ansi-regex": {
-      "version": "6.2.2",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz",
-      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
-      }
-    },
-    "node_modules/@isaacs/cliui/node_modules/strip-ansi": {
-      "version": "7.1.2",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.2.tgz",
-      "integrity": "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
-      }
-    },
     "node_modules/@jridgewell/gen-mapping": {
       "version": "0.3.13",
       "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
@@ -1035,21 +1040,10 @@
         "node": ">= 8"
       }
     },
-    "node_modules/@pkgjs/parseargs": {
-      "version": "0.11.0",
-      "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
-      "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "engines": {
-        "node": ">=14"
-      }
-    },
     "node_modules/@remix-run/router": {
-      "version": "1.23.0",
-      "resolved": "https://registry.npmjs.org/@remix-run/router/-/router-1.23.0.tgz",
-      "integrity": "sha512-O3rHJzAQKamUz1fvE0Qaw0xSFqsA/yafi2iqeE0pvdFtCO1viYx8QL6f3Ln/aCCTLxs68SLf0KPM9eSeM8yBnA==",
+      "version": "1.23.2",
+      "resolved": "https://registry.npmjs.org/@remix-run/router/-/router-1.23.2.tgz",
+      "integrity": "sha512-Ic6m2U/rMjTkhERIa/0ZtXJP17QUi2CbWE7cqx4J58M8aA3QTfW+2UlQ4psvTX9IO1RfNVhK3pcpdjej7L+t2w==",
       "license": "MIT",
       "engines": {
         "node": ">=14.0.0"
@@ -1063,9 +1057,9 @@
       "license": "MIT"
     },
     "node_modules/@rollup/rollup-android-arm-eabi": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.52.5.tgz",
-      "integrity": "sha512-8c1vW4ocv3UOMp9K+gToY5zL2XiiVw3k7f1ksf4yO1FlDFQ1C2u72iACFnSOceJFsWskc2WZNqeRhFRPzv+wtQ==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.57.1.tgz",
+      "integrity": "sha512-A6ehUVSiSaaliTxai040ZpZ2zTevHYbvu/lDoeAteHI8QnaosIzm4qwtezfRg1jOYaUmnzLX1AOD6Z+UJjtifg==",
       "cpu": [
         "arm"
       ],
@@ -1077,9 +1071,9 @@
       ]
     },
     "node_modules/@rollup/rollup-android-arm64": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.52.5.tgz",
-      "integrity": "sha512-mQGfsIEFcu21mvqkEKKu2dYmtuSZOBMmAl5CFlPGLY94Vlcm+zWApK7F/eocsNzp8tKmbeBP8yXyAbx0XHsFNA==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.57.1.tgz",
+      "integrity": "sha512-dQaAddCY9YgkFHZcFNS/606Exo8vcLHwArFZ7vxXq4rigo2bb494/xKMMwRRQW6ug7Js6yXmBZhSBRuBvCCQ3w==",
       "cpu": [
         "arm64"
       ],
@@ -1091,9 +1085,9 @@
       ]
     },
     "node_modules/@rollup/rollup-darwin-arm64": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.52.5.tgz",
-      "integrity": "sha512-takF3CR71mCAGA+v794QUZ0b6ZSrgJkArC+gUiG6LB6TQty9T0Mqh3m2ImRBOxS2IeYBo4lKWIieSvnEk2OQWA==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.57.1.tgz",
+      "integrity": "sha512-crNPrwJOrRxagUYeMn/DZwqN88SDmwaJ8Cvi/TN1HnWBU7GwknckyosC2gd0IqYRsHDEnXf328o9/HC6OkPgOg==",
       "cpu": [
         "arm64"
       ],
@@ -1105,9 +1099,9 @@
       ]
     },
     "node_modules/@rollup/rollup-darwin-x64": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.52.5.tgz",
-      "integrity": "sha512-W901Pla8Ya95WpxDn//VF9K9u2JbocwV/v75TE0YIHNTbhqUTv9w4VuQ9MaWlNOkkEfFwkdNhXgcLqPSmHy0fA==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.57.1.tgz",
+      "integrity": "sha512-Ji8g8ChVbKrhFtig5QBV7iMaJrGtpHelkB3lsaKzadFBe58gmjfGXAOfI5FV0lYMH8wiqsxKQ1C9B0YTRXVy4w==",
       "cpu": [
         "x64"
       ],
@@ -1119,9 +1113,9 @@
       ]
     },
     "node_modules/@rollup/rollup-freebsd-arm64": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.52.5.tgz",
-      "integrity": "sha512-QofO7i7JycsYOWxe0GFqhLmF6l1TqBswJMvICnRUjqCx8b47MTo46W8AoeQwiokAx3zVryVnxtBMcGcnX12LvA==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.57.1.tgz",
+      "integrity": "sha512-R+/WwhsjmwodAcz65guCGFRkMb4gKWTcIeLy60JJQbXrJ97BOXHxnkPFrP+YwFlaS0m+uWJTstrUA9o+UchFug==",
       "cpu": [
         "arm64"
       ],
@@ -1133,9 +1127,9 @@
       ]
     },
     "node_modules/@rollup/rollup-freebsd-x64": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.52.5.tgz",
-      "integrity": "sha512-jr21b/99ew8ujZubPo9skbrItHEIE50WdV86cdSoRkKtmWa+DDr6fu2c/xyRT0F/WazZpam6kk7IHBerSL7LDQ==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.57.1.tgz",
+      "integrity": "sha512-IEQTCHeiTOnAUC3IDQdzRAGj3jOAYNr9kBguI7MQAAZK3caezRrg0GxAb6Hchg4lxdZEI5Oq3iov/w/hnFWY9Q==",
       "cpu": [
         "x64"
       ],
@@ -1147,9 +1141,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.52.5.tgz",
-      "integrity": "sha512-PsNAbcyv9CcecAUagQefwX8fQn9LQ4nZkpDboBOttmyffnInRy8R8dSg6hxxl2Re5QhHBf6FYIDhIj5v982ATQ==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.57.1.tgz",
+      "integrity": "sha512-F8sWbhZ7tyuEfsmOxwc2giKDQzN3+kuBLPwwZGyVkLlKGdV1nvnNwYD0fKQ8+XS6hp9nY7B+ZeK01EBUE7aHaw==",
       "cpu": [
         "arm"
       ],
@@ -1161,9 +1155,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-arm-musleabihf": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.52.5.tgz",
-      "integrity": "sha512-Fw4tysRutyQc/wwkmcyoqFtJhh0u31K+Q6jYjeicsGJJ7bbEq8LwPWV/w0cnzOqR2m694/Af6hpFayLJZkG2VQ==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.57.1.tgz",
+      "integrity": "sha512-rGfNUfn0GIeXtBP1wL5MnzSj98+PZe/AXaGBCRmT0ts80lU5CATYGxXukeTX39XBKsxzFpEeK+Mrp9faXOlmrw==",
       "cpu": [
         "arm"
       ],
@@ -1175,9 +1169,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-arm64-gnu": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.52.5.tgz",
-      "integrity": "sha512-a+3wVnAYdQClOTlyapKmyI6BLPAFYs0JM8HRpgYZQO02rMR09ZcV9LbQB+NL6sljzG38869YqThrRnfPMCDtZg==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.57.1.tgz",
+      "integrity": "sha512-MMtej3YHWeg/0klK2Qodf3yrNzz6CGjo2UntLvk2RSPlhzgLvYEB3frRvbEF2wRKh1Z2fDIg9KRPe1fawv7C+g==",
       "cpu": [
         "arm64"
       ],
@@ -1189,9 +1183,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-arm64-musl": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.52.5.tgz",
-      "integrity": "sha512-AvttBOMwO9Pcuuf7m9PkC1PUIKsfaAJ4AYhy944qeTJgQOqJYJ9oVl2nYgY7Rk0mkbsuOpCAYSs6wLYB2Xiw0Q==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.57.1.tgz",
+      "integrity": "sha512-1a/qhaaOXhqXGpMFMET9VqwZakkljWHLmZOX48R0I/YLbhdxr1m4gtG1Hq7++VhVUmf+L3sTAf9op4JlhQ5u1Q==",
       "cpu": [
         "arm64"
       ],
@@ -1203,9 +1197,23 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-loong64-gnu": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.52.5.tgz",
-      "integrity": "sha512-DkDk8pmXQV2wVrF6oq5tONK6UHLz/XcEVow4JTTerdeV1uqPeHxwcg7aFsfnSm9L+OO8WJsWotKM2JJPMWrQtA==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.57.1.tgz",
+      "integrity": "sha512-QWO6RQTZ/cqYtJMtxhkRkidoNGXc7ERPbZN7dVW5SdURuLeVU7lwKMpo18XdcmpWYd0qsP1bwKPf7DNSUinhvA==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.57.1.tgz",
+      "integrity": "sha512-xpObYIf+8gprgWaPP32xiN5RVTi/s5FCR+XMXSKmhfoJjrpRAjCuuqQXyxUa/eJTdAE6eJ+KDKaoEqjZQxh3Gw==",
       "cpu": [
         "loong64"
       ],
@@ -1217,9 +1225,23 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-ppc64-gnu": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.52.5.tgz",
-      "integrity": "sha512-W/b9ZN/U9+hPQVvlGwjzi+Wy4xdoH2I8EjaCkMvzpI7wJUs8sWJ03Rq96jRnHkSrcHTpQe8h5Tg3ZzUPGauvAw==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.57.1.tgz",
+      "integrity": "sha512-4BrCgrpZo4hvzMDKRqEaW1zeecScDCR+2nZ86ATLhAoJ5FQ+lbHVD3ttKe74/c7tNT9c6F2viwB3ufwp01Oh2w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.57.1.tgz",
+      "integrity": "sha512-NOlUuzesGauESAyEYFSe3QTUguL+lvrN1HtwEEsU2rOwdUDeTMJdO5dUYl/2hKf9jWydJrO9OL/XSSf65R5+Xw==",
       "cpu": [
         "ppc64"
       ],
@@ -1231,9 +1253,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-riscv64-gnu": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.52.5.tgz",
-      "integrity": "sha512-sjQLr9BW7R/ZiXnQiWPkErNfLMkkWIoCz7YMn27HldKsADEKa5WYdobaa1hmN6slu9oWQbB6/jFpJ+P2IkVrmw==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.57.1.tgz",
+      "integrity": "sha512-ptA88htVp0AwUUqhVghwDIKlvJMD/fmL/wrQj99PRHFRAG6Z5nbWoWG4o81Nt9FT+IuqUQi+L31ZKAFeJ5Is+A==",
       "cpu": [
         "riscv64"
       ],
@@ -1245,9 +1267,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-riscv64-musl": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.52.5.tgz",
-      "integrity": "sha512-hq3jU/kGyjXWTvAh2awn8oHroCbrPm8JqM7RUpKjalIRWWXE01CQOf/tUNWNHjmbMHg/hmNCwc/Pz3k1T/j/Lg==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.57.1.tgz",
+      "integrity": "sha512-S51t7aMMTNdmAMPpBg7OOsTdn4tySRQvklmL3RpDRyknk87+Sp3xaumlatU+ppQ+5raY7sSTcC2beGgvhENfuw==",
       "cpu": [
         "riscv64"
       ],
@@ -1259,9 +1281,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-s390x-gnu": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.52.5.tgz",
-      "integrity": "sha512-gn8kHOrku8D4NGHMK1Y7NA7INQTRdVOntt1OCYypZPRt6skGbddska44K8iocdpxHTMMNui5oH4elPH4QOLrFQ==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.57.1.tgz",
+      "integrity": "sha512-Bl00OFnVFkL82FHbEqy3k5CUCKH6OEJL54KCyx2oqsmZnFTR8IoNqBF+mjQVcRCT5sB6yOvK8A37LNm/kPJiZg==",
       "cpu": [
         "s390x"
       ],
@@ -1273,9 +1295,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-x64-gnu": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.52.5.tgz",
-      "integrity": "sha512-hXGLYpdhiNElzN770+H2nlx+jRog8TyynpTVzdlc6bndktjKWyZyiCsuDAlpd+j+W+WNqfcyAWz9HxxIGfZm1Q==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.57.1.tgz",
+      "integrity": "sha512-ABca4ceT4N+Tv/GtotnWAeXZUZuM/9AQyCyKYyKnpk4yoA7QIAuBt6Hkgpw8kActYlew2mvckXkvx0FfoInnLg==",
       "cpu": [
         "x64"
       ],
@@ -1287,9 +1309,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-x64-musl": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.52.5.tgz",
-      "integrity": "sha512-arCGIcuNKjBoKAXD+y7XomR9gY6Mw7HnFBv5Rw7wQRvwYLR7gBAgV7Mb2QTyjXfTveBNFAtPt46/36vV9STLNg==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.57.1.tgz",
+      "integrity": "sha512-HFps0JeGtuOR2convgRRkHCekD7j+gdAuXM+/i6kGzQtFhlCtQkpwtNzkNj6QhCDp7DRJ7+qC/1Vg2jt5iSOFw==",
       "cpu": [
         "x64"
       ],
@@ -1300,10 +1322,24 @@
         "linux"
       ]
     },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.57.1.tgz",
+      "integrity": "sha512-H+hXEv9gdVQuDTgnqD+SQffoWoc0Of59AStSzTEj/feWTBAnSfSD3+Dql1ZruJQxmykT/JVY0dE8Ka7z0DH1hw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
     "node_modules/@rollup/rollup-openharmony-arm64": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.52.5.tgz",
-      "integrity": "sha512-QoFqB6+/9Rly/RiPjaomPLmR/13cgkIGfA40LHly9zcH1S0bN2HVFYk3a1eAyHQyjs3ZJYlXvIGtcCs5tko9Cw==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.57.1.tgz",
+      "integrity": "sha512-4wYoDpNg6o/oPximyc/NG+mYUejZrCU2q+2w6YZqrAs2UcNUChIZXjtafAiiZSUc7On8v5NyNj34Kzj/Ltk6dQ==",
       "cpu": [
         "arm64"
       ],
@@ -1315,9 +1351,9 @@
       ]
     },
     "node_modules/@rollup/rollup-win32-arm64-msvc": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.52.5.tgz",
-      "integrity": "sha512-w0cDWVR6MlTstla1cIfOGyl8+qb93FlAVutcor14Gf5Md5ap5ySfQ7R9S/NjNaMLSFdUnKGEasmVnu3lCMqB7w==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.57.1.tgz",
+      "integrity": "sha512-O54mtsV/6LW3P8qdTcamQmuC990HDfR71lo44oZMZlXU4tzLrbvTii87Ni9opq60ds0YzuAlEr/GNwuNluZyMQ==",
       "cpu": [
         "arm64"
       ],
@@ -1329,9 +1365,9 @@
       ]
     },
     "node_modules/@rollup/rollup-win32-ia32-msvc": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.52.5.tgz",
-      "integrity": "sha512-Aufdpzp7DpOTULJCuvzqcItSGDH73pF3ko/f+ckJhxQyHtp67rHw3HMNxoIdDMUITJESNE6a8uh4Lo4SLouOUg==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.57.1.tgz",
+      "integrity": "sha512-P3dLS+IerxCT/7D2q2FYcRdWRl22dNbrbBEtxdWhXrfIMPP9lQhb5h4Du04mdl5Woq05jVCDPCMF7Ub0NAjIew==",
       "cpu": [
         "ia32"
       ],
@@ -1343,9 +1379,9 @@
       ]
     },
     "node_modules/@rollup/rollup-win32-x64-gnu": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.52.5.tgz",
-      "integrity": "sha512-UGBUGPFp1vkj6p8wCRraqNhqwX/4kNQPS57BCFc8wYh0g94iVIW33wJtQAx3G7vrjjNtRaxiMUylM0ktp/TRSQ==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.57.1.tgz",
+      "integrity": "sha512-VMBH2eOOaKGtIJYleXsi2B8CPVADrh+TyNxJ4mWPnKfLB/DBUmzW+5m1xUrcwWoMfSLagIRpjUFeW5CO5hyciQ==",
       "cpu": [
         "x64"
       ],
@@ -1357,9 +1393,9 @@
       ]
     },
     "node_modules/@rollup/rollup-win32-x64-msvc": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.52.5.tgz",
-      "integrity": "sha512-TAcgQh2sSkykPRWLrdyy2AiceMckNf5loITqXxFI5VuQjS5tSuw3WlwdN8qv8vzjLAUTvYaH/mVjSFpbkFbpTg==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.57.1.tgz",
+      "integrity": "sha512-mxRFDdHIWRxg3UfIIAwCm6NzvxG0jDX/wBN6KsQFTvKFqqg9vTrWUE68qEjHt19A5wwx5X5aUi2zuZT7YR0jrA==",
       "cpu": [
         "x64"
       ],
@@ -1371,9 +1407,9 @@
       ]
     },
     "node_modules/@tanstack/query-core": {
-      "version": "5.90.6",
-      "resolved": "https://registry.npmjs.org/@tanstack/query-core/-/query-core-5.90.6.tgz",
-      "integrity": "sha512-AnZSLF26R8uX+tqb/ivdrwbVdGemdEDm1Q19qM6pry6eOZ6bEYiY7mWhzXT1YDIPTNEVcZ5kYP9nWjoxDLiIVw==",
+      "version": "5.90.20",
+      "resolved": "https://registry.npmjs.org/@tanstack/query-core/-/query-core-5.90.20.tgz",
+      "integrity": "sha512-OMD2HLpNouXEfZJWcKeVKUgQ5n+n3A2JFmBaScpNDUqSrQSjiveC7dKMe53uJUg1nDG16ttFPz2xfilz6i2uVg==",
       "license": "MIT",
       "funding": {
         "type": "github",
@@ -1381,12 +1417,12 @@
       }
     },
     "node_modules/@tanstack/react-query": {
-      "version": "5.90.6",
-      "resolved": "https://registry.npmjs.org/@tanstack/react-query/-/react-query-5.90.6.tgz",
-      "integrity": "sha512-gB1sljYjcobZKxjPbKSa31FUTyr+ROaBdoH+wSSs9Dk+yDCmMs+TkTV3PybRRVLC7ax7q0erJ9LvRWnMktnRAw==",
+      "version": "5.90.21",
+      "resolved": "https://registry.npmjs.org/@tanstack/react-query/-/react-query-5.90.21.tgz",
+      "integrity": "sha512-0Lu6y5t+tvlTJMTO7oh5NSpJfpg/5D41LlThfepTixPYkJ0sE2Jj0m0f6yYqujBwIXlId87e234+MxG3D3g7kg==",
       "license": "MIT",
       "dependencies": {
-        "@tanstack/query-core": "5.90.6"
+        "@tanstack/query-core": "5.90.20"
       },
       "funding": {
         "type": "github",
@@ -1484,9 +1520,9 @@
       }
     },
     "node_modules/@types/d3-shape": {
-      "version": "3.1.7",
-      "resolved": "https://registry.npmjs.org/@types/d3-shape/-/d3-shape-3.1.7.tgz",
-      "integrity": "sha512-VLvUQ33C+3J+8p+Daf+nYSOsjB4GXp19/S/aGo60m9h1v6XaxjiT82lKVWJCfzhtuZ3yD7i/TPeC/fuKLLOSmg==",
+      "version": "3.1.8",
+      "resolved": "https://registry.npmjs.org/@types/d3-shape/-/d3-shape-3.1.8.tgz",
+      "integrity": "sha512-lae0iWfcDeR7qt7rA88BNiqdvPS5pFVPpo5OfjElwNaT2yyekbM0C9vK+yqBqEmHr6lDkRnYNoTBYlAgJa7a4w==",
       "license": "MIT",
       "dependencies": {
         "@types/d3-path": "*"
@@ -1519,9 +1555,9 @@
       "license": "MIT"
     },
     "node_modules/@types/node": {
-      "version": "24.10.0",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.10.0.tgz",
-      "integrity": "sha512-qzQZRBqkFsYyaSWXuEHc2WR9c0a0CXwiE5FWUvn7ZM+vdy1uZLfCunD38UzhuB7YN/J11ndbDBcTmOdxJo9Q7A==",
+      "version": "24.10.13",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.10.13.tgz",
+      "integrity": "sha512-oH72nZRfDv9lADUBSo104Aq7gPHpQZc4BTx38r9xf9pg5LfP6EzSyH2n7qFmmxRQXh7YlUXODcYsg6PuTDSxGg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -1536,14 +1572,14 @@
       "license": "MIT"
     },
     "node_modules/@types/react": {
-      "version": "18.3.26",
-      "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.26.tgz",
-      "integrity": "sha512-RFA/bURkcKzx/X9oumPG9Vp3D3JUgus/d0b67KB0t5S/raciymilkOa66olh78MUI92QLbEJevO7rvqU/kjwKA==",
+      "version": "18.3.28",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.28.tgz",
+      "integrity": "sha512-z9VXpC7MWrhfWipitjNdgCauoMLRdIILQsAEV+ZesIzBq/oUlxk0m3ApZuMFCXdnS4U7KrI+l3WRUEGQ8K1QKw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@types/prop-types": "*",
-        "csstype": "^3.0.2"
+        "csstype": "^3.2.2"
       }
     },
     "node_modules/@types/react-dom": {
@@ -1907,9 +1943,9 @@
       "license": "MIT"
     },
     "node_modules/autoprefixer": {
-      "version": "10.4.21",
-      "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.21.tgz",
-      "integrity": "sha512-O+A6LWV5LDHSJD3LjHYoNi4VLsj/Whi7k6zG12xTYaU4cQ8oxQGckXNX8cRHK5yOZ/ppVHe0ZBXGzSV9jXdVbQ==",
+      "version": "10.4.24",
+      "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.24.tgz",
+      "integrity": "sha512-uHZg7N9ULTVbutaIsDRoUkoS8/h3bdsmVJYZ5l3wv8Cp/6UIIoRDm90hZ+BwxUj/hGBEzLxdHNSKuFpn8WOyZw==",
       "dev": true,
       "funding": [
         {
@@ -1927,10 +1963,9 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "browserslist": "^4.24.4",
-        "caniuse-lite": "^1.0.30001702",
-        "fraction.js": "^4.3.7",
-        "normalize-range": "^0.1.2",
+        "browserslist": "^4.28.1",
+        "caniuse-lite": "^1.0.30001766",
+        "fraction.js": "^5.3.4",
         "picocolors": "^1.1.1",
         "postcss-value-parser": "^4.2.0"
       },
@@ -1945,13 +1980,13 @@
       }
     },
     "node_modules/axios": {
-      "version": "1.13.1",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-1.13.1.tgz",
-      "integrity": "sha512-hU4EGxxt+j7TQijx1oYdAjw4xuIp1wRQSsbMFwSthCWeBQur1eF+qJ5iQ5sN3Tw8YRzQNKb8jszgBdMDVqwJcw==",
+      "version": "1.13.5",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.13.5.tgz",
+      "integrity": "sha512-cz4ur7Vb0xS4/KUN0tPWe44eqxrIu31me+fbang3ijiNscE129POzipJJA6zniq2C/Z6sJCjMimjS8Lc/GAs8Q==",
       "license": "MIT",
       "dependencies": {
-        "follow-redirects": "^1.15.6",
-        "form-data": "^4.0.4",
+        "follow-redirects": "^1.15.11",
+        "form-data": "^4.0.5",
         "proxy-from-env": "^1.1.0"
       }
     },
@@ -1963,9 +1998,9 @@
       "license": "MIT"
     },
     "node_modules/baseline-browser-mapping": {
-      "version": "2.8.23",
-      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.8.23.tgz",
-      "integrity": "sha512-616V5YX4bepJFzNyOfce5Fa8fDJMfoxzOIzDCZwaGL8MKVpFrXqfNUoIpRn9YMI5pXf/VKgzjB4htFMsFKKdiQ==",
+      "version": "2.9.19",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.9.19.tgz",
+      "integrity": "sha512-ipDqC8FrAl/76p2SSWKSI+H9tFwm7vYqXQrItCuiVPt26Km0jS+NzSsBWAaBusvSbQcfJG+JitdMm+wZAgTYqg==",
       "dev": true,
       "license": "Apache-2.0",
       "bin": {
@@ -2009,9 +2044,9 @@
       }
     },
     "node_modules/browserslist": {
-      "version": "4.27.0",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.27.0.tgz",
-      "integrity": "sha512-AXVQwdhot1eqLihwasPElhX2tAZiBjWdJ9i/Zcj2S6QYIjkx62OKSfnobkriB81C3l4w0rVy3Nt4jaTBltYEpw==",
+      "version": "4.28.1",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz",
+      "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==",
       "dev": true,
       "funding": [
         {
@@ -2029,11 +2064,11 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "baseline-browser-mapping": "^2.8.19",
-        "caniuse-lite": "^1.0.30001751",
-        "electron-to-chromium": "^1.5.238",
-        "node-releases": "^2.0.26",
-        "update-browserslist-db": "^1.1.4"
+        "baseline-browser-mapping": "^2.9.0",
+        "caniuse-lite": "^1.0.30001759",
+        "electron-to-chromium": "^1.5.263",
+        "node-releases": "^2.0.27",
+        "update-browserslist-db": "^1.2.0"
       },
       "bin": {
         "browserslist": "cli.js"
@@ -2076,9 +2111,9 @@
       }
     },
     "node_modules/caniuse-lite": {
-      "version": "1.0.30001753",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001753.tgz",
-      "integrity": "sha512-Bj5H35MD/ebaOV4iDLqPEtiliTN29qkGtEHCwawWn4cYm+bPJM2NsaP30vtZcnERClMzp52J4+aw2UNbK4o+zw==",
+      "version": "1.0.30001769",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001769.tgz",
+      "integrity": "sha512-BCfFL1sHijQlBGWBMuJyhZUhzo7wer5sVj9hqekB/7xn0Ypy+pER/edCYQm4exbXj4WiySGp40P8UuTh6w1srg==",
       "dev": true,
       "funding": [
         {
@@ -2245,9 +2280,9 @@
       }
     },
     "node_modules/csstype": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
-      "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==",
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
       "license": "MIT"
     },
     "node_modules/d3-array": {
@@ -2281,9 +2316,9 @@
       }
     },
     "node_modules/d3-format": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-3.1.0.tgz",
-      "integrity": "sha512-YyUI6AEuY/Wpt8KWLgZHsIU86atmikuoOmCfommt0LYHiQSPjvX2AcFc38PX0CBpr2RCyZhjex+NS/LPOv6YqA==",
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-3.1.2.tgz",
+      "integrity": "sha512-AJDdYOdnyRDV5b6ArilzCPPwc1ejkHcoyFarqlPqT7zRYjhavcT3uSrqcMvsgh2CgoPbK3RCwyHaVyxYcP2Arg==",
       "license": "ISC",
       "engines": {
         "node": ">=12"
@@ -2491,27 +2526,13 @@
         "node": ">= 0.4"
       }
     },
-    "node_modules/eastasianwidth": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
-      "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/electron-to-chromium": {
-      "version": "1.5.244",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.244.tgz",
-      "integrity": "sha512-OszpBN7xZX4vWMPJwB9illkN/znA8M36GQqQxi6MNy9axWxhOfJyZZJtSLQCpEFLHP2xK33BiWx9aIuIEXVCcw==",
+      "version": "1.5.286",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.286.tgz",
+      "integrity": "sha512-9tfDXhJ4RKFNerfjdCcZfufu49vg620741MNs26a9+bhLThdB+plgMeou98CAaHu/WATj2iHOOHTp1hWtABj2A==",
       "dev": true,
       "license": "ISC"
     },
-    "node_modules/emoji-regex": {
-      "version": "9.2.2",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
-      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/es-define-property": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
@@ -2558,9 +2579,9 @@
       }
     },
     "node_modules/esbuild": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
-      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.3.tgz",
+      "integrity": "sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==",
       "dev": true,
       "hasInstallScript": true,
       "license": "MIT",
@@ -2568,32 +2589,35 @@
         "esbuild": "bin/esbuild"
       },
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       },
       "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.21.5",
-        "@esbuild/android-arm": "0.21.5",
-        "@esbuild/android-arm64": "0.21.5",
-        "@esbuild/android-x64": "0.21.5",
-        "@esbuild/darwin-arm64": "0.21.5",
-        "@esbuild/darwin-x64": "0.21.5",
-        "@esbuild/freebsd-arm64": "0.21.5",
-        "@esbuild/freebsd-x64": "0.21.5",
-        "@esbuild/linux-arm": "0.21.5",
-        "@esbuild/linux-arm64": "0.21.5",
-        "@esbuild/linux-ia32": "0.21.5",
-        "@esbuild/linux-loong64": "0.21.5",
-        "@esbuild/linux-mips64el": "0.21.5",
-        "@esbuild/linux-ppc64": "0.21.5",
-        "@esbuild/linux-riscv64": "0.21.5",
-        "@esbuild/linux-s390x": "0.21.5",
-        "@esbuild/linux-x64": "0.21.5",
-        "@esbuild/netbsd-x64": "0.21.5",
-        "@esbuild/openbsd-x64": "0.21.5",
-        "@esbuild/sunos-x64": "0.21.5",
-        "@esbuild/win32-arm64": "0.21.5",
-        "@esbuild/win32-ia32": "0.21.5",
-        "@esbuild/win32-x64": "0.21.5"
+        "@esbuild/aix-ppc64": "0.27.3",
+        "@esbuild/android-arm": "0.27.3",
+        "@esbuild/android-arm64": "0.27.3",
+        "@esbuild/android-x64": "0.27.3",
+        "@esbuild/darwin-arm64": "0.27.3",
+        "@esbuild/darwin-x64": "0.27.3",
+        "@esbuild/freebsd-arm64": "0.27.3",
+        "@esbuild/freebsd-x64": "0.27.3",
+        "@esbuild/linux-arm": "0.27.3",
+        "@esbuild/linux-arm64": "0.27.3",
+        "@esbuild/linux-ia32": "0.27.3",
+        "@esbuild/linux-loong64": "0.27.3",
+        "@esbuild/linux-mips64el": "0.27.3",
+        "@esbuild/linux-ppc64": "0.27.3",
+        "@esbuild/linux-riscv64": "0.27.3",
+        "@esbuild/linux-s390x": "0.27.3",
+        "@esbuild/linux-x64": "0.27.3",
+        "@esbuild/netbsd-arm64": "0.27.3",
+        "@esbuild/netbsd-x64": "0.27.3",
+        "@esbuild/openbsd-arm64": "0.27.3",
+        "@esbuild/openbsd-x64": "0.27.3",
+        "@esbuild/openharmony-arm64": "0.27.3",
+        "@esbuild/sunos-x64": "0.27.3",
+        "@esbuild/win32-arm64": "0.27.3",
+        "@esbuild/win32-ia32": "0.27.3",
+        "@esbuild/win32-x64": "0.27.3"
       }
     },
     "node_modules/escalade": {
@@ -2690,9 +2714,9 @@
       }
     },
     "node_modules/eslint-plugin-react-refresh": {
-      "version": "0.4.24",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.4.24.tgz",
-      "integrity": "sha512-nLHIW7TEq3aLrEYWpVaJ1dRgFR+wLDPN8e8FpYAql/bMV2oBEfC37K0gLEGgv9fy66juNShSMV8OkTqzltcG/w==",
+      "version": "0.4.26",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.4.26.tgz",
+      "integrity": "sha512-1RETEylht2O6FM/MvgnyvT+8K21wLqDNg4qD51Zj3guhjt433XbnnkVttHMyaVyAFD03QSV4LPS5iE3VQmO7XQ==",
       "dev": true,
       "license": "MIT",
       "peerDependencies": {
@@ -2772,9 +2796,9 @@
       }
     },
     "node_modules/esquery": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz",
-      "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==",
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz",
+      "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==",
       "dev": true,
       "license": "BSD-3-Clause",
       "dependencies": {
@@ -2823,6 +2847,12 @@
       "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==",
       "license": "MIT"
     },
+    "node_modules/fancy-canvas": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fancy-canvas/-/fancy-canvas-2.1.0.tgz",
+      "integrity": "sha512-nifxXJ95JNLFR2NgRV4/MxVP45G9909wJTEKz5fg/TZS20JJZA6hfgRVh/bC9bwl2zBtBNcYPjiBE4njQHVBwQ==",
+      "license": "MIT"
+    },
     "node_modules/fast-deep-equal": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
@@ -2831,9 +2861,9 @@
       "license": "MIT"
     },
     "node_modules/fast-equals": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/fast-equals/-/fast-equals-5.3.2.tgz",
-      "integrity": "sha512-6rxyATwPCkaFIL3JLqw8qXqMpIZ942pTX/tbQFkRsDGblS8tNGtlUauA/+mt6RUfqn/4MoEr+WDkYoIQbibWuQ==",
+      "version": "5.4.0",
+      "resolved": "https://registry.npmjs.org/fast-equals/-/fast-equals-5.4.0.tgz",
+      "integrity": "sha512-jt2DW/aNFNwke7AUd+Z+e6pz39KO5rzdbbFCg2sGafS4mk13MI7Z8O5z9cADNn5lhGODIgLwug6TZO2ctf7kcw==",
       "license": "MIT",
       "engines": {
         "node": ">=6.0.0"
@@ -2884,9 +2914,9 @@
       "license": "MIT"
     },
     "node_modules/fastq": {
-      "version": "1.19.1",
-      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz",
-      "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==",
+      "version": "1.20.1",
+      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.20.1.tgz",
+      "integrity": "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==",
       "dev": true,
       "license": "ISC",
       "dependencies": {
@@ -2978,27 +3008,10 @@
         }
       }
     },
-    "node_modules/foreground-child": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
-      "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "cross-spawn": "^7.0.6",
-        "signal-exit": "^4.0.1"
-      },
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/form-data": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.4.tgz",
-      "integrity": "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==",
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
+      "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
       "license": "MIT",
       "dependencies": {
         "asynckit": "^0.4.0",
@@ -3012,16 +3025,16 @@
       }
     },
     "node_modules/fraction.js": {
-      "version": "4.3.7",
-      "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.3.7.tgz",
-      "integrity": "sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==",
+      "version": "5.3.4",
+      "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-5.3.4.tgz",
+      "integrity": "sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==",
       "dev": true,
       "license": "MIT",
       "engines": {
         "node": "*"
       },
       "funding": {
-        "type": "patreon",
+        "type": "github",
         "url": "https://github.com/sponsors/rawify"
       }
     },
@@ -3107,7 +3120,7 @@
       "version": "7.2.3",
       "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
       "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
-      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
       "dev": true,
       "license": "ISC",
       "dependencies": {
@@ -3371,16 +3384,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/is-fullwidth-code-point": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
-      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/is-glob": {
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
@@ -3421,22 +3424,6 @@
       "dev": true,
       "license": "ISC"
     },
-    "node_modules/jackspeak": {
-      "version": "3.4.3",
-      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz",
-      "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "@isaacs/cliui": "^8.0.2"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      },
-      "optionalDependencies": {
-        "@pkgjs/parseargs": "^0.11.0"
-      }
-    },
     "node_modules/jiti": {
       "version": "1.21.7",
       "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz",
@@ -3454,9 +3441,9 @@
       "license": "MIT"
     },
     "node_modules/js-yaml": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -3537,6 +3524,15 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/lightweight-charts": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/lightweight-charts/-/lightweight-charts-4.2.3.tgz",
+      "integrity": "sha512-5kS/2hY3wNYNzhnS8Gb+GAS07DX8GPF2YVDnd2NMC85gJVQ6RLU6YrXNgNJ6eg0AnWPwCnvaGtYmGky3HiLQEw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "fancy-canvas": "2.1.0"
+      }
+    },
     "node_modules/lilconfig": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz",
@@ -3574,9 +3570,9 @@
       }
     },
     "node_modules/lodash": {
-      "version": "4.17.21",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
-      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
+      "version": "4.17.23",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.23.tgz",
+      "integrity": "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==",
       "license": "MIT"
     },
     "node_modules/lodash.merge": {
@@ -3687,16 +3683,6 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
-    "node_modules/minipass": {
-      "version": "7.1.2",
-      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
-      "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": ">=16 || 14 >=14.17"
-      }
-    },
     "node_modules/ms": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
@@ -3759,16 +3745,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/normalize-range": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz",
-      "integrity": "sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
     "node_modules/object-assign": {
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
@@ -3848,13 +3824,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/package-json-from-dist": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
-      "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==",
-      "dev": true,
-      "license": "BlueOak-1.0.0"
-    },
     "node_modules/parent-module": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
@@ -3905,30 +3874,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/path-scurry": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz",
-      "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "lru-cache": "^10.2.0",
-        "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0"
-      },
-      "engines": {
-        "node": ">=16 || 14 >=14.18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/path-scurry/node_modules/lru-cache": {
-      "version": "10.4.3",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
-      "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
-      "dev": true,
-      "license": "ISC"
-    },
     "node_modules/path-type": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
@@ -4248,12 +4193,12 @@
       }
     },
     "node_modules/react-router": {
-      "version": "6.30.1",
-      "resolved": "https://registry.npmjs.org/react-router/-/react-router-6.30.1.tgz",
-      "integrity": "sha512-X1m21aEmxGXqENEPG3T6u0Th7g0aS4ZmoNynhbs+Cn+q+QGTLt+d5IQ2bHAXKzKcxGJjxACpVbnYQSCRcfxHlQ==",
+      "version": "6.30.3",
+      "resolved": "https://registry.npmjs.org/react-router/-/react-router-6.30.3.tgz",
+      "integrity": "sha512-XRnlbKMTmktBkjCLE8/XcZFlnHvr2Ltdr1eJX4idL55/9BbORzyZEaIkBFDhFGCEWBBItsVrDxwx3gnisMitdw==",
       "license": "MIT",
       "dependencies": {
-        "@remix-run/router": "1.23.0"
+        "@remix-run/router": "1.23.2"
       },
       "engines": {
         "node": ">=14.0.0"
@@ -4263,13 +4208,13 @@
       }
     },
     "node_modules/react-router-dom": {
-      "version": "6.30.1",
-      "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-6.30.1.tgz",
-      "integrity": "sha512-llKsgOkZdbPU1Eg3zK8lCn+sjD9wMRZZPuzmdWWX5SUs8OFkN5HnFVC0u5KMeMaC9aoancFI/KoLuKPqN+hxHw==",
+      "version": "6.30.3",
+      "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-6.30.3.tgz",
+      "integrity": "sha512-pxPcv1AczD4vso7G4Z3TKcvlxK7g7TNt3/FNGMhfqyntocvYKj+GCatfigGDjbLozC4baguJ0ReCigoDJXb0ag==",
       "license": "MIT",
       "dependencies": {
-        "@remix-run/router": "1.23.0",
-        "react-router": "6.30.1"
+        "@remix-run/router": "1.23.2",
+        "react-router": "6.30.3"
       },
       "engines": {
         "node": ">=14.0.0"
@@ -4425,9 +4370,9 @@
       }
     },
     "node_modules/rollup": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.52.5.tgz",
-      "integrity": "sha512-3GuObel8h7Kqdjt0gxkEzaifHTqLVW56Y/bjN7PSQtkKr0w3V/QYSdt6QWYtd7A1xUtYQigtdUfgj1RvWVtorw==",
+      "version": "4.57.1",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.57.1.tgz",
+      "integrity": "sha512-oQL6lgK3e2QZeQ7gcgIkS2YZPg5slw37hYufJ3edKlfQSGGm8ICoxswK15ntSzF/a8+h7ekRy7k7oWc3BQ7y8A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -4441,28 +4386,31 @@
         "npm": ">=8.0.0"
       },
       "optionalDependencies": {
-        "@rollup/rollup-android-arm-eabi": "4.52.5",
-        "@rollup/rollup-android-arm64": "4.52.5",
-        "@rollup/rollup-darwin-arm64": "4.52.5",
-        "@rollup/rollup-darwin-x64": "4.52.5",
-        "@rollup/rollup-freebsd-arm64": "4.52.5",
-        "@rollup/rollup-freebsd-x64": "4.52.5",
-        "@rollup/rollup-linux-arm-gnueabihf": "4.52.5",
-        "@rollup/rollup-linux-arm-musleabihf": "4.52.5",
-        "@rollup/rollup-linux-arm64-gnu": "4.52.5",
-        "@rollup/rollup-linux-arm64-musl": "4.52.5",
-        "@rollup/rollup-linux-loong64-gnu": "4.52.5",
-        "@rollup/rollup-linux-ppc64-gnu": "4.52.5",
-        "@rollup/rollup-linux-riscv64-gnu": "4.52.5",
-        "@rollup/rollup-linux-riscv64-musl": "4.52.5",
-        "@rollup/rollup-linux-s390x-gnu": "4.52.5",
-        "@rollup/rollup-linux-x64-gnu": "4.52.5",
-        "@rollup/rollup-linux-x64-musl": "4.52.5",
-        "@rollup/rollup-openharmony-arm64": "4.52.5",
-        "@rollup/rollup-win32-arm64-msvc": "4.52.5",
-        "@rollup/rollup-win32-ia32-msvc": "4.52.5",
-        "@rollup/rollup-win32-x64-gnu": "4.52.5",
-        "@rollup/rollup-win32-x64-msvc": "4.52.5",
+        "@rollup/rollup-android-arm-eabi": "4.57.1",
+        "@rollup/rollup-android-arm64": "4.57.1",
+        "@rollup/rollup-darwin-arm64": "4.57.1",
+        "@rollup/rollup-darwin-x64": "4.57.1",
+        "@rollup/rollup-freebsd-arm64": "4.57.1",
+        "@rollup/rollup-freebsd-x64": "4.57.1",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.57.1",
+        "@rollup/rollup-linux-arm-musleabihf": "4.57.1",
+        "@rollup/rollup-linux-arm64-gnu": "4.57.1",
+        "@rollup/rollup-linux-arm64-musl": "4.57.1",
+        "@rollup/rollup-linux-loong64-gnu": "4.57.1",
+        "@rollup/rollup-linux-loong64-musl": "4.57.1",
+        "@rollup/rollup-linux-ppc64-gnu": "4.57.1",
+        "@rollup/rollup-linux-ppc64-musl": "4.57.1",
+        "@rollup/rollup-linux-riscv64-gnu": "4.57.1",
+        "@rollup/rollup-linux-riscv64-musl": "4.57.1",
+        "@rollup/rollup-linux-s390x-gnu": "4.57.1",
+        "@rollup/rollup-linux-x64-gnu": "4.57.1",
+        "@rollup/rollup-linux-x64-musl": "4.57.1",
+        "@rollup/rollup-openbsd-x64": "4.57.1",
+        "@rollup/rollup-openharmony-arm64": "4.57.1",
+        "@rollup/rollup-win32-arm64-msvc": "4.57.1",
+        "@rollup/rollup-win32-ia32-msvc": "4.57.1",
+        "@rollup/rollup-win32-x64-gnu": "4.57.1",
+        "@rollup/rollup-win32-x64-msvc": "4.57.1",
         "fsevents": "~2.3.2"
       }
     },
@@ -4500,9 +4448,9 @@
       }
     },
     "node_modules/semver": {
-      "version": "7.7.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
-      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
+      "version": "7.7.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
       "dev": true,
       "license": "ISC",
       "bin": {
@@ -4535,19 +4483,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/signal-exit": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
-      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/slash": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz",
@@ -4568,76 +4503,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/string-width": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
-      "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "eastasianwidth": "^0.2.0",
-        "emoji-regex": "^9.2.2",
-        "strip-ansi": "^7.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/string-width-cjs": {
-      "name": "string-width",
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/string-width-cjs/node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/string-width/node_modules/ansi-regex": {
-      "version": "6.2.2",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz",
-      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
-      }
-    },
-    "node_modules/string-width/node_modules/strip-ansi": {
-      "version": "7.1.2",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.2.tgz",
-      "integrity": "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
-      }
-    },
     "node_modules/strip-ansi": {
       "version": "6.0.1",
       "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
@@ -4651,20 +4516,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/strip-ansi-cjs": {
-      "name": "strip-ansi",
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/strip-json-comments": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
@@ -4679,18 +4530,18 @@
       }
     },
     "node_modules/sucrase": {
-      "version": "3.35.0",
-      "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.0.tgz",
-      "integrity": "sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==",
+      "version": "3.35.1",
+      "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.1.tgz",
+      "integrity": "sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@jridgewell/gen-mapping": "^0.3.2",
         "commander": "^4.0.0",
-        "glob": "^10.3.10",
         "lines-and-columns": "^1.1.6",
         "mz": "^2.7.0",
         "pirates": "^4.0.1",
+        "tinyglobby": "^0.2.11",
         "ts-interface-checker": "^0.1.9"
       },
       "bin": {
@@ -4701,43 +4552,6 @@
         "node": ">=16 || 14 >=14.17"
       }
     },
-    "node_modules/sucrase/node_modules/glob": {
-      "version": "10.4.5",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
-      "integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "foreground-child": "^3.1.0",
-        "jackspeak": "^3.1.2",
-        "minimatch": "^9.0.4",
-        "minipass": "^7.1.2",
-        "package-json-from-dist": "^1.0.0",
-        "path-scurry": "^1.11.1"
-      },
-      "bin": {
-        "glob": "dist/esm/bin.mjs"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/sucrase/node_modules/minimatch": {
-      "version": "9.0.5",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
-      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=16 || 14 >=14.17"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/supports-color": {
       "version": "7.2.0",
       "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
@@ -4765,9 +4579,9 @@
       }
     },
     "node_modules/tailwind-merge": {
-      "version": "2.6.0",
-      "resolved": "https://registry.npmjs.org/tailwind-merge/-/tailwind-merge-2.6.0.tgz",
-      "integrity": "sha512-P+Vu1qXfzediirmHOC3xKGAYeZtPcV9g76X+xg2FD4tYgR71ewMA35Y3sCz3zhiN/dwefRpJX0yBcgwi1fXNQA==",
+      "version": "2.6.1",
+      "resolved": "https://registry.npmjs.org/tailwind-merge/-/tailwind-merge-2.6.1.tgz",
+      "integrity": "sha512-Oo6tHdpZsGpkKG88HJ8RR1rg/RdnEkQEfMoEk2x1XRI3F1AxeU+ijRXpiVUF4UbLfcxxRGw6TbUINKYdWVsQTQ==",
       "license": "MIT",
       "funding": {
         "type": "github",
@@ -4775,9 +4589,9 @@
       }
     },
     "node_modules/tailwindcss": {
-      "version": "3.4.18",
-      "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.18.tgz",
-      "integrity": "sha512-6A2rnmW5xZMdw11LYjhcI5846rt9pbLSabY5XPxo+XWdxwZaFEn47Go4NzFiHu9sNNmr/kXivP1vStfvMaK1GQ==",
+      "version": "3.4.19",
+      "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.19.tgz",
+      "integrity": "sha512-3ofp+LL8E+pK/JuPLPggVAIaEuhvIz4qNcf3nA1Xn2o/7fb7s/TYpHhwGDv1ZU3PkBluUVaF8PyCHcm48cKLWQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -4848,6 +4662,54 @@
       "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==",
       "license": "MIT"
     },
+    "node_modules/tinyglobby": {
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tinyglobby/node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/tinyglobby/node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
     "node_modules/to-regex-range": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
@@ -4929,9 +4791,9 @@
       "license": "MIT"
     },
     "node_modules/update-browserslist-db": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.4.tgz",
-      "integrity": "sha512-q0SPT4xyU84saUX+tomz1WLkxUbuaJnR1xWt17M7fJtEJigJeWUNGUqrauFXsHnqev9y9JTRGwk13tFBuKby4A==",
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
       "dev": true,
       "funding": [
         {
@@ -4999,21 +4861,24 @@
       }
     },
     "node_modules/vite": {
-      "version": "5.4.21",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
-      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
+      "version": "7.3.1",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.1.tgz",
+      "integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "esbuild": "^0.21.3",
-        "postcss": "^8.4.43",
-        "rollup": "^4.20.0"
+        "esbuild": "^0.27.0",
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3",
+        "postcss": "^8.5.6",
+        "rollup": "^4.43.0",
+        "tinyglobby": "^0.2.15"
       },
       "bin": {
         "vite": "bin/vite.js"
       },
       "engines": {
-        "node": "^18.0.0 || >=20.0.0"
+        "node": "^20.19.0 || >=22.12.0"
       },
       "funding": {
         "url": "https://github.com/vitejs/vite?sponsor=1"
@@ -5022,19 +4887,25 @@
         "fsevents": "~2.3.3"
       },
       "peerDependencies": {
-        "@types/node": "^18.0.0 || >=20.0.0",
-        "less": "*",
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
         "lightningcss": "^1.21.0",
-        "sass": "*",
-        "sass-embedded": "*",
-        "stylus": "*",
-        "sugarss": "*",
-        "terser": "^5.4.0"
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
       },
       "peerDependenciesMeta": {
         "@types/node": {
           "optional": true
         },
+        "jiti": {
+          "optional": true
+        },
         "less": {
           "optional": true
         },
@@ -5055,9 +4926,46 @@
         },
         "terser": {
           "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
         }
       }
     },
+    "node_modules/vite/node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite/node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -5084,107 +4992,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/wrap-ansi": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
-      "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^6.1.0",
-        "string-width": "^5.0.1",
-        "strip-ansi": "^7.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi-cjs": {
-      "name": "wrap-ansi",
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
-      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.0.0",
-        "string-width": "^4.1.0",
-        "strip-ansi": "^6.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi-cjs/node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/wrap-ansi-cjs/node_modules/string-width": {
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/ansi-regex": {
-      "version": "6.2.2",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz",
-      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/ansi-styles": {
-      "version": "6.2.3",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz",
-      "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/strip-ansi": {
-      "version": "7.1.2",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.2.tgz",
-      "integrity": "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
-      }
-    },
     "node_modules/wrappy": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
diff --git a/frontend/package.json b/frontend/package.json
index e2e34ce..2e57040 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -14,6 +14,7 @@
     "axios": "^1.6.2",
     "clsx": "^2.0.0",
     "date-fns": "^2.30.0",
+    "lightweight-charts": "^4.2.0",
     "lucide-react": "^0.294.0",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
@@ -23,8 +24,8 @@
   },
   "devDependencies": {
     "@types/node": "^24.10.0",
-    "@types/react": "^18.2.43",
-    "@types/react-dom": "^18.2.17",
+    "@types/react": "^18.3.26",
+    "@types/react-dom": "^18.3.7",
     "@typescript-eslint/eslint-plugin": "^6.14.0",
     "@typescript-eslint/parser": "^6.14.0",
     "@vitejs/plugin-react": "^4.2.1",
@@ -34,7 +35,7 @@
     "eslint-plugin-react-refresh": "^0.4.5",
     "postcss": "^8.4.32",
     "tailwindcss": "^3.3.6",
-    "typescript": "^5.2.2",
-    "vite": "^5.0.8"
+    "typescript": "^5.9.3",
+    "vite": "^7.2.2"
   }
-}
+}
\ No newline at end of file
diff --git a/frontend/src/components/CandlestickChart.tsx b/frontend/src/components/CandlestickChart.tsx
deleted file mode 100644
index 943312c..0000000
--- a/frontend/src/components/CandlestickChart.tsx
+++ /dev/null
@@ -1,434 +0,0 @@
-import { useMemo } from 'react'
-
-interface CandleData {
-    date: string
-    dateLabel: string
-    open: number
-    high: number
-    low: number
-    close: number
-    volume: number
-}
-
-interface CandlestickChartProps {
-    data: CandleData[]
-    width: number
-    height: number
-}
-
-// 이동평균 계산
-const calculateMA = (data: CandleData[], period: number): (number | null)[] => {
-    return data.map((_, index) => {
-        if (index < period - 1) return null
-        const sum = data.slice(index - period + 1, index + 1).reduce((acc, d) => acc + d.close, 0)
-        return sum / period
-    })
-}
-
-// 볼린저밴드 계산
-const calculateBollingerBands = (data: CandleData[], period: number = 20, stdDev: number = 2) => {
-    const ma = calculateMA(data, period)
-    const upper: (number | null)[] = []
-    const lower: (number | null)[] = []
-
-    data.forEach((_, index) => {
-        if (index < period - 1 || ma[index] === null) {
-            upper.push(null)
-            lower.push(null)
-            return
-        }
-
-        const slice = data.slice(index - period + 1, index + 1)
-        const mean = ma[index]!
-        const variance = slice.reduce((acc, d) => acc + Math.pow(d.close - mean, 2), 0) / period
-        const std = Math.sqrt(variance)
-
-        upper.push(mean + stdDev * std)
-        lower.push(mean - stdDev * std)
-    })
-
-    return { middle: ma, upper, lower }
-}
-
-const CandlestickChart = ({ data, width, height }: CandlestickChartProps) => {
-    const { candles, yScale, volumeScale, maxVolume, indicators } = useMemo(() => {
-        if (!data || data.length === 0) {
-            console.log('CandlestickChart: No data')
-            return {
-                candles: [],
-                yScale: { min: 0, max: 0, range: 0 },
-                volumeScale: 0,
-                maxVolume: 0,
-                indicators: { ma5: [], ma20: [], ma60: [], bb: { middle: [], upper: [], lower: [] } }
-            }
-        }
-
-        console.log('CandlestickChart: Rendering', data.length, 'candles')
-        console.log('First candle:', data[0])
-        console.log('Last candle:', data[data.length - 1])
-
-        // 지표 계산
-        const ma5 = calculateMA(data, 5)
-        const ma20 = calculateMA(data, 20)
-        const ma60 = calculateMA(data, 60)
-        const bb = calculateBollingerBands(data, 20, 2)
-
-        // 가격 범위 계산 (지표 포함)
-        const prices = data.flatMap(d => [d.open, d.high, d.low, d.close]).filter(p => p > 0)
-        const indicatorValues = [
-            ...ma5.filter((v): v is number => v !== null && v > 0),
-            ...ma20.filter((v): v is number => v !== null && v > 0),
-            ...ma60.filter((v): v is number => v !== null && v > 0),
-            ...bb.upper.filter((v): v is number => v !== null && v > 0),
-            ...bb.lower.filter((v): v is number => v !== null && v > 0),
-        ]
-        const allValues = [...prices, ...indicatorValues]
-
-        if (allValues.length === 0) {
-            console.error('❌ No valid price data')
-            return {
-                candles: [],
-                yScale: { min: 0, max: 0, range: 0 },
-                volumeScale: 0,
-                maxVolume: 0,
-                indicators: { ma5: [], ma20: [], ma60: [], bb: { middle: [], upper: [], lower: [] } }
-            }
-        }
-
-        const min = Math.min(...allValues)
-        const max = Math.max(...allValues)
-
-        // 이상치 검증: max가 min의 10배를 넘으면 지표 제외
-        const priceRange = Math.max(...prices) - Math.min(...prices)
-        const totalRange = max - min
-
-        if (totalRange > priceRange * 3) {
-            console.warn('⚠️ Detected outlier in indicators, using price range only')
-            const priceMin = Math.min(...prices)
-            const priceMax = Math.max(...prices)
-            const range = priceMax - priceMin
-            const padding = range * 0.1  // 패딩: 10%
-
-            const chartHeight = height - 80
-            const volumeHeight = 60
-            const yMin = priceMin - padding
-            const yMax = priceMax + padding
-            const yRange = yMax - yMin
-            const leftMargin = 80  // 왼쪽 여백 증가: 60 → 80
-            const rightMargin = 20  // 오른쪽 여백 추가
-            const chartWidth = width - leftMargin - rightMargin
-            const candleWidth = Math.max(5, Math.min(15, chartWidth / data.length * 0.7))  // 캔들 너비 증가
-            const spacing = chartWidth / data.length
-            const maxVol = Math.max(...data.map(d => d.volume))
-
-            const candles = data.map((item, index) => {
-                const x = leftMargin + index * spacing + spacing / 2
-                const isUp = item.close >= item.open
-                const openY = chartHeight - ((item.open - yMin) / yRange) * chartHeight + 10
-                const closeY = chartHeight - ((item.close - yMin) / yRange) * chartHeight + 10
-                const highY = chartHeight - ((item.high - yMin) / yRange) * chartHeight + 10
-                const lowY = chartHeight - ((item.low - yMin) / yRange) * chartHeight + 10
-                const bodyTop = Math.min(openY, closeY)
-                const bodyHeight = Math.abs(closeY - openY) || 1
-                const volumeBarHeight = (item.volume / maxVol) * volumeHeight
-
-                return {
-                    x, highY, lowY, bodyTop, bodyHeight, isUp,
-                    dateLabel: item.dateLabel,
-                    open: item.open, high: item.high, low: item.low, close: item.close,
-                    volume: item.volume, volumeBarHeight, candleWidth,
-                }
-            })
-
-            return {
-                candles,
-                yScale: { min: yMin, max: yMax, range: yRange },
-                volumeScale: volumeHeight,
-                maxVolume: maxVol,
-                indicators: { ma5, ma20, ma60, bb }
-            }
-        }
-
-        const range = max - min
-        const padding = range * 0.1  // 패딩: 10%
-
-        const chartHeight = height - 80 // 거래량 영역 제외
-        const volumeHeight = 60
-
-        const yMin = min - padding
-        const yMax = max + padding
-        const yRange = yMax - yMin
-
-        const leftMargin = 80  // 왼쪽 여백 증가: 60 → 80
-        const rightMargin = 20  // 오른쪽 여백 추가
-        const chartWidth = width - leftMargin - rightMargin
-        const candleWidth = Math.max(5, Math.min(15, chartWidth / data.length * 0.7))  // 캔들 너비 증가
-        const spacing = chartWidth / data.length
-
-        const maxVol = Math.max(...data.map(d => d.volume))
-
-        const candles = data.map((item, index) => {
-            const x = leftMargin + index * spacing + spacing / 2
-            const isUp = item.close >= item.open
-
-            const openY = chartHeight - ((item.open - yMin) / yRange) * chartHeight + 10
-            const closeY = chartHeight - ((item.close - yMin) / yRange) * chartHeight + 10
-            const highY = chartHeight - ((item.high - yMin) / yRange) * chartHeight + 10
-            const lowY = chartHeight - ((item.low - yMin) / yRange) * chartHeight + 10
-
-            const bodyTop = Math.min(openY, closeY)
-            const bodyHeight = Math.abs(closeY - openY) || 1
-
-            const volumeBarHeight = (item.volume / maxVol) * volumeHeight
-
-            return {
-                x,
-                highY,
-                lowY,
-                bodyTop,
-                bodyHeight,
-                isUp,
-                dateLabel: item.dateLabel,
-                open: item.open,
-                high: item.high,
-                low: item.low,
-                close: item.close,
-                volume: item.volume,
-                volumeBarHeight,
-                candleWidth,
-            }
-        })
-
-        return {
-            candles,
-            yScale: { min: yMin, max: yMax, range: yRange },
-            volumeScale: volumeHeight,
-            maxVolume: maxVol,
-            indicators: { ma5, ma20, ma60, bb }
-        }
-    }, [data, width, height])
-
-    if (!data || data.length === 0) {
-        return (
-            <div style={{ width, height, display: 'flex', alignItems: 'center', justifyContent: 'center', color: '#666' }}>
-                데이터가 없습니다
-            </div>
-        )
-    }
-
-    const chartHeight = height - 80
-    const volumeTop = chartHeight + 20
-
-    // 지표 라인을 위한 좌표 계산
-    const getLineY = (value: number) => {
-        return chartHeight - ((value - yScale.min) / yScale.range) * chartHeight + 10
-    }
-
-    const createLinePath = (values: (number | null)[]) => {
-        const segments: string[] = []
-        let currentSegment: string[] = []
-
-        values.forEach((value, index) => {
-            if (value !== null && candles[index]) {
-                const x = candles[index].x
-                const y = getLineY(value)
-                if (currentSegment.length === 0) {
-                    currentSegment.push(`M ${x} ${y}`)
-                } else {
-                    currentSegment.push(`L ${x} ${y}`)
-                }
-            } else if (currentSegment.length > 0) {
-                // null 값을 만나면 현재 세그먼트를 종료하고 새로 시작
-                segments.push(currentSegment.join(' '))
-                currentSegment = []
-            }
-        })
-
-        // 마지막 세그먼트 추가
-        if (currentSegment.length > 0) {
-            segments.push(currentSegment.join(' '))
-        }
-
-        return segments.join(' ')
-    }
-
-    // 볼린저밴드 영역 path 생성
-    const createBBAreaPath = () => {
-        const upperPoints: [number, number][] = []
-        const lowerPoints: [number, number][] = []
-
-        indicators.bb.upper.forEach((value, index) => {
-            if (value !== null && indicators.bb.lower[index] !== null && candles[index]) {
-                upperPoints.push([candles[index].x, getLineY(value)])
-                lowerPoints.push([candles[index].x, getLineY(indicators.bb.lower[index]!)])
-            }
-        })
-
-        if (upperPoints.length === 0) return ''
-
-        const pathParts: string[] = []
-        pathParts.push(`M ${upperPoints[0][0]} ${upperPoints[0][1]}`)
-        upperPoints.slice(1).forEach(([x, y]) => pathParts.push(`L ${x} ${y}`))
-        lowerPoints.reverse().forEach(([x, y]) => pathParts.push(`L ${x} ${y}`))
-        pathParts.push('Z')
-
-        return pathParts.join(' ')
-    }
-
-    return (
-        <svg width={width} height={height} style={{ background: 'transparent' }}>
-            {/* Y축 그리드 */}
-            {[0, 0.25, 0.5, 0.75, 1].map((ratio) => {
-                const y = chartHeight - ratio * chartHeight + 10
-                const price = yScale.min + ratio * yScale.range
-                return (
-                    <g key={ratio}>
-                        <line
-                            x1={80}
-                            y1={y}
-                            x2={width - 20}
-                            y2={y}
-                            stroke="#222"
-                            strokeDasharray="3 3"
-                        />
-                        <text
-                            x={75}
-                            y={y + 4}
-                            fill="#888"
-                            fontSize="11"
-                            textAnchor="end"
-                        >
-                            {new Intl.NumberFormat('ko-KR', { maximumFractionDigits: 0 }).format(price)}
-                        </text>
-                    </g>
-                )
-            })}
-
-            {/* 볼린저밴드 영역 - 그리드 뒤, 캔들 앞 */}
-            {indicators.bb.upper.length > 0 && (
-                <path
-                    d={createBBAreaPath()}
-                    fill="rgba(139, 92, 246, 0.08)"
-                    stroke="none"
-                />
-            )}
-
-            {/* 이동평균선 - 캔들 앞 */}
-            <path
-                d={createLinePath(indicators.ma60)}
-                stroke="#06b6d4"
-                strokeWidth={2}
-                fill="none"
-                opacity={0.9}
-            />
-            <path
-                d={createLinePath(indicators.ma20)}
-                stroke="#8b5cf6"
-                strokeWidth={2}
-                fill="none"
-                opacity={0.9}
-            />
-            <path
-                d={createLinePath(indicators.ma5)}
-                stroke="#f59e0b"
-                strokeWidth={2}
-                fill="none"
-                opacity={0.9}
-            />
-
-            {/* 볼린저밴드 라인 - 캔들 앞 */}
-            <path
-                d={createLinePath(indicators.bb.upper)}
-                stroke="#8b5cf6"
-                strokeWidth={1.5}
-                fill="none"
-                strokeDasharray="4 4"
-                opacity={0.5}
-            />
-            <path
-                d={createLinePath(indicators.bb.middle)}
-                stroke="#8b5cf6"
-                strokeWidth={1.5}
-                fill="none"
-                opacity={0.4}
-            />
-            <path
-                d={createLinePath(indicators.bb.lower)}
-                stroke="#8b5cf6"
-                strokeWidth={1.5}
-                fill="none"
-                strokeDasharray="4 4"
-                opacity={0.5}
-            />
-
-            {/* 캔들스틱 */}
-            {candles.map((candle, index) => (
-                <g key={index}>
-                    {/* 심지 (High-Low 라인) */}
-                    <line
-                        x1={candle.x}
-                        y1={candle.highY}
-                        x2={candle.x}
-                        y2={candle.lowY}
-                        stroke={candle.isUp ? '#22c55e' : '#ef4444'}
-                        strokeWidth={1}
-                    />
-                    {/* 캔들 몸통 */}
-                    <rect
-                        x={candle.x - candle.candleWidth / 2}
-                        y={candle.bodyTop}
-                        width={candle.candleWidth}
-                        height={candle.bodyHeight}
-                        fill={candle.isUp ? '#22c55e' : '#ef4444'}
-                        stroke={candle.isUp ? '#22c55e' : '#ef4444'}
-                        strokeWidth={1}
-                    />
-                    {/* X축 라벨 (일부만 표시) */}
-                    {index % Math.max(1, Math.floor(candles.length / 10)) === 0 && (
-                        <text
-                            x={candle.x}
-                            y={chartHeight + 25}
-                            fill="#888"
-                            fontSize="10"
-                            textAnchor="middle"
-                        >
-                            {candle.dateLabel}
-                        </text>
-                    )}
-                    {/* 거래량 바 */}
-                    <rect
-                        x={candle.x - candle.candleWidth / 2}
-                        y={volumeTop + volumeScale - candle.volumeBarHeight}
-                        width={candle.candleWidth}
-                        height={candle.volumeBarHeight}
-                        fill={candle.isUp ? '#22c55e' : '#ef4444'}
-                        opacity={0.4}
-                    />
-                </g>
-            ))}
-
-            {/* 거래량 라벨 */}
-            <text x={10} y={volumeTop + 15} fill="#888" fontSize="10">거래량</text>
-            <text x={width - 20} y={volumeTop + volumeScale} fill="#888" fontSize="10" textAnchor="end">
-                {new Intl.NumberFormat('ko-KR', { notation: 'compact' }).format(maxVolume)}
-            </text>
-
-            {/* 범례 */}
-            <g transform={`translate(70, 15)`}>
-                <line x1={0} y1={0} x2={20} y2={0} stroke="#f59e0b" strokeWidth={2} />
-                <text x={25} y={4} fill="#f59e0b" fontSize="11" fontWeight="600">MA5</text>
-
-                <line x1={70} y1={0} x2={90} y2={0} stroke="#8b5cf6" strokeWidth={2} />
-                <text x={95} y={4} fill="#8b5cf6" fontSize="11" fontWeight="600">MA20</text>
-
-                <line x1={150} y1={0} x2={170} y2={0} stroke="#06b6d4" strokeWidth={2} />
-                <text x={175} y={4} fill="#06b6d4" fontSize="11" fontWeight="600">MA60</text>
-
-                <line x1={240} y1={0} x2={260} y2={0} stroke="#94a3b8" strokeWidth={1} strokeDasharray="3 3" />
-                <text x={265} y={4} fill="#94a3b8" fontSize="11" fontWeight="600">BB</text>
-            </g>
-        </svg>
-    )
-}
-
-export default CandlestickChart
diff --git a/frontend/src/components/Layout.tsx b/frontend/src/components/Layout.tsx
index 56a561f..da00b18 100644
--- a/frontend/src/components/Layout.tsx
+++ b/frontend/src/components/Layout.tsx
@@ -1,5 +1,8 @@
 import { Link, useLocation } from 'react-router-dom'
-import { LayoutDashboard, FileText, History, Cpu } from 'lucide-react'
+import { LayoutDashboard, FileText, History, Cpu, Activity } from 'lucide-react'
+import { useQuery } from '@tanstack/react-query'
+import api from '../lib/api'
+import { useWebSocket } from '../hooks/useWebSocket'
 
 interface LayoutProps {
     children: React.ReactNode
@@ -7,58 +10,78 @@ interface LayoutProps {
 
 const Layout = ({ children }: LayoutProps) => {
     const location = useLocation()
+    const { connected: wsConnected } = useWebSocket('dashboard') // Global WS status
+
+    const { data: mcpStatus } = useQuery({
+        queryKey: ['mcp-status'],
+        queryFn: async () => (await api.get('/mcp/status')).data,
+        refetchInterval: 5000,
+    })
 
     const navItems = [
         { path: '/', icon: LayoutDashboard, label: '대시보드' },
-        { path: '/rules', icon: FileText, label: '전략 룰 설정' },
+        { path: '/rules', icon: FileText, label: '전략 룰' },
         { path: '/trades', icon: History, label: '매매 로그' },
         { path: '/mcp', icon: Cpu, label: 'MCP 상태' },
     ]
 
     return (
-        <div className="min-h-screen bg-slate-900">
-            {/* Header */}
-            <header className="bg-slate-800 border-b border-slate-700">
-                <div className="container mx-auto px-4 py-4">
-                    <h1 className="text-2xl font-bold text-white">
-                        Auto Stock Trading System
-                    </h1>
-                    <p className="text-slate-400 text-sm">
-                        Claude AI & MCP 기반 자동 매매 시스템
-                    </p>
-                </div>
-            </header>
+        <div className="min-h-screen bg-[#0f1115] text-gray-100 font-sans flex flex-col">
+            {/* Top Navigation Bar */}
+            <header className="border-b border-gray-800 bg-[#161b22] h-16 flex items-center justify-between px-6 sticky top-0 z-50 backdrop-blur-md bg-opacity-90">
+                <div className="flex items-center gap-8">
+                    {/* Brand */}
+                    <div className="flex items-center gap-3">
+                        <div className="bg-blue-600 p-2 rounded-lg shadow-lg shadow-blue-500/20">
+                            <Activity className="text-white" size={20} />
+                        </div>
+                        <div>
+                            <h1 className="text-xl font-bold bg-gradient-to-r from-blue-400 to-purple-400 bg-clip-text text-transparent leading-none">
+                                AutoStock
+                            </h1>
+                            <p className="text-[10px] text-gray-500 font-mono tracking-wider">GEN 3 ALGO</p>
+                        </div>
+                    </div>
 
-            <div className="flex">
-                {/* Sidebar */}
-                <aside className="w-64 bg-slate-800 min-h-[calc(100vh-73px)] border-r border-slate-700">
-                    <nav className="p-4 space-y-2">
+                    {/* Navigation */}
+                    <nav className="flex items-center gap-1">
                         {navItems.map((item) => {
                             const Icon = item.icon
                             const isActive = location.pathname === item.path
-
                             return (
                                 <Link
                                     key={item.path}
                                     to={item.path}
-                                    className={`flex items-center space-x-3 px-4 py-3 rounded-lg transition-colors ${isActive
-                                            ? 'bg-primary text-white'
-                                            : 'text-slate-400 hover:bg-slate-700 hover:text-white'
+                                    className={`flex items-center gap-2 px-3 py-2 rounded-md transition-all text-sm font-medium ${isActive
+                                        ? 'bg-gray-800 text-blue-400'
+                                        : 'text-gray-400 hover:text-white hover:bg-gray-800/50'
                                         }`}
                                 >
-                                    <Icon size={20} />
+                                    <Icon size={16} />
                                     <span>{item.label}</span>
                                 </Link>
                             )
                         })}
                     </nav>
-                </aside>
+                </div>
 
-                {/* Main Content */}
-                <main className="flex-1 p-6">
-                    {children}
-                </main>
-            </div>
+                {/* Status Indicators */}
+                <div className="flex items-center gap-4">
+                    <div className="flex items-center gap-2 px-3 py-1.5 bg-gray-800/50 rounded-full border border-gray-700/50">
+                        <div className={`w-2 h-2 rounded-full ${wsConnected ? 'bg-green-500 shadow-[0_0_8px_rgba(34,197,94,0.5)]' : 'bg-red-500'}`} />
+                        <span className="text-xs text-gray-400">{wsConnected ? 'LIVE' : 'OFFLINE'}</span>
+                    </div>
+                    <div className="flex items-center gap-2 px-3 py-1.5 bg-gray-800/50 rounded-full border border-gray-700/50">
+                        <div className={`w-2 h-2 rounded-full ${mcpStatus?.status === 'connected' ? 'bg-blue-500 shadow-[0_0_8px_rgba(59,130,246,0.5)]' : 'bg-yellow-500'}`} />
+                        <span className="text-xs text-gray-400">MCP: {mcpStatus?.status || 'Unknown'}</span>
+                    </div>
+                </div>
+            </header>
+
+            {/* Main Content Area */}
+            <main className="flex-1 overflow-x-hidden">
+                {children}
+            </main>
         </div>
     )
 }
diff --git a/frontend/src/components/PortfolioSummary.tsx b/frontend/src/components/PortfolioSummary.tsx
new file mode 100644
index 0000000..196fa66
--- /dev/null
+++ b/frontend/src/components/PortfolioSummary.tsx
@@ -0,0 +1,90 @@
+import { ArrowUpRight, ArrowDownRight, AlertTriangle, Activity, TrendingUp, TrendingDown, DollarSign } from 'lucide-react';
+
+interface PortfolioSummaryProps {
+    summary: any;
+    error: any;
+}
+
+export const PortfolioSummary = ({ summary, error }: PortfolioSummaryProps) => {
+    if (error) {
+        return (
+            <div className="bg-red-900/20 border border-red-500/30 rounded-lg p-4 flex items-center gap-3 text-red-400">
+                <AlertTriangle className="w-5 h-5 flex-shrink-0" />
+                <span>포트폴리오 정보를 불러오는데 실패했습니다.</span>
+            </div>
+        );
+    }
+
+    if (!summary) {
+        return (
+            <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4 animate-pulse">
+                {[...Array(4)].map((_, i) => (
+                    <div key={i} className="bg-gray-800/50 h-24 rounded-xl" />
+                ))}
+            </div>
+        );
+    }
+
+    const { total_assets, total_value, total_investment, total_profit_loss, total_profit_loss_rate, available_cash } = summary;
+    const isProfit = total_profit_loss >= 0;
+
+    return (
+        <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4 mb-6">
+            {/* 총 자산 */}
+            <div className="bg-gray-800/50 backdrop-blur-sm border border-gray-700/50 p-5 rounded-xl">
+                <div className="flex justify-between items-start mb-2">
+                    <p className="text-gray-400 text-sm font-medium">총 자산</p>
+                    <div className="p-2 bg-blue-500/10 rounded-lg text-blue-400">
+                        <DollarSign size={18} />
+                    </div>
+                </div>
+                <h3 className="text-2xl font-bold text-white mb-1">
+                    {Math.round(total_assets || 0).toLocaleString()}원
+                </h3>
+                <div className="flex flex-col gap-0.5 text-xs text-gray-400">
+                    <span>예수금: {Math.round(available_cash || 0).toLocaleString()}원</span>
+                    <span>평가금액: {Math.round(total_value || 0).toLocaleString()}원</span>
+                </div>
+            </div>
+
+            {/* 총 매입금액 */}
+            <div className="bg-gray-800/50 backdrop-blur-sm border border-gray-700/50 p-5 rounded-xl">
+                <div className="flex justify-between items-start mb-2">
+                    <p className="text-gray-400 text-sm font-medium">총 매입금액</p>
+                    <div className="p-2 bg-purple-500/10 rounded-lg text-purple-400">
+                        <Activity size={18} />
+                    </div>
+                </div>
+                <h3 className="text-2xl font-bold text-white mb-1">
+                    {Math.round(total_investment || 0).toLocaleString()}원
+                </h3>
+            </div>
+
+            {/* 총 평가손익 */}
+            <div className="bg-gray-800/50 backdrop-blur-sm border border-gray-700/50 p-5 rounded-xl">
+                <div className="flex justify-between items-start mb-2">
+                    <p className="text-gray-400 text-sm font-medium">총 평가손익</p>
+                    <div className={`p-2 rounded-lg ${isProfit ? 'bg-red-500/10 text-red-400' : 'bg-blue-500/10 text-blue-400'}`}>
+                        {isProfit ? <TrendingUp size={18} /> : <TrendingDown size={18} />}
+                    </div>
+                </div>
+                <h3 className={`text-2xl font-bold mb-1 ${isProfit ? 'text-red-400' : 'text-blue-400'}`}>
+                    {total_profit_loss > 0 ? '+' : ''}{Math.round(total_profit_loss || 0).toLocaleString()}원
+                </h3>
+            </div>
+
+            {/* 수익률 */}
+            <div className="bg-gray-800/50 backdrop-blur-sm border border-gray-700/50 p-5 rounded-xl">
+                <div className="flex justify-between items-start mb-2">
+                    <p className="text-gray-400 text-sm font-medium">수익률</p>
+                    <div className={`p-2 rounded-lg ${isProfit ? 'bg-red-500/10 text-red-400' : 'bg-blue-500/10 text-blue-400'}`}>
+                        {isProfit ? <ArrowUpRight size={18} /> : <ArrowDownRight size={18} />}
+                    </div>
+                </div>
+                <h3 className={`text-2xl font-bold mb-1 ${isProfit ? 'text-red-400' : 'text-blue-400'}`}>
+                    {total_profit_loss_rate > 0 ? '+' : ''}{total_profit_loss_rate?.toFixed(2)}%
+                </h3>
+            </div>
+        </div>
+    );
+};
diff --git a/frontend/src/components/TradingChart.tsx b/frontend/src/components/TradingChart.tsx
new file mode 100644
index 0000000..dd7fe02
--- /dev/null
+++ b/frontend/src/components/TradingChart.tsx
@@ -0,0 +1,512 @@
+// @ts-nocheck
+import { useEffect, useRef, useMemo } from 'react';
+import { createChart, CrosshairMode, IChartApi, ISeriesApi, CandlestickData, LineData, HistogramData } from 'lightweight-charts';
+import {
+    calculateSMA,
+    calculateBollingerBands,
+    calculateRSI,
+    calculateMACD
+} from '../utils/technicalIndicators';
+
+interface TradingChartProps {
+    data: any[];
+}
+
+// 한국 시장 색상 규칙
+const COLORS = {
+    candleUp: '#ef4444',       // 상승: 빨강
+    candleDown: '#3b82f6',     // 하락: 파랑
+    ma5: '#fbbf24',            // 5일선: 노란색
+    ma20: '#f6ad55',           // 20일선: 오렌지색
+    ma60: '#10b981',           // 60일선: 초록색
+    bbLine: '#4a5568',         // 볼린저 밴드: 회색
+    rsi: '#a78bfa',            // RSI: 보라색
+    macd: '#3b82f6',           // MACD: 파란색
+    signal: '#f97316',         // Signal: 주황색
+    background: '#0b0e14',
+    grid: '#1a1f2e',
+    text: '#9ca3af',
+    border: '#374151',
+};
+
+export const TradingChart = ({ data }: TradingChartProps) => {
+    // Refs for chart containers
+    const mainChartRef = useRef<HTMLDivElement>(null);
+    const volumeChartRef = useRef<HTMLDivElement>(null);
+    const rsiChartRef = useRef<HTMLDivElement>(null);
+    const macdChartRef = useRef<HTMLDivElement>(null);
+
+    // Refs for chart instances
+    const mainChartInstanceRef = useRef<IChartApi | null>(null);
+    const volumeChartInstanceRef = useRef<IChartApi | null>(null);
+    const rsiChartInstanceRef = useRef<IChartApi | null>(null);
+    const macdChartInstanceRef = useRef<IChartApi | null>(null);
+
+    // Refs for series
+    const candlestickSeriesRef = useRef<ISeriesApi<'Candlestick'> | null>(null);
+    const volumeSeriesRef = useRef<ISeriesApi<'Histogram'> | null>(null);
+
+    // 날짜를 차트 시간 형식으로 변환하는 헬퍼 함수
+    const toChartTime = (date: string | Date): string => {
+        if (typeof date === 'string') {
+            // YYYY-MM-DD 형식이면 그대로 반환
+            if (/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+                return date;
+            }
+            // YYYYMMDD 형식이면 YYYY-MM-DD로 변환
+            if (/^\d{8}$/.test(date)) {
+                return `${date.slice(0, 4)}-${date.slice(4, 6)}-${date.slice(6, 8)}`;
+            }
+        }
+        // 그 외의 경우 Date 객체로 변환
+        const d = new Date(date);
+        return d.toISOString().split('T')[0]; // "YYYY-MM-DD"
+    };
+
+    // 데이터 계산 (메모이제이션)
+    const processedData = useMemo(() => {
+        if (!data || data.length === 0) return null;
+
+        // 데이터 정렬 (시간 오름차순)
+        const sortedData = [...data].sort((a, b) => {
+            const timeA = new Date(a.date).getTime();
+            const timeB = new Date(b.date).getTime();
+            return timeA - timeB;
+        });
+        const closes = sortedData.map(d => d.close);
+
+        // 기술적 지표 계산
+        const bollinger = calculateBollingerBands(closes, 20);
+        const sma5 = calculateSMA(closes, 5);
+        const sma60 = calculateSMA(closes, 60);
+        const rsi = calculateRSI(closes, 14);
+        const { macd, signal, histogram } = calculateMACD(closes);
+
+        // 캔들스틱 데이터 변환 (날짜 문자열을 YYYY-MM-DD 형식으로 변환)
+        const candles: CandlestickData[] = sortedData.map(item => ({
+            time: toChartTime(item.date) as any,
+            open: item.open,
+            high: item.high,
+            low: item.low,
+            close: item.close,
+        }));
+
+        // 거래량 데이터 (한국 시장 색상 적용)
+        const volumes: HistogramData[] = sortedData.map(item => ({
+            time: toChartTime(item.date) as any,
+            value: item.volume,
+            color: item.close >= item.open
+                ? 'rgba(239, 68, 68, 0.6)'  // 상승: 빨강
+                : 'rgba(59, 130, 246, 0.6)'  // 하락: 파랑
+        }));
+
+        // 볼린저 밴드 데이터
+        const bbUpperData: LineData[] = sortedData
+            .map((item, i) => ({
+                time: toChartTime(item.date) as any,
+                value: bollinger.upper[i],
+            }))
+            .filter(d => !isNaN(d.value));
+
+        const bbMiddleData: LineData[] = sortedData
+            .map((item, i) => ({
+                time: toChartTime(item.date) as any,
+                value: bollinger.middle[i],
+            }))
+            .filter(d => !isNaN(d.value));
+
+        const bbLowerData: LineData[] = sortedData
+            .map((item, i) => ({
+                time: toChartTime(item.date) as any,
+                value: bollinger.lower[i],
+            }))
+            .filter(d => !isNaN(d.value));
+
+        // 이동평균선 데이터
+        const sma5Data: LineData[] = sortedData
+            .map((item, i) => ({
+                time: toChartTime(item.date) as any,
+                value: sma5[i],
+            }))
+            .filter(d => !isNaN(d.value));
+
+        const sma60Data: LineData[] = sortedData
+            .map((item, i) => ({
+                time: toChartTime(item.date) as any,
+                value: sma60[i],
+            }))
+            .filter(d => !isNaN(d.value));
+
+        // RSI 데이터
+        const rsiData: LineData[] = sortedData
+            .map((item, i) => ({
+                time: toChartTime(item.date) as any,
+                value: rsi[i],
+            }))
+            .filter(d => !isNaN(d.value));
+
+        // RSI 기준선 (30, 50, 70)
+        const rsiLine30: LineData[] = sortedData.map(item => ({
+            time: toChartTime(item.date) as any,
+            value: 30,
+        }));
+        const rsiLine50: LineData[] = sortedData.map(item => ({
+            time: toChartTime(item.date) as any,
+            value: 50,
+        }));
+        const rsiLine70: LineData[] = sortedData.map(item => ({
+            time: toChartTime(item.date) as any,
+            value: 70,
+        }));
+
+        // MACD 데이터
+        const macdHistogramData: HistogramData[] = sortedData
+            .map((item, i) => ({
+                time: toChartTime(item.date) as any,
+                value: histogram[i],
+                color: histogram[i] >= 0
+                    ? 'rgba(239, 68, 68, 0.6)'  // 양수: 빨강
+                    : 'rgba(59, 130, 246, 0.6)'  // 음수: 파랑
+            }))
+            .filter(d => !isNaN(d.value));
+
+        const macdLineData: LineData[] = sortedData
+            .map((item, i) => ({
+                time: toChartTime(item.date) as any,
+                value: macd[i],
+            }))
+            .filter(d => !isNaN(d.value));
+
+        const signalLineData: LineData[] = sortedData
+            .map((item, i) => ({
+                time: toChartTime(item.date) as any,
+                value: signal[i],
+            }))
+            .filter(d => !isNaN(d.value));
+
+        return {
+            candles,
+            volumes,
+            bollinger: { upper: bbUpperData, middle: bbMiddleData, lower: bbLowerData },
+            sma5: sma5Data,
+            sma60: sma60Data,
+            rsi: { data: rsiData, line30: rsiLine30, line50: rsiLine50, line70: rsiLine70 },
+            macd: { histogram: macdHistogramData, line: macdLineData, signal: signalLineData },
+        };
+    }, [data]);
+
+    // 공통 차트 옵션
+    const getChartOptions = (height: number) => ({
+        layout: {
+            background: { color: COLORS.background },
+            textColor: COLORS.text,
+            fontSize: 11,
+        },
+        grid: {
+            vertLines: { color: '#1a1f2e', style: 1 },  // 더 얇은 그리드
+            horzLines: { color: '#1a1f2e', style: 1 },
+        },
+        crosshair: {
+            mode: CrosshairMode.Normal,
+            vertLine: {
+                color: '#4a5568',
+                width: 1,
+                style: 2,  // dashed
+            },
+            horzLine: {
+                color: '#4a5568',
+                width: 1,
+                style: 2,
+            },
+        },
+        timeScale: {
+            borderColor: COLORS.border,
+            timeVisible: true,
+            secondsVisible: false,
+            borderVisible: false,  // 테두리 제거
+        },
+        rightPriceScale: {
+            borderColor: COLORS.border,
+            borderVisible: false,  // 테두리 제거
+        },
+        height,
+    });
+
+    // 차트 초기화 및 데이터 설정
+    useEffect(() => {
+        if (!processedData ||
+            !mainChartRef.current ||
+            !volumeChartRef.current ||
+            !rsiChartRef.current ||
+            !macdChartRef.current) {
+            return;
+        }
+
+        const containerWidth = mainChartRef.current.clientWidth;
+
+        try {
+            // === 1. 메인 차트 (캔들스틱 + 지표) ===
+            const mainChart = createChart(mainChartRef.current, {
+                ...getChartOptions(365),
+                width: containerWidth,
+            });
+
+            // 캔들스틱 시리즈 (한국 시장 색상)
+            const candlestickSeries = (mainChart ).addCandlestickSeries({
+                upColor: COLORS.candleUp,
+                downColor: COLORS.candleDown,
+                borderVisible: false,
+                wickUpColor: COLORS.candleUp,
+                wickDownColor: COLORS.candleDown,
+            });
+            candlestickSeries.setData(processedData.candles);
+
+            // 볼린저 밴드
+            const bbUpperSeries = (mainChart ).addLineSeries({
+                color: COLORS.bbLine,
+                lineWidth: 1,
+            });
+            bbUpperSeries.setData(processedData.bollinger.upper);
+
+            const bbMiddleSeries = (mainChart ).addLineSeries({
+                color: COLORS.ma20,
+                lineWidth: 1,
+            });
+            bbMiddleSeries.setData(processedData.bollinger.middle);
+
+            const bbLowerSeries = (mainChart ).addLineSeries({
+                color: COLORS.bbLine,
+                lineWidth: 1,
+            });
+            bbLowerSeries.setData(processedData.bollinger.lower);
+
+            // 5일 이동평균선
+            const sma5Series = (mainChart ).addLineSeries({
+                color: COLORS.ma5,
+                lineWidth: 1.5,
+            });
+            sma5Series.setData(processedData.sma5);
+
+            // 60일 이동평균선
+            const sma60Series = (mainChart ).addLineSeries({
+                color: COLORS.ma60,
+                lineWidth: 1.5,
+            });
+            sma60Series.setData(processedData.sma60);
+
+            // === 2. 거래량 차트 ===
+            const volumeChart = createChart(volumeChartRef.current, {
+                ...getChartOptions(67),
+                width: containerWidth,
+            });
+
+            const volumeSeries = (volumeChart ).addHistogramSeries({
+                priceFormat: {
+                    type: 'volume',
+                },
+            });
+            volumeSeries.setData(processedData.volumes);
+
+            // === 3. RSI 차트 ===
+            const rsiChart = createChart(rsiChartRef.current, {
+                ...getChartOptions(100),
+                width: containerWidth,
+            });
+
+            // RSI 라인
+            const rsiSeries = (rsiChart ).addLineSeries({
+                color: COLORS.rsi,
+                lineWidth: 2,
+            });
+            rsiSeries.setData(processedData.rsi.data);
+
+            // RSI 기준선 (30, 50, 70)
+            const rsiLine30Series = (rsiChart ).addLineSeries({
+                color: COLORS.border,
+                lineWidth: 1,
+                lineStyle: 2, // dashed
+                crosshairMarkerVisible: false,
+            });
+            rsiLine30Series.setData(processedData.rsi.line30);
+
+            const rsiLine50Series = (rsiChart ).addLineSeries({
+                color: COLORS.border,
+                lineWidth: 1,
+                lineStyle: 2,
+                crosshairMarkerVisible: false,
+            });
+            rsiLine50Series.setData(processedData.rsi.line50);
+
+            const rsiLine70Series = (rsiChart ).addLineSeries({
+                color: COLORS.border,
+                lineWidth: 1,
+                lineStyle: 2,
+                crosshairMarkerVisible: false,
+            });
+            rsiLine70Series.setData(processedData.rsi.line70);
+
+            // RSI Y축 범위 고정 (0-100)
+            (rsiChart ).priceScale('right').applyOptions({
+                scaleMargins: {
+                    top: 0.1,
+                    bottom: 0.1,
+                },
+            });
+
+            // === 4. MACD 차트 ===
+            const macdChart = createChart(macdChartRef.current, {
+                ...getChartOptions(100),
+                width: containerWidth,
+            });
+
+            // MACD 히스토그램
+            const macdHistogramSeries = (macdChart ).addHistogramSeries();
+            macdHistogramSeries.setData(processedData.macd.histogram);
+
+            // MACD 라인
+            const macdLineSeries = (macdChart ).addLineSeries({
+                color: COLORS.macd,
+                lineWidth: 1.5,
+            });
+            macdLineSeries.setData(processedData.macd.line);
+
+            // Signal 라인
+            const signalLineSeries = (macdChart ).addLineSeries({
+                color: COLORS.signal,
+                lineWidth: 1.5,
+            });
+            signalLineSeries.setData(processedData.macd.signal);
+
+            // === 시간축 동기화 ===
+            // 초기 visible range 설정 (모든 차트가 동일한 범위를 보이도록)
+            mainChart.timeScale().fitContent();
+
+            // 메인 차트의 visible range를 다른 차트들에 적용
+            const initialRange = mainChart.timeScale().getVisibleRange();
+            if (initialRange) {
+                volumeChart.timeScale().setVisibleRange(initialRange);
+                rsiChart.timeScale().setVisibleRange(initialRange);
+                macdChart.timeScale().setVisibleRange(initialRange);
+            }
+
+            // 실시간 동기화
+            mainChart.timeScale().subscribeVisibleTimeRangeChange((timeRange) => {
+                if (timeRange) {
+                    volumeChart.timeScale().setVisibleRange(timeRange);
+                    rsiChart.timeScale().setVisibleRange(timeRange);
+                    macdChart.timeScale().setVisibleRange(timeRange);
+                }
+            });
+
+            // === 모든 차트 설정 완료 후 refs에 저장 ===
+            // (cleanup이 부분적으로 구성된 차트를 제거하지 않도록)
+            mainChartInstanceRef.current = mainChart;
+            volumeChartInstanceRef.current = volumeChart;
+            rsiChartInstanceRef.current = rsiChart;
+            macdChartInstanceRef.current = macdChart;
+            candlestickSeriesRef.current = candlestickSeries;
+            volumeSeriesRef.current = volumeSeries;
+
+            // === 반응형 처리 ===
+            const handleResize = () => {
+                const width = mainChartRef.current?.clientWidth || 0;
+                mainChart.applyOptions({ width });
+                volumeChart.applyOptions({ width });
+                rsiChart.applyOptions({ width });
+                macdChart.applyOptions({ width });
+            };
+
+            window.addEventListener('resize', handleResize);
+
+            // Cleanup
+            return () => {
+                window.removeEventListener('resize', handleResize);
+
+                // Safely remove chart instances
+                try {
+                    if (mainChartInstanceRef.current) {
+                        mainChartInstanceRef.current.remove();
+                        mainChartInstanceRef.current = null;
+                    }
+                } catch (e) {
+                    // Chart already disposed
+                }
+
+                try {
+                    if (volumeChartInstanceRef.current) {
+                        volumeChartInstanceRef.current.remove();
+                        volumeChartInstanceRef.current = null;
+                    }
+                } catch (e) {
+                    // Chart already disposed
+                }
+
+                try {
+                    if (rsiChartInstanceRef.current) {
+                        rsiChartInstanceRef.current.remove();
+                        rsiChartInstanceRef.current = null;
+                    }
+                } catch (e) {
+                    // Chart already disposed
+                }
+
+                try {
+                    if (macdChartInstanceRef.current) {
+                        macdChartInstanceRef.current.remove();
+                        macdChartInstanceRef.current = null;
+                    }
+                } catch (e) {
+                    // Chart already disposed
+                }
+            };
+        } catch (error: any) {
+            console.error('❌ 차트 렌더링 중 오류 발생:', error);
+            console.error('오류 상세:', {
+                message: error?.message || '알 수 없는 오류',
+                stack: error?.stack,
+                processedData: processedData,
+            });
+        }
+    }, [processedData]);
+
+    return (
+        <div className="w-full h-[665px] relative bg-[#0b0e14] rounded-lg overflow-hidden">
+            {/* 메인 차트 (55%) - 더 크게 */}
+            <div ref={mainChartRef} style={{ height: '365px' }} />
+
+            {/* 거래량 (10%) */}
+            <div ref={volumeChartRef} style={{ height: '67px', marginTop: '2px' }} />
+
+            {/* RSI (15%) */}
+            <div ref={rsiChartRef} style={{ height: '100px', marginTop: '2px' }} />
+
+            {/* MACD (15%) */}
+            <div ref={macdChartRef} style={{ height: '100px', marginTop: '2px' }} />
+
+            {/* 간소화된 범례 - 배경 투명도 높임 */}
+            <div className="absolute top-2 left-2 text-[10px]">
+                <div className="flex gap-2 bg-gray-900/60 px-2 py-1 rounded backdrop-blur-sm">
+                    <span className="text-[#fbbf24]">MA5</span>
+                    <span className="text-[#f6ad55]">MA20</span>
+                    <span className="text-[#10b981]">MA60</span>
+                    <span className="text-gray-500">|</span>
+                    <span className="text-[#4a5568]">BB</span>
+                </div>
+            </div>
+
+            {/* 한국 시장 표시 - 더 작게 */}
+            <div className="absolute top-2 right-2 text-[10px]">
+                <div className="flex gap-1.5 bg-gray-900/60 px-2 py-1 rounded backdrop-blur-sm">
+                    <span className="flex items-center gap-1">
+                        <div className="w-2 h-2 bg-[#ef4444] rounded-sm"></div>
+                        <span className="text-gray-400">상승</span>
+                    </span>
+                    <span className="flex items-center gap-1">
+                        <div className="w-2 h-2 bg-[#3b82f6] rounded-sm"></div>
+                        <span className="text-gray-400">하락</span>
+                    </span>
+                </div>
+            </div>
+        </div>
+    );
+};
diff --git a/frontend/src/config.ts b/frontend/src/config.ts
index da00c54..6d36665 100644
--- a/frontend/src/config.ts
+++ b/frontend/src/config.ts
@@ -1,5 +1,13 @@
 const API_BASE_URL = import.meta.env.VITE_API_URL || 'http://localhost:8000'
-const WS_BASE_URL = import.meta.env.VITE_WS_URL || 'ws://localhost:8000'
+
+// WebSocket URL: 현재 페이지 기준으로 자동 결정 (Docker/로컬 모두 호환)
+const deriveWsUrl = () => {
+    const env = import.meta.env.VITE_WS_URL
+    if (env) return env
+    const proto = window.location.protocol === 'https:' ? 'wss:' : 'ws:'
+    return `${proto}//${window.location.host}`
+}
+const WS_BASE_URL = deriveWsUrl()
 
 export const config = {
     apiBaseUrl: API_BASE_URL,
diff --git a/frontend/src/hooks/useWebSocket.ts b/frontend/src/hooks/useWebSocket.ts
index b3cc1de..abb4608 100644
--- a/frontend/src/hooks/useWebSocket.ts
+++ b/frontend/src/hooks/useWebSocket.ts
@@ -1,4 +1,4 @@
-import { useEffect, useState, useCallback } from 'react'
+import { useEffect, useState, useCallback, useRef } from 'react'
 import { config } from '../config'
 
 interface WebSocketMessage {
@@ -10,40 +10,91 @@ export const useWebSocket = (clientId: string) => {
     const [socket, setSocket] = useState<WebSocket | null>(null)
     const [messages, setMessages] = useState<WebSocketMessage[]>([])
     const [connected, setConnected] = useState(false)
+    const reconnectTimeoutRef = useRef<NodeJS.Timeout | null>(null)
+    const pingIntervalRef = useRef<NodeJS.Timeout | null>(null)
+    const reconnectAttemptsRef = useRef(0)
+    const mountedRef = useRef(true)
+    const baseDelay = 3000
 
-    useEffect(() => {
-        const ws = new WebSocket(`${config.wsBaseUrl}/ws/${clientId}`)
+    const connect = useCallback(() => {
+        if (!mountedRef.current) return
 
-        ws.onopen = () => {
-            console.log('WebSocket connected')
-            setConnected(true)
-        }
+        try {
+            const ws = new WebSocket(`${config.wsBaseUrl}/ws/${clientId}`)
 
-        ws.onmessage = (event) => {
-            try {
-                const message = JSON.parse(event.data) as WebSocketMessage
-                setMessages((prev: WebSocketMessage[]) => [...prev, message])
-            } catch (error) {
-                console.error('Failed to parse WebSocket message:', error)
+            ws.onopen = () => {
+                console.log('🔗 WebSocket connected')
+                setConnected(true)
+                reconnectAttemptsRef.current = 0
+
+                // 30초마다 ping 전송 (Nginx/프록시 타임아웃 방지)
+                pingIntervalRef.current = setInterval(() => {
+                    if (ws.readyState === WebSocket.OPEN) {
+                        ws.send(JSON.stringify({ type: 'ping' }))
+                    }
+                }, 30000)
             }
-        }
 
-        ws.onerror = (error) => {
-            console.error('WebSocket error:', error)
-        }
+            ws.onmessage = (event) => {
+                try {
+                    const message = JSON.parse(event.data) as WebSocketMessage
+                    if (message.type === 'pong') return
+                    setMessages((prev: WebSocketMessage[]) => [...prev, message])
+                } catch (error) {
+                    console.error('Failed to parse WebSocket message:', error)
+                }
+            }
 
-        ws.onclose = () => {
-            console.log('WebSocket disconnected')
-            setConnected(false)
-        }
+            ws.onerror = () => {
+                // onclose가 항상 뒤따르므로 여기서는 무시
+            }
 
-        setSocket(ws)
+            ws.onclose = () => {
+                console.log('🔌 WebSocket disconnected')
+                setConnected(false)
+                setSocket(null)
 
-        return () => {
-            ws.close()
+                if (pingIntervalRef.current) {
+                    clearInterval(pingIntervalRef.current)
+                    pingIntervalRef.current = null
+                }
+
+                // 지수 백오프 재연결 (최대 30초 간격, 무제한 재시도)
+                if (mountedRef.current) {
+                    const attempt = reconnectAttemptsRef.current
+                    const delay = Math.min(baseDelay * Math.pow(1.5, attempt), 30000)
+                    reconnectAttemptsRef.current += 1
+                    console.log(`🔄 Reconnecting WebSocket in ${(delay / 1000).toFixed(1)}s (attempt ${attempt + 1})...`)
+                    reconnectTimeoutRef.current = setTimeout(() => {
+                        connect()
+                    }, delay)
+                }
+            }
+
+            setSocket(ws)
+        } catch (error) {
+            console.error('Failed to create WebSocket:', error)
         }
     }, [clientId])
 
+    useEffect(() => {
+        mountedRef.current = true
+        connect()
+
+        return () => {
+            mountedRef.current = false
+            if (reconnectTimeoutRef.current) {
+                clearTimeout(reconnectTimeoutRef.current)
+            }
+            if (pingIntervalRef.current) {
+                clearInterval(pingIntervalRef.current)
+            }
+            if (socket) {
+                socket.close()
+            }
+        }
+    }, [connect])
+
     const sendMessage = useCallback((message: string) => {
         if (socket && connected) {
             socket.send(message)
diff --git a/frontend/src/main.tsx b/frontend/src/main.tsx
index a1e2d38..545139f 100644
--- a/frontend/src/main.tsx
+++ b/frontend/src/main.tsx
@@ -17,7 +17,12 @@ const queryClient = new QueryClient({
 ReactDOM.createRoot(document.getElementById('root')!).render(
     <React.StrictMode>
         <QueryClientProvider client={queryClient}>
-            <BrowserRouter>
+            <BrowserRouter
+                future={{
+                    v7_startTransition: true,
+                    v7_relativeSplatPath: true,
+                }}
+            >
                 <App />
             </BrowserRouter>
         </QueryClientProvider>
diff --git a/frontend/src/pages/Dashboard.css b/frontend/src/pages/Dashboard.css
index 784b135..73c9872 100644
--- a/frontend/src/pages/Dashboard.css
+++ b/frontend/src/pages/Dashboard.css
@@ -1,660 +1,18 @@
-/* HTS 대시보드 컨테이너 */
-.hts-container {
-    height: 100%;
-    display: flex;
-    flex-direction: column;
-    background: #000000;
-    color: #e0e6ed;
-    font-family: 'Segoe UI', 'Malgun Gothic', sans-serif;
-    overflow: hidden;
-}
-
-/* 메인 레이아웃 */
-.hts-main-layout {
-    display: grid;
-    grid-template-columns: 300px 1fr 420px;
-    gap: 12px;
-    padding: 12px;
-    flex: 1;
-    overflow: hidden;
-}
-
-/* 왼쪽 패널: 계좌 정보 & 보유종목 */
-.left-panel {
-    background: #1a1a1a;
-    border: 1px solid #333;
-    border-radius: 4px;
-    display: flex;
-    flex-direction: column;
-    overflow: hidden;
-}
-
-.panel-header {
-    padding: 12px 15px;
-    background: #222;
-    border-bottom: 1px solid #333;
-    font-weight: 600;
-    font-size: 14px;
-}
-
-.balance-info {
-    padding: 12px 15px;
-    background: #111;
-    border-bottom: 1px solid #333;
-}
-
-.balance-row {
-    display: flex;
-    justify-content: space-between;
-    margin-bottom: 8px;
-    font-size: 13px;
-}
-
-.balance-row span:first-child {
-    color: #999;
-}
-
-.balance-row span.up {
-    color: #ff3b3b;
-    font-weight: 600;
-}
-
-.balance-row span.down {
-    color: #2979ff;
-    font-weight: 600;
-}
-
-.portfolio-list {
-    flex: 1;
-    overflow-y: auto;
-    padding: 8px;
-}
-
-.portfolio-item {
-    padding: 10px;
-    margin-bottom: 6px;
-    background: #222;
-    border: 1px solid #333;
-    border-radius: 4px;
-    cursor: pointer;
-    transition: all 0.2s;
-}
-
-.portfolio-item:hover {
-    background: #2a2a2a;
-    border-color: #4fc3f7;
-}
-
-.portfolio-item .stock-name {
-    font-weight: 600;
-    font-size: 13px;
-    margin-bottom: 6px;
-    display: block;
-    color: #fff;
-}
-
-.portfolio-item .stock-info {
-    display: flex;
-    justify-content: space-between;
-    font-size: 11px;
-    color: #999;
-}
-
-.portfolio-item .stock-info span.up {
-    color: #ff3b3b;
-    font-weight: 600;
-}
-
-.portfolio-item .stock-info span.down {
-    color: #2979ff;
-    font-weight: 600;
-}
-
-/* 중앙 패널 */
-.center-panel {
-    display: flex;
-    flex-direction: column;
-    gap: 8px;
-    overflow: hidden;
-}
-
-/* 차트 섹션 */
-.chart-section {
-    background: #1a1a1a;
-    border: 1px solid #333;
-    border-radius: 4px;
-    padding: 15px;
-    display: flex;
-    flex-direction: column;
-    min-height: 420px;
-    flex: 1;
-}
-
-.chart-toolbar {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    margin-bottom: 12px;
-    gap: 12px;
-    flex-wrap: wrap;
-}
-
-.chart-stocks {
-    display: flex;
-    gap: 8px;
-    flex-wrap: wrap;
-}
-
-.chart-stock {
-    background: #111;
-    border: 1px solid #333;
-    border-radius: 4px;
-    padding: 8px 12px;
-    display: flex;
-    flex-direction: column;
-    min-width: 120px;
-    cursor: pointer;
-    transition: all 0.2s;
-}
-
-.chart-stock .name {
-    font-size: 13px;
-    font-weight: 600;
-    color: #fff;
-    margin-bottom: 4px;
-}
-
-.chart-stock .rate {
-    font-size: 11px;
-    font-weight: 600;
-}
-
-.chart-stock.active {
-    border-color: #00ff88;
-    box-shadow: 0 0 12px rgba(0, 255, 136, 0.2);
-}
-
-.chart-actions {
-    display: flex;
-    align-items: center;
-    gap: 12px;
-}
-
-.ws-status {
-    padding: 6px 12px;
-    border-radius: 999px;
-    font-size: 11px;
-    font-weight: 600;
-    background: rgba(136, 146, 176, 0.2);
-    border: 1px solid rgba(136, 146, 176, 0.4);
-}
-
-.ws-status.online {
-    background: rgba(0, 255, 136, 0.15);
-    border-color: rgba(0, 255, 136, 0.5);
-    color: #00ff88;
-}
-
-.ws-status.offline {
-    color: #8892b0;
-}
-
-.chart-period {
-    display: flex;
-    gap: 6px;
-}
-
-.chart-period button {
-    padding: 6px 12px;
-    border-radius: 4px;
-    border: 1px solid #333;
-    background: #111;
-    color: #8892b0;
-    font-size: 12px;
-    font-weight: 600;
-    cursor: pointer;
-    transition: all 0.2s;
-}
-
-.chart-period button.active,
-.chart-period button:hover {
-    border-color: #00ff88;
-    color: #00ff88;
-}
-
-.chart-container {
-    flex: 1;
-    min-height: 340px;
-    background: #0a0a0a;
-    border: 1px solid #222;
-    border-radius: 4px;
-    padding: 8px;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-}
-
-/* 거래 이력 섹션 */
-.trades-section {
-    background: #1a1a1a;
-    border: 1px solid #333;
-    border-radius: 4px;
-    padding: 15px;
-    overflow: hidden;
-    display: flex;
-    flex-direction: column;
-    min-height: 280px;
-    max-height: 320px;
-}
-
-.trades-table-container {
-    flex: 1;
-    overflow-y: auto;
-}
-
-.trades-table {
-    width: 100%;
-    border-collapse: collapse;
-}
-
-.trades-table thead {
-    position: sticky;
-    top: 0;
-    background: #1a1a1a;
-    z-index: 1;
-}
-
-.trades-table th {
-    padding: 8px;
-    font-size: 11px;
-    color: #999;
-    font-weight: 600;
-    text-align: left;
-    border-bottom: 1px solid #333;
-}
-
-.trades-table td {
-    padding: 8px;
-    font-size: 11px;
-    color: #ccc;
-    border-bottom: 1px solid #222;
-}
-
-.trades-table tbody tr:hover {
-    background: #222;
-}
-
-.trade-status {
-    padding: 2px 6px;
-    border-radius: 3px;
-    font-size: 10px;
-    font-weight: 600;
-}
-
-.trade-status.executed {
-    background: rgba(76, 175, 80, 0.2);
-    color: #4caf50;
-}
-
-.trade-status.pending {
-    background: rgba(255, 152, 0, 0.2);
-    color: #ff9800;
-}
-
-.trade-status.failed {
-    background: rgba(244, 67, 54, 0.2);
-    color: #f44336;
-}
-
-/* 오른쪽 패널 */
-.right-panel {
-    display: flex;
-    flex-direction: column;
-    gap: 8px;
-}
-
-.recommend-section,
-.mcp-status-section,
-.news-section,
-.ai-analysis-section,
-.risk-check-section {
-    background: #1a1a1a;
-    border: 1px solid #333;
-    border-radius: 4px;
-    padding: 15px;
-    display: flex;
-    flex-direction: column;
-}
-
-.ai-analysis-section {
-    min-height: 180px;
-    max-height: 220px;
-}
-
-.risk-check-section {
-    min-height: 150px;
-    max-height: 180px;
-}
-
-.analysis-content,
-.risk-content {
-    flex: 1;
-    overflow-y: auto;
-    padding: 12px;
-    background: #0a0a0a;
-    border: 1px solid #222;
-    border-radius: 4px;
-    font-size: 12px;
-    line-height: 1.6;
-    color: #ccc;
-}
-
-.analysis-loading,
-.risk-loading {
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    height: 100%;
-    color: #666;
-    font-size: 12px;
-}
-
-.risk-item {
-    padding: 8px;
-    margin-bottom: 6px;
-    background: #111;
-    border: 1px solid #333;
-    border-radius: 4px;
-    font-size: 11px;
-}
-
-.risk-item-header {
-    display: flex;
-    justify-content: space-between;
-    margin-bottom: 4px;
-    font-weight: 600;
-}
-
-.risk-level {
-    padding: 2px 8px;
-    border-radius: 3px;
-    font-size: 10px;
-}
-
-.risk-level.low {
-    background: rgba(76, 175, 80, 0.2);
-    color: #4caf50;
-}
-
-.risk-level.medium {
-    background: rgba(255, 152, 0, 0.2);
-    color: #ff9800;
-}
-
-.risk-level.high {
-    background: rgba(244, 67, 54, 0.2);
-    color: #f44336;
-}
-
-.risk-description {
-    color: #999;
-    font-size: 10px;
-    line-height: 1.4;
-}
-
-.recommend-section {
-    min-height: 300px;
-    max-height: 360px;
-}
-
-.recommend-list {
-    display: flex;
-    flex-direction: column;
-    gap: 8px;
-    overflow-y: auto;
-    flex: 1;
-}
-
-.recommend-item {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    width: 100%;
-    background: #111;
-    border: 1px solid #333;
-    border-radius: 4px;
-    padding: 10px 12px;
-    cursor: pointer;
-    transition: all 0.2s;
-}
-
-.recommend-item .info {
-    display: flex;
-    flex-direction: column;
-    gap: 4px;
-}
-
-.recommend-item .info .name {
-    font-size: 13px;
-    font-weight: 600;
-    color: #fff;
-}
-
-.recommend-item .info .code {
-    font-size: 10px;
-    color: #666;
-    letter-spacing: 0.5px;
-}
-
-.recommend-item .figures {
-    display: flex;
-    flex-direction: column;
-    align-items: flex-end;
-    gap: 4px;
-}
-
-.recommend-item .figures .price {
-    font-size: 13px;
-    font-weight: 600;
-    color: #fff;
-}
-
-.recommend-item .figures .rate {
-    font-size: 11px;
-    font-weight: 600;
-}
-
-.recommend-item:hover,
-.recommend-item.active {
-    border-color: #00ff88;
-    box-shadow: 0 0 12px rgba(0, 255, 136, 0.2);
-}
-
-.btn-small {
-    background: #1a1a1a;
-    border: 1px solid #333;
-    color: #4fc3f7;
-    border-radius: 4px;
-    cursor: pointer;
-    transition: all 0.2s;
-}
-
-.btn-small:hover {
-    background: #222;
-    border-color: #4fc3f7;
-}
-
-.btn-primary {
-    background: #4fc3f7;
-    color: #000;
-    border: none;
-    border-radius: 4px;
-    font-weight: 600;
-    cursor: pointer;
-    transition: all 0.2s;
-}
-
-.btn-primary:hover {
-    background: #6fd4ff;
-}
-
-.btn-primary:disabled {
-    background: #2a4a5a;
-    color: #666;
-    cursor: not-allowed;
-}
-
-.mcp-status-section {
-    display: flex;
-    flex-direction: column;
-    gap: 12px;
-}
-
-.mcp-status {
-    display: flex;
-    align-items: center;
-    gap: 10px;
-    padding: 10px;
-    background: #222;
-    border-radius: 4px;
-    margin-bottom: 10px;
-}
-
-.status-indicator {
-    width: 12px;
-    height: 12px;
-    border-radius: 50%;
-    animation: pulse 2s infinite;
-}
-
-.status-indicator.connected {
-    background: #4caf50;
-}
-
-.status-indicator.disconnected {
-    background: #f44336;
-}
-
-@keyframes pulse {
-
-    0%,
-    100% {
-        opacity: 1;
-    }
-
-    50% {
-        opacity: 0.5;
-    }
-}
-
-.status-text {
-    flex: 1;
-}
-
-.status-label {
-    font-size: 11px;
-    color: #999;
-}
-
-.status-value {
-    font-size: 13px;
-    font-weight: 600;
-    color: #fff;
-}
-
-.mcp-tools-grid {
-    display: grid;
-    grid-template-columns: repeat(2, 1fr);
-    gap: 6px;
-}
-
-.mcp-tool-badge {
-    padding: 6px;
-    background: #111;
-    border: 1px solid #333;
-    border-radius: 3px;
-    font-size: 10px;
-    color: #999;
-    text-align: center;
-}
-
-.news-section {
-    flex: 1;
-    min-height: 180px;
-    max-height: 220px;
-    overflow: hidden;
-}
-
-.news-section .news-list {
-    max-height: 160px;
-    overflow-y: auto;
-}
-
-.news-list {
-    display: flex;
-    flex-direction: column;
-    gap: 8px;
-}
-
-.news-item {
-    padding: 10px;
-    background: #222;
-    border: 1px solid #333;
-    border-radius: 4px;
-    cursor: pointer;
-    transition: all 0.2s;
-}
-
-.news-item:hover {
-    border-color: #4fc3f7;
-    transform: translateX(2px);
-}
-
-.news-title {
-    font-size: 12px;
-    font-weight: 600;
-    color: #fff;
-    margin-bottom: 4px;
-    line-height: 1.3;
-}
-
-.news-meta {
-    font-size: 10px;
-    color: #666;
-}
-
-/* 공통 */
-.no-data {
-    padding: 40px 20px;
-    text-align: center;
-    color: #666;
-    font-size: 13px;
-}
-
-/* 색상 */
-.up {
-    color: #ff3b3b !important;
-}
-
-.down {
-    color: #2979ff !important;
-}
-
-/* 스크롤바 */
-::-webkit-scrollbar {
+/* Custom Scrollbar for Dashboard containers */
+.custom-scrollbar::-webkit-scrollbar {
     width: 6px;
     height: 6px;
 }
 
-::-webkit-scrollbar-track {
-    background: #1a1a1a;
+.custom-scrollbar::-webkit-scrollbar-track {
+    background: transparent;
 }
 
-::-webkit-scrollbar-thumb {
-    background: #333;
+.custom-scrollbar::-webkit-scrollbar-thumb {
+    background: #374151; /* gray-700 */
     border-radius: 3px;
 }
 
-::-webkit-scrollbar-thumb:hover {
-    background: #444;
-}
\ No newline at end of file
+.custom-scrollbar::-webkit-scrollbar-thumb:hover {
+    background: #4b5563; /* gray-600 */
+}
diff --git a/frontend/src/pages/Dashboard.tsx b/frontend/src/pages/Dashboard.tsx
index 56b7206..885aba3 100644
--- a/frontend/src/pages/Dashboard.tsx
+++ b/frontend/src/pages/Dashboard.tsx
@@ -1,922 +1,784 @@
-import { useQuery } from '@tanstack/react-query'
+import { useEffect, useState, useRef } from 'react'
+import { useQuery, useQueryClient } from '@tanstack/react-query'
 import api from '../lib/api'
 import { useWebSocket } from '../hooks/useWebSocket'
-import { useEffect, useMemo, useState } from 'react'
-import HtsPage from '../components/HtsPage'
-import CandlestickChart from '../components/CandlestickChart'
+import { PortfolioSummary } from '../components/PortfolioSummary'
+import { TradingChart } from '../components/TradingChart'
+import { Activity, Brain, RefreshCw } from 'lucide-react'
 import './Dashboard.css'
 
-const Dashboard = () => {
-    console.log('🚀 Dashboard component mounted')
+// 마켓 운영 시간 체크 (한국장 + 미국장)
+const checkMarketOpen = () => {
+    const now = new Date();
+    const kstTime = new Date(now.toLocaleString("en-US", { timeZone: "Asia/Seoul" }));
+    const day = kstTime.getDay();
+    const currentMinutes = kstTime.getHours() * 60 + kstTime.getMinutes();
 
-    const { connected: wsConnected } = useWebSocket('dashboard')
+    // 주말 체크 (토요일 오전 7시 이후 ~ 일요일은 폐장)
+    if (day === 0 || (day === 6 && currentMinutes >= 420)) return false; // 일요일 or 토요일 7시 이후
+
+    // 한국장: 월~금 09:00 ~ 15:30 (540 ~ 930)
+    const isKoreaOpen = currentMinutes >= 540 && currentMinutes <= 930;
+
+    // 미국장 (서머타임 고려):
+    // - 여름(3월~11월): 22:30 ~ 다음날 05:00 (1350 ~ 1440 + 0 ~ 300)
+    // - 겨울(11월~3월): 23:30 ~ 다음날 06:00 (1410 ~ 1440 + 0 ~ 360)
+    // 간단히: 22:30 ~ 다음날 06:00 (1350 ~ 1440 + 0 ~ 360)
+    const isUSOpen = currentMinutes >= 1350 || currentMinutes <= 360;
+
+    // 금요일 밤 ~ 토요일 새벽은 미국장 개장 (금요일 22:30 ~ 토요일 06:00)
+    if (day === 5 && currentMinutes >= 1350) return true; // 금요일 밤
+    if (day === 6 && currentMinutes <= 360) return true;  // 토요일 새벽 (미국 금요일)
+
+    return isKoreaOpen || isUSOpen;
+};
+
+const Dashboard = () => {
+    const { connected: wsConnected, messages: wsMessages } = useWebSocket('dashboard')
     const [selectedStock, setSelectedStock] = useState<string>('')
     const [chartPeriod, setChartPeriod] = useState<'D' | 'W' | 'M'>('D')
-    const [showIndicators, setShowIndicators] = useState(false)
-    const [indicators, setIndicators] = useState({
-        use_macd: false,
-        use_rsi: true,
-        use_bollinger: false,
-        use_moving_average: true,
-        use_stochastic: false,
-        use_adx: false,
-        use_obv: false,
-    })
+    const queryClient = useQueryClient()
+    const prevLatestTradeIdRef = useRef<number | null>(null)
 
-    console.log('🔧 Setting up queries...')
+    const isMarketOpen = checkMarketOpen();
+
+    // --- Queries ---
+    // 장 마감 시에는 자동 폴링 완전 중단 (refetchInterval: false)
 
     const { data: portfolioSummary, error: portfolioSummaryError } = useQuery({
         queryKey: ['portfolio-summary'],
-        queryFn: async () => {
-            console.log('🔵 Fetching portfolio summary...')
-            const response = await api.get('/portfolio/summary')
-            console.log('🟢 Portfolio summary received:', response.data)
-            return response.data
-        },
-        refetchInterval: 5000,
+        queryFn: async () => (await api.get('/portfolio/summary')).data,
+        refetchInterval: isMarketOpen ? 10000 : false,
     })
 
-    const { data: portfolio, error: portfolioError } = useQuery({
+    const { data: portfolio } = useQuery({
         queryKey: ['portfolio'],
         queryFn: async () => {
-            console.log('🔵 Fetching portfolio...')
-            try {
-                const response = await api.get('/portfolio')
-                console.log('🟢 Portfolio received:', response.data)
-                return response.data
-            } catch (error) {
-                console.error('❌ Portfolio fetch error:', error)
-                throw error
-            }
+            const data = (await api.get('/portfolio')).data;
+            // 수량 0인 종목 필터링 (안전장치)
+            return data.filter((item: any) => item.quantity > 0);
         },
-        refetchInterval: 5000,
-        retry: 1,
-    })
-
-    // 에러 로깅
-    useEffect(() => {
-        if (portfolioSummaryError) {
-            console.error('❌ Portfolio Summary Error:', portfolioSummaryError)
-        }
-        if (portfolioError) {
-            console.error('❌ Portfolio Error:', portfolioError)
-        }
-    }, [portfolioSummaryError, portfolioError])
-
-    const { data: recentTrades } = useQuery({
-        queryKey: ['recent-trades'],
-        queryFn: async () => {
-            const response = await api.get('/trades', { params: { limit: 20 } })
-            return response.data
-        },
-        refetchInterval: 5000,
+        refetchInterval: isMarketOpen ? 10000 : false,
     })
 
     const { data: mcpStatus } = useQuery({
         queryKey: ['mcp-status'],
-        queryFn: async () => {
-            const response = await api.get('/mcp/status')
-            return response.data
-        },
-        refetchInterval: 5000,
+        queryFn: async () => (await api.get('/mcp/status')).data,
+        refetchInterval: isMarketOpen ? 5000 : false,
     })
 
-    const { data: news } = useQuery({
-        queryKey: ['market-news'],
-        queryFn: async () => {
-            const response = await api.get('/market-data/news', { params: { limit: 5 } })
-            return response.data
-        },
-        refetchInterval: 30000,
-    })
-
-    // 규칙 기반 자동 추천 (자동 로드)
     const { data: ruleBasedRecommendations } = useQuery({
         queryKey: ['rule-based-recommendations'],
         queryFn: async () => {
-            console.log('🔵 Fetching rule-based recommendations...')
-            try {
-                const response = await api.get('/recommendations/rule-based')
-                console.log('🟢 Rule-based recommendations received:', response.data)
-                return response.data
-            } catch (error) {
-                console.error('🔴 Rule-based recommendations error:', error)
-                throw error
+            const response = await api.get('/recommendations/rule-based', {
+                params: {
+                    realtime: false,
+                    auto_trade: true  // 자동매매 활성화
+                }
+            });
+
+            const data = response.data;
+
+            // 실제로 거래가 체결된 경우에만 거래 내역 갱신
+            if (data.trades_executed && data.trades_executed.length > 0) {
+                setTimeout(() => {
+                    queryClient.invalidateQueries({ queryKey: ['trade-history'] });
+                    console.log('✅ 자동매매 체결:', data.trades_executed.length, '건');
+                }, 3000);
             }
+
+            return data;
         },
-        refetchInterval: 300000, // 5분마다 자동 갱신
+        refetchInterval: isMarketOpen ? 10000 : false,
+        // 장외에도 초기 로드는 실행 (DB 조회는 빠름)
     })
 
-    // 수동 지표 분석 (AI 분석 버튼용)
-    const { data: aiRecommendations, refetch: refetchRecommendations, isLoading: recommendationsLoading, error: recommendationsError } = useQuery({
-        queryKey: ['ai-recommendations', indicators],
-        queryFn: async () => {
-            console.log('🔵 Fetching recommendations with indicators:', indicators)
-            try {
-                const response = await api.get('/recommendations', { params: indicators })
-                console.log('🟢 Recommendations received:', response.data)
-                return response.data
-            } catch (error) {
-                console.error('🔴 Recommendations fetch error:', error)
-                throw error
-            }
-        },
-        enabled: false, // 수동으로만 호출
-    })
-
-    // 추천 종목 에러 로깅
-    if (recommendationsError) {
-        console.error('❌ Recommendations query error:', recommendationsError)
-    }
-
-    // 규칙 기반 추천 로깅
-    if (ruleBasedRecommendations) {
-        console.log('✅ Rule-based Recommendations:', {
-            total: ruleBasedRecommendations.total,
-            activeRules: ruleBasedRecommendations.active_rules,
-            found: ruleBasedRecommendations.recommendations?.length || 0
-        })
-    }
-
-    // 수동 추천 결과 로깅
-    if (aiRecommendations) {
-        console.log('✅ AI Recommendations:', {
-            total: aiRecommendations.total,
-            analyzed: aiRecommendations.analyzed_stocks,
-            found: aiRecommendations.recommendations?.length || 0
-        })
-    }
-
-    const { data: chartData, isLoading: chartLoading, error: chartError } = useQuery({
+    const { data: chartData, isLoading: chartLoading } = useQuery({
         queryKey: ['chart-data', selectedStock, chartPeriod],
         queryFn: async () => {
-            if (!selectedStock) {
-                console.log('⚠️ No stock selected, skipping chart fetch')
-                return null
-            }
-            console.log('🔵 Fetching chart data for:', selectedStock, 'period:', chartPeriod)
-            try {
-                const response = await api.get(`/market-data/chart/${selectedStock}`, {
-                    params: { period: chartPeriod },
-                })
-                console.log('🟢 Chart data received:', {
-                    stock_code: response.data.stock_code,
-                    selectedStock: selectedStock,
-                    dataLength: response.data.data?.length,
-                    firstPrice: response.data.data?.[0]?.close,
-                    match: response.data.stock_code === selectedStock
-                })
-                return response.data
-            } catch (error) {
-                console.error('🔴 Chart data fetch error:', error)
-                throw error
-            }
-        },
-        enabled: Boolean(selectedStock),
-        refetchInterval: 60000,
-    })
-
-    // 차트 에러 로깅
-    if (chartError) {
-        console.error('❌ Chart query error:', chartError)
-    }
-
-    // AI 종합 분석 (선택된 종목에 대해)
-    const { data: aiAnalysis, isLoading: aiAnalysisLoading } = useQuery({
-        queryKey: ['ai-analysis', selectedStock, chartData],
-        queryFn: async () => {
-            if (!selectedStock || !chartData?.data?.[0]) return null
-            console.log('🔵 Fetching AI analysis for:', selectedStock)
-            try {
-                const response = await fetch('http://localhost:8001/analyze', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        analysis_type: 'MARKET_ANALYSIS',
-                        data: {
-                            stock_code: selectedStock,
-                            market_data: {
-                                stock_name: chartData?.stock_name || selectedStock,
-                                current_price: Number(chartData.data[0].close),
-                                change_rate: Number(chartData.data[0].change_rate || 0),
-                                volume: Number(chartData.data[0].volume || 0),
-                                high: Number(chartData.data[0].high),
-                                low: Number(chartData.data[0].low)
-                            },
-                            news: []
-                        }
-                    })
-                })
-                const result = await response.json()
-                console.log('🟢 AI analysis received:', result)
-                return result.result || result.analysis
-            } catch (error) {
-                console.error('🔴 AI analysis error:', error)
-                return '⚠️ AI 분석 서비스에 연결할 수 없습니다.'
-            }
-        },
-        enabled: Boolean(selectedStock && chartData?.data?.[0]),
-        refetchInterval: 300000, // 5분마다
-    })
-
-    // 리스크 체크
-    const { data: riskCheck, isLoading: riskCheckLoading } = useQuery({
-        queryKey: ['risk-check', selectedStock, portfolio, chartData],
-        queryFn: async () => {
-            if (!selectedStock || !chartData?.data?.[0]) return null
-            console.log('🔵 Fetching risk check for:', selectedStock)
-            try {
-                const response = await fetch('http://localhost:8001/analyze', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        analysis_type: 'RISK_ASSESSMENT',
-                        data: {
-                            portfolio: {
-                                total_value: portfolioSummary?.total_value || 0,
-                                total_stocks: portfolioSummary?.total_stocks || 0,
-                                holdings: portfolio || []
-                            },
-                            trade_plan: {
-                                stock_code: selectedStock,
-                                stock_name: chartData?.stock_name || selectedStock,
-                                current_price: Number(chartData.data[0].close),
-                                action: 'BUY',
-                                quantity: 1
-                            }
-                        }
-                    })
-                })
-                const result = await response.json()
-                console.log('🟢 Risk check received:', result)
-                return result.result || result.analysis
-            } catch (error) {
-                console.error('🔴 Risk check error:', error)
-                return '⚠️ 리스크 분석 서비스에 연결할 수 없습니다.'
-            }
-        },
-        enabled: Boolean(selectedStock && chartData?.data?.[0]),
-        refetchInterval: 300000, // 5분마다
-    })
-
-    // 차트 상단에 표시할 종목 리스트 생성
-    const displayStocks = useMemo(() => {
-        // 1. 규칙 기반 추천이 있으면 우선 사용
-        if (ruleBasedRecommendations?.recommendations_by_rule?.length > 0) {
-            const stocks: any[] = []
-            ruleBasedRecommendations.recommendations_by_rule.forEach((ruleGroup: any) => {
-                if (ruleGroup.stocks && stocks.length < 4) {
-                    ruleGroup.stocks.slice(0, 4 - stocks.length).forEach((stock: any) => {
-                        stocks.push(stock)
-                    })
-                }
+            if (!selectedStock) return null
+            const response = await api.get(`/market-data/chart/${selectedStock}`, {
+                params: { period: chartPeriod, realtime: true, limit: 200 },
             })
-            return stocks.slice(0, 4)
-        }
 
-        // 2. 포트폴리오가 있으면 사용
-        if (portfolio && portfolio.length > 0) {
-            return [...portfolio]
-                .sort((a: any, b: any) => (b.profit_loss_rate ?? 0) - (a.profit_loss_rate ?? 0))
-                .slice(0, 4)
-        }
+            const rawData = response.data.data || [];
 
-        // 3. 둘 다 없으면 빈 배열 (테스트 데이터 제거)
-        return []
-    }, [ruleBasedRecommendations, portfolio])
-
-    // 표시할 종목들의 최신 가격 가져오기
-    const stockCodesToFetch = displayStocks.map((item: any) => item.stock_code)
-
-    const { data: stockPrices = {} } = useQuery<Record<string, number>>({
-        queryKey: ['all-stock-prices', stockCodesToFetch.join(',')],
-        queryFn: async () => {
-            if (stockCodesToFetch.length === 0) {
-                return {}
-            }
-            const promises = stockCodesToFetch.map(async (code: string) => {
-                try {
-                    const response = await api.get(`/market-data/chart/${code}`, {
-                        params: { period: 'D' },
-                    })
-                    // KIS API는 최신 데이터가 첫번째 (index 0)
-                    const latestPrice = response.data?.data?.[0]?.close || 0
-                    return { code, price: Number(latestPrice) }
-                } catch (error) {
-                    console.error(`Failed to fetch price for ${code}:`, error)
-                    return { code, price: 0 }
-                }
-            })
-            const results = await Promise.all(promises)
-            return results.reduce((acc: Record<string, number>, item) => {
-                acc[item.code] = item.price
-                return acc
-            }, {})
-        },
-        enabled: stockCodesToFetch.length > 0,
-        refetchInterval: 60000,
-    })
-
-    const recommendedStocks = useMemo(() => {
-        console.log('💡 Building recommendedStocks:', {
-            displayStocksCount: displayStocks.length,
-            stockPricesCount: Object.keys(stockPrices).length,
-            stockPrices
-        })
-        return displayStocks.map((item: any) => {
-            const priceFromQuery = stockPrices[item.stock_code]
-            const finalPrice = priceFromQuery || item.current_price || 0
-            console.log(`  - ${item.stock_code}: query=${priceFromQuery}, original=${item.current_price}, final=${finalPrice}`)
-            return {
-                ...item,
-                current_price: finalPrice,
-            }
-        })
-    }, [displayStocks, stockPrices])
-
-    const currentStockPrice = useMemo(() => {
-        if (!chartData?.data || chartData.data.length === 0) {
-            console.log('❌ currentStockPrice: No data')
-            return null
-        }
-        // KIS API는 최신 데이터가 첫번째 (index 0)
-        const price = Number(chartData.data[0].close)
-        console.log('✅ currentStockPrice:', price, 'from', chartData.data[0].date)
-        return price
-    }, [chartData])
-
-    // 초기 종목 선택 (한 번만 실행)
-    useEffect(() => {
-        console.log('📊 Initial stock selection check')
-
-        // 이미 종목이 선택되어 있으면 변경하지 않음
-        if (selectedStock && selectedStock !== '') {
-            console.log('✅ Stock already selected:', selectedStock)
-            return
-        }
-
-        // 규칙 기반 추천이 있으면 첫 번째 종목 선택
-        if (ruleBasedRecommendations?.recommendations_by_rule?.length > 0) {
-            const firstRule = ruleBasedRecommendations.recommendations_by_rule[0]
-            if (firstRule.stocks?.length > 0) {
-                const firstStock = firstRule.stocks[0]
-                console.log('🎯 Auto-selecting first rule-based recommendation:', firstStock.stock_code)
-                setSelectedStock(firstStock.stock_code)
-                return
-            }
-        }
-
-        // 포트폴리오가 있으면 첫 번째 종목 선택
-        if (portfolio && portfolio.length > 0) {
-            console.log('🎯 Auto-selecting first portfolio stock:', portfolio[0].stock_code)
-            setSelectedStock(portfolio[0].stock_code)
-            return
-        }
-
-        // 아무것도 없으면 종목 선택 없음 (테스트 데이터 제거)
-        console.log('⚠️ No stocks available')
-    }, [ruleBasedRecommendations, portfolio]) // selectedStock은 의존성에서 제거
-
-    const chartSeries = useMemo(() => {
-        if (!selectedStock) {
-            console.log('⚠️ chartSeries: No stock selected')
-            return []
-        }
-
-        if (!chartData?.data || chartData.data.length === 0) {
-            console.log('❌ chartSeries: No data', chartData)
-            return []
-        }
-
-        // 차트 데이터가 선택된 종목과 일치하는지 확인
-        if (chartData.stock_code !== selectedStock) {
-            console.error('🔴 CRITICAL: Chart data mismatch!', {
-                chartStock: chartData.stock_code,
-                selectedStock: selectedStock,
-                chartName: chartData.stock_name,
-                dataLength: chartData.data.length
-            })
-            // 데이터가 일치하지 않으면 빈 배열 반환 (새 데이터 로딩 대기)
-            return []
-        }
-
-        console.log('✅ Chart data matches selected stock:', selectedStock)
-
-        console.log('✅ Raw chartData:', {
-            stock: chartData.stock_code,
-            dataLength: chartData.data.length,
-            first: chartData.data[0],
-            last: chartData.data[chartData.data.length - 1]
-        })
-
-        // KIS API는 최신 데이터가 첫번째 (20251104, 20251103, ...)
-        // 차트는 오래된 것부터 최신 순서로 표시해야 하므로 reverse 필요
-        const sortedData = [...chartData.data]
-            .reverse() // 오래된 날짜부터 정렬
-            // KIS API가 반환하는 모든 데이터 사용 (slice 제거)
-            .filter((item: any) => {
-                // 유효한 데이터만 필터링 (0이 아닌 가격)
-                return item.open > 0 && item.high > 0 && item.low > 0 && item.close > 0
-            })
-            .map((item: any) => ({
+            return rawData.map((item: any) => ({
                 date: item.date,
-                dateLabel: item.date ? `${item.date.slice(4, 6)}/${item.date.slice(6, 8)}` : '',
                 open: Number(item.open),
                 high: Number(item.high),
                 low: Number(item.low),
                 close: Number(item.close),
-                volume: Number(item.volume),
-            }))
+                volume: Number(item.volume)
+            })).reverse();
+        },
+        enabled: Boolean(selectedStock),
+        refetchInterval: isMarketOpen ? 10000 : false,
+    })
 
-        console.log('✅ Chart series processed:', {
-            length: sortedData.length,
-            first: sortedData[0],
-            last: sortedData[sortedData.length - 1]
-        })
+    const { data: orderbook } = useQuery({
+        queryKey: ['orderbook', selectedStock],
+        queryFn: async () => {
+            if (!selectedStock) return null;
+            try {
+                const response = await api.get(`/market-data/orderbook/${selectedStock}`);
+                return response.data;
+            } catch (error: any) {
+                console.error(`❌ 호가 조회 실패 (${selectedStock}):`, error.response?.data?.detail || error.message);
+                return null;
+            }
+        },
+        enabled: Boolean(selectedStock),
+        refetchInterval: isMarketOpen ? 5000 : false, // 5초마다 갱신 (API 부하 감소)
+        retry: 1, // 재시도 1회로 제한
+    })
 
-        if (sortedData.length === 0) {
-            console.log('❌ All data filtered out (invalid prices)')
+    const { data: tradeHistory } = useQuery({
+        queryKey: ['trade-history'],
+        queryFn: async () => {
+            const data = (await api.get('/trades', { params: { limit: 50 } })).data;
+
+            // ID 기반 중복 제거 (DB에서 이미 unique)
+            const seen = new Set();
+            return data.filter((trade: any) => {
+                if (seen.has(trade.id)) return false;
+                seen.add(trade.id);
+                return true;
+            }).slice(0, 20);
+        },
+        staleTime: 0,
+        refetchInterval: isMarketOpen ? 30000 : false,
+        refetchOnWindowFocus: true,
+    })
+
+    const { data: journals } = useQuery({
+        queryKey: ['journals'],
+        queryFn: async () => (await api.get('/journals', { params: { limit: 20 } })).data,
+        staleTime: 0,
+        refetchOnWindowFocus: true,
+    })
+
+    // 거래 이력이 변경되면 포트폴리오 즉시 갱신 (매매 발생 시에만 조회)
+    useEffect(() => {
+        if (tradeHistory && tradeHistory.length > 0) {
+            const latestTrade = tradeHistory[0];
+            const latestId = latestTrade.id;
+
+            // 새로운 거래 ID가 감지되면 포트폴리오 강제 갱신
+            if (prevLatestTradeIdRef.current !== null && latestId > prevLatestTradeIdRef.current) {
+                console.log('✅ 새 매매 감지:', latestTrade.stock_name, latestTrade.order_type, '→ 포트폴리오 갱신');
+
+                // 포트폴리오 즉시 갱신
+                queryClient.invalidateQueries({ queryKey: ['portfolio'] });
+                queryClient.invalidateQueries({ queryKey: ['portfolio-summary'] });
+
+                // 1초, 3초 후 추가 갱신 (백엔드 동기화 대기)
+                setTimeout(() => {
+                    queryClient.invalidateQueries({ queryKey: ['portfolio'] });
+                    queryClient.invalidateQueries({ queryKey: ['portfolio-summary'] });
+                }, 1000);
+                setTimeout(() => {
+                    queryClient.invalidateQueries({ queryKey: ['portfolio'] });
+                    queryClient.invalidateQueries({ queryKey: ['portfolio-summary'] });
+                }, 3000);
+            }
+            prevLatestTradeIdRef.current = latestId;
         }
+    }, [tradeHistory, queryClient])
 
-        return sortedData
-    }, [chartData, selectedStock])
-
-    const formatCurrency = (value: number) => {
-        if (!value) {
-            return '0원'
+    // WebSocket journal_created 이벤트 → 매매일지 즉시 갱신
+    useEffect(() => {
+        if (wsMessages.length === 0) return
+        const latest = wsMessages[wsMessages.length - 1]
+        if (latest.type === 'journal_created') {
+            queryClient.invalidateQueries({ queryKey: ['journals'] })
         }
-        return new Intl.NumberFormat('ko-KR').format(value) + '원'
-    }
+    }, [wsMessages, queryClient])
 
-    const formatPercent = (value: number) => {
-        if (!value) {
-            return '+0.00%'
+    // 보유 종목 코드 Set (추천 목록 필터링용)
+    const heldStockCodes = new Set((portfolio || []).map((s: any) => s.stock_code))
+
+    // 매수 진행 중인 종목 코드 Set (PENDING BUY 주문)
+    const pendingBuyStockCodes = new Set(
+        (tradeHistory || [])
+            .filter((t: any) => t.status === 'PENDING' && t.trade_type === 'BUY')
+            .map((t: any) => t.stock_code)
+    )
+
+    // 미체결 주문 정리 함수
+    const resetPendingTrades = async () => {
+        try {
+            const response = await api.delete('/trades/pending');
+            queryClient.invalidateQueries({ queryKey: ['trade-history'] });
+            console.log('✅ 미체결 주문 정리 완료:', response.data);
+            // alert 제거 - 콘솔 로그로만 확인
+        } catch (error: any) {
+            console.error('미체결 주문 정리 실패:', error);
+            // alert 제거 - 콘솔 로그로만 확인
         }
-        return `${value >= 0 ? '+' : ''}${value.toFixed(2)}%`
-    }
+    };
 
-    const formatDate = (dateStr: string) => {
-        if (!dateStr || dateStr.length !== 8) return ''
-        // YYYYMMDD → MM/DD
-        return `${dateStr.slice(4, 6)}/${dateStr.slice(6, 8)}`
-    }
+    // 주기적 거래 내역 갱신 제거 - 실제 매매 발생 시에만 갱신 (138-164번 줄 로직 사용)
+    // useEffect(() => {
+    //     if (!isMarketOpen) {
+    //         return;
+    //     }
+    //     const interval = setInterval(() => {
+    //         queryClient.invalidateQueries({ queryKey: ['trade-history'] });
+    //     }, 60000);
+    //     return () => clearInterval(interval);
+    // }, [isMarketOpen, queryClient])
 
-    const getTradeStatusClass = (status: string) => {
-        switch (status) {
-            case 'EXECUTED':
-                return 'executed'
-            case 'PENDING':
-                return 'pending'
-            case 'FAILED':
-                return 'failed'
-            default:
-                return ''
+    const { data: aiAnalysisData, refetch: refetchAiAnalysis } = useQuery({
+        queryKey: ['ai-analysis', selectedStock],
+        queryFn: async () => {
+            if (!selectedStock) return null;
+            console.log('🤖 AI 분석 요청:', selectedStock);
+
+            try {
+                // AI 분석 API 호출
+                const response = await api.get(`/market-data/ai-analysis/${selectedStock}`);
+                const data = response.data;
+
+                // 분석 텍스트 생성
+                let analysis = `📈 ${data.stock_name} (${data.stock_code})\n\n`;
+
+                // 현재가 & 거래량
+                analysis += `💰 현재가: ${data.current_price.toLocaleString()}원\n`;
+                analysis += `📊 고가/저가: ${data.high_price.toLocaleString()} / ${data.low_price.toLocaleString()}원\n`;
+                analysis += `📦 거래량: ${(data.volume / 1000).toFixed(0)}K주\n`;
+
+                // 기술적 지표 (항상 표시)
+                analysis += `\n📊 기술적 지표:\n`;
+                const hasIndicators = data.indicators && Object.values(data.indicators).some(v => v !== null && v !== undefined);
+
+                if (hasIndicators) {
+                    if (data.indicators.rsi !== null && data.indicators.rsi !== undefined) {
+                        analysis += `  RSI(14): ${data.indicators.rsi.toFixed(1)}\n`;
+                    }
+                    if (data.indicators.ma5 !== null) {
+                        analysis += `  5일 이평: ${data.indicators.ma5.toFixed(0)}원\n`;
+                    }
+                    if (data.indicators.ma20 !== null) {
+                        analysis += `  20일 이평: ${data.indicators.ma20.toFixed(0)}원\n`;
+                    }
+                    if (data.indicators.ma60 !== null) {
+                        analysis += `  60일 이평: ${data.indicators.ma60.toFixed(0)}원\n`;
+                    }
+                    if (data.indicators.stochastic_k !== null) {
+                        analysis += `  스토캐스틱 K: ${data.indicators.stochastic_k.toFixed(1)}\n`;
+                    }
+                } else {
+                    analysis += `  (DB에 저장된 지표 없음 - 배치 작업 대기중)\n`;
+                }
+
+                // 추천 및 추세
+                analysis += `\n🤖 분석 결과:\n`;
+                const recommendMap: any = {
+                    'BUY': '💚 매수',
+                    'SELL': '❤️ 매도',
+                    'HOLD': '💛 관망'
+                };
+                const trendMap: any = {
+                    'UP': '📈 상승',
+                    'DOWN': '📉 하락',
+                    'SIDEWAYS': '➡️ 횡보'
+                };
+                analysis += `  추천: ${recommendMap[data.recommendation] || data.recommendation}\n`;
+                analysis += `  신뢰도: ${(data.confidence * 100).toFixed(0)}%\n`;
+                analysis += `  추세: ${trendMap[data.trend] || data.trend}\n`;
+
+                // 분석 근거 (의미있는 내용만 표시)
+                const skipMessages = [
+                    '기술적 지표 데이터 없음',
+                    '기술적 지표 데이터 부족',
+                    'AI 분석을 사용할 수 없습니다.',
+                    '충분한 신호 없음'
+                ];
+
+                if (data.ai_analysis && !skipMessages.includes(data.ai_analysis)) {
+                    analysis += `\n💡 분석 근거:\n${data.ai_analysis}\n`;
+                }
+
+                return { analysis, data };
+            } catch (error: any) {
+                console.error('❌ AI 분석 실패:', error);
+                return {
+                    analysis: `❌ AI 분석을 불러올 수 없습니다.\n${error.response?.data?.detail || error.message}`,
+                    data: null
+                };
+            }
+        },
+        enabled: !!selectedStock,
+        staleTime: 30000,
+    });
+
+    // Extract analysis text from the query result
+    const aiAnalysisText = aiAnalysisData?.analysis || null;
+
+    // 초기 종목 선택 (포트폴리오가 있으면 첫번째, 아니면 추천 종목 첫번째)
+    useEffect(() => {
+        if (!selectedStock) {
+            if (portfolio && portfolio.length > 0) {
+                setSelectedStock(portfolio[0].stock_code)
+            } else if (ruleBasedRecommendations?.recommendations_by_rule?.length > 0) {
+                const firstRule = ruleBasedRecommendations.recommendations_by_rule[0];
+                if (firstRule.stocks && firstRule.stocks.length > 0) {
+                    setSelectedStock(firstRule.stocks[0].stock_code)
+                }
+            }
         }
-    }
-
-    const handleStockSelect = (stockCode: string) => {
-        setSelectedStock(stockCode)
-    }
+    }, [portfolio, ruleBasedRecommendations, selectedStock])
 
     return (
-        <HtsPage contentClassName="dashboard-content">
-            <div className="hts-container">
-                <div className="hts-main-layout">
-                    <div className="left-panel">
-                        <div className="panel-header">계좌 정보</div>
-                        <div className="balance-info">
-                            <div className="balance-row">
-                                <span>예수금</span>
-                                <span style={{ color: '#22c55e' }}>10,000,000원</span>
-                            </div>
-                            <div className="balance-row">
-                                <span>총 자산</span>
-                                <span>{formatCurrency((portfolioSummary?.total_value || 0) + 10000000)}</span>
-                            </div>
-                            <div className="balance-row">
-                                <span>총 손익</span>
-                                <span className={(portfolioSummary?.total_profit_loss || 0) >= 0 ? 'up' : 'down'}>
-                                    {formatCurrency(portfolioSummary?.total_profit_loss || 0)}
-                                </span>
-                            </div>
-                            <div className="balance-row">
-                                <span>수익률</span>
-                                <span className={(portfolioSummary?.total_profit_loss_rate || 0) >= 0 ? 'up' : 'down'}>
-                                    {formatPercent(portfolioSummary?.total_profit_loss_rate || 0)}
-                                </span>
-                            </div>
-                            <div className="balance-row">
-                                <span>보유 종목</span>
-                                <span>{portfolioSummary?.total_stocks || 0}개</span>
-                            </div>
-                        </div>
+        <div className="min-h-screen bg-[#0f1115] text-gray-100 font-sans flex flex-col h-screen overflow-hidden">
 
-                        <div className="panel-header" style={{ borderTop: '1px solid #333', marginTop: '12px' }}>보유 종목</div>
-                        <div className="portfolio-list" style={{ maxHeight: '200px', overflowY: 'auto' }}>
-                            {portfolio && portfolio.length > 0 ? (
-                                portfolio.map((item: any) => (
-                                    <div
-                                        key={item.id}
-                                        className="portfolio-item"
-                                        onClick={() => handleStockSelect(item.stock_code)}
-                                        style={{ cursor: 'pointer' }}
-                                    >
-                                        <div className="stock-name">{item.stock_name} ({item.stock_code})</div>
-                                        <div className="stock-info">
-                                            <span>{item.quantity}주</span>
-                                            <span>{formatCurrency(item.current_price)}</span>
-                                            <span className={(item.profit_loss_rate || 0) >= 0 ? 'up' : 'down'}>
-                                                {formatPercent(item.profit_loss_rate || 0)}
-                                            </span>
-                                        </div>
+            <header className="border-b border-gray-800 bg-[#161b22] px-6 py-4 flex justify-between items-center z-50 backdrop-blur-md bg-opacity-90 flex-shrink-0">
+                <div className="flex items-center gap-3">
+                    <div className="bg-blue-600 p-2 rounded-lg shadow-lg shadow-blue-500/20">
+                        <Activity className="text-white" size={20} />
+                    </div>
+                    <div>
+                        <h1 className="text-xl font-bold bg-gradient-to-r from-blue-400 to-purple-400 bg-clip-text text-transparent">
+                            AutoStock Trader
+                        </h1>
+                        <p className="text-xs text-gray-500">Gen 3 AI Algorithm</p>
+                    </div>
+                </div>
+                <div className="flex items-center gap-4">
+                    <div className="flex items-center gap-2 px-3 py-1.5 bg-gray-800 rounded-full border border-gray-700">
+                        <div className={`w-2 h-2 rounded-full ${wsConnected ? 'bg-green-500 shadow-[0_0_8px_rgba(34,197,94,0.5)]' : 'bg-red-500'}`} />
+                        <span className="text-xs text-gray-400">{wsConnected ? '실시간 연결됨' : '연결 끊김'}</span>
+                    </div>
+                    <div className="flex items-center gap-2 px-3 py-1.5 bg-gray-800 rounded-full border border-gray-700">
+                        <div className={`w-2 h-2 rounded-full ${mcpStatus?.status === 'connected' ? 'bg-blue-500 shadow-[0_0_8px_rgba(59,130,246,0.5)]' : 'bg-yellow-500'}`} />
+                        <span className="text-xs text-gray-400">MCP: {mcpStatus?.status || 'Unknown'}</span>
+                    </div>
+                </div>
+            </header>
+
+            <main className="flex-1 p-4 max-w-[1920px] mx-auto w-full flex flex-col gap-4 overflow-hidden">
+                <div className="flex-shrink-0">
+                    <PortfolioSummary summary={portfolioSummary} error={portfolioSummaryError} />
+                </div>
+
+                <div className="grid grid-cols-12 gap-4 flex-1 min-h-0">
+
+                    {/* [Left Column] 보유 종목 (Holding Stocks) */}
+                    <div className="col-span-2 flex flex-col gap-4 h-full overflow-hidden">
+                        <div className="bg-gray-800/50 backdrop-blur-sm border border-gray-700/50 rounded-xl overflow-hidden flex flex-col h-full shadow-lg">
+                            <div className="p-3 border-b border-gray-700/50 flex justify-between items-center bg-[#1c222c]">
+                                <h3 className="font-semibold flex items-center gap-2 text-gray-200 text-sm">
+                                    <Activity className="w-4 h-4 text-blue-400" />
+                                    보유 종목
+                                </h3>
+                                <span className="text-xs bg-blue-500/20 text-blue-300 px-2 py-0.5 rounded-full">
+                                    {portfolio?.length || 0}
+                                </span>
+                            </div>
+                            <div className="divide-y divide-gray-700/50 overflow-y-auto custom-scrollbar flex-1">
+                                {portfolio && portfolio.length > 0 ? (
+                                    portfolio.map((stock: any) => {
+                                        const currentPrice = Number(stock.current_price || 0);
+                                        const avgPrice = Number(stock.average_price || 0);
+                                        const quantity = Number(stock.quantity || 0);
+                                        const totalValue = currentPrice * quantity;
+                                        const profitLossRate = Number(stock.profit_loss_rate || 0);
+
+                                        const handleSell = async (e: React.MouseEvent) => {
+                                            e.stopPropagation();
+                                            if (!confirm(`${stock.stock_name} 전량(${quantity}주)을 시장가로 매도하시겠습니까?`)) {
+                                                return;
+                                            }
+                                            try {
+                                                await api.post('/portfolio/sell', {
+                                                    stock_code: stock.stock_code,
+                                                    quantity: quantity,
+                                                    price: null  // 시장가
+                                                });
+                                                queryClient.invalidateQueries({ queryKey: ['portfolio'] });
+                                                queryClient.invalidateQueries({ queryKey: ['trade-history'] });
+                                                console.log(`✅ ${stock.stock_name} 매도 주문 완료`);
+                                            } catch (error: any) {
+                                                console.error('매도 실패:', error);
+                                                alert(`매도 실패: ${error.response?.data?.detail || error.message}`);
+                                            }
+                                        };
+
+                                        return (
+                                            <div
+                                                key={stock.stock_code}
+                                                className={`w-full p-3 hover:bg-gray-700/30 transition-all duration-200 group ${selectedStock === stock.stock_code ? 'bg-blue-500/10 border-l-2 border-blue-500' : 'border-l-2 border-transparent'}`}
+                                            >
+                                                <div
+                                                    onClick={() => {
+                                                        setSelectedStock(stock.stock_code);
+                                                        refetchAiAnalysis();
+                                                    }}
+                                                    className="cursor-pointer"
+                                                >
+                                                    <div className="flex justify-between items-start mb-1">
+                                                        <span className={`font-bold text-sm ${selectedStock === stock.stock_code ? 'text-blue-400' : 'text-gray-200'}`}>
+                                                            {stock.stock_name}
+                                                        </span>
+                                                        <span className={`text-xs font-bold ${profitLossRate > 0 ? 'text-red-400' : 'text-blue-400'}`}>
+                                                            {profitLossRate > 0 ? '+' : ''}{profitLossRate.toFixed(2)}%
+                                                        </span>
+                                                    </div>
+                                                    <div className="flex justify-between items-center text-[11px] text-gray-400 mb-0.5">
+                                                        <span className="font-mono">{stock.stock_code}</span>
+                                                        <span>{quantity}주</span>
+                                                    </div>
+                                                    <div className="flex justify-between items-center text-[11px]">
+                                                        <span className="text-gray-500">{avgPrice.toLocaleString()}원</span>
+                                                        <span className="text-white font-medium">{currentPrice.toLocaleString()}원</span>
+                                                    </div>
+                                                    <div className="flex justify-between items-center text-[11px] mt-0.5">
+                                                        <span className="text-gray-500">평가금액</span>
+                                                        <span className={`font-medium ${profitLossRate > 0 ? 'text-red-400' : 'text-blue-400'}`}>
+                                                            {totalValue.toLocaleString()}원
+                                                        </span>
+                                                    </div>
+                                                </div>
+                                                {/* 청산 버튼 */}
+                                                <button
+                                                    onClick={handleSell}
+                                                    className="w-full mt-2 px-2 py-1 text-[10px] bg-blue-500/20 hover:bg-blue-500/30 text-blue-400 rounded border border-blue-500/30 transition-colors font-bold"
+                                                >
+                                                    🔵 전량 청산 (시장가)
+                                                </button>
+                                            </div>
+                                        );
+                                    })
+                                ) : (
+                                    <div className="h-full flex flex-col items-center justify-center text-gray-500 p-4 text-center text-xs">
+                                        <p>보유 중인 종목이 없습니다.</p>
                                     </div>
-                                ))
-                            ) : (
-                                <div className="no-data" style={{ padding: '20px', textAlign: 'center', color: '#666' }}>
-                                    보유 종목 없음
-                                </div>
-                            )}
+                                )}
+                            </div>
                         </div>
                     </div>
 
-                    <div className="center-panel">
-                        <div className="chart-section">
-                            <div className="panel-header">대표 종목 차트</div>
-                            <div className="chart-toolbar">
-                                <div className="chart-stocks">
-                                    {recommendedStocks.length > 0 ? (
-                                        recommendedStocks.map((item: any) => {
-                                            const isSelected = selectedStock === item.stock_code
-                                            // stockPrices에서 최신 가격 가져오기 (차트 상단과 추천 종목 동일한 가격)
-                                            const displayPrice = stockPrices[item.stock_code] || item.current_price || 0
-                                            return (
-                                                <button
-                                                    key={item.stock_code}
-                                                    className={`chart-stock ${isSelected ? 'active' : ''}`}
-                                                    onClick={() => handleStockSelect(item.stock_code)}
-                                                >
-                                                    <span className="name">{item.stock_name}</span>
-                                                    <span className="price">{formatCurrency(displayPrice)}</span>
-                                                </button>
-                                            )
-                                        })
+                    {/* [Center Column] 차트 & 트레이딩 정보 (Chart, AI, Trade) */}
+                    <div className="col-span-7 flex flex-col h-full gap-4 overflow-hidden">
+                        {/* 차트 섹션 (Top) */}
+                        <div className="bg-gray-800/50 backdrop-blur-sm border border-gray-700/50 rounded-xl p-1 shadow-lg h-[45%] flex flex-col min-h-0">
+                            <div className="px-5 py-3 flex justify-between items-center border-b border-gray-700/30">
+                                <div>
+                                    <h2 className="text-lg font-bold flex items-center gap-3 text-white">
+                                        {portfolio?.find((s: any) => s.stock_code === selectedStock)?.stock_name ||
+                                            ruleBasedRecommendations?.recommendations_by_rule?.flatMap((r: any) => r.stocks).find((s: any) => s.stock_code === selectedStock)?.stock_name ||
+                                            selectedStock || '종목을 선택해주세요'}
+                                        {selectedStock && <span className="text-xs font-normal text-gray-500 font-mono bg-gray-800 px-2 py-0.5 rounded">{selectedStock}</span>}
+                                    </h2>
+                                </div>
+                                <div className="flex bg-gray-900/50 rounded-lg p-1 border border-gray-700/50 scale-90">
+                                    {['D', 'W', 'M'].map((p) => (
+                                        <button
+                                            key={p}
+                                            onClick={() => setChartPeriod(p as any)}
+                                            className={`px-3 py-1 text-xs font-medium rounded-md transition-all ${chartPeriod === p ? 'bg-blue-600 text-white shadow-lg shadow-blue-900/20' : 'text-gray-400 hover:text-white hover:bg-gray-800'
+                                                }`}
+                                        >
+                                            {p === 'D' ? '일봉' : p === 'W' ? '주봉' : '월봉'}
+                                        </button>
+                                    ))}
+                                </div>
+                            </div>
+
+                            <div className="flex-1 relative bg-[#0b0e14] rounded-b-lg overflow-hidden">
+                                {chartLoading ? (
+                                    <div className="absolute inset-0 flex items-center justify-center text-gray-500 bg-[#0b0e14]">
+                                        <div className="flex flex-col items-center gap-2">
+                                            <RefreshCw className="animate-spin w-6 h-6 text-blue-500" />
+                                            <span className="text-sm">차트 로딩중...</span>
+                                        </div>
+                                    </div>
+                                ) : chartData && chartData.length > 0 ? (
+                                    <TradingChart data={chartData} />
+                                ) : (
+                                    <div className="absolute inset-0 flex items-center justify-center text-gray-600 text-sm">
+                                        데이터가 없습니다.
+                                    </div>
+                                )}
+                            </div>
+                        </div>
+
+                        {/* 하단: AI 투자 분석 & 관련 뉴스 (Bottom Split) */}
+                        <div className="flex-1 grid grid-cols-2 gap-4 min-h-0">
+                            {/* AI 투자 분석 */}
+                            <div className="bg-gray-800/50 backdrop-blur-sm border border-gray-700/50 rounded-xl p-4 shadow-lg flex flex-col">
+                                <h3 className="font-bold flex items-center gap-2 mb-2 text-purple-400 text-sm">
+                                    <Brain size={16} />
+                                    AI 투자 분석
+                                </h3>
+                                <div className="bg-gray-900/50 rounded-lg p-3 text-gray-300 text-sm leading-relaxed overflow-y-auto custom-scrollbar flex-1 border border-gray-700/30 whitespace-pre-wrap">
+                                    {aiAnalysisText ? (
+                                        typeof aiAnalysisText === 'string'
+                                            ? aiAnalysisText
+                                            : JSON.stringify(aiAnalysisText, null, 2)
                                     ) : (
-                                        <div className="no-data">추천 종목 로딩 중...</div>
+                                        <div className="h-full flex items-center justify-center text-gray-600 text-center text-xs">
+                                            <p>종목을 선택하면<br />AI 투자 분석을 표시합니다.</p>
+                                        </div>
                                     )}
                                 </div>
-                                <div className="chart-actions">
-                                    <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'flex-start', gap: '4px' }}>
-                                        {/* MCP 상태 UI 제거됨 */}
-                                        {/* 실시간 연결 UI 제거됨 */}
-                                    </div>
-                                    <div className="chart-period">
-                                        {(['D', 'W', 'M'] as const).map((period) => (
-                                            <button
-                                                key={period}
-                                                className={chartPeriod === period ? 'active' : ''}
-                                                onClick={() => setChartPeriod(period)}
-                                            >
-                                                {period === 'D' ? '일봉' : period === 'W' ? '주봉' : '월봉'}
-                                            </button>
-                                        ))}
-                                    </div>
-                                </div>
                             </div>
-                            <div className="chart-container">
-                                {chartLoading && <div className="no-data">차트 로딩 중...</div>}
-                                {!chartLoading && chartSeries.length === 0 && (
-                                    <div className="no-data">차트 데이터가 없습니다.</div>
-                                )}
-                                {!chartLoading && chartSeries.length > 0 && (
-                                    <div style={{ width: '100%', height: '100%' }}>
-                                        <CandlestickChart
-                                            data={chartSeries}
-                                            width={1100}
-                                            height={380}
-                                        />
-                                    </div>
-                                )}
-                            </div>
-                        </div>
 
-                        <div className="trades-section">
-                            <div className="panel-header">최근 거래 내역</div>
-                            <div className="trades-table-container">
-                                <table className="trades-table">
-                                    <thead>
-                                        <tr>
-                                            <th>시간</th>
-                                            <th>종목</th>
-                                            <th>구분</th>
-                                            <th>수량</th>
-                                            <th>가격</th>
-                                            <th>상태</th>
-                                        </tr>
-                                    </thead>
-                                    <tbody>
-                                        {recentTrades && recentTrades.length > 0 ? (
-                                            recentTrades.map((trade: any) => (
-                                                <tr key={trade.id}>
-                                                    <td>{new Date(trade.created_at).toLocaleTimeString('ko-KR')}</td>
-                                                    <td>{trade.stock_name}</td>
-                                                    <td className={trade.order_type === 'BUY' ? 'up' : 'down'}>
-                                                        {trade.order_type}
-                                                    </td>
-                                                    <td>{trade.order_quantity}</td>
-                                                    <td>{formatCurrency(trade.order_price || 0)}</td>
-                                                    <td>
-                                                        <span className={`trade-status ${getTradeStatusClass(trade.status)}`}>
-                                                            {trade.status}
-                                                        </span>
-                                                    </td>
-                                                </tr>
-                                            ))
-                                        ) : (
-                                            <tr>
-                                                <td colSpan={6} className="no-data">거래 내역 없음</td>
-                                            </tr>
-                                        )}
-                                    </tbody>
-                                </table>
+                            {/* 호가창 - 증권사 스타일 (2컬럼) */}
+                            <div className="bg-gray-800/50 backdrop-blur-sm border border-gray-700/50 rounded-xl p-4 shadow-lg flex flex-col">
+                                <h3 className="font-bold flex items-center gap-2 mb-3 text-yellow-400 text-sm">
+                                    <Activity size={16} />
+                                    실시간 호가
+                                </h3>
+                                <div className="overflow-y-auto custom-scrollbar flex-1">
+                                    {orderbook ? (() => {
+                                        // 현재가 주변 ±10단계를 10원 단위로 연속 생성
+                                        const currentPrice = orderbook.current_price;
+                                        const priceUnit = 10;
+                                        const steps = 10;
+
+                                        // 매도 호가: 현재가 + 10 ~ 현재가 + 100 (높은 가격부터)
+                                        const sequentialAsks = [];
+                                        for (let i = steps; i >= 1; i--) {
+                                            const price = currentPrice + (priceUnit * i);
+                                            const existingAsk = orderbook.asks?.find((ask: any) => ask.price === price);
+                                            sequentialAsks.push({
+                                                price: price,
+                                                volume: existingAsk ? existingAsk.volume : 0
+                                            });
+                                        }
+
+                                        // 매수 호가: 현재가 - 10 ~ 현재가 - 100 (높은 가격부터)
+                                        const sequentialBids = [];
+                                        for (let i = 1; i <= steps; i++) {
+                                            const price = currentPrice - (priceUnit * i);
+                                            const existingBid = orderbook.bids?.find((bid: any) => bid.price === price);
+                                            sequentialBids.push({
+                                                price: price,
+                                                volume: existingBid ? existingBid.volume : 0
+                                            });
+                                        }
+
+                                        return (
+                                            <div className="space-y-2">
+                                                {/* 매도 영역 (상단 10단계) */}
+                                                <div className="space-y-0.5">
+                                                    {sequentialAsks.map((ask: any, i: number) => (
+                                                        <div key={`ask-${i}`} className="grid grid-cols-3 items-center gap-2 py-1 px-2">
+                                                            {/* 매도잔량 (좌측, 우측정렬) */}
+                                                            <div className="text-xs text-gray-300 font-medium text-right font-mono">
+                                                                {ask.volume > 0 ? ask.volume.toLocaleString() : '-'}
+                                                            </div>
+                                                            {/* 매도호가 (중앙, 빨간색) */}
+                                                            <div className="text-sm font-bold text-red-400 font-mono text-center">
+                                                                {ask.price.toLocaleString()}
+                                                            </div>
+                                                            {/* 빈 공간 */}
+                                                            <div></div>
+                                                        </div>
+                                                    ))}
+                                                </div>
+
+                                                {/* 현재가 (중앙 강조) */}
+                                                <div className="py-3 bg-gradient-to-r from-red-900/20 via-red-800/30 to-red-900/20 rounded-lg border-2 border-red-500/30 my-2">
+                                                    <div className="flex items-center justify-center gap-4 px-4">
+                                                        <div className="text-2xl font-bold text-red-400 font-mono">
+                                                            {currentPrice?.toLocaleString()}
+                                                        </div>
+                                                        {orderbook.current_volume > 0 && (
+                                                            <div className="text-xs text-gray-400 font-mono">
+                                                                ({orderbook.current_volume.toLocaleString()})
+                                                            </div>
+                                                        )}
+                                                    </div>
+                                                    <div className="text-xs text-red-300 mt-1 text-center">
+                                                        연속 호가창
+                                                    </div>
+                                                </div>
+
+                                                {/* 매수 영역 (하단 10단계) */}
+                                                <div className="space-y-0.5">
+                                                    {sequentialBids.map((bid: any, i: number) => (
+                                                        <div key={`bid-${i}`} className="grid grid-cols-3 items-center gap-2 py-1 px-2">
+                                                            {/* 빈 공간 */}
+                                                            <div></div>
+                                                            {/* 매수호가 (중앙, 파란색) */}
+                                                            <div className="text-sm font-bold text-blue-400 font-mono text-center">
+                                                                {bid.price.toLocaleString()}
+                                                            </div>
+                                                            {/* 매수잔량 (우측, 좌측정렬) */}
+                                                            <div className="text-xs text-gray-300 font-medium text-left font-mono">
+                                                                {bid.volume > 0 ? bid.volume.toLocaleString() : '-'}
+                                                            </div>
+                                                        </div>
+                                                    ))}
+                                                </div>
+                                            </div>
+                                        );
+                                    })() : (
+                                        <div className="h-full flex items-center justify-center text-gray-600 text-xs text-center">
+                                            종목을 선택하면 호가 정보가 표시됩니다.
+                                        </div>
+                                    )}
+                                </div>
                             </div>
                         </div>
                     </div>
 
-                    <div className="right-panel">
-                        <div className="recommend-section">
-                            <div className="panel-header" style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
-                                <span>추천 종목</span>
-                                <button
-                                    onClick={async () => {
-                                        console.log('🤖 자동매매 버튼 클릭됨')
-
-                                        if (!confirm('규칙에 맞는 종목을 자동으로 매수/매도 하시겠습니까?')) {
-                                            console.log('⚠️ 사용자가 자동매매 취소함')
-                                            return
-                                        }
-
-                                        console.log('✅ 자동매매 확인됨, API 호출 시작...')
-
-                                        try {
-                                            console.log('📡 POST /api/v1/recommendations/auto-trade')
-                                            const response = await api.post('/recommendations/auto-trade')
-                                            console.log('🟢 자동매매 응답:', response.data)
-
-                                            const result = response.data
-
-                                            if (!result.trades || result.trades.length === 0) {
-                                                alert(`⚠️ ${result.message || '실행된 거래가 없습니다'}`)
-                                                return
-                                            }
-
-                                            alert(`✅ ${result.message}\n\n${result.trades.map((t: any) =>
-                                                `${t.action}: ${t.stock} ${t.quantity}주 @ ${t.price.toLocaleString()}원`
-                                            ).join('\n')}`)
-                                        } catch (error: any) {
-                                            console.error('🔴 자동매매 에러:', error)
-                                            console.error('🔴 에러 상세:', {
-                                                message: error.message,
-                                                response: error.response?.data,
-                                                status: error.response?.status
-                                            })
-
-                                            const errorMsg = error.response?.data?.detail || error.message || '알 수 없는 오류'
-                                            alert(`❌ 자동 매매 실패: ${errorMsg}`)
-                                        }
-                                    }}
-                                    style={{
-                                        padding: '4px 8px',
-                                        background: '#22c55e',
-                                        color: '#fff',
-                                        border: 'none',
-                                        borderRadius: '4px',
-                                        cursor: 'pointer',
-                                        fontSize: '11px',
-                                        fontWeight: '600'
-                                    }}
-                                >
-                                    🤖 자동매매 시작
-                                </button>
+                    {/* [Right Column] 분석 종목 & 매수/체결 */}
+                    <div className="col-span-3 flex flex-col gap-4 h-full overflow-hidden">
+                        {/* 분석 종목 (Top) */}
+                        <div className="bg-gray-800/50 backdrop-blur-sm border border-gray-700/50 rounded-xl overflow-hidden flex flex-col h-1/2 shadow-lg">
+                            <div className="p-3 border-b border-gray-700/50 flex justify-between items-center bg-[#1c222c]">
+                                <h3 className="font-semibold flex items-center gap-2 text-gray-200 text-sm">
+                                    <Brain className="w-4 h-4 text-purple-400" />
+                                    분석 종목
+                                </h3>
+                                <span className="text-xs bg-purple-500/20 text-purple-300 px-2 py-0.5 rounded-full">
+                                    {ruleBasedRecommendations?.analyzed_stocks || 0}
+                                </span>
                             </div>
-
-                            <div className="recommend-list" style={{ maxHeight: '280px', overflowY: 'auto' }}>
-                                {(() => {
-                                    console.log('🎯 Rendering recommend-list:', {
-                                        hasRule: !!ruleBasedRecommendations,
-                                        ruleLength: ruleBasedRecommendations?.recommendations?.length || 0,
-                                        hasAI: !!aiRecommendations,
-                                        aiLength: aiRecommendations?.recommendations?.length || 0,
-                                        portfolioLength: recommendedStocks.length
-                                    })
-                                    return null
-                                })()}
-                                {/* 1. 규칙 기반 추천 (규칙별 그룹핑) */}
-                                {ruleBasedRecommendations && ruleBasedRecommendations.recommendations_by_rule?.length > 0 ? (
-                                    ruleBasedRecommendations.recommendations_by_rule.map((ruleGroup: any) => (
-                                        <div key={ruleGroup.rule_id} style={{ marginBottom: '16px' }}>
-                                            {/* 규칙 헤더 */}
-                                            <div style={{
-                                                display: 'flex',
-                                                alignItems: 'center',
-                                                gap: '8px',
-                                                marginBottom: '8px',
-                                                padding: '8px',
-                                                background: '#0a0a0a',
-                                                borderRadius: '4px',
-                                                borderLeft: '3px solid #22c55e'
-                                            }}>
-                                                <span style={{
-                                                    fontSize: '11px',
-                                                    fontWeight: '600',
-                                                    color: '#22c55e',
-                                                    background: 'rgba(34, 197, 94, 0.1)',
-                                                    padding: '2px 8px',
-                                                    borderRadius: '4px'
-                                                }}>
-                                                    규칙 {ruleGroup.priority}
-                                                </span>
-                                                <span style={{ fontSize: '12px', fontWeight: '600', color: '#fff' }}>
-                                                    {ruleGroup.rule_name}
-                                                </span>
-                                                <span style={{ fontSize: '10px', color: '#666' }}>
-                                                    ({ruleGroup.matched_count}개 종목 매칭)
+                            <div className="divide-y divide-gray-700/50 overflow-y-auto custom-scrollbar flex-1">
+                                {ruleBasedRecommendations === undefined ? (
+                                    <div className="h-full flex flex-col items-center justify-center text-gray-500 text-xs p-4">
+                                        <RefreshCw className="w-6 h-6 animate-spin mb-2 text-purple-400" />
+                                        <p>분석 종목 로딩 중...</p>
+                                        <p className="text-[10px] text-gray-600 mt-1">최초 로딩 시 10초 정도 소요됩니다</p>
+                                    </div>
+                                ) : (ruleBasedRecommendations?.analyzed_stock_list || []).length > 0 ? (
+                                    (ruleBasedRecommendations.analyzed_stock_list as any[]).map((stock: any, idx: number) => {
+                                        const isRecommended = (ruleBasedRecommendations?.recommendations || []).some((r: any) => r.stock_code === stock.stock_code)
+                                        const isHeld = heldStockCodes.has(stock.stock_code)
+                                        const isPending = pendingBuyStockCodes.has(stock.stock_code)
+                                        const changeRate = stock.change_rate || 0
+                                        return (
+                                        <button
+                                            key={`${stock.stock_code}-${idx}`}
+                                            onClick={() => {
+                                                setSelectedStock(stock.stock_code);
+                                                refetchAiAnalysis();
+                                            }}
+                                            className={`w-full p-3 text-left hover:bg-gray-700/30 transition-all duration-200 ${selectedStock === stock.stock_code ? 'bg-purple-500/10 border-l-2 border-purple-500' : 'border-l-2 border-transparent'}`}
+                                        >
+                                            <div className="flex justify-between items-start mb-1">
+                                                <div className="flex-1 min-w-0">
+                                                    <div className="flex items-center gap-1.5 mb-0.5">
+                                                        <span className="font-bold text-gray-200 text-xs truncate">{stock.stock_name}</span>
+                                                        <span className="text-[9px] text-gray-500 flex-shrink-0">({stock.stock_code})</span>
+                                                    </div>
+                                                    {stock.signals && stock.signals.length > 0 && (
+                                                        <div className="text-[9px] text-gray-500 truncate">
+                                                            {stock.signals.slice(0, 2).join(' · ')}
+                                                        </div>
+                                                    )}
+                                                </div>
+                                                <div className="flex flex-col items-end gap-0.5 flex-shrink-0 ml-1">
+                                                    {isPending ? (
+                                                        <span className="text-[9px] text-orange-400 border border-orange-500/20 bg-orange-500/10 px-1 py-0.5 rounded flex items-center gap-0.5">
+                                                            <RefreshCw className="w-2 h-2 animate-spin" />매수중
+                                                        </span>
+                                                    ) : isHeld ? (
+                                                        <span className="text-[9px] text-blue-400 border border-blue-500/20 bg-blue-500/10 px-1 py-0.5 rounded">보유중</span>
+                                                    ) : isRecommended ? (
+                                                        <span className="text-[9px] text-green-400 border border-green-500/20 bg-green-500/10 px-1 py-0.5 rounded">매수신호</span>
+                                                    ) : null}
+                                                    <span className={`text-[9px] font-bold ${changeRate > 0 ? 'text-red-400' : changeRate < 0 ? 'text-blue-400' : 'text-gray-500'}`}>
+                                                        {changeRate > 0 ? '+' : ''}{changeRate.toFixed(2)}%
+                                                    </span>
+                                                </div>
+                                            </div>
+                                            <div className="flex justify-between items-center text-[9px] text-gray-500 mt-0.5">
+                                                <span>{Math.round(stock.current_price || 0).toLocaleString()}원</span>
+                                                <span className="flex gap-2">
+                                                    {stock.rsi != null && <span>RSI {stock.rsi.toFixed(0)}</span>}
+                                                    {stock.stochastic_k != null && <span>K {stock.stochastic_k.toFixed(0)}</span>}
+                                                    {stock.score > 0 && <span className="text-purple-400">{stock.score}점</span>}
                                                 </span>
                                             </div>
+                                        </button>
+                                        )
+                                    })
+                                ) : (
+                                    <div className="h-full flex flex-col items-center justify-center text-gray-500 p-4 text-center text-xs">
+                                        <p>배치 분석 데이터가 없습니다.</p>
+                                        <p className="text-[10px] text-gray-600 mt-1">make batch-test 실행 필요</p>
+                                    </div>
+                                )}
+                            </div>
+                        </div>
+
+                        {/* 매매일지 (전체 너비) */}
+                        <div className="bg-gray-800/50 backdrop-blur-sm border border-gray-700/50 rounded-xl overflow-hidden flex flex-col h-1/2 shadow-lg">
+                            <div className="flex flex-col h-full p-3">
+                                <div className="flex flex-col h-full min-h-0">
+                                    <div className="flex items-center justify-between mb-2 flex-shrink-0">
+                                        <h3 className="font-bold flex items-center gap-2 text-green-400 text-sm">
+                                            <Activity size={16} />
+                                            매매일지
+                                        </h3>
+                                        <button
+                                            onClick={resetPendingTrades}
+                                            className="px-2 py-1 text-[10px] bg-red-500/20 hover:bg-red-500/30 text-red-400 rounded border border-red-500/30 transition-colors"
+                                            title="미체결 주문 정리"
+                                        >
+                                            미체결 정리
+                                        </button>
+                                    </div>
+                                    <div className="space-y-2 overflow-y-auto custom-scrollbar flex-1">
+                                        {journals && journals.length > 0 ? (
+                                            journals.map((journal: any) => {
+                                                const journalDate = new Date(journal.journal_date || journal.created_at);
+                                                const dateStr = journalDate.toLocaleDateString('ko-KR', { month: '2-digit', day: '2-digit' });
+                                                const timeStr = journalDate.toLocaleTimeString('ko-KR', { hour: '2-digit', minute: '2-digit', hour12: false });
+                                                const isGoodMood = journal.mood === '좋음' || journal.mood === 'good' || journal.mood === 'positive';
+                                                const isBadMood = journal.mood === '나쁨' || journal.mood === 'bad' || journal.mood === 'negative';
+                                                const tags: string[] = Array.isArray(journal.tags) ? journal.tags : [];
+                                                const hasProfitTag = tags.some((t: string) => t.includes('익절') || t.includes('profit'));
+                                                const hasLossTag = tags.some((t: string) => t.includes('손절') || t.includes('loss'));
 
-                                            {/* 종목 리스트 */}
-                                            {ruleGroup.stocks.map((item: any) => {
-                                                // stockPrices에서 최신 가격 가져오기 (숫자 변환)
-                                                const latestPrice = Number(stockPrices[item.stock_code] || item.current_price || 0)
                                                 return (
-                                                    <button
-                                                        key={item.stock_code}
-                                                        className={`recommend-item ${selectedStock === item.stock_code ? 'active' : ''}`}
-                                                        onClick={() => handleStockSelect(item.stock_code)}
-                                                        style={{ width: '100%', marginBottom: '4px' }}
-                                                    >
-                                                        <div className="info">
-                                                            <span className="name">{item.stock_name}</span>
-                                                            <span className="code">{item.stock_code}</span>
-                                                        </div>
-                                                        <div className="figures">
-                                                            <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'flex-end' }}>
-                                                                <span className="price">{formatCurrency(latestPrice)}</span>
-                                                                {item.price_date && (
-                                                                    <span style={{ fontSize: '9px', color: '#64748b' }}>
-                                                                        {formatDate(item.price_date)} 기준
-                                                                    </span>
-                                                                )}
+                                                    <div key={journal.id} className="p-3 hover:bg-gray-700/30 rounded-lg transition-colors bg-gray-900/30 border border-gray-700/30">
+                                                        <div className="flex justify-between items-start mb-1.5">
+                                                            <div className="flex items-center gap-2">
+                                                                <span className={`text-base ${isGoodMood ? '' : isBadMood ? '' : ''}`}>
+                                                                    {isGoodMood ? '😊' : isBadMood ? '😔' : '📝'}
+                                                                </span>
+                                                                <span className="font-bold text-gray-200 text-sm">{journal.stock_name || journal.stock_code}</span>
+                                                                {hasProfitTag && <span className="px-1.5 py-0.5 text-[9px] rounded bg-green-500/20 text-green-400">익절</span>}
+                                                                {hasLossTag && <span className="px-1.5 py-0.5 text-[9px] rounded bg-red-500/20 text-red-400">손절</span>}
                                                             </div>
-                                                            <span className={`rate ${(item.change_rate ?? 0) >= 0 ? 'up' : 'down'}`}>
-                                                                {formatPercent(item.change_rate ?? 0)}
-                                                            </span>
+                                                            <span className="text-[10px] text-gray-500 font-mono">{dateStr} {timeStr}</span>
                                                         </div>
-                                                        <div style={{ fontSize: '10px', color: '#64748b', marginTop: '4px' }}>
-                                                            점수: {item.score} | {item.signals?.slice(0, 2).join(', ')}
+                                                        <div className="text-[11px] text-gray-300 leading-relaxed line-clamp-3 whitespace-pre-line">
+                                                            {journal.content}
                                                         </div>
-                                                    </button>
-                                                )
-                                            })}
-                                        </div>
-                                    ))
-                                ) : aiRecommendations && aiRecommendations.recommendations?.length > 0 ? (
-                                    /* 2. 수동 지표 분석 추천 */
-                                    aiRecommendations.recommendations.map((item: any) => {
-                                        // stockPrices에서 최신 가격 가져오기 (숫자 변환)
-                                        const latestPrice = Number(stockPrices[item.stock_code] || item.current_price || 0)
-                                        return (
-                                            <button
-                                                key={item.stock_code}
-                                                className={`recommend-item ${selectedStock === item.stock_code ? 'active' : ''}`}
-                                                onClick={() => handleStockSelect(item.stock_code)}
-                                            >
-                                                <div className="info">
-                                                    <span className="name">{item.stock_name}</span>
-                                                    <span className="code">{item.stock_code}</span>
-                                                </div>
-                                                <div className="figures">
-                                                    <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'flex-end' }}>
-                                                        <span className="price">{formatCurrency(latestPrice)}</span>
-                                                        {item.price_date && (
-                                                            <span style={{ fontSize: '9px', color: '#64748b' }}>
-                                                                {formatDate(item.price_date)} 기준
-                                                            </span>
+                                                        {tags.length > 0 && (
+                                                            <div className="flex flex-wrap gap-1 mt-1.5">
+                                                                {tags.slice(0, 4).map((tag: string, i: number) => (
+                                                                    <span key={i} className="px-1.5 py-0.5 text-[9px] rounded bg-gray-700/50 text-gray-400">#{tag}</span>
+                                                                ))}
+                                                            </div>
                                                         )}
                                                     </div>
-                                                    <span className={`rate ${(item.change_rate ?? 0) >= 0 ? 'up' : 'down'}`}>
-                                                        {formatPercent(item.change_rate ?? 0)}
-                                                    </span>
-                                                </div>
-                                                <div style={{ fontSize: '10px', color: '#64748b', marginTop: '4px' }}>
-                                                    점수: {item.score} | {item.signals.slice(0, 2).join(', ')}
-                                                </div>
-                                            </button>
-                                        )
-                                    })
-                                ) : recommendedStocks.length > 0 ? (
-                                    recommendedStocks.map((item: any) => {
-                                        const displayPrice = Number(selectedStock === item.stock_code && currentStockPrice
-                                            ? currentStockPrice
-                                            : item.current_price)
-                                        return (
-                                            <button
-                                                key={item.stock_code}
-                                                className={`recommend-item ${selectedStock === item.stock_code ? 'active' : ''}`}
-                                                onClick={() => handleStockSelect(item.stock_code)}
-                                            >
-                                                <div className="info">
-                                                    <span className="name">{item.stock_name}</span>
-                                                    <span className="code">{item.stock_code}</span>
-                                                </div>
-                                                <div className="figures">
-                                                    <span className="price">{formatCurrency(displayPrice || 0)}</span>
-                                                    <span className={`rate ${(item.profit_loss_rate ?? 0) >= 0 ? 'up' : 'down'}`}>
-                                                        {formatPercent(item.profit_loss_rate ?? 0)}
-                                                    </span>
-                                                </div>
-                                            </button>
-                                        )
-                                    })
-                                ) : (
-                                    <div className="no-data">보유 종목이 없습니다</div>
-                                )}
-                            </div>
-                        </div>
-
-                        {/* AI 분석 섹션 */}
-                        <div className="ai-analysis-section">
-                            <div className="panel-header">🤖 AI 종합 분석</div>
-                            <div className="analysis-content">
-                                {aiAnalysisLoading ? (
-                                    <div className="analysis-loading">분석 중...</div>
-                                ) : aiAnalysis ? (
-                                    typeof aiAnalysis === 'string' ? (
-                                        <div style={{ whiteSpace: 'pre-wrap' }}>{aiAnalysis}</div>
-                                    ) : typeof aiAnalysis === 'object' && aiAnalysis !== null ? (
-                                        <div style={{ whiteSpace: 'pre-wrap' }}>
-                                            {aiAnalysis.analysis || aiAnalysis.recommendation || JSON.stringify(aiAnalysis, null, 2)}
-                                        </div>
-                                    ) : (
-                                        <div className="no-data">분석 결과를 표시할 수 없습니다</div>
-                                    )
-                                ) : (
-                                    <div className="no-data">종목을 선택하세요</div>
-                                )}
-                            </div>
-                        </div>
-
-                        {/* 리스크 체크 섹션 */}
-                        <div className="risk-check-section">
-                            <div className="panel-header">⚠️ 리스크 체크</div>
-                            <div className="risk-content">
-                                {riskCheckLoading ? (
-                                    <div className="risk-loading">분석 중...</div>
-                                ) : riskCheck ? (
-                                    typeof riskCheck === 'string' ? (
-                                        <div style={{ whiteSpace: 'pre-wrap' }}>{riskCheck}</div>
-                                    ) : typeof riskCheck === 'object' && riskCheck !== null ? (
-                                        <div style={{ whiteSpace: 'pre-wrap' }}>
-                                            {riskCheck.analysis || riskCheck.recommendation || JSON.stringify(riskCheck, null, 2)}
-                                        </div>
-                                    ) : (
-                                        <div className="no-data">분석 결과를 표시할 수 없습니다</div>
-                                    )
-                                ) : (
-                                    <div className="no-data">종목을 선택하세요</div>
-                                )}
-                            </div>
-                        </div>
-
-                        <div className="news-section">
-                            <div className="panel-header">시장 뉴스</div>
-                            <div className="news-list">
-                                {news && news.length > 0 ? (
-                                    // 선택된 종목에 해당하는 뉴스만 필터링
-                                    news.filter((item: any) => !selectedStock || item.stock_code === selectedStock)
-                                        .slice(0, 5)
-                                        .map((item: any) => (
-                                            <div key={item.id} className="news-item" onClick={() => window.open(item.url, '_blank')}>
-                                                <div className="news-title">{item.title}</div>
-                                                <div className="news-meta">
-                                                    {new Date(item.published_at).toLocaleString('ko-KR', {
-                                                        month: '2-digit',
-                                                        day: '2-digit',
-                                                        hour: '2-digit',
-                                                        minute: '2-digit',
-                                                    })}
-                                                </div>
+                                                );
+                                            })
+                                        ) : (
+                                            <div className="h-full flex flex-col items-center justify-center text-gray-600 text-xs gap-1">
+                                                <span>매매일지 없음</span>
+                                                <span className="text-[10px] text-gray-700">매도 체결 후 자동으로 생성됩니다</span>
                                             </div>
-                                        ))
-                                ) : (
-                                    <div className="no-data">뉴스 없음</div>
-                                )}
+                                        )}
+                                    </div>
+                                </div>
                             </div>
                         </div>
                     </div>
                 </div>
-            </div>
-        </HtsPage>
-    )
+            </main>
+        </div>
+    );
 }
 
-export default Dashboard
+export default Dashboard;
+
diff --git a/frontend/src/pages/TradeHistory.tsx b/frontend/src/pages/TradeHistory.tsx
index d3154b1..b86391d 100644
--- a/frontend/src/pages/TradeHistory.tsx
+++ b/frontend/src/pages/TradeHistory.tsx
@@ -8,6 +8,7 @@ import api from '../lib/api'
 interface Trade {
     id: string
     created_at: string
+    executed_at?: string
     status: 'EXECUTED' | 'FAILED' | 'PENDING' | string
     stock_code: string
     stock_name?: string
@@ -16,7 +17,13 @@ interface Trade {
     order_quantity: number
     executed_price: number | null
     executed_quantity: number | null
+    total_amount?: number | null
     message?: string | null
+    entry_reason?: string | null
+    exit_reason?: string | null
+    signals?: string[] | null
+    profit_loss?: number | null
+    profit_loss_rate?: number | null
 }
 
 const TradeHistory = () => {
@@ -82,11 +89,11 @@ const TradeHistory = () => {
                                 <th className="text-left py-3 px-4 text-slate-400">상태</th>
                                 <th className="text-left py-3 px-4 text-slate-400">종목</th>
                                 <th className="text-center py-3 px-4 text-slate-400">구분</th>
-                                <th className="text-right py-3 px-4 text-slate-400">주문가</th>
+                                <th className="text-right py-3 px-4 text-slate-400">가격</th>
                                 <th className="text-right py-3 px-4 text-slate-400">수량</th>
-                                <th className="text-right py-3 px-4 text-slate-400">체결가</th>
-                                <th className="text-right py-3 px-4 text-slate-400">체결수량</th>
-                                <th className="text-left py-3 px-4 text-slate-400">메시지</th>
+                                <th className="text-right py-3 px-4 text-slate-400">총액</th>
+                                <th className="text-right py-3 px-4 text-slate-400">손익</th>
+                                <th className="text-left py-3 px-4 text-slate-400">이유/신호</th>
                             </tr>
                         </thead>
                         <tbody>
@@ -130,19 +137,55 @@ const TradeHistory = () => {
                                         </span>
                                     </td>
                                     <td className="py-3 px-4 text-right text-white">
-                                        {formatCurrency(trade.order_price)}
+                                        {formatCurrency(trade.executed_price || trade.order_price)}
                                     </td>
                                     <td className="py-3 px-4 text-right text-white">
-                                        {trade.order_quantity.toLocaleString()}
+                                        {(trade.executed_quantity || trade.order_quantity).toLocaleString()}주
                                     </td>
-                                    <td className="py-3 px-4 text-right text-white">
-                                        {trade.executed_price != null ? formatCurrency(trade.executed_price) : '-'}
+                                    <td className="py-3 px-4 text-right text-white font-medium">
+                                        {trade.total_amount != null ? formatCurrency(trade.total_amount) : '-'}
                                     </td>
-                                    <td className="py-3 px-4 text-right text-white">
-                                        {trade.executed_quantity != null ? trade.executed_quantity.toLocaleString() : '-'}
+                                    <td className="py-3 px-4 text-right">
+                                        {trade.order_type === 'SELL' && trade.profit_loss != null ? (
+                                            <div className="space-y-0.5">
+                                                <div className={`font-medium ${Number(trade.profit_loss) >= 0 ? 'text-primary' : 'text-danger'
+                                                    }`}>
+                                                    {Number(trade.profit_loss) >= 0 ? '+' : ''}{formatCurrency(Number(trade.profit_loss))}
+                                                </div>
+                                                {trade.profit_loss_rate != null && (
+                                                    <div className={`text-xs ${Number(trade.profit_loss_rate) >= 0 ? 'text-primary' : 'text-danger'
+                                                        }`}>
+                                                        ({Number(trade.profit_loss_rate) >= 0 ? '+' : ''}{Number(trade.profit_loss_rate).toFixed(2)}%)
+                                                    </div>
+                                                )}
+                                            </div>
+                                        ) : (
+                                            <span className="text-slate-500">-</span>
+                                        )}
                                     </td>
-                                    <td className="py-3 px-4 text-slate-400 text-sm">
-                                        {trade.message || '-'}
+                                    <td className="py-3 px-4 text-slate-400 text-sm max-w-md">
+                                        {trade.order_type === 'BUY' && trade.entry_reason && (
+                                            <div className="space-y-1">
+                                                <div className="text-primary text-xs font-medium">📈 진입 이유</div>
+                                                <div>{trade.entry_reason}</div>
+                                                {trade.signals && trade.signals.length > 0 && (
+                                                    <div className="flex flex-wrap gap-1 mt-1">
+                                                        {trade.signals.slice(0, 3).map((signal, idx) => (
+                                                            <span key={idx} className="text-xs bg-slate-700 px-2 py-0.5 rounded">
+                                                                {signal}
+                                                            </span>
+                                                        ))}
+                                                    </div>
+                                                )}
+                                            </div>
+                                        )}
+                                        {trade.order_type === 'SELL' && trade.exit_reason && (
+                                            <div className="space-y-1">
+                                                <div className="text-danger text-xs font-medium">📉 매도 이유</div>
+                                                <div>{trade.exit_reason}</div>
+                                            </div>
+                                        )}
+                                        {!trade.entry_reason && !trade.exit_reason && (trade.message || '-')}
                                     </td>
                                 </tr>
                             ))}
diff --git a/frontend/src/pages/TradingRules.tsx b/frontend/src/pages/TradingRules.tsx
index 91a216d..7e3787b 100644
--- a/frontend/src/pages/TradingRules.tsx
+++ b/frontend/src/pages/TradingRules.tsx
@@ -11,9 +11,10 @@ const TradingRules = () => {
         name: '',
         description: '',
         rule_type: 'BUY',
-        priority: 1,
-        conditions: '{\n  "rsi_threshold": 40,\n  "sma_short": 5,\n  "sma_long": 20\n}',
-        actions: '{\n  "take_profit": 5.0,\n  "stop_loss": 3.0,\n  "position_sizing": {\n    "target_ratio": 0.15\n  }\n}'
+        risk_level: 'MEDIUM',
+        stop_loss: 3.0,
+        take_profit: 5.0,
+        max_quantity: 1
     })
 
     // 트레이딩 규칙 조회
@@ -28,36 +29,27 @@ const TradingRules = () => {
     // 규칙 생성
     const createMutation = useMutation({
         mutationFn: async (data: any) => {
-            // MCP로 규칙 검증
-            try {
-                const validateResponse = await fetch('http://localhost:8001/analyze', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        analysis_type: 'RULE_VALIDATION',
-                        data: {
-                            name: data.name,
-                            conditions: JSON.parse(data.conditions),
-                            actions: JSON.parse(data.actions)
-                        }
-                    })
-                });
-                const validation = await validateResponse.json();
+            // AI 자동 매매를 위한 기본 템플릿 구성
+            const finalConditions = {
+                type: "AI_AUTO_OPTIMIZATION",
+                risk_level: data.risk_level,
+                description: "AI가 시장 상황에 따라 진입 조건을 동적으로 결정합니다."
+            };
 
-                if (!confirm(`🤖 AI 규칙 검증 결과:\n\n${validation.analysis || validation.result}\n\n계속 진행하시겠습니까?`)) {
-                    throw new Error('사용자가 취소했습니다.');
-                }
-            } catch (error: any) {
-                if (error.message === '사용자가 취소했습니다.') {
-                    throw error;
-                }
-                console.warn('MCP 검증 실패, 그대로 진행:', error);
-            }
+            const finalActions = {
+                stop_loss: parseFloat(data.stop_loss),
+                take_profit: parseFloat(data.take_profit),
+                max_quantity: parseInt(data.max_quantity),
+                trailing_stop: true
+            };
 
             return api.post('/rules', {
-                ...data,
-                conditions: JSON.parse(data.conditions),
-                actions: JSON.parse(data.actions)
+                name: data.name,
+                description: data.description,
+                rule_type: data.rule_type,
+                priority: 1,
+                conditions: finalConditions,
+                actions: finalActions
             })
         },
         onSuccess: () => {
@@ -67,16 +59,15 @@ const TradingRules = () => {
                 name: '',
                 description: '',
                 rule_type: 'BUY',
-                priority: 1,
-                conditions: '{\n  "rsi_threshold": 40,\n  "sma_short": 5,\n  "sma_long": 20\n}',
-                actions: '{\n  "take_profit": 5.0,\n  "stop_loss": 3.0,\n  "position_sizing": {\n    "target_ratio": 0.15\n  }\n}'
+                risk_level: 'MEDIUM',
+                stop_loss: 3.0,
+                take_profit: 5.0,
+                max_quantity: 1
             })
-            alert('✅ 규칙이 성공적으로 추가되었습니다!')
+            alert('✅ AI 자동매매 규칙이 설정되었습니다!')
         },
         onError: (error: any) => {
-            if (error.message !== '사용자가 취소했습니다.') {
-                alert(`❌ 규칙 추가 실패: ${error.response?.data?.detail || error.message}`)
-            }
+            alert(`❌ 규칙 추가 실패: ${error.response?.data?.detail || error.message}`)
         },
     })
 
@@ -158,35 +149,50 @@ const TradingRules = () => {
                                         </select>
                                     </div>
                                     <div>
-                                        <label className="block text-sm font-medium text-slate-300 mb-1">우선순위</label>
+                                        <label className="block text-sm font-medium text-slate-300 mb-1">리스크 레벨</label>
+                                        <select
+                                            value={formData.risk_level}
+                                            onChange={(e) => setFormData({ ...formData, risk_level: e.target.value })}
+                                            className="w-full px-3 py-2 bg-slate-800 border border-slate-700 rounded text-white"
+                                        >
+                                            <option value="LOW">LOW (보수적)</option>
+                                            <option value="MEDIUM">MEDIUM (중립)</option>
+                                            <option value="HIGH">HIGH (공격적)</option>
+                                        </select>
+                                    </div>
+                                </div>
+                                <div className="grid grid-cols-2 gap-4">
+                                    <div>
+                                        <label className="block text-sm font-medium text-slate-300 mb-1">기본 손절가 (%)</label>
                                         <input
                                             type="number"
-                                            value={formData.priority}
-                                            onChange={(e) => setFormData({ ...formData, priority: parseInt(e.target.value) })}
+                                            value={formData.stop_loss}
+                                            onChange={(e) => setFormData({ ...formData, stop_loss: parseFloat(e.target.value) })}
                                             className="w-full px-3 py-2 bg-slate-800 border border-slate-700 rounded text-white"
-                                            min="1"
+                                            step="0.1"
+                                        />
+                                    </div>
+                                    <div>
+                                        <label className="block text-sm font-medium text-slate-300 mb-1">기본 익절가 (%)</label>
+                                        <input
+                                            type="number"
+                                            value={formData.take_profit}
+                                            onChange={(e) => setFormData({ ...formData, take_profit: parseFloat(e.target.value) })}
+                                            className="w-full px-3 py-2 bg-slate-800 border border-slate-700 rounded text-white"
+                                            step="0.1"
                                         />
                                     </div>
                                 </div>
                                 <div>
-                                    <label className="block text-sm font-medium text-slate-300 mb-1">조건 (JSON)</label>
-                                    <textarea
-                                        value={formData.conditions}
-                                        onChange={(e) => setFormData({ ...formData, conditions: e.target.value })}
-                                        className="w-full px-3 py-2 bg-slate-800 border border-slate-700 rounded text-white font-mono text-xs"
-                                        rows={6}
-                                        required
-                                    />
-                                </div>
-                                <div>
-                                    <label className="block text-sm font-medium text-slate-300 mb-1">실행 액션 (JSON)</label>
-                                    <textarea
-                                        value={formData.actions}
-                                        onChange={(e) => setFormData({ ...formData, actions: e.target.value })}
-                                        className="w-full px-3 py-2 bg-slate-800 border border-slate-700 rounded text-white font-mono text-xs"
-                                        rows={6}
-                                        required
+                                    <label className="block text-sm font-medium text-slate-300 mb-1">최대 매수 수량</label>
+                                    <input
+                                        type="number"
+                                        value={formData.max_quantity}
+                                        onChange={(e) => setFormData({ ...formData, max_quantity: parseInt(e.target.value) })}
+                                        className="w-full px-3 py-2 bg-slate-800 border border-slate-700 rounded text-white"
+                                        min="1"
                                     />
+                                    <p className="text-xs text-slate-500 mt-1">* 실제 진입 타이밍은 AI가 시장 상황에 따라 최적화합니다.</p>
                                 </div>
                             </div>
                             <div className="mt-4 flex justify-end space-x-2">
@@ -202,7 +208,7 @@ const TradingRules = () => {
                                     className="btn-primary text-sm"
                                     disabled={createMutation.isPending}
                                 >
-                                    {createMutation.isPending ? '검증 중...' : '🤖 AI 검증 후 추가'}
+                                    {createMutation.isPending ? '처리 중...' : '자동매매 규칙 등록'}
                                 </button>
                             </div>
                         </form>
diff --git a/frontend/src/utils/technicalIndicators.ts b/frontend/src/utils/technicalIndicators.ts
new file mode 100644
index 0000000..5ef38db
--- /dev/null
+++ b/frontend/src/utils/technicalIndicators.ts
@@ -0,0 +1,116 @@
+// 기술적 지표 계산 유틸리티
+// 기존 TradingChart.tsx에서 검증된 로직을 재사용
+
+/**
+ * 단순이동평균 (Simple Moving Average)
+ * @param data 가격 데이터 배열
+ * @param period 이동평균 기간
+ * @returns SMA 값 배열
+ */
+export const calculateSMA = (data: number[], period: number): number[] => {
+    const result: number[] = [];
+    for (let i = 0; i < data.length; i++) {
+        if (i < period - 1) {
+            result.push(NaN);
+        } else {
+            const sum = data.slice(i - period + 1, i + 1).reduce((a, b) => a + b, 0);
+            result.push(sum / period);
+        }
+    }
+    return result;
+};
+
+/**
+ * 지수이동평균 (Exponential Moving Average)
+ * @param data 가격 데이터 배열
+ * @param period EMA 기간
+ * @returns EMA 값 배열
+ */
+export const calculateEMA = (data: number[], period: number): number[] => {
+    const k = 2 / (period + 1);
+    const ema: number[] = [];
+
+    for (let i = 0; i < data.length; i++) {
+        if (i === 0) {
+            ema.push(data[i]);
+        } else {
+            ema.push(data[i] * k + ema[i - 1] * (1 - k));
+        }
+    }
+
+    return ema;
+};
+
+/**
+ * 볼린저 밴드 (Bollinger Bands)
+ * @param closes 종가 배열
+ * @param period 기간 (기본값: 20)
+ * @returns 상단, 중간(SMA), 하단 밴드 배열
+ */
+export const calculateBollingerBands = (closes: number[], period: number = 20) => {
+    const sma = calculateSMA(closes, period);
+    const upper: number[] = [];
+    const lower: number[] = [];
+
+    for (let i = 0; i < closes.length; i++) {
+        if (i < period - 1) {
+            upper.push(NaN);
+            lower.push(NaN);
+        } else {
+            const slice = closes.slice(i - period + 1, i + 1);
+            const mean = sma[i];
+            const variance = slice.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / period;
+            const stdDev = Math.sqrt(variance);
+            upper.push(mean + 2 * stdDev);
+            lower.push(mean - 2 * stdDev);
+        }
+    }
+
+    return { upper, middle: sma, lower };
+};
+
+/**
+ * RSI (Relative Strength Index)
+ * @param closes 종가 배열
+ * @param period RSI 기간 (기본값: 14)
+ * @returns RSI 값 배열
+ */
+export const calculateRSI = (closes: number[], period: number = 14): number[] => {
+    const rsi: number[] = [];
+    const gains: number[] = [];
+    const losses: number[] = [];
+
+    for (let i = 1; i < closes.length; i++) {
+        const change = closes[i] - closes[i - 1];
+        gains.push(change > 0 ? change : 0);
+        losses.push(change < 0 ? -change : 0);
+    }
+
+    for (let i = 0; i < closes.length; i++) {
+        if (i < period) {
+            rsi.push(NaN);
+        } else {
+            const avgGain = gains.slice(i - period, i).reduce((a, b) => a + b, 0) / period;
+            const avgLoss = losses.slice(i - period, i).reduce((a, b) => a + b, 0) / period;
+            const rs = avgLoss === 0 ? 100 : avgGain / avgLoss;
+            rsi.push(100 - (100 / (1 + rs)));
+        }
+    }
+
+    return rsi;
+};
+
+/**
+ * MACD (Moving Average Convergence Divergence)
+ * @param closes 종가 배열
+ * @returns MACD, Signal, Histogram 배열
+ */
+export const calculateMACD = (closes: number[]) => {
+    const ema12 = calculateEMA(closes, 12);
+    const ema26 = calculateEMA(closes, 26);
+    const macd = ema12.map((val, i) => val - ema26[i]);
+    const signal = calculateEMA(macd, 9);
+    const histogram = macd.map((val, i) => val - signal[i]);
+
+    return { macd, signal, histogram };
+};
diff --git a/frontend/tsconfig.json b/frontend/tsconfig.json
index a868d17..e24b6f9 100644
--- a/frontend/tsconfig.json
+++ b/frontend/tsconfig.json
@@ -2,7 +2,6 @@
     "compilerOptions": {
         "target": "ES2020",
         "useDefineForClassFields": true,
-        "ignoreDeprecations": "5.0",
         "lib": [
             "ES2020",
             "DOM",
@@ -17,6 +16,13 @@
         "isolatedModules": true,
         "noEmit": true,
         "jsx": "react-jsx",
+        "esModuleInterop": true,
+        "allowSyntheticDefaultImports": true,
+        "types": [
+            "react",
+            "react-dom",
+            "node"
+        ],
         /* Linting */
         "strict": true,
         "noUnusedLocals": true,
diff --git a/frontend/vite.config.ts b/frontend/vite.config.ts
index 8ffb161..fcaa8af 100644
--- a/frontend/vite.config.ts
+++ b/frontend/vite.config.ts
@@ -14,14 +14,15 @@ export default defineConfig({
         },
     },
     server: {
+        host: '0.0.0.0', // Docker 등의 환경에서 외부 접속 허용
         port: 3000,
         proxy: {
             '/api': {
-                target: 'http://localhost:8000',
+                target: process.env.VITE_API_TARGET || 'http://localhost:8090',
                 changeOrigin: true,
             },
             '/ws': {
-                target: 'ws://localhost:8000',
+                target: 'ws://localhost:8090',
                 ws: true,
             },
         },
diff --git a/mcp-server/auto_trade_claude.py b/mcp-server/auto_trade_claude.py
new file mode 100644
index 0000000..fa25c5f
--- /dev/null
+++ b/mcp-server/auto_trade_claude.py
@@ -0,0 +1,85 @@
+import re
+import asyncio
+import json
+import os
+from datetime import datetime, timezone
+from app.services.korea_investment_api import korea_investment_api
+
+# Claude 응답에서 종목/가격 추출
+CLAUDE_FORMAT = r"종목[:\s]+(\d+)"  # 종목코드
+ENTRY_FORMAT = r"진입가[:\s]+([\d,]+)"  # 진입가
+STOP_FORMAT = r"손절가[:\s]+([\d,]+)"  # 손절가
+TARGET_FORMAT = r"목표가[:\s]+([\d,]+)"  # 목표가
+
+ACTIVE_TRADES_FILE = os.path.join(os.path.dirname(__file__), 'active_trades.json')
+
+def parse_claude_response(text):
+    code = re.search(CLAUDE_FORMAT, text)
+    entry = re.search(ENTRY_FORMAT, text)
+    stop = re.search(STOP_FORMAT, text)
+    target = re.search(TARGET_FORMAT, text)
+    return {
+        'stock_code': code.group(1) if code else None,
+        'entry_price': int(entry.group(1).replace(',', '')) if entry else None,
+        'stop_loss': int(stop.group(1).replace(',', '')) if stop else None,
+        'take_profit': int(target.group(1).replace(',', '')) if target else None,
+    }
+
+def save_active_trade(trade_info):
+    """활성화된 거래를 JSON 파일에 저장합니다."""
+    trades = []
+    if os.path.exists(ACTIVE_TRADES_FILE):
+        with open(ACTIVE_TRADES_FILE, 'r', encoding='utf-8') as f:
+            try:
+                trades = json.load(f)
+            except json.JSONDecodeError:
+                print(f"경고: {ACTIVE_TRADES_FILE} 파일이 비어있거나 잘못된 형식입니다. 새 파일을 생성합니다.")
+    
+    trades.append(trade_info)
+    
+    with open(ACTIVE_TRADES_FILE, 'w', encoding='utf-8') as f:
+        json.dump(trades, f, indent=4, ensure_ascii=False)
+    print(f"✅ 거래 정보 저장 완료: {trade_info['stock_code']}")
+
+async def auto_trade_from_claude(text, quantity=1):
+    info = parse_claude_response(text)
+    if info['stock_code'] and info['entry_price']:
+        print(f"▶️ 매수 주문 시도: {info['stock_code']}, 수량: {quantity}, 가격: {info['entry_price']}")
+        # 지정가 매수 주문
+        result = await korea_investment_api.place_order(
+            stock_code=info['stock_code'],
+            order_type='BUY',
+            quantity=quantity,
+            price=info['entry_price']
+        )
+        print('주문 결과:', result)
+        
+        # API 응답 구조에 따라 rt_cd가 '0'이면 성공으로 간주
+        if result and result.get('rt_cd') == '0':
+            print("✅ 매수 주문 성공. 거래 정보를 저장합니다.")
+            trade_details = {
+                'stock_code': info['stock_code'],
+                'quantity': quantity,
+                'entry_price': info['entry_price'],
+                'stop_loss': info['stop_loss'],
+                'take_profit': info['take_profit'],
+                'order_id': result.get('ODNO'),  # 주문번호
+                'order_time': result.get('ORD_TMD'), # 주문시각
+                'timestamp': datetime.now(timezone.utc).isoformat()
+            }
+            save_active_trade(trade_details)
+        else:
+            error_message = result.get('msg1', '알 수 없는 오류')
+            print(f"❌ 매수 주문 실패: {error_message}")
+            
+    else:
+        print('Claude 응답에서 종목/가격을 찾을 수 없습니다.')
+
+if __name__ == "__main__":
+    # 예시: Claude 응답 텍스트를 받아 자동매매 실행
+    import sys
+    if len(sys.argv) > 1:
+        text = sys.argv[1]
+        asyncio.run(auto_trade_from_claude(text))
+    else:
+        print("사용법: python auto_trade_claude.py 'Claude 응답 텍스트'")
diff --git a/mcp-server/claude_client.py b/mcp-server/claude_client.py
index 6f415a7..2425093 100644
--- a/mcp-server/claude_client.py
+++ b/mcp-server/claude_client.py
@@ -1,5 +1,6 @@
-from anthropic import Anthropic
+from anthropic import AsyncAnthropic
 from config import settings
+from utils import _dumps
 from typing import Dict, Any, List
 import json
 import logging
@@ -9,9 +10,9 @@ logger = logging.getLogger(__name__)
 
 class ClaudeClient:
     """Claude AI 클라이언트"""
-    
+
     def __init__(self):
-        self.client = Anthropic(api_key=settings.ANTHROPIC_API_KEY)
+        self.client = AsyncAnthropic(api_key=settings.ANTHROPIC_API_KEY)
         self.model = settings.CLAUDE_MODEL
     
     async def analyze(
@@ -37,7 +38,7 @@ class ClaudeClient:
             if tools:
                 params["tools"] = tools
             
-            response = self.client.messages.create(**params)
+            response = await self.client.messages.create(**params)
             
             # 응답 파싱
             result = {
@@ -72,27 +73,18 @@ class ClaudeClient:
     async def validate_trading_rule(
         self,
         rule: Dict[str, Any],
-        market_data: Dict[str, Any]
+        market_data: Dict[str, Any],
+        news_data: List[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
         """트레이딩 규칙 검증"""
-        system_prompt = """당신은 주식 트레이딩 규칙을 분석하고 검증하는 전문가입니다.
-주어진 규칙과 시장 데이터를 분석하여 다음을 제공하세요:
-1. 규칙이 현재 시장 상황에 적합한지 여부
-2. 실행 가능성 (0-1 사이의 점수)
-3. 리스크 평가
-4. 추천 사항
+        system_prompt = """주식 트레이딩 규칙 검증 전문가. 규칙/시장/뉴스를 분석하여 JSON으로 응답.
+필수 필드: decision(BUY/SELL/HOLD), confidence(0-1), risk_level, recommendation.
+악재(유상증자,감자,소송,실적악화) 시 confidence 낮추고 경고 포함."""
 
-JSON 형식으로 응답하세요."""
-        
-        user_message = f"""
-트레이딩 규칙:
-{json.dumps(rule, ensure_ascii=False, indent=2)}
+        user_message = f"규칙:{_dumps(rule)}\n시장:{_dumps(market_data)}"
 
-시장 데이터:
-{json.dumps(market_data, ensure_ascii=False, indent=2)}
-
-이 규칙이 현재 시장 상황에서 실행되어야 하는지 분석해주세요.
-"""
+        if news_data:
+            user_message += f"\n뉴스:{_dumps(news_data)}"
         
         response = await self.analyze(system_prompt, user_message)
         
@@ -123,32 +115,17 @@ JSON 형식으로 응답하세요."""
         news: List[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
         """시장 분석"""
-        system_prompt = """당신은 주식 시장 분석 전문가입니다.
-주어진 시장 데이터와 뉴스를 분석하여 다음을 제공하세요:
-1. 시장 트렌드 (상승/하락/횡보)
-2. 주요 기술적 지표 분석
-3. 뉴스 센티먼트 (긍정/부정/중립)
-4. 투자 추천 (매수/매도/보유)
-5. 신뢰도 (0-1)
+        system_prompt = """주식 시장 분석 전문가. JSON으로 응답.
+필수 필드: trend(UP/DOWN/SIDEWAYS), sentiment(POSITIVE/NEGATIVE/NEUTRAL), recommendation(BUY/SELL/HOLD), confidence(0-1), analysis(간략설명)."""
 
-JSON 형식으로 응답하세요."""
-        
+        news_limit = settings.NEWS_LIMIT if settings.TOKEN_SAVE_MODE else 5
         news_text = ""
         if news:
-            news_text = "\n\n최근 뉴스:\n" + "\n".join([
-                f"- {item.get('title', '')}: {item.get('content', '')[:200]}"
-                for item in news[:5]
+            news_text = "\n뉴스:" + ",".join([
+                item.get('title', '') for item in news[:news_limit]
             ])
-        
-        user_message = f"""
-종목 코드: {stock_code}
 
-시장 데이터:
-{json.dumps(market_data, ensure_ascii=False, indent=2)}
-{news_text}
-
-이 종목에 대한 종합적인 시장 분석을 제공해주세요.
-"""
+        user_message = f"종목:{stock_code}\n시장:{_dumps(market_data)}{news_text}"
         
         response = await self.analyze(system_prompt, user_message)
         
@@ -179,43 +156,10 @@ JSON 형식으로 응답하세요."""
         financial_data: Dict[str, Any] = None
     ) -> Dict[str, Any]:
         """AI 기반 적정 매수/매도 가격 산출"""
-        system_prompt = """당신은 주식 가치 평가 및 가격 전략 전문가입니다.
-기술적 분석과 시장 데이터를 기반으로 다음을 제공하세요:
-1. 적정 매수 가격 (공격적, 중립적, 보수적)
-2. 적정 매도 가격 (목표가 1, 2, 3)
-3. 손절가
-4. 근거 및 전략
-5. 신뢰도 (0-1)
+        system_prompt = """주식 가격 전략 전문가. JSON으로 응답.
+필수 필드: buy_prices(aggressive,neutral,conservative), sell_prices(target1,target2,target3), stop_loss, strategy, confidence(0-1)."""
 
-JSON 형식으로 응답하세요. 예시:
-{
-  "buy_prices": {
-    "aggressive": 100000,
-    "neutral": 105000,
-    "conservative": 110000
-  },
-  "sell_prices": {
-    "target1": 120000,
-    "target2": 130000,
-    "target3": 140000
-  },
-  "stop_loss": 95000,
-  "strategy": "기술적 분석 기반 설명...",
-  "confidence": 0.75
-}"""
-        
-        user_message = f"""
-종목 코드: {stock_code}
-
-시장 데이터:
-- 현재가: {market_data.get('current_price')}
-- 고가: {market_data.get('high_price')}
-- 저가: {market_data.get('low_price')}
-- 거래량: {market_data.get('volume')}
-- 기술적 지표: {json.dumps(market_data.get('indicators', {}), ensure_ascii=False)}
-
-이 종목의 적정 매수/매도 가격과 전략을 제시해주세요.
-"""
+        user_message = f"종목:{stock_code} 현재가:{market_data.get('current_price')} 고가:{market_data.get('high_price')} 저가:{market_data.get('low_price')} 거래량:{market_data.get('volume')} 지표:{_dumps(market_data.get('indicators', {}))}"
         
         response = await self.analyze(system_prompt, user_message)
         
@@ -243,25 +187,10 @@ JSON 형식으로 응답하세요. 예시:
         trade_plan: Dict[str, Any]
     ) -> Dict[str, Any]:
         """리스크 평가"""
-        system_prompt = """당신은 투자 리스크 관리 전문가입니다.
-현재 포트폴리오와 계획된 거래를 분석하여 다음을 제공하세요:
-1. 리스크 레벨 (LOW/MEDIUM/HIGH/CRITICAL)
-2. 주요 리스크 요인
-3. 포트폴리오 다양성 평가
-4. 추천 사항
-5. 승인 여부 (APPROVED/REJECTED)
+        system_prompt = """투자 리스크 관리 전문가. JSON으로 응답.
+필수 필드: risk_level(LOW/MEDIUM/HIGH/CRITICAL), risk_factors, approval(APPROVED/REJECTED), recommendation."""
 
-JSON 형식으로 응답하세요."""
-        
-        user_message = f"""
-현재 포트폴리오:
-{json.dumps(portfolio, ensure_ascii=False, indent=2)}
-
-계획된 거래:
-{json.dumps(trade_plan, ensure_ascii=False, indent=2)}
-
-이 거래의 리스크를 평가하고 실행 여부를 결정해주세요.
-"""
+        user_message = f"포트폴리오:{_dumps(portfolio)}\n거래계획:{_dumps(trade_plan)}"
         
         response = await self.analyze(system_prompt, user_message)
         
@@ -277,11 +206,66 @@ JSON 형식으로 응답하세요."""
                         "analysis": content["text"]
                     }
         
-        return {
-            "risk_level": "UNKNOWN",
-            "approval": "REJECTED",
-            "confidence": 0.0
-        }
+        return {"error": "Failed to assess risk"}
+
+    async def optimize_trading_rules(
+        self,
+        stock_code: str,
+        market_data: Dict[str, Any],
+        news_data: List[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """시장 상황에 맞는 트레이딩 규칙 최적화"""
+        system_prompt = """알고리즘 트레이딩 전략가. JSON으로만 응답.
+필수 필드: strategy_name, market_condition, parameters(buy_conditions,sell_conditions(take_profit_rate,stop_loss_rate,trailing_stop)), risk_assessment, confidence_score(0-100).
+악재시 보수적, 호재시 적극적 설정."""
+
+        user_message = f"종목:{stock_code}\n시장:{_dumps(market_data)}"
+
+        if news_data:
+            user_message += f"\n뉴스:{_dumps(news_data)}"
+
+        response = await self.analyze(system_prompt, user_message)
+        
+        # 텍스트 응답 파싱
+        for content in response["content"]:
+            if content["type"] == "text":
+                try:
+                    text = content["text"]
+                    json_start = text.find('{')
+                    json_end = text.rfind('}') + 1
+                    if json_start != -1 and json_end != -1:
+                        return json.loads(text[json_start:json_end])
+                except Exception as e:
+                    logger.error(f"Failed to parse optimization result: {e}")
+                    
+        return {"error": "Failed to generate optimized rules"}
+
+    async def generate_trade_journal(
+        self,
+        trade_info: Dict[str, Any],
+        market_data: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """매매일지 자동 작성"""
+        system_prompt = """매매일지 작성 전문가. JSON으로 응답.
+필수 필드: title, content(간략 Markdown), mood(평정심/흥분/공포/아쉬움/만족), tags(배열), score(0-100).
+매매근거, 잘한점/아쉬운점, 개선사항 포함."""
+
+        user_message = f"거래:{_dumps(trade_info)}\n시장:{_dumps(market_data)}"
+        
+        response = await self.analyze(system_prompt, user_message)
+        
+        for content in response["content"]:
+            if content["type"] == "text":
+                try:
+                    text = content["text"]
+                    json_start = text.find('{')
+                    json_end = text.rfind('}') + 1
+                    if json_start != -1 and json_end != -1:
+                        return json.loads(text[json_start:json_end])
+                except Exception as e:
+                    logger.error(f"Failed to parse journal result: {e}")
+        
+        return {"error": "Failed to generate journal"}
 
 
 claude_client = ClaudeClient()
diff --git a/mcp-server/config.py b/mcp-server/config.py
index dfbe8e0..77eb22b 100644
--- a/mcp-server/config.py
+++ b/mcp-server/config.py
@@ -7,31 +7,43 @@ load_dotenv()
 class Settings:
     # API Keys
     ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY", "")
-    PERPLEXITY_API_KEY = os.getenv("PERPLEXITY_API_KEY", "")
-    
-    # AI Provider Selection
-    AI_PROVIDER = os.getenv("AI_PROVIDER", "perplexity")  # claude or perplexity
-    
+    GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "")
+
+    # AI Provider Selection (claude or gemini)
+    AI_PROVIDER = os.getenv("AI_PROVIDER", "gemini")
+
     # Server Settings
     MCP_SERVER_HOST = os.getenv("MCP_SERVER_HOST", "0.0.0.0")
     MCP_SERVER_PORT = int(os.getenv("MCP_SERVER_PORT", "8001"))
-    
+
     # Database
     DATABASE_URL = os.getenv("DATABASE_URL", "")
     REDIS_URL = os.getenv("REDIS_URL", "")
-    
+
     # Logging
     LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
-    
+
     # Claude Settings
     CLAUDE_MODEL = os.getenv("CLAUDE_MODEL", "claude-3-5-sonnet-20241022")
-    
-    # Perplexity Settings
-    PERPLEXITY_MODEL = os.getenv("PERPLEXITY_MODEL", "llama-3.1-sonar-large-128k-online")
-    
-    # Common AI Settings
-    MAX_TOKENS = int(os.getenv("PERPLEXITY_MAX_TOKENS" if AI_PROVIDER == "perplexity" else "CLAUDE_MAX_TOKENS", "4096"))
-    TEMPERATURE = float(os.getenv("PERPLEXITY_TEMPERATURE" if AI_PROVIDER == "perplexity" else "CLAUDE_TEMPERATURE", "0.7"))
+
+    # Gemini Settings
+    GEMINI_MODEL = os.getenv("GEMINI_MODEL", "gemini-2.0-flash")
+
+    # Common AI Settings (AI_PROVIDER에 따라 자동 선택)
+    MAX_TOKENS = int(os.getenv(
+        "GEMINI_MAX_TOKENS" if AI_PROVIDER == "gemini" else "CLAUDE_MAX_TOKENS",
+        "1024"
+    ))
+    TEMPERATURE = float(os.getenv(
+        "GEMINI_TEMPERATURE" if AI_PROVIDER == "gemini" else "CLAUDE_TEMPERATURE",
+        "0.3"
+    ))
+
+    # Token Optimization Settings
+    TOKEN_SAVE_MODE = os.getenv("TOKEN_SAVE_MODE", "false").lower() == "true"
+    NEWS_LIMIT = int(os.getenv("NEWS_LIMIT", "5"))
+    CHART_DAYS = int(os.getenv("CHART_DAYS", "100"))
+    JSON_COMPACT = os.getenv("JSON_COMPACT", "false").lower() == "true"
 
 
 settings = Settings()
diff --git a/mcp-server/gemini_client.py b/mcp-server/gemini_client.py
new file mode 100644
index 0000000..8c49382
--- /dev/null
+++ b/mcp-server/gemini_client.py
@@ -0,0 +1,188 @@
+from google import genai
+from google.genai import types
+from config import settings
+from utils import _dumps
+from typing import Dict, Any, List
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class GeminiClient:
+    """Gemini AI 클라이언트 (ClaudeClient와 동일한 인터페이스)"""
+
+    def __init__(self):
+        self.client = genai.Client(api_key=settings.GEMINI_API_KEY)
+        self.model_name = settings.GEMINI_MODEL
+        self.generate_config = types.GenerateContentConfig(
+            max_output_tokens=settings.MAX_TOKENS,
+            temperature=settings.TEMPERATURE,
+        )
+
+    async def analyze(
+        self,
+        system_prompt: str,
+        user_message: str,
+        tools: List[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """Gemini를 통한 분석 실행"""
+        try:
+            response = await self.client.aio.models.generate_content(
+                model=self.model_name,
+                contents=f"{system_prompt}\n\n{user_message}",
+                config=self.generate_config,
+            )
+
+            text = response.text if response.text else ""
+            return {
+                "content": [{"type": "text", "text": text}],
+                "stop_reason": "end_turn",
+                "usage": {
+                    "input_tokens": response.usage_metadata.prompt_token_count if response.usage_metadata else 0,
+                    "output_tokens": response.usage_metadata.candidates_token_count if response.usage_metadata else 0,
+                }
+            }
+
+        except Exception as e:
+            logger.error(f"Gemini analysis error: {e}")
+            raise
+
+    def _parse_json_response(self, response: Dict[str, Any], fallback: Dict[str, Any]) -> Dict[str, Any]:
+        """응답 텍스트에서 JSON 파싱 (공통 헬퍼)"""
+        for content in response["content"]:
+            if content["type"] == "text":
+                try:
+                    text = content["text"]
+                    json_start = text.find('{')
+                    json_end = text.rfind('}') + 1
+                    if json_start != -1 and json_end > json_start:
+                        return json.loads(text[json_start:json_end])
+                except (json.JSONDecodeError, Exception):
+                    return {**fallback, "analysis": content["text"]}
+        return fallback
+
+    async def validate_trading_rule(
+        self,
+        rule: Dict[str, Any],
+        market_data: Dict[str, Any],
+        news_data: List[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """트레이딩 규칙 검증"""
+        system_prompt = """주식 트레이딩 규칙 검증 전문가. 규칙/시장/뉴스를 분석하여 JSON으로만 응답.
+필수 필드: decision(BUY/SELL/HOLD), confidence(0-1), risk_level, recommendation.
+악재(유상증자,감자,소송,실적악화) 시 confidence 낮추고 경고 포함. JSON 외 텍스트 금지."""
+
+        user_message = f"규칙:{_dumps(rule)}\n시장:{_dumps(market_data)}"
+        if news_data:
+            user_message += f"\n뉴스:{_dumps(news_data)}"
+
+        response = await self.analyze(system_prompt, user_message)
+        return self._parse_json_response(
+            response,
+            {"decision": "HOLD", "confidence": 0.0, "analysis": "분석 실패"}
+        )
+
+    async def analyze_market(
+        self,
+        stock_code: str,
+        market_data: Dict[str, Any],
+        news: List[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """시장 분석"""
+        system_prompt = """주식 시장 분석 전문가. JSON으로만 응답.
+필수 필드: trend(UP/DOWN/SIDEWAYS), sentiment(POSITIVE/NEGATIVE/NEUTRAL), recommendation(BUY/SELL/HOLD), confidence(0-1), analysis(간략설명). JSON 외 텍스트 금지."""
+
+        news_limit = settings.NEWS_LIMIT if settings.TOKEN_SAVE_MODE else 5
+        news_text = ""
+        if news:
+            news_text = "\n뉴스:" + ",".join([item.get('title', '') for item in news[:news_limit]])
+
+        user_message = f"종목:{stock_code}\n시장:{_dumps(market_data)}{news_text}"
+
+        response = await self.analyze(system_prompt, user_message)
+        return self._parse_json_response(
+            response,
+            {"trend": "UNKNOWN", "sentiment": "NEUTRAL", "recommendation": "HOLD", "confidence": 0.0}
+        )
+
+    async def calculate_fair_price(
+        self,
+        stock_code: str,
+        market_data: Dict[str, Any],
+        financial_data: Dict[str, Any] = None
+    ) -> Dict[str, Any]:
+        """AI 기반 적정 매수/매도 가격 산출"""
+        system_prompt = """주식 가격 전략 전문가. JSON으로만 응답.
+필수 필드: buy_prices(aggressive,neutral,conservative), sell_prices(target1,target2,target3), stop_loss, strategy, confidence(0-1). JSON 외 텍스트 금지."""
+
+        user_message = (
+            f"종목:{stock_code} 현재가:{market_data.get('current_price')} "
+            f"고가:{market_data.get('high_price')} 저가:{market_data.get('low_price')} "
+            f"거래량:{market_data.get('volume')} 지표:{_dumps(market_data.get('indicators', {}))}"
+        )
+
+        response = await self.analyze(system_prompt, user_message)
+        return self._parse_json_response(
+            response,
+            {"error": "분석 실패", "confidence": 0.0}
+        )
+
+    async def assess_risk(
+        self,
+        portfolio: Dict[str, Any],
+        trade_plan: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """리스크 평가"""
+        system_prompt = """투자 리스크 관리 전문가. JSON으로만 응답.
+필수 필드: risk_level(LOW/MEDIUM/HIGH/CRITICAL), risk_factors, approval(APPROVED/REJECTED), recommendation. JSON 외 텍스트 금지."""
+
+        user_message = f"포트폴리오:{_dumps(portfolio)}\n거래계획:{_dumps(trade_plan)}"
+
+        response = await self.analyze(system_prompt, user_message)
+        return self._parse_json_response(
+            response,
+            {"error": "Failed to assess risk"}
+        )
+
+    async def optimize_trading_rules(
+        self,
+        stock_code: str,
+        market_data: Dict[str, Any],
+        news_data: List[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """시장 상황에 맞는 트레이딩 규칙 최적화"""
+        system_prompt = """알고리즘 트레이딩 전략가. JSON으로만 응답.
+필수 필드: strategy_name, market_condition, parameters(buy_conditions,sell_conditions(take_profit_rate,stop_loss_rate,trailing_stop)), risk_assessment, confidence_score(0-100).
+악재시 보수적, 호재시 적극적 설정. JSON 외 텍스트 금지."""
+
+        user_message = f"종목:{stock_code}\n시장:{_dumps(market_data)}"
+        if news_data:
+            user_message += f"\n뉴스:{_dumps(news_data)}"
+
+        response = await self.analyze(system_prompt, user_message)
+        return self._parse_json_response(
+            response,
+            {"error": "Failed to generate optimized rules"}
+        )
+
+    async def generate_trade_journal(
+        self,
+        trade_info: Dict[str, Any],
+        market_data: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """매매일지 자동 작성"""
+        system_prompt = """매매일지 작성 전문가. JSON으로만 응답.
+필수 필드: title, content(간략 Markdown), mood(평정심/흥분/공포/아쉬움/만족), tags(배열), score(0-100).
+매매근거, 잘한점/아쉬운점, 개선사항 포함. JSON 외 텍스트 금지."""
+
+        user_message = f"거래:{_dumps(trade_info)}\n시장:{_dumps(market_data)}"
+
+        response = await self.analyze(system_prompt, user_message)
+        return self._parse_json_response(
+            response,
+            {"error": "Failed to generate journal"}
+        )
+
+
+gemini_client = GeminiClient()
diff --git a/mcp-server/main.py b/mcp-server/main.py
index d003754..fcb5099 100644
--- a/mcp-server/main.py
+++ b/mcp-server/main.py
@@ -6,11 +6,14 @@ import logging
 
 from config import settings
 from claude_client import claude_client
-from perplexity_client import perplexity_client
 from mcp_tools import mcp_tools
 
-# AI 클라이언트 선택
-ai_client = perplexity_client if settings.AI_PROVIDER == "perplexity" else claude_client
+# AI_PROVIDER에 따라 클라이언트 동적 선택
+if settings.AI_PROVIDER == "gemini":
+    from gemini_client import gemini_client
+    ai_client = gemini_client
+else:
+    ai_client = claude_client
 
 # 로깅 설정
 logging.basicConfig(
@@ -61,7 +64,7 @@ async def health_check():
         "status": "healthy",
         "ai_provider": settings.AI_PROVIDER,
         "claude_configured": bool(settings.ANTHROPIC_API_KEY),
-        "perplexity_configured": bool(settings.PERPLEXITY_API_KEY)
+        "gemini_configured": bool(settings.GEMINI_API_KEY),
     }
 
 
@@ -102,7 +105,18 @@ async def analyze(request: AnalysisRequest):
                     detail="rule and market_data are required"
                 )
             
-            result = await ai_client.validate_trading_rule(rule, market_data)
+            # 뉴스 정보 추가 수집
+            stock_code = market_data.get("stock_code")
+            news_data = []
+            if stock_code:
+                try:
+                    news_result = await mcp_tools.get_news(stock_code, limit=settings.NEWS_LIMIT)
+                    if "news" in news_result:
+                        news_data = news_result["news"]
+                except Exception as e:
+                    logger.warning(f"Failed to fetch news for validation: {e}")
+
+            result = await ai_client.validate_trading_rule(rule, market_data, news_data)
             return {
                 "analysis_type": analysis_type,
                 "result": result
@@ -162,6 +176,49 @@ async def analyze(request: AnalysisRequest):
                 "analysis_type": analysis_type,
                 "result": result
             }
+            
+        elif analysis_type == "RULE_OPTIMIZATION":
+            # 트레이딩 규칙 최적화/생성
+            stock_code = data.get("stock_code")
+            market_data = data.get("market_data")
+            
+            if not stock_code or not market_data:
+                raise HTTPException(
+                    status_code=400,
+                    detail="stock_code and market_data are required"
+                )
+            
+            # 뉴스 정보 추가 수집
+            news_data = []
+            try:
+                news_result = await mcp_tools.get_news(stock_code, limit=settings.NEWS_LIMIT)
+                if "news" in news_result:
+                    news_data = news_result["news"]
+            except Exception as e:
+                logger.warning(f"Failed to fetch news for optimization: {e}")
+                
+            result = await ai_client.optimize_trading_rules(stock_code, market_data, news_data)
+            return {
+                "analysis_type": analysis_type,
+                "result": result
+            }
+            
+        elif analysis_type == "GENERATE_JOURNAL":
+            # 매매일지 생성
+            trade_info = data.get("trade_info")
+            market_data = data.get("market_data")
+            
+            if not trade_info or not market_data:
+                raise HTTPException(
+                    status_code=400,
+                    detail="trade_info and market_data are required"
+                )
+                
+            result = await ai_client.generate_trade_journal(trade_info, market_data)
+            return {
+                "analysis_type": analysis_type,
+                "result": result
+            }
         
         else:
             raise HTTPException(
diff --git a/mcp-server/mcp_tools.py b/mcp-server/mcp_tools.py
index 533301f..c5db1cc 100644
--- a/mcp-server/mcp_tools.py
+++ b/mcp-server/mcp_tools.py
@@ -1,20 +1,29 @@
 from typing import Dict, Any, Callable
+import logging
 import pandas as pd
 import numpy as np
 from ta.trend import SMAIndicator, EMAIndicator, MACD
 from ta.momentum import RSIIndicator, StochasticOscillator
 from ta.volatility import BollingerBands
-import logging
+import httpx
+from bs4 import BeautifulSoup
+from config import settings
+
+# Optional: KIS API dependency (not currently available in MCP server directly)
+korea_investment_api = None
 
 logger = logging.getLogger(__name__)
 
 
 class MCPTools:
     """MCP Tools Registry"""
+
     
     def __init__(self):
         self.tools: Dict[str, Callable] = {}
         self._register_tools()
+        # Initialize KIS API if available
+        self.korea_investment_api = None
     
     def _register_tools(self):
         """도구 등록"""
@@ -155,17 +164,76 @@ class MCPTools:
             }
     
     async def get_market_data(self, stock_code: str, period: str = "D") -> Dict[str, Any]:
-        """시장 데이터 조회 (실제로는 Korea Investment API 호출)"""
-        # 여기서는 샘플 데이터 반환
-        # 실제로는 backend API를 호출해야 함
-        return {
-            "stock_code": stock_code,
-            "period": period,
-            "current_price": 70000,
-            "change_rate": 1.5,
-            "volume": 1000000,
-            "data": []
-        }
+        """시장 데이터 조회 (국내/해외 통합)"""
+        if not korea_investment_api:
+             return {"error": "Korea Investment API not available"}
+
+        try:
+            # 국내 주식 여부 판단 (6자리 숫자)
+            is_domestic = stock_code.isdigit() and len(stock_code) == 6
+            
+            if is_domestic:
+                # 현재가 조회
+                current_price_data = await korea_investment_api.get_current_price(stock_code)
+                
+                # 차트 데이터 조회
+                chart_data = await korea_investment_api.get_daily_chart(stock_code, period, limit=settings.CHART_DAYS)
+                
+                output2 = chart_data.get('output2', [])
+                formatted_data = []
+                for item in output2:
+                    formatted_data.append({
+                        "date": item.get('stck_bsop_date'),
+                        "open": int(item.get('stck_oprc')) if item.get('stck_oprc') else 0,
+                        "high": int(item.get('stck_hgpr')) if item.get('stck_hgpr') else 0,
+                        "low": int(item.get('stck_lwpr')) if item.get('stck_lwpr') else 0,
+                        "close": int(item.get('stck_clpr')) if item.get('stck_clpr') else 0,
+                        "volume": int(item.get('acml_vol')) if item.get('acml_vol') else 0
+                    })
+                    
+                current_output = current_price_data.get('output', {})
+                return {
+                    "stock_code": stock_code,
+                    "period": period,
+                    "current_price": int(current_output.get('stck_prpr', 0)) if current_output else 0,
+                    "change_rate": float(current_output.get('prdy_ctrt', 0)) if current_output else 0,
+                    "volume": int(current_output.get('acml_vol', 0)) if current_output else 0,
+                    "data": formatted_data
+                }
+            else:
+                # 해외 주식 logic (기본 NASD 가정)
+                exchange = "NASD" 
+                # TODO: 거래소 판별 로직 고도화 필요 (현재는 NASD 고정)
+                
+                current_price_data = await korea_investment_api.get_overseas_price(stock_code, exchange)
+                chart_data = await korea_investment_api.get_overseas_daily_chart(stock_code, exchange, period)
+                
+                output2 = chart_data.get('output2', [])
+                formatted_data = []
+                for item in output2:
+                    # 해외주식 데이터 키 매핑 (Key names depend on actual API response, adjusted to common KIS overseas response)
+                    formatted_data.append({
+                        "date": item.get('xymd'), # 일자
+                        "open": float(item.get('open')) if item.get('open') else 0.0,
+                        "high": float(item.get('high')) if item.get('high') else 0.0,
+                        "low": float(item.get('low')) if item.get('low') else 0.0,
+                        "close": float(item.get('clos')) if item.get('clos') else 0.0,
+                        "volume": float(item.get('tvol')) if item.get('tvol') else 0.0 
+                    })
+                
+                curr = current_price_data.get('output', {})
+                return {
+                    "stock_code": stock_code,
+                    "period": period,
+                    "current_price": float(curr.get('last', 0)) if curr else 0.0,
+                    "change_rate": float(curr.get('rate', 0)) if curr else 0.0, 
+                    "volume": float(curr.get('tvol', 0)) if curr else 0.0,
+                    "data": formatted_data
+                }
+
+        except Exception as e:
+            logger.error(f"Failed to get market data for {stock_code}: {e}")
+            raise
     
     async def calculate_indicators(
         self,
@@ -230,18 +298,41 @@ class MCPTools:
     
     async def check_portfolio(self, stock_code: str = None) -> Dict[str, Any]:
         """포트폴리오 확인"""
-        # 실제로는 backend API 호출
-        return {
-            "total_value": 10000000,
-            "holdings": [
-                {
-                    "stock_code": "005930",
-                    "quantity": 10,
-                    "average_price": 70000,
-                    "current_price": 71000
-                }
-            ]
-        }
+        if not korea_investment_api:
+             return {"error": "Korea Investment API not available"}
+        
+        try:
+            balance = await korea_investment_api.get_balance()
+            output1 = balance.get('output1', [])
+            output2 = balance.get('output2', []) # Total asset summary
+            
+            holdings = []
+            for item in output1:
+                # Filter if stock_code provided
+                if stock_code and item.get('pdno') != stock_code:
+                    continue
+                    
+                holdings.append({
+                    "stock_code": item.get('pdno'),
+                    "stock_name": item.get('prdt_name'),
+                    "quantity": int(item.get('hldg_qty')),
+                    "average_price": float(item.get('pchs_avg_pric')),
+                    "current_price": float(item.get('prpr')),
+                    "profit_loss": float(item.get('evlu_pfls_amt')),
+                    "profit_rate": float(item.get('evlu_pfls_rt'))
+                })
+                
+            total_eval = 0
+            if output2:
+                 total_eval = float(output2[0].get('tot_evlu_mony', 0))
+
+            return {
+                "total_value": total_eval,
+                "holdings": holdings
+            }
+        except Exception as e:
+            logger.error(f"Failed to get portfolio: {e}")
+            raise
     
     async def validate_rules(
         self,
@@ -274,22 +365,88 @@ class MCPTools:
         price: float = None
     ) -> Dict[str, Any]:
         """주문 실행 (실제로는 backend API 호출)"""
-        return {
-            "order_id": "ORD20241104001",
-            "status": "PENDING",
-            "stock_code": stock_code,
-            "order_type": order_type,
-            "quantity": quantity,
-            "price": price
-        }
+        if not korea_investment_api:
+             return {"error": "Korea Investment API not available"}
+
+        try:
+             # 국내/해외 구분
+             is_domestic = stock_code.isdigit() and len(stock_code) == 6
+             
+             if is_domestic:
+                result = await korea_investment_api.place_order(
+                    stock_code=stock_code,
+                    order_type=order_type,
+                    quantity=quantity,
+                    price=int(price) if price else None
+                )
+             else:
+                # 해외 주문 (지정가 필수)
+                if price is None:
+                    return {"error": "Overseas orders require a limit price."}
+                
+                result = await korea_investment_api.place_overseas_order(
+                    symbol=stock_code,
+                    order_type=order_type,
+                    quantity=quantity,
+                    price=price,
+                    exchange_code="NASD" # 기본값
+                )
+             
+             return result
+        except Exception as e:
+             logger.error(f"Failed to place order: {e}")
+             raise
     
-    async def get_news(self, stock_code: str = None, limit: int = 10) -> Dict[str, Any]:
-        """뉴스 조회"""
-        # 실제로는 뉴스 API 호출
-        return {
-            "stock_code": stock_code,
-            "news": []
-        }
+    async def get_news(self, stock_code: str = None, limit: int = 5) -> Dict[str, Any]:
+        """네이버 금융 뉴스 크롤링"""
+        if not stock_code:
+            return {"error": "stock_code is required"}
+
+        try:
+            url = f"https://finance.naver.com/item/news_news.naver?code={stock_code}&page=1"
+            headers = {
+                "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+            }
+            
+            async with httpx.AsyncClient() as client:
+                response = await client.get(url, headers=headers)
+                
+            if response.status_code != 200:
+                return {"error": f"Failed to fetch news: {response.status_code}"}
+            
+            soup = BeautifulSoup(response.text, 'html.parser')
+            news_items = []
+            
+            # 네이버 금융 뉴스 구조에 맞춰 파싱
+            for row in soup.select('table.type5 tbody tr'):
+                title_tag = row.select_one('.title a')
+                if not title_tag:
+                    continue
+                    
+                title = title_tag.get_text(strip=True)
+                link = "https://finance.naver.com" + title_tag['href']
+                date_tag = row.select_one('.date')
+                date = date_tag.get_text(strip=True) if date_tag else ""
+                source_tag = row.select_one('.info')
+                source = source_tag.get_text(strip=True) if source_tag else ""
+                
+                # 관련뉴스/공시 제외하고 싶으면 필터링 가능
+                item = {"title": title, "date": date, "source": source}
+                if not settings.TOKEN_SAVE_MODE:
+                    item["link"] = link
+                news_items.append(item)
+                
+                if len(news_items) >= limit:
+                    break
+            
+            return {
+                "stock_code": stock_code,
+                "news": news_items
+            }
+            
+        except Exception as e:
+            logger.error(f"Error fetching news for {stock_code}: {e}")
+            return {"error": str(e), "news": []}
 
 
 mcp_tools = MCPTools()
diff --git a/mcp-server/perplexity_client.py b/mcp-server/perplexity_client.py
deleted file mode 100644
index de36d64..0000000
--- a/mcp-server/perplexity_client.py
+++ /dev/null
@@ -1,333 +0,0 @@
-import httpx
-from config import settings
-from typing import Dict, Any, List
-import json
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class PerplexityClient:
-    """Perplexity AI 클라이언트"""
-    
-    def __init__(self):
-        self.api_key = settings.PERPLEXITY_API_KEY
-        self.model = settings.PERPLEXITY_MODEL
-        self.base_url = "https://api.perplexity.ai"
-    
-    async def analyze(
-        self,
-        system_prompt: str,
-        user_message: str
-    ) -> Dict[str, Any]:
-        """Perplexity를 통한 분석 실행"""
-        try:
-            # API 키 검증
-            if not self.api_key or not self.api_key.startswith("pplx-"):
-                logger.warning("Invalid Perplexity API key format. Using mock response.")
-                return self._mock_response(user_message)
-            
-            async with httpx.AsyncClient() as client:
-                response = await client.post(
-                    f"{self.base_url}/chat/completions",
-                    headers={
-                        "Authorization": f"Bearer {self.api_key}",
-                        "Content-Type": "application/json"
-                    },
-                    json={
-                        "model": self.model,
-                        "messages": [
-                            {"role": "system", "content": system_prompt},
-                            {"role": "user", "content": user_message}
-                        ],
-                        "max_tokens": settings.MAX_TOKENS,
-                        "temperature": settings.TEMPERATURE,
-                        "top_p": 0.9,
-                        "stream": False
-                    },
-                    timeout=30.0
-                )
-                
-                response.raise_for_status()
-                result = response.json()
-                
-                # 응답 파싱
-                content = result.get("choices", [{}])[0].get("message", {}).get("content", "")
-                
-                return {
-                    "content": [{"type": "text", "text": content}],
-                    "usage": result.get("usage", {})
-                }
-        
-        except Exception as e:
-            logger.error(f"Perplexity analysis error: {e}")
-            logger.warning("Using mock response due to API error")
-            return self._mock_response(user_message)
-    
-    def _mock_response(self, user_message: str) -> Dict[str, Any]:
-        """Mock 응답 생성 (API 키 없을 때)"""
-        # 분석 타입 감지
-        if "적정" in user_message and "가격" in user_message:
-            mock_text = """{
-                "buy_prices": {
-                    "aggressive": 50000,
-                    "neutral": 52000,
-                    "conservative": 54000
-                },
-                "sell_prices": {
-                    "target1": 56000,
-                    "target2": 58000,
-                    "target3": 60000
-                },
-                "stop_loss": 48000,
-                "strategy": "기술적 분석: 현재 이동평균선 정배열 상태로 상승 추세 지속 중. 지지선 48,000원 유지 시 56,000원까지 상승 가능. 거래량 증가 시 추가 상승 기대.",
-                "confidence": 0.75
-            }"""
-        elif "시장" in user_message and "분석" in user_message:
-            mock_text = """{
-                "trend": "UPTREND",
-                "sentiment": "POSITIVE",
-                "recommendation": "BUY",
-                "confidence": 0.7,
-                "analysis": "기술적 분석 결과 상승 추세 지속 중. 거래량 증가와 함께 매수세 강화. 단기 목표가 달성 가능성 높음."
-            }"""
-        elif "규칙" in user_message or "검증" in user_message:
-            mock_text = """{
-                "decision": "BUY",
-                "confidence": 0.75,
-                "analysis": "현재 시장 상황이 규칙 조건을 만족. 이동평균선 정배열 및 거래량 증가 확인됨. 매수 시점 적절."
-            }"""
-        elif "리스크" in user_message:
-            mock_text = """{
-                "risk_level": "MEDIUM",
-                "approval": "APPROVED",
-                "confidence": 0.7,
-                "analysis": "포트폴리오 분산 적절. 투자 금액 비중 관리 필요. 손절가 설정 권장."
-            }"""
-        else:
-            mock_text = """{
-                "analysis": "Mock AI 분석 결과",
-                "confidence": 0.6
-            }"""
-        
-        return {
-            "content": [{"type": "text", "text": mock_text}],
-            "usage": {"input_tokens": 0, "output_tokens": 0}
-        }
-    
-    async def validate_trading_rule(
-        self,
-        rule: Dict[str, Any],
-        market_data: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """트레이딩 규칙 검증"""
-        system_prompt = """당신은 주식 트레이딩 규칙을 분석하고 검증하는 전문가입니다.
-주어진 규칙과 시장 데이터를 분석하여 다음을 제공하세요:
-1. 규칙이 현재 시장 상황에 적합한지 여부
-2. 실행 가능성 (0-1 사이의 점수)
-3. 리스크 평가
-4. 추천 사항
-
-JSON 형식으로 응답하세요."""
-        
-        user_message = f"""
-트레이딩 규칙:
-{json.dumps(rule, ensure_ascii=False, indent=2)}
-
-시장 데이터:
-{json.dumps(market_data, ensure_ascii=False, indent=2)}
-
-이 규칙이 현재 시장 상황에서 실행되어야 하는지 분석해주세요.
-"""
-        
-        response = await self.analyze(system_prompt, user_message)
-        
-        # 텍스트 응답 파싱
-        for content in response["content"]:
-            if content["type"] == "text":
-                try:
-                    # JSON 응답 파싱 시도
-                    return json.loads(content["text"])
-                except json.JSONDecodeError:
-                    # JSON이 아닌 경우 기본 구조로 반환
-                    return {
-                        "decision": "HOLD",
-                        "confidence": 0.5,
-                        "analysis": content["text"]
-                    }
-        
-        return {
-            "decision": "HOLD",
-            "confidence": 0.0,
-            "analysis": "분석 실패"
-        }
-    
-    async def analyze_market(
-        self,
-        stock_code: str,
-        market_data: Dict[str, Any],
-        news: List[Dict[str, Any]] = None
-    ) -> Dict[str, Any]:
-        """시장 분석"""
-        system_prompt = """당신은 주식 시장 분석 전문가입니다.
-주어진 시장 데이터와 뉴스를 분석하여 다음을 제공하세요:
-1. 시장 트렌드 (상승/하락/횡보)
-2. 주요 기술적 지표 분석
-3. 뉴스 센티먼트 (긍정/부정/중립)
-4. 투자 추천 (매수/매도/보유)
-5. 신뢰도 (0-1)
-
-JSON 형식으로 응답하세요."""
-        
-        news_text = ""
-        if news:
-            news_text = "\n\n최근 뉴스:\n" + "\n".join([
-                f"- {item.get('title', '')}: {item.get('content', '')[:200]}"
-                for item in news[:5]
-            ])
-        
-        user_message = f"""
-종목 코드: {stock_code}
-
-시장 데이터:
-{json.dumps(market_data, ensure_ascii=False, indent=2)}
-{news_text}
-
-이 종목에 대한 종합적인 시장 분석을 제공해주세요.
-"""
-        
-        response = await self.analyze(system_prompt, user_message)
-        
-        for content in response["content"]:
-            if content["type"] == "text":
-                try:
-                    return json.loads(content["text"])
-                except json.JSONDecodeError:
-                    return {
-                        "trend": "SIDEWAYS",
-                        "sentiment": "NEUTRAL",
-                        "recommendation": "HOLD",
-                        "confidence": 0.5,
-                        "analysis": content["text"]
-                    }
-        
-        return {
-            "trend": "UNKNOWN",
-            "sentiment": "NEUTRAL",
-            "recommendation": "HOLD",
-            "confidence": 0.0
-        }
-    
-    async def calculate_fair_price(
-        self,
-        stock_code: str,
-        market_data: Dict[str, Any],
-        financial_data: Dict[str, Any] = None
-    ) -> Dict[str, Any]:
-        """AI 기반 적정 매수/매도 가격 산출"""
-        system_prompt = """당신은 주식 가치 평가 및 가격 전략 전문가입니다.
-기술적 분석과 시장 데이터를 기반으로 다음을 제공하세요:
-1. 적정 매수 가격 (공격적, 중립적, 보수적)
-2. 적정 매도 가격 (목표가 1, 2, 3)
-3. 손절가
-4. 근거 및 전략
-5. 신뢰도 (0-1)
-
-JSON 형식으로 응답하세요. 예시:
-{
-  "buy_prices": {
-    "aggressive": 100000,
-    "neutral": 105000,
-    "conservative": 110000
-  },
-  "sell_prices": {
-    "target1": 120000,
-    "target2": 130000,
-    "target3": 140000
-  },
-  "stop_loss": 95000,
-  "strategy": "기술적 분석 기반 설명...",
-  "confidence": 0.75
-}"""
-        
-        user_message = f"""
-종목 코드: {stock_code}
-
-시장 데이터:
-- 현재가: {market_data.get('current_price')}
-- 고가: {market_data.get('high_price')}
-- 저가: {market_data.get('low_price')}
-- 거래량: {market_data.get('volume')}
-- 기술적 지표: {json.dumps(market_data.get('indicators', {}), ensure_ascii=False)}
-
-이 종목의 적정 매수/매도 가격과 전략을 제시해주세요.
-"""
-        
-        response = await self.analyze(system_prompt, user_message)
-        
-        for content in response["content"]:
-            if content["type"] == "text":
-                try:
-                    return json.loads(content["text"])
-                except json.JSONDecodeError:
-                    return {
-                        "buy_prices": {"neutral": market_data.get('current_price', 0)},
-                        "sell_prices": {"target1": market_data.get('current_price', 0) * 1.05},
-                        "stop_loss": market_data.get('current_price', 0) * 0.97,
-                        "strategy": content["text"],
-                        "confidence": 0.5
-                    }
-        
-        return {
-            "error": "분석 실패",
-            "confidence": 0.0
-        }
-    
-    async def assess_risk(
-        self,
-        portfolio: Dict[str, Any],
-        trade_plan: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """리스크 평가"""
-        system_prompt = """당신은 투자 리스크 관리 전문가입니다.
-현재 포트폴리오와 계획된 거래를 분석하여 다음을 제공하세요:
-1. 리스크 레벨 (LOW/MEDIUM/HIGH/CRITICAL)
-2. 주요 리스크 요인
-3. 포트폴리오 다양성 평가
-4. 추천 사항
-5. 승인 여부 (APPROVED/REJECTED)
-
-JSON 형식으로 응답하세요."""
-        
-        user_message = f"""
-현재 포트폴리오:
-{json.dumps(portfolio, ensure_ascii=False, indent=2)}
-
-계획된 거래:
-{json.dumps(trade_plan, ensure_ascii=False, indent=2)}
-
-이 거래의 리스크를 평가하고 실행 여부를 결정해주세요.
-"""
-        
-        response = await self.analyze(system_prompt, user_message)
-        
-        for content in response["content"]:
-            if content["type"] == "text":
-                try:
-                    return json.loads(content["text"])
-                except json.JSONDecodeError:
-                    return {
-                        "risk_level": "MEDIUM",
-                        "approval": "HOLD",
-                        "confidence": 0.5,
-                        "analysis": content["text"]
-                    }
-        
-        return {
-            "risk_level": "UNKNOWN",
-            "approval": "REJECTED",
-            "confidence": 0.0
-        }
-
-
-perplexity_client = PerplexityClient()
diff --git a/mcp-server/requirements.txt b/mcp-server/requirements.txt
index 62d7e09..01caba3 100644
--- a/mcp-server/requirements.txt
+++ b/mcp-server/requirements.txt
@@ -1,6 +1,7 @@
 fastapi>=0.104.1
 uvicorn[standard]>=0.24.0
 anthropic>=0.18.0
+google-genai>=1.0.0
 pydantic>=2.5.0
 python-dotenv==1.0.0
 httpx==0.25.2
@@ -10,3 +11,4 @@ ta==0.11.0
 sqlalchemy==2.0.23
 asyncpg>=0.30.0
 redis==5.0.1
+beautifulsoup4>=4.12.0
diff --git a/mcp-server/stdio_server.py b/mcp-server/stdio_server.py
new file mode 100755
index 0000000..42977d3
--- /dev/null
+++ b/mcp-server/stdio_server.py
@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""
+MCP Server with stdio transport for Claude CLI
+
+This server provides stock trading tools via Model Context Protocol
+using stdio transport for direct integration with Claude CLI.
+"""
+
+import asyncio
+import sys
+from typing import Any
+import httpx
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import Tool, TextContent
+
+# Import configuration
+from config import settings
+from utils import _dumps
+
+# Initialize MCP Server
+app = Server("auto-stock-mcp")
+
+# Backend API base URL
+BACKEND_URL = "http://localhost:8000/api/v1"
+
+
+@app.list_tools()
+async def list_tools() -> list[Tool]:
+    """List available tools"""
+    return [
+        Tool(
+            name="get_portfolio",
+            description="Get current portfolio information including holdings and balance",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+                "required": []
+            }
+        ),
+        Tool(
+            name="get_market_data",
+            description="Get real-time market data for a specific stock",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "stock_code": {
+                        "type": "string",
+                        "description": "Stock code (e.g., '005930' for Samsung)"
+                    }
+                },
+                "required": ["stock_code"]
+            }
+        ),
+        Tool(
+            name="get_recommendations",
+            description="Get AI-generated stock recommendations based on technical analysis",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+                "required": []
+            }
+        ),
+        Tool(
+            name="get_trade_history",
+            description="Get recent trade history",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "limit": {
+                        "type": "number",
+                        "description": "Number of trades to return (default: 20)"
+                    }
+                },
+                "required": []
+            }
+        ),
+        Tool(
+            name="analyze_stock",
+            description="Perform detailed technical analysis on a stock",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "stock_code": {
+                        "type": "string",
+                        "description": "Stock code to analyze"
+                    }
+                },
+                "required": ["stock_code"]
+            }
+        )
+    ]
+
+
+@app.call_tool()
+async def call_tool(name: str, arguments: Any) -> list[TextContent]:
+    """Handle tool calls"""
+    
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            if name == "get_portfolio":
+                response = await client.get(f"{BACKEND_URL}/portfolio")
+                data = response.json()
+                return [TextContent(
+                    type="text",
+                    text=_dumps(data)
+                )]
+            
+            elif name == "get_market_data":
+                stock_code = arguments.get("stock_code")
+                response = await client.get(
+                    f"{BACKEND_URL}/market-data/prices",
+                    params={"codes": stock_code}
+                )
+                data = response.json()
+                return [TextContent(
+                    type="text",
+                    text=_dumps(data)
+                )]
+            
+            elif name == "get_recommendations":
+                response = await client.get(f"{BACKEND_URL}/recommendations/rule-based")
+                data = response.json()
+                return [TextContent(
+                    type="text",
+                    text=_dumps(data)
+                )]
+            
+            elif name == "get_trade_history":
+                limit = arguments.get("limit", 10 if settings.TOKEN_SAVE_MODE else 20)
+                response = await client.get(
+                    f"{BACKEND_URL}/trades",
+                    params={"limit": limit}
+                )
+                data = response.json()
+                return [TextContent(
+                    type="text",
+                    text=_dumps(data)
+                )]
+            
+            elif name == "analyze_stock":
+                stock_code = arguments.get("stock_code")
+                # Get chart data
+                response = await client.get(
+                    f"{BACKEND_URL}/market-data/chart/{stock_code}",
+                    params={"period": "D", "realtime": "true"}
+                )
+                data = response.json()
+                return [TextContent(
+                    type="text",
+                    text=_dumps(data)
+                )]
+            
+            else:
+                return [TextContent(
+                    type="text",
+                    text=f"Unknown tool: {name}"
+                )]
+    
+    except Exception as e:
+        return [TextContent(
+            type="text",
+            text=f"Error calling tool {name}: {str(e)}"
+        )]
+
+
+async def main():
+    """Run the MCP server with stdio transport"""
+    async with stdio_server() as (read_stream, write_stream):
+        await app.run(
+            read_stream,
+            write_stream,
+            app.create_initialization_options()
+        )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/mcp-server/trade_monitor.py b/mcp-server/trade_monitor.py
new file mode 100644
index 0000000..ced7330
--- /dev/null
+++ b/mcp-server/trade_monitor.py
@@ -0,0 +1,169 @@
+import asyncio
+import json
+import os
+from datetime import datetime
+import logging
+from decimal import Decimal
+
+# backend 경로를 sys.path에 추가하여 서비스 모듈 임포트
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../backend')))
+
+from sqlalchemy import select, update
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker
+
+from app.core.config import settings
+from app.models.models import ActiveTrade
+from app.services.korea_investment_api import korea_investment_api
+
+# 로깅 설정
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# --- DB 설정 ---
+engine = create_async_engine(settings.DATABASE_URL, echo=False)
+AsyncSessionLocal = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+# ----------------
+
+ACTIVE_TRADES_FILE = os.path.join(os.path.dirname(__file__), 'active_trades.json')
+MONITORING_INTERVAL_SECONDS = 60  # 60초마다 확인
+
+async def sync_json_from_db(db: AsyncSession):
+    """DB의 active_trades 목록을 JSON 파일에 동기화(덮어쓰기)합니다."""
+    try:
+        result = await db.execute(select(ActiveTrade).where(ActiveTrade.status == 'active'))
+        active_trades_from_db = result.scalars().all()
+        
+        json_trades = [
+            {
+                'stock_code': trade.stock_code,
+                'stock_name': trade.stock_name,
+                'quantity': trade.quantity,
+                'entry_price': float(trade.entry_price),
+                'stop_loss': float(trade.stop_loss),
+                'take_profit': float(trade.take_profit),
+                'order_id': trade.order_id,
+                'reason': trade.entry_reason,
+                'timestamp': trade.created_at.isoformat()
+            }
+            for trade in active_trades_from_db
+        ]
+        
+        with open(ACTIVE_TRADES_FILE, 'w', encoding='utf-8') as f:
+            json.dump(json_trades, f, indent=4, ensure_ascii=False)
+        logging.info(f"💾 [JSON] DB와 동기화 완료. 활성 거래 {len(json_trades)}건.")
+
+    except Exception as e:
+        logging.error(f"❌ [JSON] DB 동기화 실패: {e}")
+
+
+async def check_and_execute_trades(db: AsyncSession):
+    """
+    DB에서 활성화된 거래를 확인하고 손절/익절 조건에 따라 매도 주문을 실행합니다.
+    """
+    logging.info(" 거래 모니터링 시작 (DB 기반)...")
+    
+    result = await db.execute(select(ActiveTrade).where(ActiveTrade.status == 'active'))
+    active_trades = result.scalars().all()
+    
+    if not active_trades:
+        logging.info("현재 활성화된 거래가 없습니다.")
+        return
+
+    for trade in active_trades:
+        stock_code = trade.stock_code
+        stop_loss = float(trade.stop_loss)
+        take_profit = float(trade.take_profit)
+        quantity = trade.quantity
+        entry_price = float(trade.entry_price)
+        
+        should_sell = False
+        sell_reason = ""
+
+        try:
+            # 현재가 조회
+            price_info, _ = await korea_investment_api._make_request(
+                "GET",
+                "/uapi/domestic-stock/v1/quotations/inquire-price",
+                "FHKST01010100",
+                params={"FID_COND_MRKT_DIV_CODE": "J", "FID_INPUT_ISCD": stock_code}
+            )
+            
+            if price_info and price_info.get('rt_cd') == '0':
+                current_price_str = price_info.get('output', {}).get('stck_prpr')
+                if not current_price_str:
+                    logging.error(f"[{stock_code}] 현재가 정보를 응답에서 찾을 수 없습니다: {price_info}")
+                    continue
+
+                current_price = int(current_price_str)
+                logging.info(f"[{stock_code}] 현재가: {current_price} (매수가: {entry_price}, 손절가: {stop_loss}, 목표가: {take_profit})")
+
+                # 손절 조건 확인
+                if stop_loss and current_price <= stop_loss:
+                    should_sell = True
+                    sell_reason = f"손절가 도달 (현재가: {current_price} <= 손절가: {stop_loss})"
+                
+                # 익절 조건 확인
+                elif take_profit and current_price >= take_profit:
+                    should_sell = True
+                    sell_reason = f"목표가 도달 (현재가: {current_price} >= 목표가: {take_profit})"
+
+            else:
+                logging.error(f"[{stock_code}] 현재가 조회 실패: {price_info.get('msg1', '알 수 없는 오류')}")
+                continue
+
+        except Exception as e:
+            logging.error(f"[{stock_code}] 처리 중 예외 발생: {e}")
+            continue
+
+        if should_sell:
+            logging.warning(f"🚨 [{stock_code}] 매도 조건 충족: {sell_reason}")
+            try:
+                # 시장가 매도 주문 (price=None)
+                sell_result = await korea_investment_api.place_order(
+                    stock_code=stock_code,
+                    order_type='SELL',
+                    quantity=quantity,
+                    price=None
+                )
+                logging.info(f"[{stock_code}] 매도 주문 결과: {sell_result}")
+
+                if sell_result and sell_result.get('rt_cd') == '0':
+                    logging.info(f"✅ [{stock_code}] 매도 주문 성공. DB 상태를 'closed'로 변경합니다.")
+                    trade.status = 'closed'
+                    trade.updated_at = datetime.utcnow()
+                    db.add(trade)
+                    await db.commit()
+                else:
+                    logging.error(f"❌ [{stock_code}] 매도 주문 실패: {sell_result.get('msg1', '알 수 없는 오류')}")
+
+            except Exception as e:
+                logging.error(f"[{stock_code}] 매도 주문 중 예외 발생: {e}")
+                await db.rollback()
+
+async def main():
+    """메인 실행 루프"""
+    logging.info("🚀 자동 매도 모니터링 시스템을 시작합니다. (DB 모드)")
+    logging.info(f"점검 주기: {MONITORING_INTERVAL_SECONDS}초")
+    
+    # 시작 시 DB와 JSON 동기화
+    async with AsyncSessionLocal() as db:
+        await sync_json_from_db(db)
+        
+    while True:
+        try:
+            async with AsyncSessionLocal() as db:
+                await check_and_execute_trades(db)
+                # 매 사이클 종료 후 DB와 JSON 동기화
+                await sync_json_from_db(db)
+        except Exception as e:
+            logging.critical(f"모니터링 루프에서 치명적 오류 발생: {e}", exc_info=True)
+        
+        logging.info(f"{MONITORING_INTERVAL_SECONDS}초 후 다음 점검을 시작합니다.\n")
+        await asyncio.sleep(MONITORING_INTERVAL_SECONDS)
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        logging.info("사용자에 의해 프로그램이 종료되었습니다.")
diff --git a/mcp-server/utils.py b/mcp-server/utils.py
new file mode 100644
index 0000000..ac4a256
--- /dev/null
+++ b/mcp-server/utils.py
@@ -0,0 +1,10 @@
+"""공용 유틸리티 (MCP 서버)"""
+import json
+from config import settings
+
+
+def _dumps(obj) -> str:
+    """토큰 절약 모드에 따라 compact/pretty JSON 직렬화"""
+    if settings.JSON_COMPACT or settings.TOKEN_SAVE_MODE:
+        return json.dumps(obj, ensure_ascii=False, separators=(',', ':'))
+    return json.dumps(obj, ensure_ascii=False, indent=2)
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 0000000..fee3f8a
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,146 @@
+{
+  "name": "auto-stock",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "apexcharts": "^4.7.0",
+        "react-apexcharts": "^1.9.0"
+      }
+    },
+    "node_modules/@svgdotjs/svg.draggable.js": {
+      "version": "3.0.6",
+      "resolved": "https://registry.npmjs.org/@svgdotjs/svg.draggable.js/-/svg.draggable.js-3.0.6.tgz",
+      "integrity": "sha512-7iJFm9lL3C40HQcqzEfezK2l+dW2CpoVY3b77KQGqc8GXWa6LhhmX5Ckv7alQfUXBuZbjpICZ+Dvq1czlGx7gA==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@svgdotjs/svg.js": "^3.2.4"
+      }
+    },
+    "node_modules/@svgdotjs/svg.filter.js": {
+      "version": "3.0.9",
+      "resolved": "https://registry.npmjs.org/@svgdotjs/svg.filter.js/-/svg.filter.js-3.0.9.tgz",
+      "integrity": "sha512-/69XMRCDoam2HgC4ldHIaDgeQf1ViHIsa0Ld4uWgiXtZ+E24DWHe/9Ib6kbNiZ7WRIdlVokUDR1Fg0kjIpkfbw==",
+      "license": "MIT",
+      "dependencies": {
+        "@svgdotjs/svg.js": "^3.2.4"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/@svgdotjs/svg.js": {
+      "version": "3.2.5",
+      "resolved": "https://registry.npmjs.org/@svgdotjs/svg.js/-/svg.js-3.2.5.tgz",
+      "integrity": "sha512-/VNHWYhNu+BS7ktbYoVGrCmsXDh+chFMaONMwGNdIBcFHrWqk2jY8fNyr3DLdtQUIalvkPfM554ZSFa3dm3nxQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Fuzzyma"
+      }
+    },
+    "node_modules/@svgdotjs/svg.resize.js": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@svgdotjs/svg.resize.js/-/svg.resize.js-2.0.5.tgz",
+      "integrity": "sha512-4heRW4B1QrJeENfi7326lUPYBCevj78FJs8kfeDxn5st0IYPIRXoTtOSYvTzFWgaWWXd3YCDE6ao4fmv91RthA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.18"
+      },
+      "peerDependencies": {
+        "@svgdotjs/svg.js": "^3.2.4",
+        "@svgdotjs/svg.select.js": "^4.0.1"
+      }
+    },
+    "node_modules/@svgdotjs/svg.select.js": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/@svgdotjs/svg.select.js/-/svg.select.js-4.0.3.tgz",
+      "integrity": "sha512-qkMgso1sd2hXKd1FZ1weO7ANq12sNmQJeGDjs46QwDVsxSRcHmvWKL2NDF7Yimpwf3sl5esOLkPqtV2bQ3v/Jg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.18"
+      },
+      "peerDependencies": {
+        "@svgdotjs/svg.js": "^3.2.4"
+      }
+    },
+    "node_modules/@yr/monotone-cubic-spline": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@yr/monotone-cubic-spline/-/monotone-cubic-spline-1.0.3.tgz",
+      "integrity": "sha512-FQXkOta0XBSUPHndIKON2Y9JeQz5ZeMqLYZVVK93FliNBFm7LNMIZmY6FrMEB9XPcDbE2bekMbZD6kzDkxwYjA==",
+      "license": "MIT"
+    },
+    "node_modules/apexcharts": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/apexcharts/-/apexcharts-4.7.0.tgz",
+      "integrity": "sha512-iZSrrBGvVlL+nt2B1NpqfDuBZ9jX61X9I2+XV0hlYXHtTwhwLTHDKGXjNXAgFBDLuvSYCB/rq2nPWVPRv2DrGA==",
+      "license": "MIT",
+      "dependencies": {
+        "@svgdotjs/svg.draggable.js": "^3.0.4",
+        "@svgdotjs/svg.filter.js": "^3.0.8",
+        "@svgdotjs/svg.js": "^3.2.4",
+        "@svgdotjs/svg.resize.js": "^2.0.2",
+        "@svgdotjs/svg.select.js": "^4.0.1",
+        "@yr/monotone-cubic-spline": "^1.0.3"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "license": "MIT"
+    },
+    "node_modules/loose-envify": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "js-tokens": "^3.0.0 || ^4.0.0"
+      },
+      "bin": {
+        "loose-envify": "cli.js"
+      }
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/prop-types": {
+      "version": "15.8.1",
+      "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
+      "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.4.0",
+        "object-assign": "^4.1.1",
+        "react-is": "^16.13.1"
+      }
+    },
+    "node_modules/react-apexcharts": {
+      "version": "1.9.0",
+      "resolved": "https://registry.npmjs.org/react-apexcharts/-/react-apexcharts-1.9.0.tgz",
+      "integrity": "sha512-DDBzQFuKdwyCEZnji1yIcjlnV8hRr4VDabS5Y3iuem/WcTq6n4VbjWPzbPm3aOwW4I+rf/gA3zWqhws4z9CwLw==",
+      "license": "SEE LICENSE IN LICENSE",
+      "dependencies": {
+        "prop-types": "^15.8.1"
+      },
+      "peerDependencies": {
+        "apexcharts": ">=4.0.0",
+        "react": ">=16.8.0"
+      }
+    },
+    "node_modules/react-is": {
+      "version": "16.13.1",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
+      "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
+      "license": "MIT"
+    }
+  }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..b67437c
--- /dev/null
+++ b/package.json
@@ -0,0 +1,6 @@
+{
+  "dependencies": {
+    "apexcharts": "^4.7.0",
+    "react-apexcharts": "^1.9.0"
+  }
+}
diff --git a/restart-all.sh b/restart-all.sh
deleted file mode 100755
index 9052dad..0000000
--- a/restart-all.sh
+++ /dev/null
@@ -1,21 +0,0 @@
-#!/bin/bash
-
-# Auto Stock Trading System - 재시작 스크립트
-
-echo "================================================"
-echo "  Auto Stock Trading System Restarting..."
-echo "================================================"
-
-# 프로젝트 루트 디렉토리
-PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-# 먼저 모든 서비스 종료
-"$PROJECT_ROOT/stop-all.sh"
-
-echo ""
-echo "⏳ Waiting 3 seconds before restart..."
-sleep 3
-echo ""
-
-# 모든 서비스 시작
-"$PROJECT_ROOT/start-all.sh"
diff --git a/run-batch-analysis.sh b/run-batch-analysis.sh
new file mode 100755
index 0000000..8bf4213
--- /dev/null
+++ b/run-batch-analysis.sh
@@ -0,0 +1,31 @@
+#!/bin/bash
+
+# 배치 분석 수동 실행 스크립트 (Docker 컨테이너 내부 실행)
+# 사용법: ./run-batch-analysis.sh [limit]
+# 예: ./run-batch-analysis.sh 50  (테스트용 50개 종목만)
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+LOG_DIR="$SCRIPT_DIR/logs"
+CONTAINER="autostock-backend"
+
+mkdir -p "$LOG_DIR"
+
+# 컨테이너 실행 확인
+if ! docker ps --format '{{.Names}}' | grep -q "^${CONTAINER}$"; then
+    echo "❌ 오류: $CONTAINER 컨테이너가 실행 중이 아닙니다."
+    echo "먼저 다음 명령어로 서비스를 시작하세요:"
+    echo "  docker compose up -d"
+    exit 1
+fi
+
+if [ -n "$1" ]; then
+    echo "🧪 Running batch analysis in Docker (limited to $1 stocks)..."
+    docker exec "$CONTAINER" python /app/batch_daily_analysis.py --limit "$1" 2>&1 | tee "$LOG_DIR/batch_analysis_manual.log"
+else
+    echo "🚀 Running full batch analysis in Docker (all stocks)..."
+    docker exec "$CONTAINER" python /app/batch_daily_analysis.py 2>&1 | tee "$LOG_DIR/batch_analysis_manual.log"
+fi
+
+echo ""
+echo "✅ Batch analysis completed!"
+echo "📝 Log saved to: $LOG_DIR/batch_analysis_manual.log"
diff --git a/run-batch.sh b/run-batch.sh
deleted file mode 100755
index 717850c..0000000
--- a/run-batch.sh
+++ /dev/null
@@ -1,17 +0,0 @@
-#!/bin/bash
-
-# 매일 아침 배치 분석 실행 스크립트
-
-cd "$(dirname "$0")"
-
-echo "🚀 Starting daily batch analysis..."
-echo "📅 Date: $(date)"
-
-# Python 환경 활성화 (필요시)
-# source venv/bin/activate
-
-# 배치 실행
-cd backend
-python3 batch_daily_analysis.py "$@"
-
-echo "✅ Batch analysis completed at $(date)"
diff --git a/scripts/backup.sh b/scripts/backup.sh
deleted file mode 100755
index 6cdc27e..0000000
--- a/scripts/backup.sh
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/bin/bash
-
-# 백업 스크립트
-
-BACKUP_DIR="backups"
-TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
-BACKUP_FILE="$BACKUP_DIR/backup_$TIMESTAMP.sql"
-
-echo "데이터베이스 백업 시작..."
-
-# 백업 디렉토리 생성
-mkdir -p $BACKUP_DIR
-
-# PostgreSQL 백업
-docker exec autostock-postgres pg_dump -U autostock autostock_db > $BACKUP_FILE
-
-if [ $? -eq 0 ]; then
-    echo "✓ 백업 완료: $BACKUP_FILE"
-    
-    # 30일 이상 된 백업 파일 삭제
-    find $BACKUP_DIR -name "backup_*.sql" -mtime +30 -delete
-    echo "✓ 오래된 백업 파일 정리 완료"
-else
-    echo "✗ 백업 실패"
-    exit 1
-fi
diff --git a/scripts/deploy.sh b/scripts/deploy.sh
index 3ddf3ed..e994033 100755
--- a/scripts/deploy.sh
+++ b/scripts/deploy.sh
@@ -26,8 +26,14 @@ fi
 echo -e "${YELLOW}환경 변수 로드 중...${NC}"
 source .env
 
-# 필수 환경 변수 확인
-REQUIRED_VARS=("KOREA_INVESTMENT_APP_KEY" "KOREA_INVESTMENT_APP_SECRET" "ANTHROPIC_API_KEY")
+# 필수 환경 변수 확인 (KIS_MODE 기반)
+KIS_MODE="${KIS_MODE:-virtual}"
+if [ "$KIS_MODE" = "real" ]; then
+    REQUIRED_VARS=("KIS_REAL_APP_KEY" "KIS_REAL_APP_SECRET" "KIS_REAL_ACCOUNT_NO")
+else
+    REQUIRED_VARS=("KIS_VIRTUAL_APP_KEY" "KIS_VIRTUAL_APP_SECRET" "KIS_VIRTUAL_ACCOUNT_NO")
+fi
+
 for var in "${REQUIRED_VARS[@]}"; do
     if [ -z "${!var}" ]; then
         echo -e "${RED}오류: $var 환경 변수가 설정되지 않았습니다.${NC}"
diff --git a/scripts/dev.sh b/scripts/dev.sh
index 0b551cf..b912080 100755
--- a/scripts/dev.sh
+++ b/scripts/dev.sh
@@ -1,66 +1,5 @@
 #!/bin/bash
-
 # 개발 모드 실행 스크립트
-# 각 서비스를 개별적으로 실행
 
-set -e
-
-echo "====================================="
-echo "개발 모드 시작"
-echo "====================================="
-
-# 색상 정의
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-RED='\033[0;31m'
-NC='\033[0m'
-
-# 환경 변수 파일 확인
-if [ ! -f .env ]; then
-    echo -e "${RED}오류: .env 파일이 없습니다.${NC}"
-    echo "먼저 .env.example을 복사하여 .env 파일을 생성하고 설정을 완료해주세요."
-    exit 1
-fi
-
-source .env
-
-# 인프라 서비스만 Docker로 시작
-echo -e "${YELLOW}인프라 서비스 시작 중 (PostgreSQL, Redis, RabbitMQ)...${NC}"
-if docker compose version &> /dev/null; then
-    docker compose up -d postgres redis rabbitmq
-else
-    docker-compose up -d postgres redis rabbitmq
-fi
-
-sleep 5
-
-echo -e "${GREEN}✓ 인프라 서비스 시작 완료${NC}"
-
-echo ""
-echo "====================================="
-echo "애플리케이션 서비스 시작"
-echo "====================================="
-echo "다음 명령어로 각 서비스를 수동으로 시작하세요:"
-echo ""
-echo -e "${YELLOW}Backend:${NC}"
-echo "  cd backend"
-echo "  pip install -r requirements.txt"
-echo "  uvicorn app.main:app --reload --host 0.0.0.0 --port 8000"
-echo ""
-echo -e "${YELLOW}MCP Server:${NC}"
-echo "  cd mcp-server"
-echo "  pip install -r requirements.txt"
-echo "  uvicorn main:app --reload --host 0.0.0.0 --port 8001"
-echo ""
-echo -e "${YELLOW}Frontend:${NC}"
-echo "  cd frontend"
-echo "  npm install"
-echo "  npm run dev"
-echo ""
-echo "====================================="
-echo "서비스 URL"
-echo "====================================="
-echo -e "PostgreSQL: ${GREEN}localhost:5432${NC}"
-echo -e "Redis:      ${GREEN}localhost:6379${NC}"
-echo -e "RabbitMQ:   ${GREEN}localhost:15672${NC} (guest/guest)"
-echo ""
+echo "Starting Auto Stock Trading System in DEV mode..."
+docker-compose -f docker-compose.dev.yml up --build
diff --git a/scripts/logs.sh b/scripts/logs.sh
index 06ba74b..27b1a4b 100755
--- a/scripts/logs.sh
+++ b/scripts/logs.sh
@@ -1,23 +1,4 @@
 #!/bin/bash
-
 # 로그 확인 스크립트
 
-SERVICE=$1
-
-if [ -z "$SERVICE" ]; then
-    echo "전체 서비스 로그:"
-    echo ""
-    if docker compose version &> /dev/null; then
-        docker compose logs --tail=100 -f
-    else
-        docker-compose logs --tail=100 -f
-    fi
-else
-    echo "$SERVICE 서비스 로그:"
-    echo ""
-    if docker compose version &> /dev/null; then
-        docker compose logs --tail=100 -f $SERVICE
-    else
-        docker-compose logs --tail=100 -f $SERVICE
-    fi
-fi
+docker-compose logs -f
diff --git a/backend/register_rules.sh b/scripts/register_rules.sh
similarity index 100%
rename from backend/register_rules.sh
rename to scripts/register_rules.sh
diff --git a/setup-cron.sh b/setup-cron.sh
new file mode 100755
index 0000000..7991714
--- /dev/null
+++ b/setup-cron.sh
@@ -0,0 +1,63 @@
+#!/bin/bash
+
+# 배치 분석 자동 실행을 위한 cron 설정 (Docker 컨테이너 내부 실행)
+# 매일 아침 8시 50분에 실행 (장 시작 전 분석)
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+LOG_DIR="$SCRIPT_DIR/logs"
+CONTAINER="autostock-backend"
+DOCKER_BIN="$(command -v docker)"
+
+# 로그 디렉토리 생성
+mkdir -p "$LOG_DIR"
+
+if [ -z "$DOCKER_BIN" ]; then
+    echo "❌ 오류: docker 명령어를 찾을 수 없습니다."
+    exit 1
+fi
+
+# cron 작업 추가 (기존 작업 중복 방지)
+TOKEN_JOB="0 6 * * 1-5 $DOCKER_BIN exec $CONTAINER python /app/prefetch_token.py >> $LOG_DIR/token_prefetch.log 2>&1"
+DAILY_JOB="50 8 * * 1-5 $DOCKER_BIN exec $CONTAINER python /app/batch_daily_analysis.py >> $LOG_DIR/batch_analysis.log 2>&1"
+INTRADAY_JOB="*/10 9-15 * * 1-5 $DOCKER_BIN exec $CONTAINER python /app/batch_intraday_analysis.py >> $LOG_DIR/batch_intraday.log 2>&1"
+
+ADDED=0
+
+# 토큰 선제 발급 (06:00)
+(crontab -l 2>/dev/null | grep -F "prefetch_token.py") || {
+    (crontab -l 2>/dev/null; echo "$TOKEN_JOB") | crontab -
+    echo "✅ Token prefetch cron added (06:00 평일)"
+    ADDED=1
+}
+
+# 아침 전체 배치
+(crontab -l 2>/dev/null | grep -F "batch_daily_analysis.py") || {
+    (crontab -l 2>/dev/null; echo "$DAILY_JOB") | crontab -
+    echo "✅ Daily batch cron added (08:50 평일)"
+    ADDED=1
+}
+
+# 장중 미니배치 — 항상 최신 설정(*/10)으로 교체
+crontab -l 2>/dev/null | grep -v "batch_intraday_analysis.py" | crontab -
+(crontab -l 2>/dev/null; echo "$INTRADAY_JOB") | crontab -
+echo "✅ Intraday batch cron set (*/10 9-15 평일, 분석종목 관리)"
+ADDED=1
+
+if [ $ADDED -eq 0 ]; then
+    echo "✅ All cron jobs already exist"
+    exit 0
+fi
+
+echo ""
+echo "📅 스케줄:"
+echo "  - 토큰 선제발급: 06:00 평일"
+echo "  - 아침 배치:     08:50 평일 (500종목 전체 분석)"
+echo "  - 장중 미니배치: 09:00~15:30 매 10분 평일 (분석종목 재분석·진입·제거)"
+echo "📝 로그:"
+echo "  - $LOG_DIR/token_prefetch.log"
+echo "  - $LOG_DIR/batch_analysis.log"
+echo "  - $LOG_DIR/batch_intraday.log"
+echo "🐳 실행 컨테이너: $CONTAINER"
+echo ""
+echo "확인: crontab -l"
+echo "수정: crontab -e"
diff --git a/start-all.sh b/start-all.sh
deleted file mode 100755
index 0d40e4c..0000000
--- a/start-all.sh
+++ /dev/null
@@ -1,145 +0,0 @@
-#!/bin/bash
-
-# Auto Stock Trading System - 전체 시작 스크립트
-
-echo "================================================"
-echo "  Auto Stock Trading System Starting..."
-echo "================================================"
-
-# 색상 정의
-GREEN='\033[0;32m'
-RED='\033[0;31m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-# 프로젝트 루트 디렉토리
-PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-cd "$PROJECT_ROOT"
-
-# 로그 디렉토리 생성
-mkdir -p logs
-
-echo ""
-echo "📍 Project Root: $PROJECT_ROOT"
-echo ""
-
-# 1. Python 가상환경 확인 및 생성
-echo "🐍 [1/5] Checking Python Virtual Environment..."
-# Python 3.12 사용 (3.13은 SQLAlchemy와 호환성 문제)
-SYSTEM_PYTHON="/opt/homebrew/bin/python3.12"
-
-if [ ! -d ".venv" ]; then
-    echo "${YELLOW}Creating Python virtual environment...${NC}"
-    $SYSTEM_PYTHON -m venv .venv
-    echo "${GREEN}✓ Virtual environment created${NC}"
-else
-    echo "${GREEN}✓ Virtual environment found${NC}"
-fi
-
-PYTHON_CMD="$PROJECT_ROOT/.venv/bin/python"
-PIP_CMD="$PROJECT_ROOT/.venv/bin/pip"
-
-# 2. Backend 의존성 확인
-echo ""
-echo "📦 [2/5] Checking Backend Dependencies..."
-cd "$PROJECT_ROOT/backend"
-if [ -f "requirements.txt" ]; then
-    $PIP_CMD install -q -r requirements.txt
-    echo "${GREEN}✓ Backend dependencies installed${NC}"
-fi
-
-# 3. MCP Server 의존성 확인
-echo ""
-echo "📦 [3/5] Checking MCP Server Dependencies..."
-cd "$PROJECT_ROOT/mcp-server"
-if [ -f "requirements.txt" ]; then
-    $PIP_CMD install -q -r requirements.txt
-    echo "${GREEN}✓ MCP Server dependencies installed${NC}"
-fi
-
-# 4. Frontend 의존성 확인
-echo ""
-echo "📦 [4/5] Checking Frontend Dependencies..."
-cd "$PROJECT_ROOT/frontend"
-if [ ! -d "node_modules" ]; then
-    echo "${YELLOW}Installing frontend dependencies...${NC}"
-    npm install
-    echo "${GREEN}✓ Frontend dependencies installed${NC}"
-else
-    echo "${GREEN}✓ Frontend dependencies already installed${NC}"
-fi
-
-# 5. 서비스 시작
-echo ""
-echo "🚀 [5/5] Starting Services..."
-echo ""
-
-# Backend 시작
-echo "  └─ Starting Backend Server (Port 8000)..."
-cd "$PROJECT_ROOT/backend"
-nohup $PYTHON_CMD -m uvicorn app.main:app --host 0.0.0.0 --port 8000 > "$PROJECT_ROOT/logs/backend.log" 2>&1 &
-BACKEND_PID=$!
-echo "     PID: $BACKEND_PID"
-sleep 2
-
-# Backend 상태 확인
-if curl -s http://localhost:8000/health > /dev/null 2>&1; then
-    echo "     ${GREEN}✓ Backend Server is running${NC}"
-else
-    echo "     ${RED}✗ Backend Server failed to start${NC}"
-fi
-
-# MCP Server 시작
-echo ""
-echo "  └─ Starting MCP Server (Port 8001)..."
-cd "$PROJECT_ROOT/mcp-server"
-nohup $PYTHON_CMD main.py > "$PROJECT_ROOT/logs/mcp-server.log" 2>&1 &
-MCP_PID=$!
-echo "     PID: $MCP_PID"
-sleep 2
-
-# MCP Server 상태 확인
-if curl -s http://localhost:8001/ > /dev/null 2>&1; then
-    echo "     ${GREEN}✓ MCP Server is running${NC}"
-else
-    echo "     ${RED}✗ MCP Server failed to start${NC}"
-fi
-
-# Frontend 시작
-echo ""
-echo "  └─ Starting Frontend Dev Server (Port 3000)..."
-cd "$PROJECT_ROOT/frontend"
-nohup npm run dev > "$PROJECT_ROOT/logs/frontend.log" 2>&1 &
-FRONTEND_PID=$!
-echo "     PID: $FRONTEND_PID"
-sleep 3
-
-# Frontend 상태 확인
-if curl -s http://localhost:3000 > /dev/null 2>&1; then
-    echo "     ${GREEN}✓ Frontend Dev Server is running${NC}"
-else
-    echo "     ${YELLOW}⚠ Frontend Dev Server may take a moment to start${NC}"
-fi
-
-# PID 파일 저장
-echo "$BACKEND_PID" > "$PROJECT_ROOT/logs/backend.pid"
-echo "$MCP_PID" > "$PROJECT_ROOT/logs/mcp-server.pid"
-echo "$FRONTEND_PID" > "$PROJECT_ROOT/logs/frontend.pid"
-
-echo ""
-echo "================================================"
-echo "  ${GREEN}All Services Started Successfully!${NC}"
-echo "================================================"
-echo ""
-echo "📋 Service Status:"
-echo "  • Backend API:    http://localhost:8000"
-echo "  • MCP Server:     http://localhost:8001"
-echo "  • Frontend UI:    http://localhost:3000"
-echo ""
-echo "📝 Log Files:"
-echo "  • Backend:        logs/backend.log"
-echo "  • MCP Server:     logs/mcp-server.log"
-echo "  • Frontend:       logs/frontend.log"
-echo ""
-echo "🛑 To stop all services, run: ./stop-all.sh"
-echo ""
diff --git a/status.sh b/status.sh
deleted file mode 100755
index 2a3e9af..0000000
--- a/status.sh
+++ /dev/null
@@ -1,75 +0,0 @@
-#!/bin/bash
-
-# Auto Stock Trading System - 상태 확인 스크립트
-
-echo "================================================"
-echo "  Auto Stock Trading System Status"
-echo "================================================"
-
-# 색상 정의
-GREEN='\033[0;32m'
-RED='\033[0;31m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-check_service() {
-    local service_name=$1
-    local port=$2
-    local url=$3
-    
-    echo ""
-    echo "📊 $service_name (Port $port):"
-    
-    # 포트 체크
-    if lsof -ti:$port > /dev/null 2>&1; then
-        local pid=$(lsof -ti:$port)
-        echo "  Status: ${GREEN}● Running${NC} (PID: $pid)"
-        
-        # HTTP 체크
-        if curl -s "$url" > /dev/null 2>&1; then
-            echo "  Health: ${GREEN}✓ Healthy${NC}"
-        else
-            echo "  Health: ${YELLOW}⚠ Port open but not responding${NC}"
-        fi
-    else
-        echo "  Status: ${RED}● Stopped${NC}"
-    fi
-}
-
-echo ""
-echo "🔍 Checking Services..."
-
-# Backend 체크
-check_service "Backend Server" "8000" "http://localhost:8000/health"
-
-# MCP Server 체크
-check_service "MCP Server" "8001" "http://localhost:8001/"
-
-# Frontend 체크 (3000)
-if lsof -ti:3000 > /dev/null 2>&1; then
-    check_service "Frontend Dev Server" "3000" "http://localhost:3000"
-else
-    echo ""
-    echo "📊 Frontend Dev Server:"
-    echo "  Status: ${RED}● Stopped${NC}"
-fi
-
-echo ""
-echo "================================================"
-echo ""
-echo "📋 Quick Access URLs:"
-echo "  • Backend API:    http://localhost:8000/docs"
-echo "  • MCP Server:     http://localhost:8001/"
-echo "  • Frontend UI:    http://localhost:3000"
-echo ""
-echo "📝 Log Files:"
-echo "  • Backend:        logs/backend.log"
-echo "  • MCP Server:     logs/mcp-server.log"
-echo "  • Frontend:       logs/frontend.log"
-echo ""
-echo "💡 Commands:"
-echo "  • Start All:      ./start-all.sh"
-echo "  • Stop All:       ./stop-all.sh"
-echo "  • Restart All:    ./restart-all.sh"
-echo "  • View Logs:      ./view-logs.sh"
-echo ""
diff --git a/stop-all.sh b/stop-all.sh
deleted file mode 100755
index 4693fc5..0000000
--- a/stop-all.sh
+++ /dev/null
@@ -1,100 +0,0 @@
-#!/bin/bash
-
-# Auto Stock Trading System - 전체 종료 스크립트
-
-echo "================================================"
-echo "  Auto Stock Trading System Stopping..."
-echo "================================================"
-
-# 색상 정의
-GREEN='\033[0;32m'
-RED='\033[0;31m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-# 프로젝트 루트 디렉토리
-PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-cd "$PROJECT_ROOT"
-
-echo ""
-echo "🛑 Stopping all services..."
-echo ""
-
-# PID 파일에서 프로세스 종료
-stop_service() {
-    local service_name=$1
-    local pid_file="$PROJECT_ROOT/logs/${service_name}.pid"
-    
-    if [ -f "$pid_file" ]; then
-        local pid=$(cat "$pid_file")
-        if ps -p $pid > /dev/null 2>&1; then
-            echo "  └─ Stopping $service_name (PID: $pid)..."
-            kill $pid
-            sleep 2
-            
-            # 강제 종료가 필요한 경우
-            if ps -p $pid > /dev/null 2>&1; then
-                echo "     ${YELLOW}Force killing $service_name...${NC}"
-                kill -9 $pid
-            fi
-            
-            echo "     ${GREEN}✓ $service_name stopped${NC}"
-        else
-            echo "  └─ $service_name is not running"
-        fi
-        rm -f "$pid_file"
-    else
-        echo "  └─ No PID file found for $service_name"
-    fi
-}
-
-# 각 서비스 종료
-stop_service "backend"
-stop_service "mcp-server"
-stop_service "frontend"
-
-echo ""
-
-# 포트로 실행 중인 프로세스 강제 종료
-echo "🔍 Checking for remaining processes on ports..."
-echo ""
-
-# Backend (8000)
-if lsof -ti:8000 > /dev/null 2>&1; then
-    echo "  └─ Killing process on port 8000..."
-    kill -9 $(lsof -ti:8000) 2>/dev/null
-    echo "     ${GREEN}✓ Port 8000 cleared${NC}"
-fi
-
-# MCP Server (8001)
-if lsof -ti:8001 > /dev/null 2>&1; then
-    echo "  └─ Killing process on port 8001..."
-    kill -9 $(lsof -ti:8001) 2>/dev/null
-    echo "     ${GREEN}✓ Port 8001 cleared${NC}"
-fi
-
-# Frontend (3000)
-if lsof -ti:3000 > /dev/null 2>&1; then
-    echo "  └─ Killing process on port 3000..."
-    kill -9 $(lsof -ti:3000) 2>/dev/null
-    echo "     ${GREEN}✓ Port 3000 cleared${NC}"
-fi
-
-# Python 프로세스 정리
-echo ""
-echo "🧹 Cleaning up Python processes..."
-pkill -f "uvicorn.*8000" 2>/dev/null && echo "  ${GREEN}✓ Backend processes cleaned${NC}"
-pkill -f "main.py" 2>/dev/null && echo "  ${GREEN}✓ MCP Server processes cleaned${NC}"
-
-# Node 프로세스 정리
-echo ""
-echo "🧹 Cleaning up Node processes..."
-pkill -f "vite.*3000" 2>/dev/null && echo "  ${GREEN}✓ Frontend processes cleaned${NC}"
-
-echo ""
-echo "================================================"
-echo "  ${GREEN}All Services Stopped Successfully!${NC}"
-echo "================================================"
-echo ""
-echo "🚀 To start all services again, run: ./start-all.sh"
-echo ""
diff --git a/backend/insert_test_data.py b/tests/insert_test_data.py
similarity index 100%
rename from backend/insert_test_data.py
rename to tests/insert_test_data.py
diff --git a/backend/test_api_safety.py b/tests/test_api_safety.py
similarity index 100%
rename from backend/test_api_safety.py
rename to tests/test_api_safety.py
diff --git a/backend/test_db_connection.py b/tests/test_db_connection.py
similarity index 100%
rename from backend/test_db_connection.py
rename to tests/test_db_connection.py
diff --git a/view-logs.sh b/view-logs.sh
deleted file mode 100755
index a5381ff..0000000
--- a/view-logs.sh
+++ /dev/null
@@ -1,70 +0,0 @@
-#!/bin/bash
-
-# Auto Stock Trading System - 로그 보기 스크립트
-
-# 색상 정의
-GREEN='\033[0;32m'
-RED='\033[0;31m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-echo "================================================"
-echo "  Auto Stock Trading System Logs"
-echo "================================================"
-echo ""
-echo "Select a service to view logs:"
-echo ""
-echo "  1) Backend Server"
-echo "  2) MCP Server"
-echo "  3) Frontend Dev Server"
-echo "  4) All Services (tail -f)"
-echo "  5) Exit"
-echo ""
-read -p "Enter choice [1-5]: " choice
-
-case $choice in
-    1)
-        echo ""
-        echo "${BLUE}=== Backend Server Logs ===${NC}"
-        if [ -f "$PROJECT_ROOT/logs/backend.log" ]; then
-            tail -f "$PROJECT_ROOT/logs/backend.log"
-        else
-            echo "${RED}Log file not found: logs/backend.log${NC}"
-        fi
-        ;;
-    2)
-        echo ""
-        echo "${BLUE}=== MCP Server Logs ===${NC}"
-        if [ -f "$PROJECT_ROOT/logs/mcp-server.log" ]; then
-            tail -f "$PROJECT_ROOT/logs/mcp-server.log"
-        else
-            echo "${RED}Log file not found: logs/mcp-server.log${NC}"
-        fi
-        ;;
-    3)
-        echo ""
-        echo "${BLUE}=== Frontend Dev Server Logs ===${NC}"
-        if [ -f "$PROJECT_ROOT/logs/frontend.log" ]; then
-            tail -f "$PROJECT_ROOT/logs/frontend.log"
-        else
-            echo "${RED}Log file not found: logs/frontend.log${NC}"
-        fi
-        ;;
-    4)
-        echo ""
-        echo "${BLUE}=== All Services Logs ===${NC}"
-        echo ""
-        tail -f "$PROJECT_ROOT/logs/"*.log 2>/dev/null
-        ;;
-    5)
-        echo "Exiting..."
-        exit 0
-        ;;
-    *)
-        echo "${RED}Invalid choice${NC}"
-        exit 1
-        ;;
-esac