Merge branch 'main' into feature/multi-symbol-trading

- Added design document outlining the architecture for multi-symbol trading, including independent TradingBot instances and shared RiskManager.
- Created implementation plan detailing tasks for configuration, risk management, and execution structure for multi-symbol support.
- Updated configuration to support multiple trading symbols and correlation symbols, ensuring backward compatibility.
- Introduced shared RiskManager with constraints on position limits and direction to manage global risk effectively.

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

.env.example

@@ -8,4 +8,4 @@ DISCORD_WEBHOOK_URL=
 ML_THRESHOLD=0.55
 MAX_SAME_DIRECTION=2
 BINANCE_TESTNET_API_KEY=
-BINANCE_TESTNET_API_SECRET=
+BINANCE_TESTNET_API_SECRET=

ARCHITECTURE.md

@@ -17,7 +17,22 @@
 
 ## 1. 시스템 오버뷰
 
-CoinTrader는 **Binance Futures 자동매매 봇**입니다. 기술 지표 신호를 1차 필터로, LightGBM(또는 MLX 신경망) 모델을 2차 필터로 사용하여 XRPUSDT 선물 포지션을 자동 진입·청산합니다.
+CoinTrader는 **Binance Futures 자동매매 봇**입니다. 기술 지표 신호를 1차 필터로, LightGBM(또는 MLX 신경망) 모델을 2차 필터로 사용하여 다중 심볼(XRP, TRX, DOGE 등) 선물 포지션을 동시에 자동 진입·청산합니다.
+
+### 멀티심볼 아키텍처
+
+```
+main.py
+  └─ Config (SYMBOLS=XRPUSDT,TRXUSDT,DOGEUSDT)
+  └─ RiskManager (공유 싱글턴, asyncio.Lock)
+  └─ asyncio.gather(
+       TradingBot(symbol="XRPUSDT", risk=shared_risk),
+       TradingBot(symbol="TRXUSDT", risk=shared_risk),
+       TradingBot(symbol="DOGEUSDT", risk=shared_risk),
+     )
+```
+
+각 봇은 독립적인 `Exchange`, `MLFilter`, `DataStream`을 소유합니다. `RiskManager`만 공유 싱글턴으로 글로벌 리스크(일일 손실 한도, 동일 방향 제한, 최대 포지션 수)를 관리합니다.
 
 ### 전체 데이터 파이프라인 흐름도
 
@@ -30,11 +45,11 @@ flowchart TD
     end
 
     subgraph 실시간봇["실시간 봇 (bot.py — asyncio)"]
-        DS["data_stream.py<br/>MultiSymbolStream<br/>캔들 버퍼 (deque 200개)"]
+        DS["data_stream.py<br/>MultiSymbolStream (심볼별)<br/>캔들 버퍼 (deque 200개)"]
         IND["indicators.py<br/>기술 지표 계산<br/>RSI·MACD·BB·EMA·StochRSI·ATR·ADX"]
         MF["ml_features.py<br/>23개 피처 추출<br/>(XRP 13 + BTC/ETH 8 + OI/FR 2)"]
         ML["ml_filter.py<br/>MLFilter<br/>ONNX 우선 / LightGBM 폴백<br/>확률 ≥ 0.60 시 진입 허용"]
-        RM["risk_manager.py<br/>RiskManager<br/>일일 손실 5% 한도<br/>동적 증거금 비율"]
+        RM["risk_manager.py<br/>RiskManager (공유 싱글턴)<br/>일일 손실 5% 한도<br/>동적 증거금 비율<br/>동일 방향 제한"]
         EX["exchange.py<br/>BinanceFuturesClient<br/>주문·레버리지·잔고 API"]
         UDS["user_data_stream.py<br/>UserDataStream<br/>TP/SL 즉시 감지"]
         NT["notifier.py<br/>DiscordNotifier<br/>진입·청산·오류 알림"]
@@ -119,17 +134,17 @@ flowchart TD
 
 **파일:** `src/data_stream.py`
 
-봇이 시작되면 가장 먼저 실행되는 레이어입니다. Binance Combined WebSocket 단일 연결로 XRP·BTC·ETH 3개 심볼의 15분봉 캔들을 동시에 수신합니다.
+각 봇 인스턴스가 시작되면 가장 먼저 실행되는 레이어입니다. Binance Combined WebSocket 단일 연결로 주 거래 심볼 + 상관관계 심볼(BTC/ETH)의 15분봉 캔들을 동시에 수신합니다.
 
 **핵심 동작:**
 
 1. **프리로드**: 봇 시작 시 REST API로 과거 캔들 200개를 `deque`에 즉시 채웁니다. EMA50 안정화에 필요한 최소 캔들(100개)을 확보하여 첫 캔들부터 신호를 계산할 수 있게 합니다.
 2. **버퍼 관리**: 심볼별 `deque(maxlen=200)`에 마감된 캔들만 추가합니다. 미마감 캔들(`is_closed=False`)은 무시합니다.
-3. **콜백 트리거**: XRP(주 심볼) 캔들이 마감되면 `bot._on_candle_closed()`를 호출합니다. BTC·ETH는 버퍼에만 쌓이고 콜백을 트리거하지 않습니다.
+3. **콜백 트리거**: 주 거래 심볼 캔들이 마감되면 `bot._on_candle_closed()`를 호출합니다. 상관관계 심볼(BTC·ETH)은 버퍼에만 쌓이고 콜백을 트리거하지 않습니다.
 
 ```
-Combined WebSocket
+예: TRXUSDT 봇의 Combined WebSocket
-  ├── xrpusdt@kline_15m  →  buffers["xrpusdt"]  →  on_candle() 호출
+  ├── trxusdt@kline_15m  →  buffers["trxusdt"]  →  on_candle() 호출
   ├── btcusdt@kline_15m  →  buffers["btcusdt"]  (콜백 없음)
   └── ethusdt@kline_15m  →  buffers["ethusdt"]  (콜백 없음)
 ```
@@ -252,11 +267,15 @@ SL/TP 주문은 `/fapi/v1/algoOrder` 엔드포인트로 전송됩니다 (일반
 | 제어 항목 | 기준 |
 |----------|------|
 | 일일 최대 손실 | 기준 잔고의 5% |
-| 최대 동시 포지션 | 3개 |
+| 최대 동시 포지션 | 3개 (전체 심볼 합산) |
+| 동일 방향 제한 | 2개 (LONG 2개면 3번째 LONG 차단) |
+| 같은 심볼 중복 | 차단 (1심볼 1포지션) |
 | 최소 명목금액 | $5 USDT |
 
 **반대 시그널 재진입:** 보유 포지션과 반대 방향 신호 발생 시 기존 포지션을 즉시 청산하고, ML 필터 통과 시 반대 방향으로 재진입합니다. 재진입 중 User Data Stream 콜백이 신규 포지션 상태를 덮어쓰지 않도록 `_is_reentering` 플래그로 보호합니다.
 
+**마진 균등 배분:** 멀티심볼 모드에서 각 봇은 전체 잔고를 심볼 수로 나눈 금액만큼만 사용합니다 (`balance / len(symbols)`). 공유 `RiskManager`의 `asyncio.Lock`으로 동시 포지션 등록/해제 시 경합 조건을 방지합니다.
+
 ---
 
 ### Layer 5: Event / Alert Layer
@@ -272,7 +291,7 @@ Binance `ORDER_TRADE_UPDATE` 웹소켓 이벤트를 구독하여 TP/SL 체결을
 ```
 이벤트 필터링 조건:
   e == "ORDER_TRADE_UPDATE"
-  AND s == "XRPUSDT"          ← 심볼 필터
+  AND s == self.symbol         ← 심볼 필터 (봇별 독립)
   AND x == "TRADE"            ← 실제 체결
   AND X == "FILLED"           ← 완전 체결
   AND (reduceOnly OR order_type in {STOP_MARKET, TAKE_PROFIT_MARKET} OR rp != 0)
@@ -360,11 +379,11 @@ reg_alpha:         1e-4 ~ 1.0   (log scale)
 reg_lambda:        1e-4 ~ 1.0   (log scale)
 ```
 
-결과는 `models/tune_results_YYYYMMDD_HHMMSS.json`에 저장됩니다.
+결과는 `models/{symbol}/tune_results_YYYYMMDD_HHMMSS.json`에 저장됩니다.
 
 #### Step 2: Active Config 패턴으로 파라미터 승인
 
-Optuna가 찾은 파라미터는 **자동으로 적용되지 않습니다.** 사람이 결과를 검토하고 직접 `models/active_lgbm_params.json`을 업데이트해야 합니다.
+Optuna가 찾은 파라미터는 **자동으로 적용되지 않습니다.** 사람이 결과를 검토하고 직접 `models/{symbol}/active_lgbm_params.json`을 업데이트해야 합니다.
 
 ```json
 {
@@ -390,18 +409,20 @@ Optuna가 찾은 파라미터는 **자동으로 적용되지 않습니다.** 사
 `scripts/train_and_deploy.sh`는 3단계를 자동으로 실행합니다:
 
 ```
-[1/3] 데이터 수집 (fetch_history.py)
+[심볼별 반복] --symbol 지정 시 단일 심볼, --all 시 전체 심볼 순차 처리
-  - 기존 parquet 없음 → 1년치(365일) 전체 수집
-  - 기존 parquet 있음 → 35일치 Upsert (OI/펀딩비 0.0 구간 보충)
 
-[2/3] 모델 학습 (train_model.py)
+[1/3] 데이터 수집 (fetch_history.py --symbol {SYM})
-  - active_lgbm_params.json 파라미터 로드
+  - data/{symbol}/combined_15m.parquet 없음 → 1년치(365일) 전체 수집
+  - 있음 → 35일치 Upsert (OI/펀딩비 0.0 구간 보충)
+
+[2/3] 모델 학습 (train_model.py --symbol {SYM})
+  - models/{symbol}/active_lgbm_params.json 파라미터 로드
   - 벡터화 데이터셋 생성 (dataset_builder.py)
   - Walk-Forward 5폴드 검증 후 최종 모델 저장
-  - 학습 로그: models/training_log.json
+  - 학습 로그: models/{symbol}/training_log.json
 
-[3/3] LXC 배포 (deploy_model.sh)
+[3/3] LXC 배포 (deploy_model.sh --symbol {SYM})
-  - rsync로 lgbm_filter.pkl → LXC 서버 전송
+  - rsync로 models/{symbol}/lgbm_filter.pkl → LXC 서버 전송
   - 기존 모델 자동 백업 (lgbm_filter_prev.pkl)
   - ONNX 파일 충돌 방지 (우선순위 보장)
 ```
@@ -547,7 +568,7 @@ sequenceDiagram
 
 ### 5.1 테스트 파일 구성
 
-`tests/` 폴더에 12개 테스트 파일, 총 **81개의 테스트 케이스**가 작성되어 있습니다.
+`tests/` 폴더에 14개 테스트 파일, 총 **99개의 테스트 케이스**가 작성되어 있습니다.
 
 ```bash
 pytest tests/ -v          # 전체 실행
@@ -562,14 +583,14 @@ bash scripts/run_tests.sh  # 래퍼 스크립트 실행
 | `test_indicators.py` | `src/indicators.py` | 7 | RSI 범위(0~100), MACD 컬럼 존재, 볼린저 밴드 상하단 대소관계, 신호 반환값 유효성, ADX 컬럼 존재, ADX<25 횡보장 차단, ADX NaN 폴스루 |
 | `test_ml_features.py` | `src/ml_features.py` | 11 | 23개 피처 수, BTC/ETH 포함 시 피처 수, RS 분모 0 처리, NaN 없음, side 인코딩, OI/펀딩비 파라미터 반영 |
 | `test_ml_filter.py` | `src/ml_filter.py` | 5 | 모델 없을 때 폴백 허용, 임계값 이상/미만 판단, 핫리로드 후 상태 변화 |
-| `test_risk_manager.py` | `src/risk_manager.py` | 8 | 일일 손실 한도 초과 차단, 최대 포지션 수 제한, 동적 증거금 비율 상한/하한 클램핑 |
+| `test_risk_manager.py` | `src/risk_manager.py` | 13 | 일일 손실 한도 초과 차단, 최대 포지션 수 제한, 동일 방향 제한, 심볼 중복 차단, 비동기 포지션 등록/해제, 동적 증거금 비율 상한/하한 클램핑 |
 | `test_exchange.py` | `src/exchange.py` | 8 | 수량 계산(기본/최소명목금액/잔고0), OI·펀딩비 조회 정상/오류 시 반환값 |
 | `test_data_stream.py` | `src/data_stream.py` | 6 | 3심볼 버퍼 존재, 빈 버퍼 None 반환, 캔들 파싱, 마감 캔들 콜백 호출, 프리로드 200개 |
 | `test_label_builder.py` | `src/label_builder.py` | 4 | LONG TP 도달 → 1, LONG SL 도달 → 0, 미결 → None, SHORT TP 도달 → 1 |
 | `test_dataset_builder.py` | `src/dataset_builder.py` | 9 | DataFrame 반환, 필수 컬럼 존재, 레이블 이진값, BTC/ETH 포함 시 23개 피처, inf/NaN 없음, OI nan 마스킹, RS 분모 0 처리 |
 | `test_mlx_filter.py` | `src/mlx_filter.py` | 5 | GPU 디바이스 확인, 학습 전 예측 형태, 학습 후 유효 확률, NaN 피처 처리, 저장/로드 후 동일 예측 |
 | `test_fetch_history.py` | `scripts/fetch_history.py` | 5 | OI=0 구간 Upsert, 신규 행 추가, 기존 비0값 보존, 파일 없을 때 신규 반환, 타임스탬프 오름차순 정렬 |
-| `test_config.py` | `src/config.py` | 2 | 환경변수 로드, 동적 증거금 파라미터 로드 |
+| `test_config.py` | `src/config.py` | 6 | 환경변수 로드, 동적 증거금 파라미터 로드, `symbols` 리스트, `correlation_symbols`, `max_same_direction`, SYMBOL→symbols 폴백 |
 
 > `test_mlx_filter.py`는 Apple Silicon(`mlx` 패키지)이 없는 환경에서 자동 스킵됩니다.
 
@@ -588,6 +609,8 @@ bash scripts/run_tests.sh  # 래퍼 스크립트 실행
 | 레이블 생성 (SL/TP 룩어헤드) | ✅ | ✅ | `test_label_builder` + `test_dataset_builder` (전체 파이프라인 실제 호출) |
 | 벡터화 데이터셋 빌더 | ✅ | ✅ | `test_dataset_builder` |
 | 동적 증거금 비율 계산 | ✅ | — | `test_risk_manager` |
+| 동일 방향 포지션 제한 | ✅ | — | `test_risk_manager` |
+| 심볼 중복 진입 차단 | ✅ | — | `test_risk_manager` |
 | 일일 손실 한도 제어 | ✅ | — | `test_risk_manager` |
 | 포지션 수량 계산 | ✅ | — | `test_exchange` |
 | OI/펀딩비 API 조회 (정상/오류) | ✅ | ✅ | `test_exchange` + `test_bot` (`process_candle` → OI/펀딩비 → `build_features` 전달) |
@@ -622,25 +645,25 @@ bash scripts/run_tests.sh  # 래퍼 스크립트 실행
 
 | 파일 | 레이어 | 역할 |
 |------|--------|------|
-| `main.py` | — | 진입점. `Config` 로드 후 `TradingBot.run()` 실행 |
+| `main.py` | — | 진입점. 심볼별 `TradingBot` 생성 + 공유 `RiskManager` + `asyncio.gather()` |
-| `src/bot.py` | 오케스트레이터 | 모든 레이어를 조율하는 메인 트레이딩 루프 |
+| `src/bot.py` | 오케스트레이터 | 심볼별 독립 트레이딩 루프 (symbol, risk 주입) |
-| `src/config.py` | — | 환경변수 기반 설정 (`@dataclass`) |
+| `src/config.py` | — | 환경변수 기반 설정 (`symbols` 리스트, `correlation_symbols`) |
 | `src/data_stream.py` | Data | Combined WebSocket 캔들 수신·버퍼 관리 |
 | `src/indicators.py` | Signal | 기술 지표 계산 및 복합 신호 생성 |
 | `src/ml_features.py` | ML Filter | 23개 ML 피처 추출 |
 | `src/ml_filter.py` | ML Filter | ONNX/LightGBM 모델 로드·추론·핫리로드 |
 | `src/mlx_filter.py` | ML Filter | Apple Silicon GPU 학습 + ONNX export |
-| `src/exchange.py` | Execution | Binance Futures REST API 클라이언트 |
+| `src/exchange.py` | Execution | Binance Futures REST API 클라이언트 (심볼별 독립) |
-| `src/risk_manager.py` | Risk | 일일 손실 한도·동적 증거금 비율·포지션 수 제어 |
+| `src/risk_manager.py` | Risk | 공유 싱글턴 — 일일 손실 한도·동일 방향 제한·동적 증거금 비율 |
 | `src/user_data_stream.py` | Event | User Data Stream TP/SL 즉시 감지 |
 | `src/notifier.py` | Alert | Discord 웹훅 알림 |
 | `src/label_builder.py` | MLOps | 학습 레이블 생성 (ATR SL/TP 룩어헤드) |
 | `src/dataset_builder.py` | MLOps | 벡터화 데이터셋 빌더 (학습용) |
 | `src/logger_setup.py` | — | Loguru 로거 설정 |
-| `scripts/fetch_history.py` | MLOps | 과거 캔들 + OI/펀딩비 수집 (Parquet Upsert) |
+| `scripts/fetch_history.py` | MLOps | 과거 캔들 + OI/펀딩비 수집 (`--symbol` 지원) |
-| `scripts/train_model.py` | MLOps | LightGBM 모델 학습 (CPU) |
+| `scripts/train_model.py` | MLOps | LightGBM 모델 학습 (`--symbol` 지원) |
 | `scripts/train_mlx_model.py` | MLOps | MLX 신경망 학습 (Apple Silicon GPU) |
-| `scripts/tune_hyperparams.py` | MLOps | Optuna 하이퍼파라미터 탐색 (수동 트리거) |
+| `scripts/tune_hyperparams.py` | MLOps | Optuna 하이퍼파라미터 탐색 (`--symbol` 지원) |
-| `scripts/train_and_deploy.sh` | MLOps | 전체 파이프라인 (수집→학습→배포) |
+| `scripts/train_and_deploy.sh` | MLOps | 전체 파이프라인 (`--symbol` / `--all` 지원) |
-| `scripts/deploy_model.sh` | MLOps | 모델 파일 LXC 서버 전송 |
+| `scripts/deploy_model.sh` | MLOps | 모델 파일 LXC 서버 전송 (`--symbol` 지원) |
-| `models/active_lgbm_params.json` | MLOps | 승인된 LightGBM 파라미터 (Active Config) |
+| `models/{symbol}/active_lgbm_params.json` | MLOps | 심볼별 승인된 LightGBM 파라미터 (Active Config) |

CLAUDE.md

@@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-CoinTrader is a Python asyncio-based automated cryptocurrency trading bot for Binance Futures. It trades XRPUSDT on 15-minute candles, using BTC/ETH as correlation features. The system has 5 layers: Data (WebSocket streams) → Signal (technical indicators) → ML Filter (ONNX/LightGBM) → Execution & Risk → Event/Alert (Discord).
+CoinTrader is a Python asyncio-based automated cryptocurrency trading bot for Binance Futures. It supports multi-symbol simultaneous trading (XRP, TRX, DOGE etc.) on 15-minute candles, using BTC/ETH as correlation features. The system has 5 layers: Data (WebSocket streams) → Signal (technical indicators) → ML Filter (ONNX/LightGBM) → Execution & Risk → Event/Alert (Discord).
 
 ## Common Commands
 
@@ -24,34 +24,44 @@ bash scripts/run_tests.sh -k "bot"
 # Run pytest directly
 pytest tests/ -v --tb=short
 
-# ML training pipeline (LightGBM default)
+# ML training pipeline (all symbols)
 bash scripts/train_and_deploy.sh
 
+# Single symbol training
+bash scripts/train_and_deploy.sh --symbol TRXUSDT
+
 # MLX GPU training (macOS Apple Silicon)
-bash scripts/train_and_deploy.sh mlx
+bash scripts/train_and_deploy.sh mlx --symbol XRPUSDT
 
 # Hyperparameter tuning (50 trials, 5-fold walk-forward)
-python scripts/tune_hyperparams.py
+python scripts/tune_hyperparams.py --symbol XRPUSDT
 
-# Fetch historical data
+# Fetch historical data (single symbol with auto correlation)
+python scripts/fetch_history.py --symbol TRXUSDT --interval 15m --days 365
+
+# Fetch historical data (explicit symbols)
 python scripts/fetch_history.py --symbols XRPUSDT BTCUSDT ETHUSDT --interval 15m --days 365
 
 # Deploy models to production
-bash scripts/deploy_model.sh
+bash scripts/deploy_model.sh --symbol XRPUSDT
 ```
 
 ## Architecture
 
-**Entry point**: `main.py` → creates `Config` (dataclass from env vars) → runs `TradingBot`
+**Entry point**: `main.py` → creates `Config` → shared `RiskManager` → per-symbol `TradingBot` instances → `asyncio.gather()`
+
+**Multi-symbol architecture**: Each symbol gets its own `TradingBot` instance with independent `Exchange`, `MLFilter`, and `DataStream`. The `RiskManager` is shared as a singleton across all bots, enforcing global daily loss limits and same-direction position limits via `asyncio.Lock`.
 
 **5-layer data flow on each 15m candle close:**
-1. `src/data_stream.py` — Combined WebSocket for XRP/BTC/ETH, deque buffers (200 candles each)
+1. `src/data_stream.py` — Combined WebSocket for primary+correlation symbols, deque buffers (200 candles each)
 2. `src/indicators.py` — RSI, MACD, BB, EMA, StochRSI, ATR; weighted signal aggregation → LONG/SHORT/HOLD
 3. `src/ml_filter.py` + `src/ml_features.py` — 26-feature extraction (ADX + OI 파생 피처 포함), ONNX priority > LightGBM fallback, threshold ≥ 0.55
-4. `src/exchange.py` + `src/risk_manager.py` — Dynamic margin, MARKET orders with SL/TP, daily loss limit (5%)
+4. `src/exchange.py` + `src/risk_manager.py` — Dynamic margin, MARKET orders with SL/TP, daily loss limit (5%), same-direction limit
 5. `src/user_data_stream.py` + `src/notifier.py` — Real-time TP/SL detection via WebSocket, Discord webhooks
 
-**Parallel execution**: `user_data_stream` runs independently via `asyncio.gather()` alongside candle processing.
+**Parallel execution**: Per-symbol bots run independently via `asyncio.gather()`. Each bot's `user_data_stream` also runs in parallel.
+
+**Model/data directories**: `models/{symbol}/` and `data/{symbol}/` for per-symbol models. Falls back to `models/` root if symbol dir doesn't exist.
 
 ## Key Patterns
 
@@ -72,7 +82,7 @@ bash scripts/deploy_model.sh
 
 ## Configuration
 
-Environment variables via `.env` file (see `.env.example`). Key vars: `BINANCE_API_KEY`, `BINANCE_API_SECRET`, `SYMBOL` (default XRPUSDT), `LEVERAGE`, `DISCORD_WEBHOOK_URL`, `MARGIN_MAX_RATIO`, `MARGIN_MIN_RATIO`, `NO_ML_FILTER`.
+Environment variables via `.env` file (see `.env.example`). Key vars: `BINANCE_API_KEY`, `BINANCE_API_SECRET`, `SYMBOLS` (comma-separated, e.g. `XRPUSDT,TRXUSDT`), `CORRELATION_SYMBOLS` (default `BTCUSDT,ETHUSDT`), `LEVERAGE`, `DISCORD_WEBHOOK_URL`, `MARGIN_MAX_RATIO`, `MARGIN_MIN_RATIO`, `MAX_SAME_DIRECTION` (default 2), `NO_ML_FILTER`.
 
 `src/config.py` uses `@dataclass` with `__post_init__` to load and validate all env vars.
 
@@ -80,7 +90,7 @@ Environment variables via `.env` file (see `.env.example`). Key vars: `BINANCE_A
 
 - **Docker**: `Dockerfile` (Python 3.12-slim) + `docker-compose.yml`
 - **CI/CD**: Jenkins pipeline (Gitea → Docker registry → LXC production server)
-- Models stored in `models/`, data cache in `data/`, logs in `logs/`
+- Models stored in `models/{symbol}/`, data cache in `data/{symbol}/`, logs in `logs/`
 
 ## Design & Implementation Plans
 
@@ -118,3 +128,4 @@ All design documents and implementation plans are stored in `docs/plans/` with t
 | 2026-03-03 | `optuna-precision-objective-plan` | Completed |
 | 2026-03-03 | `demo-1m-125x` (design + plan) | In Progress |
 | 2026-03-04 | `oi-derived-features` (design + plan) | Completed |
+| 2026-03-05 | `multi-symbol-trading` (design + plan) | Completed |

README.md

@@ -1,6 +1,6 @@
 # CoinTrader
 
-Binance Futures 자동매매 봇. 복합 기술 지표와 ML 필터(LightGBM / MLX 신경망)를 결합하여 XRPUSDT(기본) 선물 포지션을 자동으로 진입·청산하며, Discord로 실시간 알림을 전송합니다.
+Binance Futures 자동매매 봇. 복합 기술 지표와 ML 필터(LightGBM / MLX 신경망)를 결합하여 다중 심볼(XRP, TRX, DOGE 등) 선물 포지션을 동시에 자동 진입·청산하며, Discord로 실시간 알림을 전송합니다.
 
 > **아키텍처 문서**: 코드 구조, 레이어별 역할, MLOps 파이프라인, 동작 시나리오를 상세히 설명한 [ARCHITECTURE.md](./ARCHITECTURE.md)를 참고하세요.
 
@@ -19,7 +19,8 @@ Binance Futures 자동매매 봇. 복합 기술 지표와 ML 필터(LightGBM / M
 - **Algo Order API 지원**: 계정 설정에 따라 STOP_MARKET/TAKE_PROFIT_MARKET 주문을 `/fapi/v1/algoOrder` 엔드포인트로 자동 전송 (오류 코드 -4120 대응)
 - **동적 증거금 비율**: 잔고 증가에 따라 선형 감소 (최대 50% → 최소 20%)
 - **반대 시그널 재진입**: 보유 포지션과 반대 신호 발생 시 즉시 청산 후 ML 필터 통과 시 반대 방향 재진입
-- **리스크 관리**: 트레이드당 리스크 비율, 최대 포지션 수, 일일 손실 한도(5%) 제어
+- **멀티심볼 동시 거래**: 심볼별 독립 봇 인스턴스를 `asyncio.gather()`로 병렬 실행. 공유 RiskManager로 글로벌 리스크 관리
+- **리스크 관리**: 트레이드당 리스크 비율, 최대 포지션 수, 동일 방향 포지션 제한(기본 2개), 일일 손실 한도(5%) 제어
 - **포지션 복구**: 봇 재시작 시 기존 포지션 자동 감지 및 상태 복원
 - **실시간 TP/SL 감지**: Binance User Data Stream으로 TP/SL 작동을 즉시 감지 (캔들 마감 대기 없음)
 - **순수익(Net PnL) 기록**: 바이낸스 `realizedProfit - commission`으로 정확한 순수익 계산
@@ -34,34 +35,40 @@ Binance Futures 자동매매 봇. 복합 기술 지표와 ML 필터(LightGBM / M
 
 ```
 cointrader/
-├── main.py                    # 진입점
+├── main.py                    # 진입점 (심볼별 봇 인스턴스 생성 + asyncio.gather)
 ├── src/
-│   ├── bot.py                 # 메인 트레이딩 루프
+│   ├── bot.py                 # 메인 트레이딩 루프 (심볼별 독립 인스턴스)
-│   ├── config.py              # 환경변수 기반 설정
+│   ├── config.py              # 환경변수 기반 설정 (symbols 리스트 지원)
-│   ├── exchange.py            # Binance Futures API 클라이언트
+│   ├── exchange.py            # Binance Futures API 클라이언트 (심볼별 독립)
-│   ├── data_stream.py         # WebSocket 15분봉 멀티심볼 스트림 (XRP/BTC/ETH)
+│   ├── data_stream.py         # WebSocket 15분봉 멀티심볼 스트림
 │   ├── indicators.py          # 기술 지표 계산 및 신호 생성
 │   ├── ml_filter.py           # ML 필터 (ONNX 우선 / LightGBM 폴백 / 핫리로드)
-│   ├── ml_features.py         # ML 피처 빌더 (23개 피처)
+│   ├── ml_features.py         # ML 피처 빌더 (26개 피처)
 │   ├── mlx_filter.py          # MLX 신경망 필터 (Apple Silicon GPU 학습 + ONNX export)
 │   ├── label_builder.py       # 학습 레이블 생성
 │   ├── dataset_builder.py     # 벡터화 데이터셋 빌더 (학습용)
-│   ├── risk_manager.py        # 리스크 관리 (일일 손실 한도, 동적 증거금 비율)
+│   ├── risk_manager.py        # 공유 리스크 관리 (asyncio.Lock, 동일 방향 제한)
 │   ├── notifier.py            # Discord 웹훅 알림
 │   └── logger_setup.py        # Loguru 로거 설정
 ├── scripts/
-│   ├── fetch_history.py       # 과거 데이터 수집 (XRP/BTC/ETH + OI/펀딩비, Upsert 지원)
+│   ├── fetch_history.py       # 과거 데이터 수집 (--symbol 단일 / --symbols 다중)
-│   ├── train_model.py         # LightGBM 모델 학습 (CPU)
+│   ├── train_model.py         # LightGBM 모델 학습 (--symbol 지원)
 │   ├── train_mlx_model.py     # MLX 신경망 학습 (Apple Silicon GPU)
-│   ├── train_and_deploy.sh    # 전체 파이프라인 (수집 → 학습 → LXC 배포)
+│   ├── train_and_deploy.sh    # 전체 파이프라인 (--symbol / --all 지원)
-│   ├── tune_hyperparams.py    # Optuna 하이퍼파라미터 자동 탐색 (수동 트리거)
+│   ├── tune_hyperparams.py    # Optuna 하이퍼파라미터 자동 탐색 (--symbol 지원)
-│   ├── deploy_model.sh        # 모델 파일 LXC 서버 전송
+│   ├── deploy_model.sh        # 모델 파일 LXC 서버 전송 (--symbol 지원)
 │   └── run_tests.sh           # 전체 테스트 실행
 ├── dashboard/
 │   ├── api/                   # FastAPI 백엔드 (로그 파서 + REST API)
 │   └── ui/                    # React 프론트엔드 (Vite + Recharts)
-├── models/                    # 학습된 모델 저장 (.pkl / .onnx)
+├── models/                    # 학습된 모델 저장 (심볼별 하위 디렉토리)
-├── data/                      # 과거 데이터 캐시 (.parquet)
+│   ├── xrpusdt/               #   models/xrpusdt/lgbm_filter.pkl
+│   ├── trxusdt/               #   models/trxusdt/lgbm_filter.pkl
+│   └── dogeusdt/              #   models/dogeusdt/lgbm_filter.pkl
+├── data/                      # 과거 데이터 캐시 (심볼별 하위 디렉토리)
+│   ├── xrpusdt/               #   data/xrpusdt/combined_15m.parquet
+│   ├── trxusdt/               #   data/trxusdt/combined_15m.parquet
+│   └── dogeusdt/              #   data/dogeusdt/combined_15m.parquet
 ├── logs/                      # 로그 파일
 ├── docs/plans/                # 설계 문서 및 구현 플랜
 ├── tests/                     # 테스트 코드
@@ -86,8 +93,10 @@ cp .env.example .env
 ```env
 BINANCE_API_KEY=your_api_key
 BINANCE_API_SECRET=your_api_secret
-SYMBOL=XRPUSDT
+SYMBOLS=XRPUSDT,TRXUSDT,DOGEUSDT
+CORRELATION_SYMBOLS=BTCUSDT,ETHUSDT
 LEVERAGE=10
+MAX_SAME_DIRECTION=2
 DISCORD_WEBHOOK_URL=https://discord.com/api/webhooks/...
 ```
 
@@ -120,14 +129,17 @@ docker compose logs -f cointrader
 
 맥미니에서 데이터 수집 → 학습 → LXC 배포까지 한 번에 실행합니다.
 
-> **자동 분기**: `data/combined_15m.parquet`가 없으면 1년치(365일) 전체 수집, 있으면 35일치 Upsert로 자동 전환합니다. 서버 이전이나 데이터 유실 시에도 사람의 개입 없이 자동 복구됩니다.
+> **자동 분기**: `data/{symbol}/combined_15m.parquet`가 없으면 1년치(365일) 전체 수집, 있으면 35일치 Upsert로 자동 전환합니다. 서버 이전이나 데이터 유실 시에도 사람의 개입 없이 자동 복구됩니다.
 
 ```bash
-# LightGBM + Walk-Forward 5폴드 (기본값)
+# 전체 심볼 학습 + 배포 (SYMBOLS 환경변수의 모든 심볼)
 bash scripts/train_and_deploy.sh
 
-# MLX GPU 학습 + Walk-Forward 5폴드
+# 단일 심볼만 학습 + 배포
-bash scripts/train_and_deploy.sh mlx
+bash scripts/train_and_deploy.sh --symbol TRXUSDT
+
+# MLX GPU 학습 (단일 심볼)
+bash scripts/train_and_deploy.sh mlx --symbol XRPUSDT
 
 # LightGBM + Walk-Forward 3폴드
 bash scripts/train_and_deploy.sh lgbm 3
@@ -139,34 +151,30 @@ bash scripts/train_and_deploy.sh lgbm 0
 ### 단계별 수동 실행
 
 ```bash
-# 1. 과거 데이터 수집 (XRP/BTC/ETH 3심볼, 15분봉, 1년치 + OI/펀딩비)
+# 1. 과거 데이터 수집 (단일 심볼 — 상관관계 심볼 자동 추가)
-# 기본값: Upsert 활성화 — 기존 parquet의 oi_change/funding_rate=0 구간을 실제 값으로 채움
+python scripts/fetch_history.py --symbol TRXUSDT --interval 15m --days 365
+# → data/trxusdt/combined_15m.parquet 에 저장
+
+# 1-alt. 명시적 심볼 지정 (기존 방식도 지원)
 python scripts/fetch_history.py \
     --symbols XRPUSDT BTCUSDT ETHUSDT \
     --interval 15m \
     --days 365 \
     --output data/combined_15m.parquet
 
-# 기존 파일을 완전히 덮어쓰려면 --no-upsert 플래그 사용
+# 2-A. LightGBM 모델 학습 (심볼별)
-python scripts/fetch_history.py \
+python scripts/train_model.py --symbol TRXUSDT
-    --symbols XRPUSDT BTCUSDT ETHUSDT \
+# → models/trxusdt/lgbm_filter.pkl 에 저장
-    --interval 15m \
-    --days 365 \
-    --output data/combined_15m.parquet \
-    --no-upsert
-
-# 2-A. LightGBM 모델 학습 (CPU)
-python scripts/train_model.py --data data/combined_15m.parquet
 
 # 2-B. MLX 신경망 학습 (Apple Silicon GPU)
-python scripts/train_mlx_model.py --data data/combined_15m.parquet
+python scripts/train_mlx_model.py --data data/xrpusdt/combined_15m.parquet
 
 # 3. LXC 서버에 모델 배포
-bash scripts/deploy_model.sh        # LightGBM
+bash scripts/deploy_model.sh --symbol XRPUSDT
-bash scripts/deploy_model.sh mlx    # MLX (ONNX)
+bash scripts/deploy_model.sh mlx --symbol XRPUSDT
 ```
 
-학습된 모델은 `models/lgbm_filter.pkl` (LightGBM) 또는 `models/mlx_filter.weights.onnx` (MLX) 에 저장됩니다.
+학습된 모델은 `models/{symbol}/lgbm_filter.pkl` (LightGBM) 또는 `models/{symbol}/mlx_filter.weights.onnx` (MLX) 에 저장됩니다. 심볼별 디렉토리가 없으면 `models/` 루트로 폴백합니다.
 
 > **모델 핫리로드**: 봇이 실행 중일 때 모델 파일을 교체하면, 다음 캔들 마감 시 자동으로 감지해 리로드합니다. 봇 재시작이 필요 없습니다.
 
@@ -176,17 +184,17 @@ bash scripts/deploy_model.sh mlx    # MLX (ONNX)
 결과를 확인하고 직접 승인한 후 재학습에 반영하는 **수동 트리거** 방식입니다.
 
 ```bash
-# 기본 실행 (50 trials, 5폴드 Walk-Forward, ~30분)
+# 심볼별 튜닝 (50 trials, 5폴드 Walk-Forward, ~30분)
-python scripts/tune_hyperparams.py
+python scripts/tune_hyperparams.py --symbol XRPUSDT
 
 # 빠른 테스트 (10 trials, 3폴드, ~5분)
-python scripts/tune_hyperparams.py --trials 10 --folds 3
+python scripts/tune_hyperparams.py --symbol TRXUSDT --trials 10 --folds 3
 
 # 베이스라인 측정 없이 탐색만
-python scripts/tune_hyperparams.py --no-baseline
+python scripts/tune_hyperparams.py --symbol XRPUSDT --no-baseline
 ```
 
-결과는 `models/tune_results_YYYYMMDD_HHMMSS.json`에 저장됩니다.
+결과는 `models/{symbol}/tune_results_YYYYMMDD_HHMMSS.json`에 저장됩니다.
 콘솔에 Best Params, 베이스라인 대비 개선폭, 폴드별 AUC를 출력하므로 직접 확인 후 판단하세요.
 
 > **주의**: Optuna가 찾은 파라미터는 과적합 위험이 있습니다. Best Params를 `train_model.py`에 반영하기 전에 반드시 폴드별 AUC 분산과 개선폭을 검토하세요.
@@ -305,8 +313,10 @@ pytest tests/ -v
 |------|--------|------|
 | `BINANCE_API_KEY` | — | Binance API 키 |
 | `BINANCE_API_SECRET` | — | Binance API 시크릿 |
-| `SYMBOL` | `XRPUSDT` | 거래 심볼 |
+| `SYMBOLS` | `XRPUSDT` | 거래 심볼 목록 (쉼표 구분, 예: `XRPUSDT,TRXUSDT,DOGEUSDT`) |
+| `CORRELATION_SYMBOLS` | `BTCUSDT,ETHUSDT` | 상관관계 심볼 (BTC/ETH 수익률·상대강도 피처용) |
 | `LEVERAGE` | `10` | 레버리지 배수 |
+| `MAX_SAME_DIRECTION` | `2` | 동일 방향 최대 포지션 수 (LONG 2개면 3번째 LONG 차단) |
 | `DISCORD_WEBHOOK_URL` | — | Discord 웹훅 URL |
 | `MARGIN_MAX_RATIO` | `0.50` | 최대 증거금 비율 (잔고 대비 50%) |
 | `MARGIN_MIN_RATIO` | `0.20` | 최소 증거금 비율 (잔고 대비 20%) |

docs/plans/2026-03-05-multi-symbol-trading-design.md

@@ -0,0 +1,209 @@
+# Multi-Symbol Trading Design
+
+## 개요
+
+현재 XRP 단일 심볼 선물 거래 봇을 TRX, DOGE 등 다중 심볼 동시 거래로 확장한다.
+
+## 요구사항
+
+- **거래 심볼**: XRPUSDT, TRXUSDT, DOGEUSDT (3개, 추후 확장 가능)
+- **상관관계 심볼**: BTCUSDT, ETHUSDT (기존과 동일)
+- **ML 모델**: 심볼별 개별 학습·배포
+- **포지션**: 심볼별 동시 포지션 허용 (최대 3개)
+- **리스크**: 심볼별 독립 운영 + 글로벌 한도 (일일 손실 5%)
+- **동일 방향 제한**: 같은 방향(LONG/SHORT) 최대 2개까지 (BTC 급락 시 3배 손실 방지)
+
+## 접근법: 심볼별 독립 TradingBot 인스턴스 + 공유 RiskManager
+
+기존 TradingBot의 단일 포지션 상태 머신을 유지하면서, 각 심볼마다 독립 인스턴스를 생성하고 `asyncio.gather()`로 병렬 실행한다. RiskManager만 싱글턴으로 공유하여 글로벌 리스크를 관리한다.
+
+### 선택 이유
+
+- 기존 TradingBot 상태 머신 수정 최소화
+- 심볼 간 완전 격리 — 한 심볼의 에러가 다른 심볼에 영향 없음
+- 점진적 확장 용이 (새 심볼 = 새 인스턴스 추가)
+- 각 단계마다 기존 XRP 단일 모드로 테스트 가능
+
+### 기각된 대안: 단일 Bot + 심볼 라우팅
+
+하나의 TradingBot에서 `Dict[str, PositionState]`로 관리하는 방식. WebSocket 효율적이나 상태 머신 대규모 리팩토링 필요, 한 심볼 에러가 전체에 영향, 복잡도 대폭 증가.
+
+## 설계 상세
+
+### 1. Config 변경
+
+```python
+# .env
+SYMBOLS=XRPUSDT,TRXUSDT,DOGEUSDT
+CORRELATION_SYMBOLS=BTCUSDT,ETHUSDT
+MAX_SAME_DIRECTION=2
+
+@dataclass
+class Config:
+    symbols: list[str]              # ["XRPUSDT", "TRXUSDT", "DOGEUSDT"]
+    correlation_symbols: list[str]  # ["BTCUSDT", "ETHUSDT"]
+    max_same_direction: int         # 같은 방향 최대 수 (기본 2)
+    # symbol: str 필드 제거
+```
+
+- 기존 `SYMBOL` 환경변수 제거, `SYMBOLS`로 통일
+- `config.symbol` 참조하는 코드 모두 → 각 봇 인스턴스의 `self.symbol`로 전환
+- 하위호환: `SYMBOLS` 미설정 시 기존 `SYMBOL` 값을 1개짜리 리스트로 변환
+
+### 2. 실행 구조 (main.py)
+
+```python
+async def main():
+    config = Config()
+    risk = RiskManager(config)  # 공유 싱글턴
+
+    bots = []
+    for symbol in config.symbols:
+        bot = TradingBot(config, symbol=symbol, risk=risk)
+        bots.append(bot)
+
+    await asyncio.gather(*[bot.run() for bot in bots])
+```
+
+- 각 봇은 독립적인 MultiSymbolStream, Exchange, UserDataStream 보유
+- RiskManager만 공유
+
+### 3. TradingBot 생성자 변경
+
+```python
+class TradingBot:
+    def __init__(self, config: Config, symbol: str, risk: RiskManager):
+        self.symbol = symbol
+        self.config = config
+        self.exchange = BinanceFuturesClient(config, symbol=symbol)
+        self.risk = risk  # 외부에서 주입 (공유)
+        self.ml_filter = MLFilter(model_dir=f"models/{symbol.lower()}")
+        ...
+```
+
+- `config.symbol` 의존 완전 제거
+- 각 봇이 자기 심볼을 직접 소유
+
+### 4. Exchange 심볼 분리
+
+```python
+class BinanceFuturesClient:
+    def __init__(self, config: Config, symbol: str):
+        self.symbol = symbol  # config.symbol → self.symbol
+```
+
+- 모든 API 호출에서 `self.config.symbol` → `self.symbol`
+
+### 5. RiskManager 공유 설계
+
+```python
+class RiskManager:
+    def __init__(self, config):
+        self.daily_pnl = 0.0
+        self.open_positions: dict[str, str] = {}  # {symbol: side}
+        self.max_positions = config.max_positions
+        self.max_same_direction = config.max_same_direction  # 기본 2
+        self._lock = asyncio.Lock()
+
+    async def can_open_new_position(self, symbol: str, side: str) -> bool:
+        async with self._lock:
+            if len(self.open_positions) >= self.max_positions:
+                return False
+            if symbol in self.open_positions:
+                return False
+            same_dir = sum(1 for s in self.open_positions.values() if s == side)
+            if same_dir >= self.max_same_direction:
+                return False
+            return True
+
+    async def register_position(self, symbol: str, side: str):
+        async with self._lock:
+            self.open_positions[symbol] = side
+
+    async def close_position(self, symbol: str, pnl: float):
+        async with self._lock:
+            self.open_positions.pop(symbol, None)
+            self.daily_pnl += pnl
+
+    def is_trading_allowed(self) -> bool:
+        # 글로벌 일일 손실 한도 체크 (기존과 동일)
+```
+
+- `asyncio.Lock()`으로 동시 접근 보호
+- 동일 방향 2개 제한으로 BTC 급락 시 3배 손실 방지
+- 마진은 심볼 수(N)로 균등 배분
+
+### 6. 데이터 스트림
+
+각 TradingBot이 자기만의 MultiSymbolStream 인스턴스를 가짐:
+
+```
+XRP Bot:  [XRPUSDT, BTCUSDT, ETHUSDT]
+TRX Bot:  [TRXUSDT, BTCUSDT, ETHUSDT]
+DOGE Bot: [DOGEUSDT, BTCUSDT, ETHUSDT]
+```
+
+- BTC/ETH 데이터 중복 수신되지만 격리성 확보
+- 각 stream의 primary_symbol이 달라 candle close 콜백 독립적
+
+### 7. 모델 & 데이터 디렉토리 분리
+
+```
+models/
+├── xrpusdt/
+│   ├── lgbm_filter.pkl
+│   └── mlx_filter.weights.onnx
+├── trxusdt/
+│   └── ...
+└── dogeusdt/
+    └── ...
+
+data/
+├── xrpusdt/
+│   └── combined_15m.parquet
+├── trxusdt/
+│   └── combined_15m.parquet
+└── dogeusdt/
+    └── combined_15m.parquet
+```
+
+- 각 parquet: 해당 심볼이 primary + BTC/ETH가 correlation
+- feature 구조 동일 (26 features)
+
+### 8. 학습 파이프라인 CLI 통일
+
+모든 스크립트에 `--symbol`과 `--all` 패턴 적용:
+
+```bash
+# 단일 심볼
+bash scripts/train_and_deploy.sh --symbol TRXUSDT
+python scripts/fetch_history.py --symbol DOGEUSDT
+python scripts/train_model.py --symbol TRXUSDT
+python scripts/tune_hyperparams.py --symbol DOGEUSDT
+
+# 전체 심볼
+bash scripts/train_and_deploy.sh --all
+bash scripts/train_and_deploy.sh  # 인자 없으면 --all 동일
+
+# MLX + 단일 심볼
+bash scripts/train_and_deploy.sh mlx --symbol DOGEUSDT
+```
+
+## 구현 순서
+
+각 단계마다 기존 XRP 단일 모드로 테스트 가능하도록 점진적 전환:
+
+1. **Config** — `symbols` 리스트, `max_same_direction` 추가
+2. **RiskManager** — 공유 싱글턴, asyncio.Lock, 동일 방향 제한
+3. **exchange.py** — `config.symbol` → `self.symbol` 분리
+4. **bot.py** — 생성자에 `symbol`, `risk` 파라미터 추가, `config.symbol` 제거
+5. **main.py** — 심볼별 봇 인스턴스 생성 + `asyncio.gather()`
+6. **학습 스크립트** — `--symbol`/`--all` CLI, 디렉토리 분리
+
+## 변경 불필요한 컴포넌트
+
+- `src/indicators.py` — 이미 심볼에 독립적
+- `src/notifier.py` — 이미 symbol 파라미터 수용
+- `src/user_data_stream.py` — 이미 심볼별 필터링 지원
+- `src/ml_features.py` — 이미 primary + auxiliary 구조
+- `src/label_builder.py` — 이미 범용적

docs/plans/2026-03-05-multi-symbol-trading-plan.md

@@ -0,0 +1,920 @@
+# Multi-Symbol Trading Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** XRP 단일 심볼 거래 봇을 TRX·DOGE 등 다중 심볼 동시 거래로 확장한다.
+
+**Architecture:** 심볼별 독립 TradingBot 인스턴스를 `asyncio.gather()`로 병렬 실행. RiskManager만 공유 싱글턴으로 글로벌 리스크(일일 손실 한도, 동일 방향 제한)를 관리한다. 각 봇은 자기 심볼을 직접 소유하고, `config.symbol` 의존을 완전 제거한다.
+
+**Tech Stack:** Python asyncio, LightGBM, ONNX, Binance Futures API
+
+**Design Doc:** `docs/plans/2026-03-05-multi-symbol-trading-design.md`
+
+---
+
+## Task 1: Config — `symbols` 리스트 추가, `symbol` 필드 유지(하위호환)
+
+**Files:**
+- Modify: `src/config.py`
+- Modify: `tests/test_config.py`
+- Modify: `.env.example`
+
+**Step 1: Write the failing tests**
+
+`tests/test_config.py`에 다음 테스트를 추가:
+
+```python
+def test_config_loads_symbols_list():
+    """SYMBOLS 환경변수로 쉼표 구분 리스트를 로드한다."""
+    os.environ["SYMBOLS"] = "XRPUSDT,TRXUSDT,DOGEUSDT"
+    os.environ.pop("SYMBOL", None)
+    cfg = Config()
+    assert cfg.symbols == ["XRPUSDT", "TRXUSDT", "DOGEUSDT"]
+
+
+def test_config_fallback_to_symbol():
+    """SYMBOLS 미설정 시 SYMBOL에서 1개짜리 리스트로 변환한다."""
+    os.environ.pop("SYMBOLS", None)
+    os.environ["SYMBOL"] = "XRPUSDT"
+    cfg = Config()
+    assert cfg.symbols == ["XRPUSDT"]
+
+
+def test_config_correlation_symbols():
+    """상관관계 심볼 로드."""
+    os.environ["CORRELATION_SYMBOLS"] = "BTCUSDT,ETHUSDT"
+    cfg = Config()
+    assert cfg.correlation_symbols == ["BTCUSDT", "ETHUSDT"]
+
+
+def test_config_max_same_direction_default():
+    """동일 방향 최대 수 기본값 2."""
+    cfg = Config()
+    assert cfg.max_same_direction == 2
+```
+
+**Step 2: Run tests to verify they fail**
+
+Run: `pytest tests/test_config.py -v`
+Expected: FAIL — `Config` has no `symbols`, `correlation_symbols`, `max_same_direction` attributes
+
+**Step 3: Implement Config changes**
+
+`src/config.py`를 수정:
+
+```python
+@dataclass
+class Config:
+    api_key: str = ""
+    api_secret: str = ""
+    symbol: str = "XRPUSDT"
+    symbols: list = None          # NEW
+    correlation_symbols: list = None  # NEW
+    leverage: int = 10
+    max_positions: int = 3
+    max_same_direction: int = 2   # NEW
+    stop_loss_pct: float = 0.015
+    take_profit_pct: float = 0.045
+    trailing_stop_pct: float = 0.01
+    discord_webhook_url: str = ""
+    margin_max_ratio: float = 0.50
+    margin_min_ratio: float = 0.20
+    margin_decay_rate: float = 0.0006
+    ml_threshold: float = 0.55
+
+    def __post_init__(self):
+        self.api_key = os.getenv("BINANCE_API_KEY", "")
+        self.api_secret = os.getenv("BINANCE_API_SECRET", "")
+        self.symbol = os.getenv("SYMBOL", "XRPUSDT")
+        self.leverage = int(os.getenv("LEVERAGE", "10"))
+        self.discord_webhook_url = os.getenv("DISCORD_WEBHOOK_URL", "")
+        self.margin_max_ratio = float(os.getenv("MARGIN_MAX_RATIO", "0.50"))
+        self.margin_min_ratio = float(os.getenv("MARGIN_MIN_RATIO", "0.20"))
+        self.margin_decay_rate = float(os.getenv("MARGIN_DECAY_RATE", "0.0006"))
+        self.ml_threshold = float(os.getenv("ML_THRESHOLD", "0.55"))
+        self.max_same_direction = int(os.getenv("MAX_SAME_DIRECTION", "2"))
+
+        # symbols: SYMBOLS 환경변수 우선, 없으면 SYMBOL에서 변환
+        symbols_env = os.getenv("SYMBOLS", "")
+        if symbols_env:
+            self.symbols = [s.strip() for s in symbols_env.split(",") if s.strip()]
+        else:
+            self.symbols = [self.symbol]
+
+        # correlation_symbols
+        corr_env = os.getenv("CORRELATION_SYMBOLS", "BTCUSDT,ETHUSDT")
+        self.correlation_symbols = [s.strip() for s in corr_env.split(",") if s.strip()]
+```
+
+`.env.example`에 추가:
+
+```
+SYMBOLS=XRPUSDT
+CORRELATION_SYMBOLS=BTCUSDT,ETHUSDT
+MAX_SAME_DIRECTION=2
+```
+
+**Step 4: Run tests to verify they pass**
+
+Run: `pytest tests/test_config.py -v`
+Expected: ALL PASS
+
+**Step 5: Run full test suite to verify no regressions**
+
+Run: `bash scripts/run_tests.sh`
+Expected: ALL PASS (기존 코드는 `config.symbol`을 여전히 사용 가능하므로 깨지지 않음)
+
+**Step 6: Commit**
+
+```bash
+git add src/config.py tests/test_config.py .env.example
+git commit -m "feat: add multi-symbol config (symbols list, correlation_symbols, max_same_direction)"
+```
+
+---
+
+## Task 2: RiskManager — 공유 싱글턴, asyncio.Lock, 동일 방향 제한
+
+**Files:**
+- Modify: `src/risk_manager.py`
+- Modify: `tests/test_risk_manager.py`
+
+**Step 1: Write the failing tests**
+
+`tests/test_risk_manager.py`에 추가:
+
+```python
+import asyncio
+
+
+@pytest.fixture
+def shared_risk(config):
+    config.max_same_direction = 2
+    return RiskManager(config)
+
+
+@pytest.mark.asyncio
+async def test_can_open_new_position_async(shared_risk):
+    """비동기 포지션 오픈 허용 체크."""
+    assert await shared_risk.can_open_new_position("XRPUSDT", "LONG") is True
+
+
+@pytest.mark.asyncio
+async def test_register_and_close_position(shared_risk):
+    """포지션 등록 후 닫기."""
+    await shared_risk.register_position("XRPUSDT", "LONG")
+    assert "XRPUSDT" in shared_risk.open_positions
+    await shared_risk.close_position("XRPUSDT", pnl=1.5)
+    assert "XRPUSDT" not in shared_risk.open_positions
+    assert shared_risk.daily_pnl == 1.5
+
+
+@pytest.mark.asyncio
+async def test_same_symbol_blocked(shared_risk):
+    """같은 심볼 중복 진입 차단."""
+    await shared_risk.register_position("XRPUSDT", "LONG")
+    assert await shared_risk.can_open_new_position("XRPUSDT", "SHORT") is False
+
+
+@pytest.mark.asyncio
+async def test_max_same_direction_limit(shared_risk):
+    """같은 방향 2개 초과 차단."""
+    await shared_risk.register_position("XRPUSDT", "LONG")
+    await shared_risk.register_position("TRXUSDT", "LONG")
+    # 3번째 LONG 차단
+    assert await shared_risk.can_open_new_position("DOGEUSDT", "LONG") is False
+    # SHORT은 허용
+    assert await shared_risk.can_open_new_position("DOGEUSDT", "SHORT") is True
+
+
+@pytest.mark.asyncio
+async def test_max_positions_global_limit(shared_risk):
+    """전체 포지션 수 한도 초과 차단."""
+    shared_risk.config.max_positions = 2
+    await shared_risk.register_position("XRPUSDT", "LONG")
+    await shared_risk.register_position("TRXUSDT", "SHORT")
+    assert await shared_risk.can_open_new_position("DOGEUSDT", "LONG") is False
+```
+
+**Step 2: Run tests to verify they fail**
+
+Run: `pytest tests/test_risk_manager.py -v -k "async or register or same_direction"`
+Expected: FAIL — `can_open_new_position`이 sync이고 파라미터가 없음
+
+**Step 3: Implement RiskManager changes**
+
+`src/risk_manager.py` 전체 교체:
+
+```python
+import asyncio
+from loguru import logger
+from src.config import Config
+
+
+class RiskManager:
+    def __init__(self, config: Config, max_daily_loss_pct: float = 0.05):
+        self.config = config
+        self.max_daily_loss_pct = max_daily_loss_pct
+        self.daily_pnl: float = 0.0
+        self.initial_balance: float = 0.0
+        self.open_positions: dict[str, str] = {}  # {symbol: side}
+        self._lock = asyncio.Lock()
+
+    def is_trading_allowed(self) -> bool:
+        """일일 최대 손실 초과 시 거래 중단"""
+        if self.initial_balance <= 0:
+            return True
+        loss_pct = abs(self.daily_pnl) / self.initial_balance
+        if self.daily_pnl < 0 and loss_pct >= self.max_daily_loss_pct:
+            logger.warning(
+                f"일일 손실 한도 초과: {loss_pct:.2%} >= {self.max_daily_loss_pct:.2%}"
+            )
+            return False
+        return True
+
+    async def can_open_new_position(self, symbol: str, side: str) -> bool:
+        """포지션 오픈 가능 여부 (전체 한도 + 중복 진입 + 동일 방향 제한)"""
+        async with self._lock:
+            if len(self.open_positions) >= self.config.max_positions:
+                logger.info(f"최대 포지션 수 도달: {len(self.open_positions)}/{self.config.max_positions}")
+                return False
+            if symbol in self.open_positions:
+                logger.info(f"{symbol} 이미 포지션 보유 중")
+                return False
+            same_dir = sum(1 for s in self.open_positions.values() if s == side)
+            if same_dir >= self.config.max_same_direction:
+                logger.info(f"동일 방향({side}) 한도 도달: {same_dir}/{self.config.max_same_direction}")
+                return False
+            return True
+
+    async def register_position(self, symbol: str, side: str):
+        """포지션 등록"""
+        async with self._lock:
+            self.open_positions[symbol] = side
+            logger.info(f"포지션 등록: {symbol} {side} (현재 {len(self.open_positions)}개)")
+
+    async def close_position(self, symbol: str, pnl: float):
+        """포지션 닫기 + PnL 기록"""
+        async with self._lock:
+            self.open_positions.pop(symbol, None)
+            self.daily_pnl += pnl
+            logger.info(f"포지션 종료: {symbol}, PnL={pnl:+.4f}, 누적={self.daily_pnl:+.4f}")
+
+    def record_pnl(self, pnl: float):
+        self.daily_pnl += pnl
+        logger.info(f"오늘 누적 PnL: {self.daily_pnl:.4f} USDT")
+
+    def reset_daily(self):
+        """매일 자정 초기화"""
+        self.daily_pnl = 0.0
+        logger.info("일일 PnL 초기화")
+
+    def set_base_balance(self, balance: float) -> None:
+        """봇 시작 시 기준 잔고 설정"""
+        self.initial_balance = balance
+
+    def get_dynamic_margin_ratio(self, balance: float) -> float:
+        """잔고에 따라 선형 감소하는 증거금 비율 반환"""
+        ratio = self.config.margin_max_ratio - (
+            (balance - self.initial_balance) * self.config.margin_decay_rate
+        )
+        return max(self.config.margin_min_ratio, min(self.config.margin_max_ratio, ratio))
+```
+
+주요 변경:
+- `open_positions: list` → `dict[str, str]` (심볼→방향 매핑)
+- `can_open_new_position()` → `async` + `symbol`, `side` 파라미터
+- `register_position()`, `close_position()` 새 메서드 추가
+- `asyncio.Lock()` 동시성 보호
+
+**Step 4: Fix existing tests that break**
+
+기존 테스트에서 `can_open_new_position()` 호출 방식이 바뀌었으므로 수정:
+
+`tests/test_risk_manager.py`의 `test_position_size_capped`를 수정:
+
+```python
+@pytest.mark.asyncio
+async def test_position_size_capped(config):
+    rm = RiskManager(config, max_daily_loss_pct=0.05)
+    await rm.register_position("XRPUSDT", "LONG")
+    await rm.register_position("TRXUSDT", "SHORT")
+    await rm.register_position("DOGEUSDT", "LONG")
+    assert await rm.can_open_new_position("SOLUSDT", "SHORT") is False
+```
+
+**Step 5: Run tests to verify they pass**
+
+Run: `pytest tests/test_risk_manager.py -v`
+Expected: ALL PASS
+
+**Step 6: Run full test suite**
+
+Run: `bash scripts/run_tests.sh`
+Expected: `test_bot.py`에서 `can_open_new_position()` 호출이 깨질 수 있음 — Task 4에서 수정할 것이므로 지금은 bot 테스트 실패 허용
+
+**Step 7: Commit**
+
+```bash
+git add src/risk_manager.py tests/test_risk_manager.py
+git commit -m "feat: shared RiskManager with async lock, same-direction limit, per-symbol tracking"
+```
+
+---
+
+## Task 3: Exchange — `config.symbol` → `self.symbol` 분리
+
+**Files:**
+- Modify: `src/exchange.py`
+- Modify: `tests/test_exchange.py`
+
+**Step 1: Write the failing test**
+
+`tests/test_exchange.py`에 추가:
+
+```python
+def test_exchange_uses_own_symbol():
+    """Exchange 클라이언트가 config.symbol 대신 생성자의 symbol을 사용한다."""
+    os.environ.update({
+        "BINANCE_API_KEY": "test_key",
+        "BINANCE_API_SECRET": "test_secret",
+        "SYMBOL": "XRPUSDT",
+    })
+    config = Config()
+    with patch("src.exchange.Client"):
+        client = BinanceFuturesClient(config, symbol="TRXUSDT")
+    assert client.symbol == "TRXUSDT"
+```
+
+**Step 2: Run test to verify it fails**
+
+Run: `pytest tests/test_exchange.py::test_exchange_uses_own_symbol -v`
+Expected: FAIL — `__init__` doesn't accept `symbol` parameter
+
+**Step 3: Implement Exchange changes**
+
+`src/exchange.py` 생성자 변경:
+
+```python
+class BinanceFuturesClient:
+    def __init__(self, config: Config, symbol: str = None):
+        self.config = config
+        self.symbol = symbol or config.symbol
+        self.client = Client(
+            api_key=config.api_key,
+            api_secret=config.api_secret,
+        )
+```
+
+모든 `self.config.symbol` 참조를 `self.symbol`로 교체 (9곳):
+- Line 34: `set_leverage` → `symbol=self.symbol`
+- Line 71: `place_order` params → `symbol=self.symbol`
+- Line 101: `_place_algo_order` params → `symbol=self.symbol`
+- Line 123: `get_position` → `symbol=self.symbol`
+- Line 137: `cancel_all_orders` 일반 → `symbol=self.symbol`
+- Line 144: `cancel_all_orders` algo → `symbol=self.symbol`
+- Line 156: `get_open_interest` → `symbol=self.symbol`
+- Line 169: `get_funding_rate` → `symbol=self.symbol`
+- Line 183: `get_oi_history` → `symbol=self.symbol`
+
+**Step 4: Fix existing test fixtures**
+
+기존 `exchange` 픽스처에서 `BinanceFuturesClient.__new__`를 사용하는 곳에 `c.symbol` 설정 추가:
+
+```python
+@pytest.fixture
+def client():
+    config = Config()
+    config.leverage = 10
+    c = BinanceFuturesClient.__new__(BinanceFuturesClient)
+    c.config = config
+    c.symbol = config.symbol  # NEW
+    return c
+
+
+@pytest.fixture
+def exchange():
+    os.environ.update({
+        "BINANCE_API_KEY": "test_key",
+        "BINANCE_API_SECRET": "test_secret",
+        "SYMBOL": "XRPUSDT",
+        "LEVERAGE": "10",
+    })
+    config = Config()
+    c = BinanceFuturesClient.__new__(BinanceFuturesClient)
+    c.config = config
+    c.symbol = config.symbol  # NEW
+    c.client = MagicMock()
+    return c
+```
+
+**Step 5: Run tests to verify they pass**
+
+Run: `pytest tests/test_exchange.py -v`
+Expected: ALL PASS
+
+**Step 6: Commit**
+
+```bash
+git add src/exchange.py tests/test_exchange.py
+git commit -m "feat: exchange client accepts explicit symbol parameter, removes config.symbol dependency"
+```
+
+---
+
+## Task 4: TradingBot — 생성자에 `symbol`, `risk` 주입
+
+**Files:**
+- Modify: `src/bot.py`
+- Modify: `tests/test_bot.py`
+
+**Step 1: Write the failing tests**
+
+`tests/test_bot.py`에 추가:
+
+```python
+def test_bot_accepts_symbol_and_risk(config):
+    """TradingBot이 symbol과 risk를 외부에서 주입받을 수 있다."""
+    from src.risk_manager import RiskManager
+    risk = RiskManager(config)
+    with patch("src.bot.BinanceFuturesClient"):
+        bot = TradingBot(config, symbol="TRXUSDT", risk=risk)
+    assert bot.symbol == "TRXUSDT"
+    assert bot.risk is risk
+
+
+def test_bot_stream_uses_injected_symbol(config):
+    """봇의 stream이 주입된 심볼을 primary로 사용한다."""
+    from src.risk_manager import RiskManager
+    risk = RiskManager(config)
+    with patch("src.bot.BinanceFuturesClient"):
+        bot = TradingBot(config, symbol="DOGEUSDT", risk=risk)
+    assert "dogeusdt" in bot.stream.buffers
+
+
+def test_bot_ml_filter_uses_symbol_model_dir(config):
+    """봇의 MLFilter가 심볼별 모델 디렉토리를 사용한다."""
+    from src.risk_manager import RiskManager
+    risk = RiskManager(config)
+    with patch("src.bot.BinanceFuturesClient"):
+        bot = TradingBot(config, symbol="TRXUSDT", risk=risk)
+    assert "trxusdt" in str(bot.ml_filter._onnx_path)
+    assert "trxusdt" in str(bot.ml_filter._lgbm_path)
+```
+
+**Step 2: Run tests to verify they fail**
+
+Run: `pytest tests/test_bot.py -v -k "accepts_symbol or injected_symbol or symbol_model_dir"`
+Expected: FAIL — `TradingBot.__init__` doesn't accept `symbol` or `risk`
+
+**Step 3: Implement TradingBot changes**
+
+`src/bot.py`의 `__init__` 변경:
+
+```python
+class TradingBot:
+    def __init__(self, config: Config, symbol: str = None, risk: RiskManager = None):
+        self.config = config
+        self.symbol = symbol or config.symbol
+        self.exchange = BinanceFuturesClient(config, symbol=self.symbol)
+        self.notifier = DiscordNotifier(config.discord_webhook_url)
+        self.risk = risk or RiskManager(config)
+        self.ml_filter = MLFilter(
+            onnx_path=f"models/{self.symbol.lower()}/mlx_filter.weights.onnx",
+            lgbm_path=f"models/{self.symbol.lower()}/lgbm_filter.pkl",
+            threshold=config.ml_threshold,
+        )
+        self.current_trade_side: str | None = None
+        self._entry_price: float | None = None
+        self._entry_quantity: float | None = None
+        self._is_reentering: bool = False
+        self._prev_oi: float | None = None
+        self._oi_history: deque = deque(maxlen=5)
+        self._latest_ret_1: float = 0.0
+        self.stream = MultiSymbolStream(
+            symbols=[self.symbol] + config.correlation_symbols,
+            interval="15m",
+            on_candle=self._on_candle_closed,
+        )
+```
+
+`_on_candle_closed` 변경:
+
+```python
+    async def _on_candle_closed(self, candle: dict):
+        primary_df = self.stream.get_dataframe(self.symbol)
+        btc_df = self.stream.get_dataframe("BTCUSDT")
+        eth_df = self.stream.get_dataframe("ETHUSDT")
+        if primary_df is not None:
+            await self.process_candle(primary_df, btc_df=btc_df, eth_df=eth_df)
+```
+
+`process_candle`에서 `can_open_new_position` 호출 변경 (2곳):
+
+```python
+# Line ~138 (신규 진입):
+if not await self.risk.can_open_new_position(self.symbol, raw_signal):
+    logger.info(f"[{self.symbol}] 포지션 오픈 불가")
+    return
+
+# Line ~322 (_close_and_reenter 내):
+if not await self.risk.can_open_new_position(self.symbol, signal):
+    logger.info(f"[{self.symbol}] 최대 포지션 수 도달 — 재진입 건너뜀")
+    return
+```
+
+`_open_position`에서 `register_position` 호출 추가:
+
+```python
+    async def _open_position(self, signal: str, df):
+        balance = await self.exchange.get_balance()
+        # 심볼 수로 마진 균등 배분
+        num_symbols = len(self.config.symbols)
+        per_symbol_balance = balance / num_symbols
+        price = df["close"].iloc[-1]
+        margin_ratio = self.risk.get_dynamic_margin_ratio(balance)
+        quantity = self.exchange.calculate_quantity(
+            balance=per_symbol_balance, price=price,
+            leverage=self.config.leverage, margin_ratio=margin_ratio,
+        )
+        # ... 기존 로직 ...
+
+        # 포지션 등록
+        await self.risk.register_position(self.symbol, signal)
+        self.current_trade_side = signal
+        # ... 나머지 동일 ...
+```
+
+`_on_position_closed`에서 `close_position` 호출:
+
+```python
+    async def _on_position_closed(self, net_pnl, close_reason, exit_price):
+        # ... 기존 PnL 계산 로직 ...
+        await self.risk.close_position(self.symbol, net_pnl)
+        # record_pnl 제거 (close_position 내에서 처리)
+        # ... 나머지 동일 ...
+```
+
+모든 `self.config.symbol` 참조를 `self.symbol`로 교체 (6곳):
+- Line 31 → `self.symbol` (stream symbols)
+- Line 37 → `self.symbol` (get_dataframe)
+- Line 197 → `self.symbol` (notify_open)
+- Line 251 → `self.symbol` (notify_close)
+- Line 340 → `self.symbol` (run 로그)
+- Line 348 → `self.symbol` (UserDataStream)
+
+`run()` 메서드의 로그도 변경:
+
+```python
+    async def run(self):
+        logger.info(f"[{self.symbol}] 봇 시작, 레버리지 {self.config.leverage}x")
+        # ... 나머지 동일, self.config.symbol → self.symbol ...
+```
+
+**Step 4: Fix existing bot tests**
+
+기존 `tests/test_bot.py`의 모든 `TradingBot(config)` 호출은 하위호환되므로 그대로 동작.
+단, `risk.can_open_new_position` 호출이 async로 바뀌었으므로 mock 수정 필요:
+
+`test_close_and_reenter_calls_open_when_ml_passes`:
+```python
+    bot.risk = MagicMock()
+    bot.risk.can_open_new_position = AsyncMock(return_value=True)
+```
+
+`test_close_and_reenter_skips_open_when_max_positions_reached`:
+```python
+    bot.risk = MagicMock()
+    bot.risk.can_open_new_position = AsyncMock(return_value=False)
+```
+
+`test_bot_processes_signal`에서 `bot.risk`도 mock:
+```python
+    bot.risk = MagicMock()
+    bot.risk.is_trading_allowed.return_value = True
+    bot.risk.can_open_new_position = AsyncMock(return_value=True)
+    bot.risk.register_position = AsyncMock()
+    bot.risk.get_dynamic_margin_ratio.return_value = 0.50
+```
+
+**Step 5: Run tests to verify they pass**
+
+Run: `pytest tests/test_bot.py -v`
+Expected: ALL PASS
+
+**Step 6: Run full test suite**
+
+Run: `bash scripts/run_tests.sh`
+Expected: ALL PASS
+
+**Step 7: Commit**
+
+```bash
+git add src/bot.py tests/test_bot.py
+git commit -m "feat: TradingBot accepts symbol and shared RiskManager, removes config.symbol dependency"
+```
+
+---
+
+## Task 5: main.py — 심볼별 봇 인스턴스 생성 + asyncio.gather
+
+**Files:**
+- Modify: `main.py`
+
+**Step 1: Implement main.py changes**
+
+```python
+import asyncio
+from dotenv import load_dotenv
+from src.config import Config
+from src.bot import TradingBot
+from src.risk_manager import RiskManager
+from src.logger_setup import setup_logger
+from loguru import logger
+
+load_dotenv()
+
+
+async def main():
+    setup_logger(log_level="INFO")
+    config = Config()
+    risk = RiskManager(config)
+
+    bots = []
+    for symbol in config.symbols:
+        bot = TradingBot(config, symbol=symbol, risk=risk)
+        bots.append(bot)
+
+    logger.info(f"멀티심볼 봇 시작: {config.symbols} ({len(bots)}개 인스턴스)")
+    await asyncio.gather(*[bot.run() for bot in bots])
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+**Step 2: Run full test suite to verify no regressions**
+
+Run: `bash scripts/run_tests.sh`
+Expected: ALL PASS
+
+**Step 3: Commit**
+
+```bash
+git add main.py
+git commit -m "feat: main.py spawns per-symbol TradingBot instances with shared RiskManager"
+```
+
+---
+
+## Task 6: MLFilter — 심볼별 모델 디렉토리 폴백
+
+**Files:**
+- Modify: `src/ml_filter.py`
+
+**Step 1: Implement MLFilter path fallback**
+
+MLFilter는 이미 `onnx_path`/`lgbm_path`를 생성자에서 받으므로, bot.py에서 심볼별 경로를 주입하면 된다 (Task 4에서 완료).
+
+다만 기존 `models/lgbm_filter.pkl` 경로에 모델이 있는 경우(단일 심볼 환경)에도 동작하도록, 심볼별 디렉토리에 모델이 없으면 루트 `models/`에서 폴백하는 로직을 `bot.py`에 추가:
+
+`src/bot.py`의 `__init__`에서:
+
+```python
+        # 심볼별 모델 디렉토리. 없으면 기존 models/ 루트로 폴백
+        symbol_model_dir = Path(f"models/{self.symbol.lower()}")
+        if symbol_model_dir.exists():
+            onnx_path = str(symbol_model_dir / "mlx_filter.weights.onnx")
+            lgbm_path = str(symbol_model_dir / "lgbm_filter.pkl")
+        else:
+            onnx_path = "models/mlx_filter.weights.onnx"
+            lgbm_path = "models/lgbm_filter.pkl"
+        self.ml_filter = MLFilter(
+            onnx_path=onnx_path,
+            lgbm_path=lgbm_path,
+            threshold=config.ml_threshold,
+        )
+```
+
+**Step 2: Run full test suite**
+
+Run: `bash scripts/run_tests.sh`
+Expected: ALL PASS
+
+**Step 3: Commit**
+
+```bash
+git add src/bot.py
+git commit -m "feat: MLFilter falls back to models/ root if symbol-specific dir not found"
+```
+
+---
+
+## Task 7: 학습 스크립트 — `--symbol` / `--all` CLI 통일
+
+**Files:**
+- Modify: `scripts/fetch_history.py`
+- Modify: `scripts/train_model.py`
+- Modify: `scripts/tune_hyperparams.py`
+- Modify: `scripts/train_and_deploy.sh`
+- Modify: `scripts/deploy_model.sh`
+
+### Step 1: fetch_history.py — `--symbol` 단일 심볼 + 출력 경로 자동 결정
+
+`scripts/fetch_history.py`의 argparse에 `--symbol` 추가 및 `--output` 자동 결정:
+
+현재 사용법: `--symbols XRPUSDT BTCUSDT ETHUSDT --output data/combined_15m.parquet`
+
+변경 후:
+```python
+parser.add_argument("--symbol", type=str, default=None,
+                    help="단일 거래 심볼 (예: TRXUSDT). 상관관계 심볼 자동 추가")
+```
+
+`--symbol TRXUSDT` 지정 시:
+- `symbols = ["TRXUSDT", "BTCUSDT", "ETHUSDT"]`
+- `output = "data/trxusdt/combined_15m.parquet"` (자동)
+
+`--symbols XRPUSDT BTCUSDT ETHUSDT` (기존 방식)도 유지.
+
+### Step 2: train_model.py — `--symbol` 추가
+
+```python
+parser.add_argument("--symbol", type=str, default=None,
+                    help="학습 대상 심볼 (예: TRXUSDT). data/{symbol}/ 에서 데이터 로드, models/{symbol}/ 에 저장")
+```
+
+`--symbol TRXUSDT` 지정 시:
+- 데이터: `data/trxusdt/combined_15m.parquet`
+- 모델: `models/trxusdt/lgbm_filter.pkl`
+- 로그: `models/trxusdt/training_log.json`
+
+`--data` 옵션이 명시되면 그것을 우선.
+
+### Step 3: tune_hyperparams.py — `--symbol` 추가
+
+train_model.py와 동일한 패턴. `--symbol`이 지정되면:
+- 데이터: `data/{symbol}/combined_15m.parquet`
+- 결과: `models/{symbol}/tune_results_*.json`
+- active params: `models/{symbol}/active_lgbm_params.json`
+
+### Step 4: train_and_deploy.sh — `--symbol` / `--all` 지원
+
+```bash
+# 사용법:
+#   bash scripts/train_and_deploy.sh [mlx|lgbm] [--symbol TRXUSDT]
+#   bash scripts/train_and_deploy.sh [mlx|lgbm] --all
+#   bash scripts/train_and_deploy.sh              # --all과 동일 (기본값)
+```
+
+`--symbol` 지정 시: 해당 심볼만 fetch → train → deploy
+`--all` 또는 인자 없음: `SYMBOLS` 환경변수의 모든 심볼 순차 처리
+
+핵심 로직:
+```bash
+if [ -n "$SYMBOL_ARG" ]; then
+    TARGETS=("$SYMBOL_ARG")
+else
+    # .env에서 SYMBOLS 로드
+    TARGETS=($(python -c "from src.config import Config; c=Config(); print(' '.join(c.symbols))"))
+fi
+
+for SYM in "${TARGETS[@]}"; do
+    SYM_LOWER=$(echo "$SYM" | tr '[:upper:]' '[:lower:]')
+    mkdir -p "data/$SYM_LOWER" "models/$SYM_LOWER"
+
+    # fetch
+    python scripts/fetch_history.py --symbol "$SYM" ...
+
+    # train
+    python scripts/train_model.py --symbol "$SYM" ...
+
+    # deploy
+    bash scripts/deploy_model.sh "$BACKEND" --symbol "$SYM"
+done
+```
+
+### Step 5: deploy_model.sh — `--symbol` 지원
+
+```bash
+# 사용법: bash scripts/deploy_model.sh [lgbm|mlx] [--symbol TRXUSDT]
+```
+
+`--symbol` 지정 시:
+- 로컬: `models/{symbol}/lgbm_filter.pkl`
+- 원격: `$LXC_MODELS_PATH/{symbol}/lgbm_filter.pkl`
+
+### Step 6: Run full test suite
+
+Run: `bash scripts/run_tests.sh`
+Expected: ALL PASS (스크립트 변경은 unit test에 영향 없음)
+
+### Step 7: Smoke test 스크립트
+
+```bash
+# fetch만 소량 테스트
+python scripts/fetch_history.py --symbol TRXUSDT --interval 15m --days 1
+ls data/trxusdt/combined_15m.parquet  # 파일 존재 확인
+```
+
+### Step 8: Commit
+
+```bash
+git add scripts/fetch_history.py scripts/train_model.py scripts/tune_hyperparams.py scripts/train_and_deploy.sh scripts/deploy_model.sh
+git commit -m "feat: add --symbol/--all CLI to all training scripts for per-symbol pipeline"
+```
+
+---
+
+## Task 8: 디렉토리 구조 생성 + .env.example 업데이트
+
+**Files:**
+- Create: `models/xrpusdt/.gitkeep`
+- Create: `models/trxusdt/.gitkeep`
+- Create: `models/dogeusdt/.gitkeep`
+- Create: `data/xrpusdt/.gitkeep`
+- Create: `data/trxusdt/.gitkeep`
+- Create: `data/dogeusdt/.gitkeep`
+- Modify: `.env.example`
+
+**Step 1: Create directory structure**
+
+```bash
+mkdir -p models/{xrpusdt,trxusdt,dogeusdt}
+mkdir -p data/{xrpusdt,trxusdt,dogeusdt}
+touch models/{xrpusdt,trxusdt,dogeusdt}/.gitkeep
+touch data/{xrpusdt,trxusdt,dogeusdt}/.gitkeep
+```
+
+**Step 2: Update .env.example**
+
+```
+BINANCE_API_KEY=
+BINANCE_API_SECRET=
+SYMBOLS=XRPUSDT
+CORRELATION_SYMBOLS=BTCUSDT,ETHUSDT
+LEVERAGE=10
+RISK_PER_TRADE=0.02
+DISCORD_WEBHOOK_URL=
+ML_THRESHOLD=0.55
+MAX_SAME_DIRECTION=2
+BINANCE_TESTNET_API_KEY=
+BINANCE_TESTNET_API_SECRET=
+```
+
+**Step 3: Commit**
+
+```bash
+git add models/ data/ .env.example
+git commit -m "feat: add per-symbol model/data directories and update .env.example"
+```
+
+---
+
+## Task 9: 기존 모델 마이그레이션 안내 + 문서 업데이트
+
+**Files:**
+- Modify: `CLAUDE.md`
+
+**Step 1: Update CLAUDE.md**
+
+Architecture 섹션에 멀티심볼 관련 내용 추가:
+
+- `main.py` → `Config` → 심볼별 `TradingBot` 인스턴스 → `asyncio.gather()`
+- `RiskManager` 공유 싱글턴 (글로벌 일일 손실 + 동일 방향 제한)
+- 모델/데이터 디렉토리: `models/{symbol}/`, `data/{symbol}/`
+
+Common Commands 섹션 업데이트:
+
+```bash
+# 단일 심볼 학습
+bash scripts/train_and_deploy.sh --symbol TRXUSDT
+
+# 전체 심볼 학습
+bash scripts/train_and_deploy.sh --all
+```
+
+**Step 2: Commit**
+
+```bash
+git add CLAUDE.md
+git commit -m "docs: update architecture and commands for multi-symbol trading"
+```
+
+---
+
+## 구현 순서 요약
+
+| Task | 내용 | 의존성 |
+|------|------|--------|
+| 1 | Config: `symbols`, `correlation_symbols`, `max_same_direction` | 없음 |
+| 2 | RiskManager: 공유 싱글턴, async Lock, 동일 방향 제한 | Task 1 |
+| 3 | Exchange: `self.symbol` 분리 | 없음 (Task 1과 병렬 가능) |
+| 4 | TradingBot: `symbol`, `risk` 주입, `config.symbol` 제거 | Task 1, 2, 3 |
+| 5 | main.py: 심볼별 봇 생성 + gather | Task 4 |
+| 6 | MLFilter: 심볼별 모델 디렉토리 폴백 | Task 4 |
+| 7 | 학습 스크립트: `--symbol` / `--all` CLI | Task 1 |
+| 8 | 디렉토리 구조 + .env.example | 없음 |
+| 9 | 문서 업데이트 | 전체 완료 후 |
+
+각 태스크 완료 후 기존 XRP 단일 모드에서 전체 테스트를 통과해야 한다.

scripts/deploy_model.sh

@@ -1,25 +1,57 @@
 #!/usr/bin/env bash
 # 맥미니에서 학습한 모델을 LXC 컨테이너 볼륨 경로로 전송한다.
-# 사용법: bash scripts/deploy_model.sh [lgbm|mlx]
+# 사용법: bash scripts/deploy_model.sh [lgbm|mlx] [--symbol TRXUSDT]
 #
 # 예시:
-#   bash scripts/deploy_model.sh        # LightGBM (기본값)
+#   bash scripts/deploy_model.sh                    # LightGBM (기본값), models/ 루트
-#   bash scripts/deploy_model.sh mlx    # MLX 신경망
+#   bash scripts/deploy_model.sh mlx                # MLX 신경망, models/ 루트
+#   bash scripts/deploy_model.sh --symbol TRXUSDT   # LightGBM, models/trxusdt/
+#   bash scripts/deploy_model.sh mlx --symbol XRPUSDT  # MLX, models/xrpusdt/
 
 set -euo pipefail
 
-BACKEND="${1:-lgbm}"
+# ── 인자 파싱 ────────────────────────────────────────────────────────────────
+BACKEND="lgbm"
+SYMBOL_ARG=""
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --symbol)
+            SYMBOL_ARG="$2"
+            shift 2
+            ;;
+        mlx|lgbm)
+            BACKEND="$1"
+            shift
+            ;;
+        *)
+            shift
+            ;;
+    esac
+done
+
 LXC_HOST="root@10.1.10.24"
 LXC_MODELS_PATH="/root/cointrader/models"
-LOCAL_LOG="models/training_log.json"
+
+# ── 심볼별 경로 결정 ─────────────────────────────────────────────────────────
+if [ -n "$SYMBOL_ARG" ]; then
+    SYM_LOWER=$(echo "$SYMBOL_ARG" | tr '[:upper:]' '[:lower:]')
+    LOCAL_MODEL_DIR="models/$SYM_LOWER"
+    REMOTE_MODEL_DIR="$LXC_MODELS_PATH/$SYM_LOWER"
+    LOCAL_LOG="models/$SYM_LOWER/training_log.json"
+else
+    LOCAL_MODEL_DIR="models"
+    REMOTE_MODEL_DIR="$LXC_MODELS_PATH"
+    LOCAL_LOG="models/training_log.json"
+fi
 
 # ── 백엔드별 파일 목록 설정 ──────────────────────────────────────────────────
 # mlx: ONNX 파일만 전송 (Linux 서버는 onnxruntime으로 추론)
 # lgbm: pkl 파일 전송
 if [ "$BACKEND" = "mlx" ]; then
-  LOCAL_FILES=("models/mlx_filter.weights.onnx")
+  LOCAL_FILES=("$LOCAL_MODEL_DIR/mlx_filter.weights.onnx")
 else
-  LOCAL_FILES=("models/lgbm_filter.pkl")
+  LOCAL_FILES=("$LOCAL_MODEL_DIR/lgbm_filter.pkl")
 fi
 
 # ── 파일 존재 확인 ────────────────────────────────────────────────────────────
@@ -30,26 +62,26 @@ for f in "${LOCAL_FILES[@]}"; do
   fi
 done
 
-echo "=== 모델 전송 시작 (백엔드: ${BACKEND}) ==="
+echo "=== 모델 전송 시작 (백엔드: ${BACKEND}${SYMBOL_ARG:+, 심볼: $SYMBOL_ARG}) ==="
-echo "  대상: ${LXC_HOST}:${LXC_MODELS_PATH}"
+echo "  대상: ${LXC_HOST}:${REMOTE_MODEL_DIR}"
 
 # ── 원격 디렉터리 생성 + 백업 + 상대 백엔드 파일 제거 ───────────────────────
 # lgbm 배포 시: 기존 lgbm 백업 후 ONNX 파일 삭제 (ONNX 우선순위 때문에 lgbm이 무시되는 것 방지)
 # mlx 배포 시: lgbm 파일 삭제 (명시적으로 mlx만 사용)
 ssh "${LXC_HOST}" "
-  mkdir -p '${LXC_MODELS_PATH}'
+  mkdir -p '${REMOTE_MODEL_DIR}'
   if [ '$BACKEND' = 'lgbm' ]; then
-    if [ -f '${LXC_MODELS_PATH}/lgbm_filter.pkl' ]; then
+    if [ -f '${REMOTE_MODEL_DIR}/lgbm_filter.pkl' ]; then
-      cp '${LXC_MODELS_PATH}/lgbm_filter.pkl' '${LXC_MODELS_PATH}/lgbm_filter_prev.pkl'
+      cp '${REMOTE_MODEL_DIR}/lgbm_filter.pkl' '${REMOTE_MODEL_DIR}/lgbm_filter_prev.pkl'
       echo '  기존 lgbm 모델 백업 완료'
     fi
-    if [ -f '${LXC_MODELS_PATH}/mlx_filter.weights.onnx' ]; then
+    if [ -f '${REMOTE_MODEL_DIR}/mlx_filter.weights.onnx' ]; then
-      rm '${LXC_MODELS_PATH}/mlx_filter.weights.onnx'
+      rm '${REMOTE_MODEL_DIR}/mlx_filter.weights.onnx'
       echo '  ONNX 파일 제거 완료 (lgbm 우선 적용)'
     fi
   else
-    if [ -f '${LXC_MODELS_PATH}/lgbm_filter.pkl' ]; then
+    if [ -f '${REMOTE_MODEL_DIR}/lgbm_filter.pkl' ]; then
-      rm '${LXC_MODELS_PATH}/lgbm_filter.pkl'
+      rm '${REMOTE_MODEL_DIR}/lgbm_filter.pkl'
       echo '  lgbm 파일 제거 완료 (mlx 우선 적용)'
     fi
   fi
@@ -68,12 +100,12 @@ _send() {
 
 # ── 모델 파일 전송 ────────────────────────────────────────────────────────────
 for f in "${LOCAL_FILES[@]}"; do
-  _send "$f" "${LXC_MODELS_PATH}/$(basename "$f")"
+  _send "$f" "${REMOTE_MODEL_DIR}/$(basename "$f")"
 done
 
 # ── 학습 로그 전송 ────────────────────────────────────────────────────────────
 if [[ -f "$LOCAL_LOG" ]]; then
-  _send "$LOCAL_LOG" "${LXC_MODELS_PATH}/training_log.json"
+  _send "$LOCAL_LOG" "${REMOTE_MODEL_DIR}/training_log.json"
   echo "  학습 로그 전송 완료"
 fi
 

scripts/fetch_history.py

@@ -333,9 +333,22 @@ def main():
     )
     args = parser.parse_args()
 
-    # 하위 호환: --symbol 단독 사용 시 symbols로 통합
+    # --symbol 모드: 단일 거래 심볼 + 상관관계 심볼 자동 추가, 출력 경로 자동 결정
-    if args.symbol and args.symbols == ["XRPUSDT"]:
+    if args.symbol:
-        args.symbols = [args.symbol]
+        from src.config import Config
+        try:
+            cfg = Config()
+            corr_symbols = cfg.correlation_symbols
+        except Exception:
+            corr_symbols = ["BTCUSDT", "ETHUSDT"]
+        args.symbols = [args.symbol] + corr_symbols
+        if args.output == "data/combined_15m.parquet":
+            sym_lower = args.symbol.lower()
+            os.makedirs(f"data/{sym_lower}", exist_ok=True)
+            args.output = f"data/{sym_lower}/combined_15m.parquet"
+    # 하위 호환: 단일 심볼만 지정된 경우
+    elif args.symbols == ["XRPUSDT"] and not args.symbol:
+        pass  # 기본값 유지
 
     if len(args.symbols) == 1:
         df = asyncio.run(fetch_klines(args.symbols[0], args.interval, args.days))

scripts/train_and_deploy.sh

@@ -1,13 +1,14 @@
 #!/usr/bin/env bash
 # 맥미니에서 전체 학습 파이프라인을 실행하고 LXC로 배포한다.
-# 사용법: bash scripts/train_and_deploy.sh [mlx|lgbm] [wf-splits]
+# 사용법: bash scripts/train_and_deploy.sh [mlx|lgbm] [--symbol TRXUSDT] [--all] [wf-splits]
 #
 # 예시:
-#   bash scripts/train_and_deploy.sh             # LightGBM + Walk-Forward 5폴드 (기본값)
+#   bash scripts/train_and_deploy.sh                        # 전체 심볼 (SYMBOLS 환경변수) + LightGBM
-#   bash scripts/train_and_deploy.sh mlx         # MLX GPU 학습 + Walk-Forward 5폴드
+#   bash scripts/train_and_deploy.sh --symbol TRXUSDT       # TRXUSDT만 학습+배포
-#   bash scripts/train_and_deploy.sh lgbm 3      # LightGBM + Walk-Forward 3폴드
+#   bash scripts/train_and_deploy.sh mlx --symbol TRXUSDT   # MLX + TRXUSDT만
-#   bash scripts/train_and_deploy.sh mlx 0       # MLX 학습만 (Walk-Forward 건너뜀)
+#   bash scripts/train_and_deploy.sh --all                  # 전체 심볼 순차 처리
-#   bash scripts/train_and_deploy.sh lgbm 0      # LightGBM 학습만 (Walk-Forward 건너뜀)
+#   bash scripts/train_and_deploy.sh lgbm 3                 # 전체 심볼 + Walk-Forward 3폴드
+#   bash scripts/train_and_deploy.sh mlx 0                  # 전체 심볼 + MLX 학습만 (WF 건너뜀)
 
 set -euo pipefail
 
@@ -26,77 +27,132 @@ else
     echo "경고: 가상환경을 찾을 수 없습니다 ($VENV_PATH). 시스템 Python을 사용합니다." >&2
 fi
 
-BACKEND="${1:-lgbm}"
-WF_SPLITS="${2:-5}"   # 두 번째 인자: Walk-Forward 폴드 수 (0이면 건너뜀)
-
 cd "$PROJECT_ROOT"
 
-mkdir -p data
+# ── 인자 파싱 ───────────────────────────────────────────────────────────────
+BACKEND="lgbm"
+WF_SPLITS="5"
+SYMBOL_ARG=""
+ALL_FLAG=false
 
-PARQUET_FILE="data/combined_15m.parquet"
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --symbol)
+            SYMBOL_ARG="$2"
+            shift 2
+            ;;
+        --all)
+            ALL_FLAG=true
+            shift
+            ;;
+        mlx|lgbm)
+            BACKEND="$1"
+            shift
+            ;;
+        *)
+            # 숫자면 WF_SPLITS로 처리
+            if [[ "$1" =~ ^[0-9]+$ ]]; then
+                WF_SPLITS="$1"
+            fi
+            shift
+            ;;
+    esac
+done
 
-echo ""
+# ── 대상 심볼 결정 ──────────────────────────────────────────────────────────
-echo "========================================"
+if [ -n "$SYMBOL_ARG" ]; then
-echo "  학습 파이프라인 시작: $(date '+%Y-%m-%d %H:%M:%S %Z')"
+    TARGETS=("$SYMBOL_ARG")
-echo "========================================"
-echo ""
-
-echo "=== [1/3] 데이터 수집 (XRP + BTC + ETH 3심볼 + OI/펀딩비) ==="
-if [ ! -f "$PARQUET_FILE" ]; then
-    echo "  [최초 실행] 기존 데이터 없음 → 1년치(365일) 전체 수집 (--no-upsert)"
-    FETCH_DAYS=365
-    UPSERT_FLAG="--no-upsert"
 else
-    echo "  [일반 실행] 기존 데이터 존재 → 35일치 Upsert (OI/펀딩비 0.0 구간 보충)"
+    # .env에서 SYMBOLS 로드 (없으면 XRPUSDT 기본값)
-    FETCH_DAYS=35
+    TARGETS=($(python -c "from dotenv import load_dotenv; load_dotenv(); from src.config import Config; c=Config(); print(' '.join(c.symbols))"))
-    UPSERT_FLAG=""
 fi
 
-python scripts/fetch_history.py \
-    --symbols XRPUSDT BTCUSDT ETHUSDT \
-    --interval 15m \
-    --days "$FETCH_DAYS" \
-    $UPSERT_FLAG \
-    --output "$PARQUET_FILE"
-
 DECAY="${TIME_WEIGHT_DECAY:-2.0}"
 
 echo ""
-echo "=== [1.5/3] OI 파생 피처 A/B 비교 ==="
+echo "========================================"
-python scripts/train_model.py --compare --data "$PARQUET_FILE" --decay "$DECAY" || true
+echo "  학습 파이프라인 시작: $(date '+%Y-%m-%d %H:%M:%S %Z')"
-
+echo "  대상 심볼: ${TARGETS[*]}"
+echo "  백엔드: ${BACKEND}, WF 폴드: ${WF_SPLITS}"
+echo "========================================"
 echo ""
-echo "=== [2/3] 모델 학습 (26개 피처: XRP 13 + BTC/ETH 8 + OI/펀딩비 2 + OI파생 2 + ADX) ==="
-if [ "$BACKEND" = "mlx" ]; then
-    echo "  백엔드: MLX (Apple Silicon GPU), decay=${DECAY}"
-    python scripts/train_mlx_model.py --data data/combined_15m.parquet --decay "$DECAY"
-else
-    echo "  백엔드: LightGBM (CPU), decay=${DECAY}"
-    python scripts/train_model.py --data data/combined_15m.parquet --decay "$DECAY"
-fi
 
-# Walk-Forward 검증 (WF_SPLITS > 0 인 경우)
+# ── 심볼별 파이프라인 ───────────────────────────────────────────────────────
-if [ "$WF_SPLITS" -gt 0 ] 2>/dev/null; then
+for SYM in "${TARGETS[@]}"; do
+    SYM_LOWER=$(echo "$SYM" | tr '[:upper:]' '[:lower:]')
+    mkdir -p "data/$SYM_LOWER" "models/$SYM_LOWER"
+
+    PARQUET_FILE="data/$SYM_LOWER/combined_15m.parquet"
+
     echo ""
-    echo "=== [2.5/3] Walk-Forward 검증 (${WF_SPLITS}폴드) ==="
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    if [ "$BACKEND" = "mlx" ]; then
+    echo "  [$SYM] 파이프라인 시작"
-        python scripts/train_mlx_model.py \
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-            --data data/combined_15m.parquet \
-            --decay "$DECAY" \
-            --wf \
-            --wf-splits "$WF_SPLITS"
-    else
-        python scripts/train_model.py \
-            --data data/combined_15m.parquet \
-            --decay "$DECAY" \
-            --wf \
-            --wf-splits "$WF_SPLITS"
-    fi
-fi
 
-echo ""
+    # === [1/3] 데이터 수집 ===
-echo "=== [3/3] LXC 배포 ==="
+    echo ""
-bash scripts/deploy_model.sh "$BACKEND"
+    echo "=== [$SYM] [1/3] 데이터 수집 (+ BTC/ETH 상관관계 + OI/펀딩비) ==="
+    if [ ! -f "$PARQUET_FILE" ]; then
+        echo "  [최초 실행] 기존 데이터 없음 → 1년치(365일) 전체 수집 (--no-upsert)"
+        FETCH_DAYS=365
+        UPSERT_FLAG="--no-upsert"
+    else
+        echo "  [일반 실행] 기존 데이터 존재 → 35일치 Upsert (OI/펀딩비 0.0 구간 보충)"
+        FETCH_DAYS=35
+        UPSERT_FLAG=""
+    fi
+
+    python scripts/fetch_history.py \
+        --symbol "$SYM" \
+        --interval 15m \
+        --days "$FETCH_DAYS" \
+        $UPSERT_FLAG
+
+    # === [1.5/3] OI 파생 피처 A/B 비교 ===
+    echo ""
+    echo "=== [$SYM] [1.5/3] OI 파생 피처 A/B 비교 ==="
+    python scripts/train_model.py --compare --symbol "$SYM" --decay "$DECAY" || true
+
+    # === [2/3] 모델 학습 ===
+    echo ""
+    echo "=== [$SYM] [2/3] 모델 학습 ==="
+    if [ "$BACKEND" = "mlx" ]; then
+        echo "  백엔드: MLX (Apple Silicon GPU), decay=${DECAY}"
+        python scripts/train_mlx_model.py --data "$PARQUET_FILE" --decay "$DECAY"
+    else
+        echo "  백엔드: LightGBM (CPU), decay=${DECAY}"
+        python scripts/train_model.py --symbol "$SYM" --decay "$DECAY"
+    fi
+
+    # Walk-Forward 검증 (WF_SPLITS > 0 인 경우)
+    if [ "$WF_SPLITS" -gt 0 ] 2>/dev/null; then
+        echo ""
+        echo "=== [$SYM] [2.5/3] Walk-Forward 검증 (${WF_SPLITS}폴드) ==="
+        if [ "$BACKEND" = "mlx" ]; then
+            python scripts/train_mlx_model.py \
+                --data "$PARQUET_FILE" \
+                --decay "$DECAY" \
+                --wf \
+                --wf-splits "$WF_SPLITS"
+        else
+            python scripts/train_model.py \
+                --symbol "$SYM" \
+                --decay "$DECAY" \
+                --wf \
+                --wf-splits "$WF_SPLITS"
+        fi
+    fi
+
+    # === [3/3] 배포 ===
+    echo ""
+    echo "=== [$SYM] [3/3] LXC 배포 ==="
+    bash scripts/deploy_model.sh "$BACKEND" --symbol "$SYM"
+
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "  [$SYM] 파이프라인 완료"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+done
 
 echo ""
 echo "=== 전체 파이프라인 완료: $(date '+%Y-%m-%d %H:%M:%S %Z') ==="

scripts/train_model.py

@@ -531,7 +531,9 @@ def compare(data_path: str, time_weight_decay: float = 2.0, tuned_params_path: s
 
 def main():
     parser = argparse.ArgumentParser()
-    parser.add_argument("--data", default="data/combined_15m.parquet")
+    parser.add_argument("--data", default=None)
+    parser.add_argument("--symbol", type=str, default=None,
+                        help="학습 대상 심볼 (예: TRXUSDT). data/{symbol}/ 에서 데이터 로드, models/{symbol}/ 에 저장")
     parser.add_argument(
         "--decay", type=float, default=2.0,
         help="시간 가중치 감쇠 강도 (0=균등, 2.0=최신이 ~7.4배 높음)",
@@ -546,6 +548,20 @@ def main():
                         help="OI 파생 피처 추가 전후 A/B 성능 비교")
     args = parser.parse_args()
 
+    # --symbol 모드: 심볼별 디렉토리 경로 자동 결정
+    if args.symbol:
+        sym_lower = args.symbol.lower()
+        if args.data is None:
+            args.data = f"data/{sym_lower}/combined_15m.parquet"
+        global MODEL_PATH, PREV_MODEL_PATH, LOG_PATH, ACTIVE_PARAMS_PATH
+        MODEL_PATH = Path(f"models/{sym_lower}/lgbm_filter.pkl")
+        PREV_MODEL_PATH = Path(f"models/{sym_lower}/lgbm_filter_prev.pkl")
+        LOG_PATH = Path(f"models/{sym_lower}/training_log.json")
+        ACTIVE_PARAMS_PATH = Path(f"models/{sym_lower}/active_lgbm_params.json")
+        MODEL_PATH.parent.mkdir(parents=True, exist_ok=True)
+    elif args.data is None:
+        args.data = "data/combined_15m.parquet"
+
     if args.compare:
         compare(args.data, time_weight_decay=args.decay, tuned_params_path=args.tuned_params)
     elif args.wf:

scripts/tune_hyperparams.py

@@ -308,9 +308,10 @@ def measure_baseline(
     n_splits: int,
     train_ratio: float,
     min_recall: float = 0.35,
+    active_params_path: "Path | None" = None,
 ) -> tuple[float, dict]:
     """현재 실전 파라미터(active 파일 또는 하드코딩 기본값)로 베이스라인을 측정한다."""
-    active_path = Path("models/active_lgbm_params.json")
+    active_path = active_params_path or Path("models/active_lgbm_params.json")
 
     if active_path.exists():
         with open(active_path, "r", encoding="utf-8") as f:
@@ -518,7 +519,9 @@ def save_results(
 
 def main():
     parser = argparse.ArgumentParser(description="Optuna LightGBM 하이퍼파라미터 튜닝")
-    parser.add_argument("--data",        default="data/combined_15m.parquet", help="학습 데이터 경로")
+    parser.add_argument("--data",        default=None, help="학습 데이터 경로")
+    parser.add_argument("--symbol",      type=str, default=None,
+                        help="튜닝 대상 심볼 (예: TRXUSDT). data/{symbol}/ 에서 데이터 로드, models/{symbol}/ 에 저장")
     parser.add_argument("--trials",      type=int,   default=50,  help="Optuna trial 수 (기본: 50)")
     parser.add_argument("--folds",       type=int,   default=5,   help="Walk-Forward 폴드 수 (기본: 5)")
     parser.add_argument("--train-ratio", type=float, default=0.6, help="학습 구간 비율 (기본: 0.6)")
@@ -526,16 +529,31 @@ def main():
     parser.add_argument("--no-baseline", action="store_true",     help="베이스라인 측정 건너뜀")
     args = parser.parse_args()
 
+    # --symbol 모드: 심볼별 디렉토리 경로 자동 결정
+    if args.symbol:
+        sym_lower = args.symbol.lower()
+        if args.data is None:
+            args.data = f"data/{sym_lower}/combined_15m.parquet"
+    elif args.data is None:
+        args.data = "data/combined_15m.parquet"
+
     # 1. 데이터셋 로드 (1회)
     X, y, w, source = load_dataset(args.data)
 
     # 2. 베이스라인 측정
+    if args.symbol:
+        sym_lower = args.symbol.lower()
+        _active_params_path = Path(f"models/{sym_lower}/active_lgbm_params.json")
+    else:
+        _active_params_path = None
+
     if args.no_baseline:
         baseline_score, baseline_details = 0.0, {}
         print("베이스라인 측정 건너뜀 (--no-baseline)\n")
     else:
         baseline_score, baseline_details = measure_baseline(
             X, y, w, source, args.folds, args.train_ratio, args.min_recall,
+            active_params_path=_active_params_path,
         )
         bl_prec = baseline_details.get("mean_precision", 0.0)
         bl_auc = baseline_details.get("mean_auc", 0.0)
@@ -593,16 +611,28 @@ def main():
     elapsed = time.time() - start_time
 
     # 4. 결과 저장 및 출력
+    import shutil
     output_path = save_results(
         study, baseline_score, baseline_details, elapsed, args.data, args.min_recall,
     )
+    # --symbol 모드: 결과 파일을 심볼별 디렉토리로 이동
+    if args.symbol:
+        sym_lower = args.symbol.lower()
+        sym_model_dir = Path(f"models/{sym_lower}")
+        sym_model_dir.mkdir(parents=True, exist_ok=True)
+        dest = sym_model_dir / output_path.name
+        shutil.move(str(output_path), str(dest))
+        output_path = dest
     print_report(
         study, baseline_score, baseline_details, elapsed, output_path, args.min_recall,
     )
 
     # 5. 성능 개선 시 active 파일 자동 갱신
-    import shutil
+    if args.symbol:
-    active_path = Path("models/active_lgbm_params.json")
+        sym_lower = args.symbol.lower()
+        active_path = Path(f"models/{sym_lower}/active_lgbm_params.json")
+    else:
+        active_path = Path("models/active_lgbm_params.json")
     if not args.no_baseline and study.best_value > baseline_score:
         shutil.copy(output_path, active_path)
         best_prec = study.best_trial.user_attrs.get("mean_precision", 0.0)