feat(image-render): main + Dockerfile + compose entry (port 18714)

feat(image-render): Redis BLPOP worker + 3 provider dispatch
feat(image-render): flux (ComfyUI 로컬) provider + GPU 장중 가드
2026-05-23 12:10:29 +09:00 · 2026-05-23 12:06:24 +09:00 · 2026-05-23 12:03:23 +09:00 · 2026-05-23 12:00:06 +09:00 · 2026-05-23 11:56:50 +09:00 · 2026-05-23 11:53:41 +09:00
162 changed files with 5624 additions and 79 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -47,11 +47,11 @@ daily_trade_history.json
 watchlist.json
 bot_ipc.json

-# Test (top-level only; signal_v2/tests tracked separately)
+# Test (top-level only; ai_trade/tests tracked separately)
 tests/
 tests/*
-!signal_v2/tests/
-!signal_v2/tests/**
+!ai_trade/tests/
+!ai_trade/tests/**

 # System
 Thumbs.db
@@ -63,5 +63,22 @@ KIS_SETUP.md
 .claude/

 # Signal V2 runtime data
-signal_v2/data/*.db
-signal_v2/data/*.db-*
+ai_trade/data/*.db
+ai_trade/data/*.db-*
+
+# Plan-B-Insta services 예외 (코드는 추적, .env는 무시 유지)
+!services/
+!services/**/
+!services/**/*.py
+!services/**/Dockerfile
+!services/**/requirements.txt
+!services/**/.env.example
+!services/**/*.j2
+!services/**/*.html
+!services/**/*.css
+!services/**/.gitkeep
+!services/**/pytest.ini
+!services/docker-compose.yml
+# 단 실 .env는 무시 유지
+services/**/.env
+services/.env
--- a/CHECK_POINT.md
+++ b/CHECK_POINT.md
@@ -0,0 +1,277 @@
+# web-ai CHECK_POINT
+
+> Windows AI Server (192.168.45.59), AMD 9800X3D + RTX 5070 Ti (16GB VRAM).
+> V1(LSTM 레거시) + V2(Chronos-2 signal pipeline) 이중 구조.
+> 2026-05-18 작성.
+
+## 🚀 2026-05-18 박재오 7 결정 — Windows 컴퓨팅 노드 신설 (1주 작업)
+
+박재오 결정 7건 완료. 상세 가이드: `Obsidian Vault/raw/2026-05-18-Windows-NAS-아키텍처-7결정-통합.md`
+
+### 결정 6 — 옵션 4 하이브리드 운영
+
+```
+[Windows AI Server]
+
+🔵 Native Python (NSSM 자동 시작, HIGH priority)
+  ├─ ai_trade (트레이딩 :8001) ⭐ 절대 우선
+  ├─ Ollama qwen3:14b (:11435)
+  └─ MusicGen (:8765)
+
+🟢 WSL2 + Docker Engine (Docker Desktop X, 라이선스·메모리 ↓)
+  ├─ insta-render (:18710) ⭐ NEW
+  ├─ music-render (:8771) ⭐ NEW
+  ├─ video-render (:18712) ⭐ NEW (외부 API 게이트웨이)
+  └─ task-watcher (옵션 d 작업 감지)
+```
+
+### Day 2 — WSL2 + Docker Engine 설치 ⭐ (2시간)
+
+```powershell
+# 관리자 PowerShell
+wsl --install -d Ubuntu-22.04
+# 재부팅 후 Ubuntu 초기 설정
+
+wsl -d Ubuntu-22.04
+# 안에서 Docker Engine 설치
+sudo apt update && sudo apt install -y ca-certificates curl gnupg
+curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
+echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list
+sudo apt update && sudo apt install -y docker-ce docker-compose-plugin
+sudo usermod -aG docker $USER
+sudo systemctl enable docker
+sudo systemctl start docker
+
+# Tailscale (NAS와 같은 LAN 확인)
+curl -fsSL https://tailscale.com/install.sh | sh
+sudo tailscale up
+```
+
+- [ ] WSL2 + Ubuntu 22.04 설치
+- [ ] Docker Engine 설치 (Desktop X)
+- [ ] Tailscale 가입
+
+### Day 3~4 — insta-render 컨테이너 신설 ⭐ (4시간)
+
+**디렉토리**: `C:\Users\jaeoh\Desktop\workspace\web-ai-services\insta-render\`
+
+**Dockerfile**: Playwright + Python 3.12 (raw 파일에 풀 코드)
+
+**main.py**: Redis 큐 worker + Playwright Browser pool + Semaphore(1)
+
+- [ ] 디렉토리 생성 + Dockerfile + main.py + requirements.txt
+- [ ] `docker compose up -d insta-render`
+- [ ] 테스트: NAS Redis에서 작업 push → Windows에서 처리 확인
+
+### Day 6 — NSSM 자동 시작 ⭐ (1시간)
+
+**NSSM 다운로드**: https://nssm.cc/download
+
+```powershell
+# 관리자 PowerShell
+
+# 트레이딩 자동 시작 (HIGH priority — 결정 b)
+nssm install ai_trade "C:\Python312\python.exe" "-m uvicorn main:app --host 0.0.0.0 --port 8001"
+nssm set ai_trade AppDirectory "C:\Users\jaeoh\Desktop\workspace\web-ai\ai_trade"
+nssm set ai_trade Priority HIGH_PRIORITY_CLASS
+nssm set ai_trade AppStartup AUTO
+
+# WSL2 + Docker 자동 시작
+nssm install wsl_docker "wsl" "-d Ubuntu-22.04 -- sudo service docker start && cd /workspace/web-ai-services && docker compose up -d"
+nssm set wsl_docker AppStartup AUTO
+
+# 시작
+nssm start ai_trade
+nssm start wsl_docker
+```
+
+- [ ] NSSM 다운로드 + 압축 해제 + PATH 추가
+- [ ] ai_trade service 등록 (HIGH priority)
+- [ ] wsl_docker service 등록
+- [ ] 재부팅 후 자동 시작 확인
+
+### Day 7 — 작업 감지 (옵션 d) — task-watcher ⭐ (2시간)
+
+박재오 작업 중 → Redis `queue:paused` 플래그 → 워커 일시정지. 트레이딩은 영향 X.
+
+선택지:
+- **A. 자동 (Python pynput + PowerShell API)** — 마우스·게임 process 감지, 자동 토글
+- **B. 수동 토글** — 박재오님이 작업 시작 시 `redis-cli SET queue:paused 1`, 종료 시 `DEL`
+- **C. NAS frontend에 토글 UI 1개** — 클릭 한 번
+
+→ 시작은 **B 수동 토글** (구현 0, 즉시 가능), 나중에 A 자동화로 진화.
+
+- [ ] B 수동 토글 명령어 확인
+- [ ] 또는 A Python pynput 자동 감지 구현 (선택, 2시간)
+
+### Day 5 — music-render 컨테이너 (선택 — MusicGen 패턴 정착)
+
+기존 NAS music-lab → Windows MusicGen 호출 패턴 이미 운영 중. 표준화만:
+- [ ] Redis 큐 사용으로 전환 (HTTP 직접 호출 X)
+- [ ] Browser pool 같은 패턴 적용 (Suno + MusicGen 동시 1개)
+
+### Day 5 — video-render 컨테이너 (선택 — 영상 생성 결정 4)
+
+외부 영상 API 6개 게이트웨이 (Runway·Sora·Veo·Pika·Kling·Luma):
+- [ ] 박재오 자금·품질 판단 후 1~2개 가입
+- [ ] `.env`에 API 키 추가
+- [ ] video-render Docker 컨테이너 신설
+
+---
+
+## 🔥 2026-05-18 추가 — NAS API 부하 진짜 원인 발견
+
+박재오 발견: 5건 + 중기 2건 적용 후 **web-ai V1+V2 4 process 종료가 NAS CPU 가장 큰 즉시 감소**.
+→ 진짜 병목은 **web-ai → NAS stock(:18500) 인바운드 API 호출 빈도**.
+
+상세: `Obsidian Vault/raw/2026-05-18-NAS-Window-AI-API-부하-해결방안.md`
+
+### 🔴 추가 즉시 작업 (50분으로 70% 부담 감소)
+
+#### A. 캐시 TTL 대폭 증가 ⭐⭐⭐ (10분)
+**파일**: `ai_trade/stock_client.py`
+```python
+# 변경 전 → 변경 후
+PORTFOLIO_TTL = 60   → 180  # 3분
+NEWS_TTL      = 300  → 600  # 10분
+SCREENER_TTL  = 60   → 300  # 5분
+```
+- [ ] 3 TTL 상수 증가
+- 효과: 분당 12 호출 → 3~4 호출 (70% 감소)
+
+#### B. V1·V2 단일화 결정 ⭐⭐ (10분 결정)
+- 동시 운영 시 NAS API 부담 2배 + KIS rate limit 충돌
+- **권장**: V1 폐기 + V2 단독 (Phase 4 자산 활용)
+- 또는 V2 임시 종료 + V1 유지 → Phase 5 진입 시 V1 폐기
+- [ ] 박재오 결정
+- [ ] 선택 안 된 쪽 `legacy/` 또는 `.disabled`
+- [ ] start.bat 한 쪽만
+
+#### C. (NAS 측) stock TTLCache — web-backend CHECK_POINT.md #13 참고
+- 박재오가 web-backend/stock에서 별도 적용
+
+## 🟢 현재 상태
+
+- **V2 Phase 4 완료** (5/17, 56/56 tests pass, main push)
+- Chronos-2 zero-shot 1일 수익률 + 분봉 모멘텀 5단계
+- 09:00~15:30 매 1분 / 16:00 일봉 추론
+- Sell-first 우선순위 (stop_loss · anomaly · take_profit) + 매수 hard gate
+- Confidence = chronos×0.5 + momentum×0.3 + screener×0.2
+
+---
+
+## 🔴 즉시 (이번 주)
+
+### 1. V1 vs V2 KIS rate limit 충돌 해결
+- **현재**: V1 + V2 동시 실행 시 KIS EGW00201 (초당 2회 제한) 충돌
+- **임시 해결**: V2 종료 상태 (현재 V1만 운영 중)
+- **결정 필요**: V1 deprecation 시점 (Phase 6)
+- [ ] 박재오 결정 — V1 폐기 일자 (예: 5/20 / 5/31)
+- [ ] Phase 5 진입 전 V1 정리
+
+### 2. `.venv` 한글 경로 문제 해결
+- 가상환경 한글 경로 깨짐 → 시스템 Python 사용 강제
+- 다른 개발 머신 협업 시 문제
+- [ ] `.venv`를 영문 경로로 이전 또는 시스템 Python으로 통일
+- [ ] start.bat에 경로 명시
+
+### 3. `state.signals` consumer-drain protocol 정의
+- Phase 5 prereq
+- 신호가 누적되기만 하고 소비 로직 미정의
+- [ ] consumer (예: agent-office /signal endpoint)가 처리한 신호 marking
+- [ ] 24h 만료 dedup 외에 *처리됨* 상태 추가
+
+---
+
+## 🟡 중기 (1~2주, Phase 5)
+
+### 4. agent-office `/signal` 엔드포인트 통합
+- web-ai V2가 매수/매도 신호 생성 → agent-office로 push
+- agent-office가 텔레그램 발송 + 사용자 결정 대기
+- [ ] V2에서 agent-office HTTP POST 호출 추가
+- [ ] payload: ticker, action, confidence, reasoning, chronos_quantile
+
+### 5. Ollama Qwen3 14B 통합 (Windows 로컬)
+- 신호 *해석* 레이어 — 단순 규칙 결과 → LLM 자연어 설명
+- 9.3GB VRAM 사용 (Chronos 7GB와 동시 가능, 15.5GB)
+- [ ] Ollama Windows 설치 (이미 실행 중인지 확인)
+- [ ] `state.signals` 큐에서 신호 pop → Qwen3 prompt → 결과 add
+- [ ] 텔레그램 전송 시 LLM 해석 텍스트 포함
+
+### 6. 이중 텔레그램 전송
+- 현재: V1만 텔레그램 발송 (Telegram Bot + KIS 자동주문)
+- Phase 5: V2도 별도 chat_id로 발송 (박재오 본인용 + 검증용)
+- [ ] V2 텔레그램 chat_id 환경변수 (`TELEGRAM_V2_CHAT_ID`)
+- [ ] V1·V2 메시지 톤 차별화 (V1 = 자동주문 / V2 = 신호 알림)
+
+### 7. holidays.json 자동 동기화
+- 현재: NAS에서 수동 copy
+- 한국 휴장일 누락 시 V2 폴링 실수 (휴장일에도 KIS 호출)
+- [ ] NAS realestate-lab 또는 별도 컨테이너에서 휴장일 자동 발급
+- [ ] V2가 부팅 시·매일 00:00에 GET 갱신
+
+---
+
+## 🟢 장기 (1개월+, Phase 6+)
+
+### 8. V1 완전 deprecation
+- LSTM 7-feature 모델 + main_server.py 폐기
+- 모든 자동매매 V2로 통일
+- [ ] V1 종료 일자 박재오 결정
+- [ ] V1 코드 `legacy/` 폴더로 이동 (read-only)
+
+### 9. Chronos-2 모델 미세조정 검토
+- 현재 zero-shot. 한국 주식 데이터로 미세조정 시 정확도 ↑ 가능?
+- 박재오 자체 학습 데이터 (KIS 1년치) → finetune
+- [ ] 데이터 수집·전처리
+- [ ] LoRA 또는 full finetune 결정
+
+### 10. KIS WebSocket 실 운영 검증
+- 현재 코드는 있으나 검증 부족
+- 실시간 호가가 1분 폴링보다 빠른 신호 확보 가능
+- [ ] 1주일 운영 후 latency·드롭 측정
+
+---
+
+## ✅ 최근 완료 (참고)
+
+- 2026-05-17: emit/skip 로깅 추가 (`2aa9f48`)
+- 2026-05-17: signal_generator poll_loop 통합 — Phase 4 완료 (`cc6310d`)
+- 2026-05-16: 코드 리뷰 수정 — sell-first 순서, anomaly 테스트 (`e574074`)
+- 2026-05-16: signal_generator 초안 — 9개 unit test (`b9def06`)
+- 2026-05-15: Foundation — 6개 env 임계값 + state.signals 필드 (`05ab284`)
+- 2026-05-14: FP32 강제 — Chronos FP16 overflow 회피 (`760f914`)
+
+---
+
+## 🔧 운영 커맨드 (Windows PowerShell)
+
+```powershell
+# V2 시작
+cd C:\Users\jaeoh\Desktop\workspace\web-ai\ai_trade
+.\start.bat
+
+# 테스트 실행 (56 tests)
+pytest tests/ -v
+
+# 로그 확인 (V2 실시간)
+Get-Content logs/ai_trade.log -Wait
+
+# Chronos 메모리 사용 확인
+nvidia-smi
+
+# KIS API 헬스 (REST)
+curl http://localhost:8001/health
+```
+
+---
+
+## 📚 참고
+
+- 위키: [[자산-주식-자동매매]] (V3.1 → V2 Phase 4 정정 필요)
+- NAS stock 연동: `192.168.45.54:18500` (X-WebAI-Key 인증)
+- CLAUDE.md (본 디렉토리 루트): Phase 진행도 + 환경변수 명세
+
+## 변경 이력
+
+- 2026-05-18: 페이지 신설. 즉시 3건 (V1/V2 충돌, .venv 한글, consumer protocol) + 중기 4건 (Phase 5) + 장기 3건 (V1 deprecation·Chronos finetune·WebSocket).
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -1,24 +1,139 @@
 # web-ai — Workspace 가이드

-Windows AI 머신 (AMD 9800X3D + RTX 5070 Ti) 의 두 시그널 파이프라인 컨테이너.
+Windows AI 머신 (AMD 9800X3D + RTX 5070 Ti 16GB) 의 두 신호 파이프라인.
+**Confidence Signal Pipeline V2 의 Windows-side 구현체** (NAS stock 백엔드와 HTTP 연동).
+
+상위 워크스페이스 컨텍스트는 `../CLAUDE.md` 참조.
+
+---

 ## 디렉토리 구조

-| 경로 | 역할 | 상태 |
-|------|------|------|
-| `signal_v1/` | V1 자체 자동매매 시스템 (main_server.py + Trading Bot + Telegram Bot + LSTM + Ollama + KIS 자동주문) | 운영 중. Confidence Signal Pipeline V2 Phase 6 에서 deprecation 예정 |
-| `signal_v2/` | V2 신호 파이프라인 (stock pull worker + Chronos-2 + signal API client) | Phase 2 에서 신설 |
-| `.env` | V1 + V2 환경변수 공유 | KIS_*, TELEGRAM_*, STOCK_API_URL, WEBAI_API_KEY 등 |
-| `start.bat` | V1 진입 (signal_v1 디렉토리 안 main_server.py 실행) | V2 별도 start 스크립트는 signal_v2/start.bat |
+| 경로 | 역할 | 포트 | 상태 |
+|------|------|------|------|
+| `signal_v1/` | ⚠️ **DEPRECATED 2026-05-19** — 레거시 LSTM 봇. 사용 안 함. `legacy/signal_v1/`로 이동 완료 (2026-05-19) | `:8000` | **OFF** |
+| `ai_trade/` | 자동매매 메인 (구 `signal_v2` 2026-05-19 rename) — Chronos-bolt + 분봉 모멘텀 + KIS WebSocket + 신호 생성 | `:8001` | **Phase 4 완료 (2026-05-17)**, Phase 5 대기 |
+| `legacy/start_v1.bat` | (deprecated) V1 진입점 — root `start.bat`에서 이동됨. 자동 실행 차단 | — | **OFF** |
+| `ai_trade/start.bat` | 자동매매 진입점 | — | `ai_trade/main.py` uvicorn 실행 |
+| `services/` | (예정) NAS↔Windows 분산 worker — insta-render·music-render·video-render·task-watcher | 18710~ | **Plan-B-Insta 작업 중** |
+| `.env` | 환경변수 (`KIS_REAL_*`, `TELEGRAM_*`, `STOCK_API_URL`, `WEBAI_API_KEY`, `LOG_LEVEL`) | — | |
+| `requirements.txt` | 공용 의존성 | — | torch, chronos-forecasting, fastapi, httpx, websockets 등 |

-## 운영 가이드
+`.venv` 는 **구조적으로 깨짐**: `pyvenv.cfg` 가 한글 사용자 경로(`C:\Users\박재오\...`) 를 포함하여 콘솔 코드페이지가 roundtrip 못함. 테스트는 시스템 Python 으로 실행: `C:\Users\jaeoh\AppData\Local\Programs\Python\Python312\python.exe -m pytest ai_trade/tests -q`.

- V1 시작: `start.bat` 또는 `cd signal_v1 && python main_server.py`
- V2 시작 (Phase 2 이후): `cd signal_v2 && python -m uvicorn main:app --port 8001`
- 둘 다 동시 실행 가능 (포트 분리: V1=8000, V2=8001)
+---
+
+## 서버 시작 방식
+
+### V1 (⚠️ DEPRECATED — 운영 X)
+2026-05-19부터 자동 시작 차단. `legacy/start_v1.bat`에 보존 (참고용만).
+별도 backtest 등 1회성 시 필요 시 박재오 직접 `legacy/start_v1.bat` 실행.
+
+### ai_trade 단독 (smoke/검증)
+```bat
+cd C:\Users\jaeoh\Desktop\workspace\web-ai\ai_trade
+.\start.bat
+```
+기대 로그: `Uvicorn running on http://0.0.0.0:8001`, `poll_loop started`, `[KIS] minute bars ... OK`, `[Chronos] predicted N tickers`, `signal emit XXXXXX buy conf=0.xxx`.
+
+휴장일/장 외 시간엔 `poll_loop` 만 idle. `Application startup complete` 만 보이면 정상.
+
+### V1 + V2 동시 실행 — **권장 안 함**
+**KIS app_key 초당 2회 한도 (EGW00201)** 충돌. V1 cycle + V2 분봉 cron 이 같은 KIS app_key 로 동시 호출하면 rate limit. 채택 해결책: V2 임시 종료 (Phase 3a 결정), Phase 6 V1 deprecation 시 자연 해소. 별도 app_key 발급은 옵션 B.
+
+---

 ## Phase 진행 상태 (Confidence Signal Pipeline V2)

-`web-ui/docs/superpowers/specs/2026-05-15-confidence-signal-pipeline-v2-architecture.md` 참조.
+| Phase | 내용 | 상태 |
+|-------|------|------|
+| 0 | Architecture & contract spec | ✅ Chronos-2 + Qwen3 14B 채택 |
+| 1 | stock 백엔드 WebAI API 보강 (NAS) | ✅ 102/102 tests, 운영 배포 |
+| 1.5 | V1 → `signal_v1/` rename | ✅ V1 정상 기동 |
+| 2 | ai_trade pull worker + signal API client + scheduler | ✅ 19/19 tests, `:8001` 기동 |
+| 3a | KIS REST 분봉 + WebSocket 호가 + NXT 스케줄 | ✅ 33/33 tests |
+| 3b | Chronos-bolt-base 추론 + 5분봉 모멘텀 분류기 | ✅ 45/45 tests, 실 KIS+Chronos chain 검증 |
+| 4 | Signal Generator (매수/매도 룰) + pull_worker 통합 + 로깅 | ✅ **2026-05-17 완료, 56/56 tests, push 완료** |
+| 5 | agent-office `/signal` + Ollama Qwen3 14B + 이중 텔레그램 | ⏳ 2주 예상 |
+| 6 | signal_v1 deprecation | ⏳ 1주 |
+| 7 | 운영 모니터링 + 4주 IC 검증 | ⏳ 1주 + 4주 |

-자세한 V1 가이드는 `signal_v1/CLAUDE.md` 참조.
+상세 spec/plan: `../web-ui/docs/superpowers/specs/` 및 `../web-ui/docs/superpowers/plans/` (web-ui repo 안에 보관됨 — V2 자체 코드와 분리 보관).
+
+---
+
+## ai_trade 디렉토리 내부
+
+| 파일 | 역할 |
+|------|------|
+| `main.py` | FastAPI app + lifespan (StockClient + KISClient + KISWebSocket + ChronosPredictor + SignalDedup 초기화). poll_loop task 생성 |
+| `config.py` | Settings dataclass — 환경변수 로드. Phase 4 추가 6 필드: `stop_loss_pct`, `take_profit_pct`, `chronos_spread_threshold`, `asking_bid_ratio_threshold`, `confidence_threshold`, `min_momentum_for_buy` |
+| `state.py` | PollState (process-wide singleton) — portfolio, screener_preview, news_sentiment, chronos_predictions, minute_bars, asking_price, **signals** (Phase 4) |
+| `stock_client.py` | NAS stock 백엔드 pull (X-WebAI-Key + 메모리 cache 60s/300s/60s + retry) |
+| `kis_client.py` | KIS REST 분봉/호가 — V1 토큰 read-only 공유 (mtime cache) + 초당 2회 throttle + 지수 backoff |
+| `kis_websocket.py` | KIS WebSocket H0STASP0 호가 + approval_key + 재연결 (1→2→4→max 30s) |
+| `chronos_predictor.py` | `amazon/chronos-bolt-base` zero-shot quantile (FP32 강제 — FP16 overflow 회피) |
+| `minute_momentum.py` | 5분봉 → strong_up/weak_up/neutral/weak_down/strong_down 5단계 분류 |
+| `signal_generator.py` | **Phase 4 — 매수/매도 룰 엔진**. `generate_signals(state, dedup, settings)` 진입. sell-first → buy 순서. 신호 emit/skip INFO/DEBUG 로그 |
+| `pull_worker.py` | asyncio cron — 장전 5분 / 장중 1분 / 장후 5분 / NXT / dead zone skip. cycle 끝에 `generate_signals` 호출 |
+| `scheduler.py` | polling window 판정 (KST 캘린더 + 휴장일) |
+| `rate_limit.py` | 초당 N회 token bucket |
+| `dedup.py` | SignalDedup SQLite WAL — `(ticker, action)` PK 24h |
+| `tests/` | 56 tests (pytest + respx HTTP mock + monkeypatch) |
+| `data/` | dedup.db (SQLite WAL) + `holidays.json` (NAS stock 에서 manual copy) |
+| `start.bat` | V2 진입 |
+
+---
+
+## 신호 룰 요약 (Phase 4)
+
+### 매수 (screener Top-N + portfolio, sell 신호 받은 종목은 skip)
+모두 충족:
+1. `chronos.median > 0`
+2. **`chronos.q90 - chronos.q10 < 0.6`** (absolute spread — 2026-05-17 spec amend, 기존 relative formula 가 zero-shot median≈0 빈번에서 모든 신호 거부)
+3. `minute_momentum == strong_up` (env 로 조정 가능)
+4. `asking_price.bid_ratio >= 0.6`
+
+종합 confidence = `chronos_conf * 0.5 + minute_score * 0.3 + screener_norm * 0.2`. `> 0.7` 시 emit.
+
+### 매도 (portfolio only, 우선순위 stop_loss → anomaly → take_profit)
+- **stop_loss**: `pnl_pct < -7%` 즉시 (confidence=1.0)
+- **anomaly**: `chronos.median < -1%` + `strong_down` + `bid_ratio < 0.4` + 종합 conf > 0.7
+- **take_profit**: `pnl_pct > 15%` 검토 (confidence=0.6)
+
+---
+
+## 알려진 함정 / Phase 7 백로그
+
+1. **KIS rate limit (EGW00201)** — V1+V2 동시 실행 시 충돌. Phase 6 자연 해소
+2. **`.venv` 한글 경로 깨짐** — 시스템 Python 사용
+3. **Chronos FP16 overflow** — 한국 주가 5만+ 시 inf. FP32 강제 (`chronos_predictor.py:39-41`)
+4. **`predict_quantiles` positional `inputs`** — ChronosBolt API 새 변경. `try/except TypeError` fallback 처리됨
+5. **`state.signals` consumer-drain protocol 미정의** — Phase 5 prereq. dict 무한 누적 위험 (실제로는 bounded by unique ticker count)
+6. **integration test 가 poll_loop 실제 호출 안 함** — `test_pull_worker.py:test_poll_loop_calls_generate_signals_after_cycle` 가 `generate_signals` 직접 호출. Phase 7 hardening 시 mock-iteration 으로 강화
+7. **KIS WebSocket URL `ws://ops.koreainvestment.com:21000/31000`** — 첫 운영 시 실제 KIS API docs 와 대조 필요
+8. **`_parse_asking_price` 필드 인덱스** — 마지막 2 필드 가정. 실 운영 raw 메시지 캡처 후 매핑 검증 필요
+9. **`holidays.json` 자동 동기화 부재** — NAS stock 의 `holidays.json` 을 수동 copy
+10. **schema rename** — Phase 0 §5.2 의 `lstm_pred_*`, `news_top[]` 는 `chronos_pred_*`, `news_reason(string)` 으로 변경됨. Phase 5 prompt 작성 시 반영
+11. **6개 env 필드가 `.env` 에 미기재** — 기본값으로 동작 가능하나 discoverability 위해 `.env.example` 또는 commented block 추가 권장
+
+---
+
+## 다음 단계 (Phase 5 진입 시 brainstorming 주제)
+
+- `state.signals` consumer 패턴: pop vs leave + Phase 5 자체 dedup
+- agent-office 의 `/signal` endpoint 설계 — POST 페이로드 schema
+- Ollama Qwen3 14B Q4 로컬 호출 — 타임아웃, retry, VRAM 공존 (Chronos + Qwen3 동시 메모리 9.3GB / 15.5GB 가용)
+- 이중 텔레그램 (본인 풀 / 아내 lite) — context augmentation 단일 호출에서 양쪽 메시지 생성
+- LLM 비용: ₩0 목표 유지 (로컬)
+
+---
+
+## 양쪽 디렉토리 (web-ui ↔ web-ai) 작업 시 주의
+
+- **코드**: ai_trade 는 web-ai/, spec/plan/메모리는 web-ui/
+- **커밋**: `web-ai` 와 `web-ui` 는 **별도 Gitea 저장소**. 각각 경로에서만 `git add/commit/push`
+- **메모리**: Claude Code 의 auto-memory 는 디렉토리별 격리. 핵심 reference 는 양쪽에 미러됨 (`./memory-mirror/` 또는 `~/.claude/projects/C--Users-jaeoh-Desktop-workspace-web-ai/memory/`)
+- **spec amendment 발생 시**: 코드는 `web-ai` 에 commit, spec 갱신은 `web-ui/docs/superpowers/specs/` 에 commit (Phase 4 spread formula 변경 사례 = web-ui commit `534ded5`)
+
+자세한 V1 가이드는 `signal_v1/CLAUDE.md` 참조 (있다면).
--- a/signal_v2/init.py
+++ b/signal_v2/init.py
--- a/signal_v2/chronos_predictor.py
+++ b/signal_v2/chronos_predictor.py
--- a/signal_v2/config.py
+++ b/signal_v2/config.py
@@ -18,7 +18,7 @@ class Settings:
    )
    port: int = field(default_factory=lambda: int(os.getenv("SIGNAL_V2_PORT", "8001")))
    db_path: Path = field(
-        default_factory=lambda: Path(__file__).parent / "data" / "signal_v2.db"
+        default_factory=lambda: Path(__file__).parent / "data" / "ai_trade.db"
    )
    # KIS — V1 호환 패턴 (KIS_ENV_TYPE virtual/real)
    kis_env_type: str = field(default_factory=lambda: os.getenv("KIS_ENV_TYPE", "virtual").lower())
@@ -35,6 +35,24 @@ class Settings:
        )
    )
    chronos_model: str = field(default_factory=lambda: os.getenv("CHRONOS_MODEL", "amazon/chronos-2"))
+    stop_loss_pct: float = field(
+        default_factory=lambda: float(os.getenv("STOP_LOSS_PCT", "-0.07"))
+    )
+    take_profit_pct: float = field(
+        default_factory=lambda: float(os.getenv("TAKE_PROFIT_PCT", "0.15"))
+    )
+    chronos_spread_threshold: float = field(
+        default_factory=lambda: float(os.getenv("CHRONOS_SPREAD_THRESHOLD", "0.6"))
+    )
+    asking_bid_ratio_threshold: float = field(
+        default_factory=lambda: float(os.getenv("ASKING_BID_RATIO_THRESHOLD", "0.6"))
+    )
+    confidence_threshold: float = field(
+        default_factory=lambda: float(os.getenv("CONFIDENCE_THRESHOLD", "0.7"))
+    )
+    min_momentum_for_buy: str = field(
+        default_factory=lambda: os.getenv("MIN_MOMENTUM_FOR_BUY", "strong_up")
+    )

    @property
    def kis_is_virtual(self) -> bool:
--- a/signal_v2/data/.gitkeep
+++ b/signal_v2/data/.gitkeep
--- a/signal_v2/holidays.json
+++ b/signal_v2/holidays.json
--- a/signal_v2/kis_client.py
+++ b/signal_v2/kis_client.py
--- a/signal_v2/kis_websocket.py
+++ b/signal_v2/kis_websocket.py
--- a/signal_v2/main.py
+++ b/signal_v2/main.py
@@ -6,14 +6,14 @@ from contextlib import asynccontextmanager

 from fastapi import FastAPI

-from signal_v2 import state as state_mod
-from signal_v2.chronos_predictor import ChronosPredictor
-from signal_v2.config import get_settings
-from signal_v2.kis_client import KISClient
-from signal_v2.kis_websocket import KISWebSocket
-from signal_v2.pull_worker import poll_loop, make_asking_price_callback
-from signal_v2.rate_limit import SignalDedup
-from signal_v2.stock_client import StockClient
+from ai_trade import state as state_mod
+from ai_trade.chronos_predictor import ChronosPredictor
+from ai_trade.config import get_settings
+from ai_trade.kis_client import KISClient
+from ai_trade.kis_websocket import KISWebSocket
+from ai_trade.pull_worker import poll_loop, make_asking_price_callback
+from ai_trade.rate_limit import SignalDedup
+from ai_trade.stock_client import StockClient

 logger = logging.getLogger(__name__)

@@ -82,6 +82,8 @@ async def lifespan(app: FastAPI):
            _ctx.client, state_mod.state, _ctx.shutdown,
            kis_client=_ctx.kis_client,
            chronos=_ctx.chronos,
+            dedup=_ctx.dedup,
+            settings=settings,
        )
    )

--- a/signal_v2/momentum_classifier.py
+++ b/signal_v2/momentum_classifier.py
--- a/signal_v2/pull_worker.py
+++ b/signal_v2/pull_worker.py
@@ -5,12 +5,12 @@ import logging
 from collections import deque
 from datetime import datetime

-from signal_v2.kis_client import KISClient
-from signal_v2.scheduler import (
+from ai_trade.kis_client import KISClient
+from ai_trade.scheduler import (
    KST, _is_market_day, _is_polling_window, _next_interval, _is_post_close_trigger,
 )
-from signal_v2.state import PollState
-from signal_v2.stock_client import StockClient
+from ai_trade.state import PollState
+from ai_trade.stock_client import StockClient

 logger = logging.getLogger(__name__)

@@ -19,6 +19,8 @@ async def poll_loop(
    client: StockClient, state: PollState, shutdown: asyncio.Event,
    kis_client: KISClient | None = None,
    chronos=None,
+    dedup=None,
+    settings=None,
 ) -> None:
    """FastAPI lifespan 에서 asyncio.create_task 로 시작."""
    logger.info("poll_loop started")
@@ -40,6 +42,13 @@ async def poll_loop(
                    await _run_post_close_cycle(kis_client, chronos, state)
                except Exception:
                    logger.exception("post-close cycle failed")
+            # Phase 4: generate signals
+            if dedup is not None and settings is not None:
+                try:
+                    from ai_trade.signal_generator import generate_signals
+                    generate_signals(state, dedup, settings)
+                except Exception:
+                    logger.exception("generate_signals failed")
        interval = _next_interval(now)
        try:
            await asyncio.wait_for(shutdown.wait(), timeout=interval)
@@ -177,7 +186,7 @@ async def _run_post_close_cycle(kis_client, chronos, state) -> None:

 def update_minute_momentum_for_all(state) -> None:
    """매 분봉 cycle 후 호출 — 모든 종목 모멘텀 갱신."""
-    from signal_v2.momentum_classifier import classify_minute_momentum
+    from ai_trade.momentum_classifier import classify_minute_momentum
    now_iso = datetime.now(KST).isoformat()
    for ticker, bars in state.minute_bars.items():
        state.minute_momentum[ticker] = classify_minute_momentum(bars)
--- a/signal_v2/pytest.ini
+++ b/signal_v2/pytest.ini
--- a/signal_v2/rate_limit.py
+++ b/signal_v2/rate_limit.py
--- a/signal_v2/scheduler.py
+++ b/signal_v2/scheduler.py
--- a/ai_trade/signal_generator.py
+++ b/ai_trade/signal_generator.py
@@ -0,0 +1,228 @@
+"""Phase 4 — 매수/매도 신호 생성.
+
+순수 함수 generate_signals(state, dedup, settings). state 를 mutate.
+"""
+from __future__ import annotations
+import logging
+from datetime import datetime
+from zoneinfo import ZoneInfo
+
+logger = logging.getLogger(__name__)
+KST = ZoneInfo("Asia/Seoul")
+
+MOMENTUM_SCORES = {
+    "strong_up": 1.0,
+    "weak_up": 0.7,
+    "neutral": 0.5,
+    "weak_down": 0.3,
+    "strong_down": 0.0,
+}
+
+
+def generate_signals(state, dedup, settings) -> None:
+    """Phase 4 entry — state-mutating. Evaluation order: sell first (priority), then buy. A ticker receiving a sell signal in this cycle is excluded from buy evaluation to avoid silent overwrite."""
+    _evaluate_sell_signals(state, dedup, settings)
+    _evaluate_buy_signals(state, dedup, settings)
+
+
+# ----- 매수 -----
+
+def _evaluate_buy_signals(state, dedup, settings) -> None:
+    candidates = _buy_candidates(state)
+    for ticker, name, rank in candidates:
+        existing = state.signals.get(ticker)
+        if existing is not None and existing.get("action") == "sell":
+            logger.debug("buy %s skipped: same-cycle sell precedence", ticker)
+            continue
+        if not _check_buy_hard_gate(state, ticker, settings):
+            logger.debug("buy %s skipped: hard gate failed", ticker)
+            continue
+        confidence = _compute_buy_confidence(state, ticker, rank)
+        if confidence <= settings.confidence_threshold:
+            logger.debug("buy %s skipped: confidence %.3f <= %.3f",
+                         ticker, confidence, settings.confidence_threshold)
+            continue
+        if dedup.is_recent(ticker, "buy", within_hours=24):
+            logger.debug("buy %s skipped: dedup 24h", ticker)
+            continue
+        state.signals[ticker] = _build_buy_signal(state, ticker, name, rank, confidence)
+        dedup.record(ticker, "buy", confidence=confidence)
+        logger.info("signal emit %s buy conf=%.3f rank=%s", ticker, confidence, rank)
+
+
+def _buy_candidates(state) -> list[tuple[str, str, int | None]]:
+    """screener Top-N (rank 1..N) + portfolio (rank=None)."""
+    candidates: list[tuple[str, str, int | None]] = []
+    seen: set[str] = set()
+    if state.screener_preview is not None:
+        for i, item in enumerate(state.screener_preview.get("items", [])):
+            ticker = item.get("ticker")
+            if not ticker or ticker in seen:
+                continue
+            seen.add(ticker)
+            name = item.get("name", ticker)
+            candidates.append((ticker, name, i + 1))
+    if state.portfolio is not None:
+        for h in state.portfolio.get("holdings", []):
+            ticker = h.get("ticker")
+            if not ticker or ticker in seen:
+                continue
+            seen.add(ticker)
+            candidates.append((ticker, h.get("name", ticker), None))
+    return candidates
+
+
+def _check_buy_hard_gate(state, ticker: str, settings) -> bool:
+    pred = state.chronos_predictions.get(ticker)
+    if pred is None or pred.get("median", 0) <= 0:
+        return False
+    spread = pred.get("q90", 0) - pred.get("q10", 0)
+    if spread >= settings.chronos_spread_threshold:
+        return False
+    momentum = state.minute_momentum.get(ticker)
+    if momentum != settings.min_momentum_for_buy:
+        return False
+    ap = state.asking_price.get(ticker)
+    if ap is None or ap.get("bid_ratio", 0) < settings.asking_bid_ratio_threshold:
+        return False
+    return True
+
+
+def _compute_buy_confidence(state, ticker: str, rank: int | None) -> float:
+    pred = state.chronos_predictions[ticker]
+    chronos_conf = pred["conf"]
+    minute_score = MOMENTUM_SCORES.get(state.minute_momentum.get(ticker, "neutral"), 0.5)
+    screener_norm = max(0.0, 1 - (rank - 1) / 20) if rank is not None else 0.0
+    return chronos_conf * 0.5 + minute_score * 0.3 + screener_norm * 0.2
+
+
+def _build_buy_signal(state, ticker: str, name: str, rank: int | None, confidence: float) -> dict:
+    ap = state.asking_price[ticker]
+    return {
+        "ticker": ticker,
+        "name": name,
+        "action": "buy",
+        "confidence_webai": confidence,
+        "current_price": ap["current_price"],
+        "avg_price": None,
+        "pnl_pct": None,
+        "context": _build_context(state, ticker, rank),
+        "as_of": datetime.now(KST).isoformat(),
+    }
+
+
+# ----- 매도 -----
+
+def _evaluate_sell_signals(state, dedup, settings) -> None:
+    if state.portfolio is None:
+        return
+    for holding in state.portfolio.get("holdings", []):
+        ticker = holding.get("ticker")
+        if not ticker:
+            continue
+        sell = _try_stop_loss(state, holding, settings)
+        if sell is None:
+            sell = _try_anomaly(state, holding, settings)
+        if sell is None:
+            sell = _try_take_profit(state, holding, settings)
+        if sell is None:
+            continue
+        if dedup.is_recent(ticker, "sell", within_hours=24):
+            logger.debug("sell %s skipped: dedup 24h", ticker)
+            continue
+        state.signals[ticker] = sell
+        dedup.record(ticker, "sell", confidence=sell["confidence_webai"])
+        logger.info("signal emit %s sell conf=%.3f reason=%s",
+                    ticker, sell["confidence_webai"],
+                    sell.get("context", {}).get("sell_reason"))
+
+
+def _try_stop_loss(state, holding: dict, settings) -> dict | None:
+    pnl = holding.get("pnl_pct")
+    if pnl is None or pnl >= settings.stop_loss_pct:
+        return None
+    return _build_sell_signal(state, holding, confidence=1.0, reason="stop_loss")
+
+
+def _try_take_profit(state, holding: dict, settings) -> dict | None:
+    pnl = holding.get("pnl_pct")
+    if pnl is None or pnl <= settings.take_profit_pct:
+        return None
+    return _build_sell_signal(state, holding, confidence=0.6, reason="take_profit")
+
+
+def _try_anomaly(state, holding: dict, settings) -> dict | None:
+    ticker = holding["ticker"]
+    pred = state.chronos_predictions.get(ticker)
+    if pred is None or pred["median"] >= -0.01:
+        return None
+    momentum = state.minute_momentum.get(ticker)
+    if momentum != "strong_down":
+        return None
+    ap = state.asking_price.get(ticker)
+    if ap is None:
+        return None
+    if ap["bid_ratio"] > (1 - settings.asking_bid_ratio_threshold):
+        return None
+    minute_score = 1.0 - MOMENTUM_SCORES.get(momentum, 0.5)
+    confidence = pred["conf"] * 0.5 + minute_score * 0.3 + 1.0 * 0.2
+    if confidence <= settings.confidence_threshold:
+        return None
+    return _build_sell_signal(state, holding, confidence=confidence, reason="anomaly")
+
+
+def _build_sell_signal(state, holding: dict, confidence: float, reason: str) -> dict:
+    ticker = holding["ticker"]
+    return {
+        "ticker": ticker,
+        "name": holding.get("name", ticker),
+        "action": "sell",
+        "confidence_webai": confidence,
+        "current_price": holding.get("current_price"),
+        "avg_price": holding.get("avg_price"),
+        "pnl_pct": holding.get("pnl_pct"),
+        "context": _build_context(state, ticker, rank=None, sell_reason=reason),
+        "as_of": datetime.now(KST).isoformat(),
+    }
+
+
+# ----- Context -----
+
+def _build_context(state, ticker: str, rank: int | None, sell_reason: str | None = None) -> dict:
+    pred = state.chronos_predictions.get(ticker) or {}
+    ap = state.asking_price.get(ticker) or {}
+    news_item = _find_news_sentiment(state, ticker)
+    screener_scores = _find_screener_scores(state, ticker)
+    context: dict = {
+        "chronos_pred_1d": pred.get("median"),
+        "chronos_pred_conf": pred.get("conf"),
+        "chronos_q10": pred.get("q10"),
+        "chronos_q90": pred.get("q90"),
+        "screener_rank": rank,
+        "screener_scores": screener_scores,
+        "minute_momentum": state.minute_momentum.get(ticker),
+        "asking_bid_ratio": ap.get("bid_ratio"),
+        "news_sentiment": news_item.get("score") if news_item else None,
+        "news_reason": news_item.get("reason") if news_item else None,
+    }
+    if sell_reason is not None:
+        context["sell_reason"] = sell_reason
+    return context
+
+
+def _find_news_sentiment(state, ticker: str) -> dict | None:
+    if state.news_sentiment is None:
+        return None
+    for item in state.news_sentiment.get("items", []):
+        if item.get("ticker") == ticker:
+            return item
+    return None
+
+
+def _find_screener_scores(state, ticker: str) -> dict | None:
+    if state.screener_preview is None:
+        return None
+    for item in state.screener_preview.get("items", []):
+        if item.get("ticker") == ticker:
+            return item.get("scores")
+    return None
--- a/ai_trade/start.bat
+++ b/ai_trade/start.bat
@@ -0,0 +1,3 @@
+@echo off
+cd /d "%~dp0\.."
+python -m uvicorn ai_trade.main:app --host 0.0.0.0 --port 8001
--- a/signal_v2/state.py
+++ b/signal_v2/state.py
@@ -14,6 +14,7 @@ class PollState:
    daily_ohlcv: dict[str, list[dict]] = field(default_factory=dict)
    chronos_predictions: dict[str, dict] = field(default_factory=dict)
    minute_momentum: dict[str, str] = field(default_factory=dict)
+    signals: dict[str, dict] = field(default_factory=dict)
    last_updated: dict[str, str] = field(default_factory=dict)
    fetch_errors: dict[str, int] = field(default_factory=dict)

--- a/signal_v2/stock_client.py
+++ b/signal_v2/stock_client.py
@@ -9,11 +9,12 @@ import httpx

 logger = logging.getLogger(__name__)

-# Cache TTL by endpoint (seconds)
+# Cache TTL by endpoint (seconds).
+# 2026-05-18 — NAS 인바운드 호출 부담 완화 (Plan-A SP-A1).
 _TTL = {
-    "portfolio": 60.0,
-    "news-sentiment": 300.0,
-    "screener-preview": 60.0,
+    "portfolio": 180.0,        # 3분 (1분 폴링 시 3 폴링당 1회 실제 fetch)
+    "news-sentiment": 600.0,   # 10분 (뉴스 sentiment는 자주 안 바뀜)
+    "screener-preview": 300.0, # 5분 (Top-20은 분 단위로 거의 안 바뀜)
 }

 # Retry policy
--- a/signal_v2/tests/init.py
+++ b/signal_v2/tests/init.py
--- a/ai_trade/tests/pycache/init.cpython-312.pyc
+++ b/ai_trade/tests/pycache/init.cpython-312.pyc
--- a/ai_trade/tests/pycache/conftest.cpython-312-pytest-9.0.2.pyc
+++ b/ai_trade/tests/pycache/conftest.cpython-312-pytest-9.0.2.pyc
--- a/ai_trade/tests/pycache/test_chronos_predictor.cpython-312-pytest-9.0.2.pyc
+++ b/ai_trade/tests/pycache/test_chronos_predictor.cpython-312-pytest-9.0.2.pyc
--- a/ai_trade/tests/pycache/test_kis_client.cpython-312-pytest-9.0.2.pyc
+++ b/ai_trade/tests/pycache/test_kis_client.cpython-312-pytest-9.0.2.pyc
--- a/ai_trade/tests/pycache/test_kis_websocket.cpython-312-pytest-9.0.2.pyc
+++ b/ai_trade/tests/pycache/test_kis_websocket.cpython-312-pytest-9.0.2.pyc
--- a/ai_trade/tests/pycache/test_main.cpython-312-pytest-9.0.2.pyc
+++ b/ai_trade/tests/pycache/test_main.cpython-312-pytest-9.0.2.pyc
--- a/ai_trade/tests/pycache/test_momentum_classifier.cpython-312-pytest-9.0.2.pyc
+++ b/ai_trade/tests/pycache/test_momentum_classifier.cpython-312-pytest-9.0.2.pyc
--- a/ai_trade/tests/pycache/test_pull_worker.cpython-312-pytest-9.0.2.pyc
+++ b/ai_trade/tests/pycache/test_pull_worker.cpython-312-pytest-9.0.2.pyc
--- a/ai_trade/tests/pycache/test_rate_limit.cpython-312-pytest-9.0.2.pyc
+++ b/ai_trade/tests/pycache/test_rate_limit.cpython-312-pytest-9.0.2.pyc
--- a/ai_trade/tests/pycache/test_scheduler.cpython-312-pytest-9.0.2.pyc
+++ b/ai_trade/tests/pycache/test_scheduler.cpython-312-pytest-9.0.2.pyc
--- a/ai_trade/tests/pycache/test_signal_generator.cpython-312-pytest-9.0.2.pyc
+++ b/ai_trade/tests/pycache/test_signal_generator.cpython-312-pytest-9.0.2.pyc
--- a/ai_trade/tests/pycache/test_stock_client.cpython-312-pytest-9.0.2.pyc
+++ b/ai_trade/tests/pycache/test_stock_client.cpython-312-pytest-9.0.2.pyc
--- a/ai_trade/tests/pycache/test_stock_client_ttl.cpython-312-pytest-9.0.2.pyc
+++ b/ai_trade/tests/pycache/test_stock_client_ttl.cpython-312-pytest-9.0.2.pyc
--- a/signal_v2/tests/conftest.py
+++ b/signal_v2/tests/conftest.py
@@ -1,4 +1,4 @@
-"""Pytest fixtures for signal_v2 tests."""
+"""Pytest fixtures for ai_trade tests."""
 from pathlib import Path

 import pytest
@@ -8,7 +8,7 @@ import respx
@pytest.fixture
 def tmp_dedup_db(tmp_path) -> Path:
    """SQLite 단위 테스트용 임시 DB path."""
-    return tmp_path / "test_signal_v2.db"
+    return tmp_path / "test_ai_trade.db"


@pytest.fixture
--- a/signal_v2/tests/test_chronos_predictor.py
+++ b/signal_v2/tests/test_chronos_predictor.py
@@ -39,7 +39,7 @@ def test_predict_batch_returns_prediction_dict(mock_pipeline, mock_torch_cpu):
    quantiles = _mk_quantiles_tensor(101.5, 102.0, 102.5)  # narrow around 102
    mock_pipeline.predict_quantiles.return_value = (quantiles, None)

-    from signal_v2.chronos_predictor import ChronosPredictor, ChronosPrediction
+    from ai_trade.chronos_predictor import ChronosPredictor, ChronosPrediction
    predictor = ChronosPredictor(model_name="mock-model")
    daily = {"005930": _daily_ohlcv([100] * 60)}
    result = predictor.predict_batch(daily)
@@ -57,7 +57,7 @@ def test_conf_high_when_distribution_narrow(mock_pipeline, mock_torch_cpu):
    quantiles = _mk_quantiles_tensor(101.99, 102.0, 102.01)
    mock_pipeline.predict_quantiles.return_value = (quantiles, None)

-    from signal_v2.chronos_predictor import ChronosPredictor
+    from ai_trade.chronos_predictor import ChronosPredictor
    predictor = ChronosPredictor(model_name="mock-model")
    daily = {"005930": _daily_ohlcv([100] * 60)}
    result = predictor.predict_batch(daily)
@@ -72,7 +72,7 @@ def test_conf_low_when_distribution_wide(mock_pipeline, mock_torch_cpu):
    quantiles = _mk_quantiles_tensor(70.0, 100.0, 130.0)
    mock_pipeline.predict_quantiles.return_value = (quantiles, None)

-    from signal_v2.chronos_predictor import ChronosPredictor
+    from ai_trade.chronos_predictor import ChronosPredictor
    predictor = ChronosPredictor(model_name="mock-model")
    daily = {"005930": _daily_ohlcv([100] * 60)}
    result = predictor.predict_batch(daily)
@@ -84,7 +84,7 @@ def test_return_computed_from_price_relative_to_last_close(mock_pipeline, mock_t
    quantiles = _mk_quantiles_tensor(109.0, 110.0, 111.0)
    mock_pipeline.predict_quantiles.return_value = (quantiles, None)

-    from signal_v2.chronos_predictor import ChronosPredictor
+    from ai_trade.chronos_predictor import ChronosPredictor
    predictor = ChronosPredictor(model_name="mock-model")
    # last close = 100
    daily = {"005930": _daily_ohlcv(list(range(41, 101)))}  # last = 100
--- a/signal_v2/tests/test_kis_client.py
+++ b/signal_v2/tests/test_kis_client.py
@@ -6,7 +6,7 @@ import httpx
 import pytest
 import respx

-from signal_v2.kis_client import KISClient
+from ai_trade.kis_client import KISClient


@pytest.fixture
--- a/signal_v2/tests/test_kis_websocket.py
+++ b/signal_v2/tests/test_kis_websocket.py
@@ -7,7 +7,7 @@ import httpx
 import pytest
 import respx

-from signal_v2.kis_websocket import KISWebSocket
+from ai_trade.kis_websocket import KISWebSocket


 BASE_REST = "https://openapivts.koreainvestment.com:29443"
--- a/signal_v2/tests/test_main.py
+++ b/signal_v2/tests/test_main.py
@@ -10,9 +10,9 @@ def test_health_endpoint_returns_status_online(monkeypatch):
    monkeypatch.setenv("WEBAI_API_KEY", "test-secret")
    # Reload modules so they pick up the new env
    import importlib
-    from signal_v2 import config as cfg
+    from ai_trade import config as cfg
    importlib.reload(cfg)
-    from signal_v2 import main as main_mod
+    from ai_trade import main as main_mod
    importlib.reload(main_mod)
    with TestClient(main_mod.app) as client:
        r = client.get("/health")
@@ -24,17 +24,17 @@ def test_health_endpoint_returns_status_online(monkeypatch):

 def test_startup_warns_if_webai_api_key_missing(monkeypatch, caplog):
    # Use setenv with empty string + no-op load_dotenv to defeat .env re-read on reload
-    monkeypatch.setattr("signal_v2.config.load_dotenv", lambda *a, **k: None)
+    monkeypatch.setattr("ai_trade.config.load_dotenv", lambda *a, **k: None)
    monkeypatch.setenv("WEBAI_API_KEY", "")
    monkeypatch.setenv("STOCK_API_URL", "https://test.stock.local")
    import importlib
-    from signal_v2 import config as cfg
+    from ai_trade import config as cfg
    importlib.reload(cfg)
    # After reload, load_dotenv reference is fresh — re-patch
-    monkeypatch.setattr("signal_v2.config.load_dotenv", lambda *a, **k: None)
-    from signal_v2 import main as main_mod
+    monkeypatch.setattr("ai_trade.config.load_dotenv", lambda *a, **k: None)
+    from ai_trade import main as main_mod
    importlib.reload(main_mod)
-    with caplog.at_level(logging.WARNING, logger="signal_v2.main"):
+    with caplog.at_level(logging.WARNING, logger="ai_trade.main"):
        with TestClient(main_mod.app) as client:
            client.get("/health")
        assert any("WEBAI_API_KEY" in rec.message for rec in caplog.records)
@@ -42,7 +42,7 @@ def test_startup_warns_if_webai_api_key_missing(monkeypatch, caplog):

 def test_startup_warns_if_kis_app_key_missing(monkeypatch, caplog):
    """KIS app_key 미설정 시 startup WARNING (KIS 호출 disabled) — V1 패턴."""
-    monkeypatch.setattr("signal_v2.config.load_dotenv", lambda *a, **k: None)
+    monkeypatch.setattr("ai_trade.config.load_dotenv", lambda *a, **k: None)
    monkeypatch.setenv("STOCK_API_URL", "https://test.stock.local")
    monkeypatch.setenv("WEBAI_API_KEY", "test-secret")
    # V1 pattern: kis_env_type=virtual, both virtual keys empty
@@ -51,12 +51,12 @@ def test_startup_warns_if_kis_app_key_missing(monkeypatch, caplog):
    monkeypatch.setenv("KIS_REAL_APP_KEY", "")

    import importlib
-    from signal_v2 import config as cfg
+    from ai_trade import config as cfg
    importlib.reload(cfg)
-    monkeypatch.setattr("signal_v2.config.load_dotenv", lambda *a, **k: None)
-    from signal_v2 import main as main_mod
+    monkeypatch.setattr("ai_trade.config.load_dotenv", lambda *a, **k: None)
+    from ai_trade import main as main_mod
    importlib.reload(main_mod)
-    with caplog.at_level(logging.WARNING, logger="signal_v2.main"):
+    with caplog.at_level(logging.WARNING, logger="ai_trade.main"):
        with TestClient(main_mod.app) as client:
            client.get("/health")
        assert any("KIS" in rec.message and "app_key" in rec.message.lower() for rec in caplog.records)
--- a/signal_v2/tests/test_momentum_classifier.py
+++ b/signal_v2/tests/test_momentum_classifier.py
@@ -1,7 +1,7 @@
 """Tests for minute momentum classifier."""
 from collections import deque

-from signal_v2.momentum_classifier import (
+from ai_trade.momentum_classifier import (
    aggregate_1min_to_5min, classify_minute_momentum,
    STRONG_UP, WEAK_UP, NEUTRAL, WEAK_DOWN, STRONG_DOWN,
 )
--- a/signal_v2/tests/test_pull_worker.py
+++ b/signal_v2/tests/test_pull_worker.py
@@ -4,12 +4,12 @@ from unittest.mock import AsyncMock, MagicMock

 import pytest

-from signal_v2.state import PollState
+from ai_trade.state import PollState


 async def test_minute_polling_cycle_updates_state_minute_bars():
    """KIS REST mock 의 분봉 데이터가 state.minute_bars[ticker] deque 에 들어간다."""
-    from signal_v2.pull_worker import _run_kis_minute_cycle
+    from ai_trade.pull_worker import _run_kis_minute_cycle

    state = PollState()
    state.portfolio = {"holdings": [{"ticker": "005930"}, {"ticker": "000660"}]}
@@ -45,7 +45,7 @@ async def test_minute_polling_cycle_updates_state_minute_bars():

 def test_websocket_message_updates_state_asking_price():
    """WebSocket callback factory → state.asking_price 갱신."""
-    from signal_v2.pull_worker import make_asking_price_callback
+    from ai_trade.pull_worker import make_asking_price_callback

    state = PollState()
    cb = make_asking_price_callback(state)
@@ -58,9 +58,9 @@ def test_websocket_message_updates_state_asking_price():
 async def test_post_close_cycle_updates_chronos_predictions():
    """mock kis + mock chronos → state.chronos_predictions + state.daily_ohlcv 갱신."""
    from unittest.mock import AsyncMock, MagicMock
-    from signal_v2.pull_worker import _run_post_close_cycle
-    from signal_v2.chronos_predictor import ChronosPrediction
-    from signal_v2.state import PollState
+    from ai_trade.pull_worker import _run_post_close_cycle
+    from ai_trade.chronos_predictor import ChronosPrediction
+    from ai_trade.state import PollState

    state = PollState()
    state.portfolio = {"holdings": [{"ticker": "005930"}]}
@@ -95,3 +95,37 @@ async def test_post_close_cycle_updates_chronos_predictions():
    assert state.chronos_predictions["005930"]["conf"] == 0.85
    assert "005930" in state.daily_ohlcv
    assert "chronos/005930" in state.last_updated
+
+
+def test_poll_loop_calls_generate_signals_after_cycle(monkeypatch):
+    """Phase 4: generate_signals 가 cycle 후 state.signals 를 갱신한다."""
+    from unittest.mock import MagicMock
+    from ai_trade.state import PollState
+    from ai_trade.signal_generator import generate_signals
+
+    state = PollState()
+    state.portfolio = {"holdings": [{
+        "ticker": "005930", "name": "삼성전자",
+        "avg_price": 75000, "current_price": 69000,
+        "pnl_pct": -0.08, "profit_rate": -8.0,
+        "quantity": 100, "broker": "키움",
+    }]}
+    state.screener_preview = {"items": []}
+
+    dedup = MagicMock()
+    dedup.is_recent.return_value = False
+
+    settings = MagicMock()
+    settings.stop_loss_pct = -0.07
+    settings.take_profit_pct = 0.15
+    settings.chronos_spread_threshold = 0.6
+    settings.asking_bid_ratio_threshold = 0.6
+    settings.confidence_threshold = 0.7
+    settings.min_momentum_for_buy = "strong_up"
+
+    generate_signals(state, dedup, settings)
+
+    assert "005930" in state.signals
+    assert state.signals["005930"]["action"] == "sell"
+    assert state.signals["005930"]["confidence_webai"] == 1.0
+    dedup.record.assert_called_with("005930", "sell", confidence=1.0)
--- a/signal_v2/tests/test_rate_limit.py
+++ b/signal_v2/tests/test_rate_limit.py
@@ -2,7 +2,7 @@
 from datetime import datetime, timedelta
 from zoneinfo import ZoneInfo

-from signal_v2.rate_limit import SignalDedup
+from ai_trade.rate_limit import SignalDedup

 KST = ZoneInfo("Asia/Seoul")

@@ -24,11 +24,11 @@ def test_is_recent_returns_false_after_24h(tmp_dedup_db, monkeypatch):
    now = datetime.now(KST)
    fake_now = now - timedelta(hours=25)
    monkeypatch.setattr(
-        "signal_v2.rate_limit._now_iso", lambda: fake_now.isoformat()
+        "ai_trade.rate_limit._now_iso", lambda: fake_now.isoformat()
    )
    dedup.record("005930", "buy", confidence=0.82)
    # Reset to real now for is_recent check
    monkeypatch.setattr(
-        "signal_v2.rate_limit._now_iso", lambda: now.isoformat()
+        "ai_trade.rate_limit._now_iso", lambda: now.isoformat()
    )
    assert dedup.is_recent("005930", "buy", within_hours=24) is False
--- a/signal_v2/tests/test_scheduler.py
+++ b/signal_v2/tests/test_scheduler.py
@@ -3,7 +3,7 @@ from datetime import datetime

 import pytest

-from signal_v2.scheduler import _next_interval, _is_market_day, KST
+from ai_trade.scheduler import _next_interval, _is_market_day, KST


 def _kst(year, month, day, hour, minute=0):
--- a/ai_trade/tests/test_signal_generator.py
+++ b/ai_trade/tests/test_signal_generator.py
@@ -0,0 +1,172 @@
+"""Tests for signal_generator."""
+from unittest.mock import MagicMock
+
+import pytest
+
+from ai_trade.signal_generator import generate_signals
+from ai_trade.state import PollState
+
+
+def _settings(**overrides):
+    """Build a Settings-like object for tests (avoid env)."""
+    defaults = dict(
+        stop_loss_pct=-0.07,
+        take_profit_pct=0.15,
+        chronos_spread_threshold=0.6,
+        asking_bid_ratio_threshold=0.6,
+        confidence_threshold=0.7,
+        min_momentum_for_buy="strong_up",
+    )
+    defaults.update(overrides)
+    m = MagicMock()
+    for k, v in defaults.items():
+        setattr(m, k, v)
+    return m
+
+
+def _make_state_with_buy_candidate(
+    ticker="005930", name="삼성전자",
+    chronos_median=0.02, chronos_q10=-0.01, chronos_q90=0.04, chronos_conf=0.85,
+    momentum="strong_up", bid_ratio=0.7, current_price=78500,
+):
+    state = PollState()
+    state.screener_preview = {"items": [{"ticker": ticker, "name": name}]}
+    state.chronos_predictions[ticker] = {
+        "median": chronos_median, "q10": chronos_q10, "q90": chronos_q90,
+        "conf": chronos_conf, "as_of": "2026-05-17T16:00:00+09:00",
+    }
+    state.minute_momentum[ticker] = momentum
+    state.asking_price[ticker] = {
+        "bid_total": int(bid_ratio * 1000),
+        "ask_total": int((1 - bid_ratio) * 1000),
+        "bid_ratio": bid_ratio,
+        "current_price": current_price,
+        "as_of": "2026-05-17T16:00:01+09:00",
+    }
+    return state
+
+
+def _make_state_with_holding(
+    ticker="005930", name="삼성전자",
+    pnl_pct=0.0, avg_price=75000, current_price=75000,
+):
+    state = PollState()
+    state.portfolio = {"holdings": [{
+        "ticker": ticker, "name": name,
+        "avg_price": avg_price, "current_price": current_price,
+        "pnl_pct": pnl_pct, "profit_rate": pnl_pct * 100,
+        "quantity": 100, "broker": "키움",
+    }]}
+    state.screener_preview = {"items": []}
+    return state
+
+
+@pytest.fixture
+def dedup_mock():
+    d = MagicMock()
+    d.is_recent.return_value = False
+    return d
+
+
+def test_buy_signal_when_all_conditions_pass_and_confidence_high(dedup_mock):
+    state = _make_state_with_buy_candidate()
+    generate_signals(state, dedup_mock, _settings())
+    assert "005930" in state.signals
+    sig = state.signals["005930"]
+    assert sig["action"] == "buy"
+    assert sig["confidence_webai"] > 0.7
+    dedup_mock.record.assert_called()
+
+
+def test_silent_when_chronos_median_negative(dedup_mock):
+    state = _make_state_with_buy_candidate(chronos_median=-0.01)
+    generate_signals(state, dedup_mock, _settings())
+    assert "005930" not in state.signals
+
+
+def test_silent_when_distribution_spread_too_wide(dedup_mock):
+    # spread = q90 - q10 = 0.5 - (-0.5) = 1.0 > 0.6 → hard gate fails
+    state = _make_state_with_buy_candidate(
+        chronos_median=0.001, chronos_q10=-0.5, chronos_q90=0.5,
+    )
+    generate_signals(state, dedup_mock, _settings())
+    assert "005930" not in state.signals
+
+
+def test_silent_when_momentum_not_strong_up(dedup_mock):
+    state = _make_state_with_buy_candidate(momentum="weak_up")
+    generate_signals(state, dedup_mock, _settings())
+    assert "005930" not in state.signals
+
+
+def test_silent_when_bid_ratio_below_threshold(dedup_mock):
+    state = _make_state_with_buy_candidate(bid_ratio=0.5)
+    generate_signals(state, dedup_mock, _settings())
+    assert "005930" not in state.signals
+
+
+def test_silent_when_confidence_below_threshold(dedup_mock):
+    # chronos_conf low + rank=20 → confidence < 0.7
+    state = _make_state_with_buy_candidate(chronos_conf=0.3)
+    # add 19 fake items to push 005930 rank to 20
+    state.screener_preview["items"] = (
+        [{"ticker": f"FAKE{i:03d}"} for i in range(19)]
+        + [{"ticker": "005930", "name": "삼성전자"}]
+    )
+    generate_signals(state, dedup_mock, _settings())
+    # confidence_webai = 0.3*0.5 + 1.0*0.3 + 0.05*0.2 = 0.46 < 0.7
+    assert "005930" not in state.signals
+
+
+def test_sell_signal_when_stop_loss_triggered(dedup_mock):
+    state = _make_state_with_holding(pnl_pct=-0.08, current_price=69000, avg_price=75000)
+    generate_signals(state, dedup_mock, _settings())
+    assert "005930" in state.signals
+    sig = state.signals["005930"]
+    assert sig["action"] == "sell"
+    assert sig["confidence_webai"] == 1.0
+    assert sig["pnl_pct"] == -0.08
+
+
+def test_sell_signal_when_take_profit_triggered(dedup_mock):
+    state = _make_state_with_holding(pnl_pct=0.16, current_price=87000, avg_price=75000)
+    generate_signals(state, dedup_mock, _settings())
+    assert "005930" in state.signals
+    sig = state.signals["005930"]
+    assert sig["action"] == "sell"
+    assert sig["confidence_webai"] == 0.6
+
+
+def test_silent_when_dedup_recently_sent(dedup_mock):
+    state = _make_state_with_buy_candidate()
+    dedup_mock.is_recent.return_value = True
+    generate_signals(state, dedup_mock, _settings())
+    assert "005930" not in state.signals
+    dedup_mock.record.assert_not_called()
+
+
+def test_sell_signal_triggers_on_anomaly_path(dedup_mock):
+    """Anomaly sell: median < -1%, momentum strong_down, low bid_ratio, confidence > threshold."""
+    state = PollState()
+    state.portfolio = {"holdings": [{
+        "ticker": "005930", "name": "삼성전자",
+        "avg_price": 75000, "current_price": 70000,
+        "pnl_pct": -0.067,  # within stop_loss tolerance (default -0.07): NOT triggering stop_loss
+        "quantity": 100, "broker": "키움",
+    }]}
+    state.screener_preview = {"items": []}
+    state.chronos_predictions["005930"] = {
+        "median": -0.025, "q10": -0.05, "q90": 0.005, "conf": 0.85,
+    }
+    state.minute_momentum["005930"] = "strong_down"
+    state.asking_price["005930"] = {"current_price": 70000, "bid_ratio": 0.30}
+    # bid_ratio 0.30 < (1 - 0.6) = 0.4 → anomaly bid_ratio gate passes
+    # confidence = 0.85*0.5 + 1.0*0.3 + 1.0*0.2 = 0.425 + 0.3 + 0.2 = 0.925 > 0.7
+
+    generate_signals(state, dedup_mock, _settings())
+
+    assert "005930" in state.signals
+    sig = state.signals["005930"]
+    assert sig["action"] == "sell"
+    assert sig["context"]["sell_reason"] == "anomaly"
+    assert sig["confidence_webai"] > 0.7
--- a/signal_v2/tests/test_stock_client.py
+++ b/signal_v2/tests/test_stock_client.py
@@ -4,7 +4,7 @@ import logging
 import pytest
 import httpx

-from signal_v2.stock_client import StockClient
+from ai_trade.stock_client import StockClient


 BASE_URL = "https://test.stock.local"
@@ -34,7 +34,7 @@ async def test_get_portfolio_normal_returns_dict_with_pnl_pct(mock_stock_api):


 async def test_get_portfolio_uses_cache_within_ttl(mock_stock_api):
-    """60s TTL 내 두번째 호출 = mock 콜 1회."""
+    """180s TTL 내 두번째 호출 = mock 콜 1회."""
    route = mock_stock_api.get("/api/webai/portfolio").mock(
        return_value=httpx.Response(
            200, json={"holdings": [], "cash": [], "summary": {}}
@@ -56,16 +56,16 @@ async def test_get_portfolio_refetches_after_ttl_expiry(mock_stock_api, monkeypa
            200, json={"holdings": [], "cash": [], "summary": {}}
        )
    )
-    # Fake clock: starts at 0, jumps to 61 between calls
+    # Fake clock: starts at 0, jumps past portfolio TTL (180s) between calls
    fake_time = [0.0]
    monkeypatch.setattr(
-        "signal_v2.stock_client.time.monotonic", lambda: fake_time[0]
+        "ai_trade.stock_client.time.monotonic", lambda: fake_time[0]
    )

    client = StockClient(BASE_URL, API_KEY)
    try:
        await client.get_portfolio()
-        fake_time[0] = 61.0  # 60s TTL 만료
+        fake_time[0] = 181.0  # 180s TTL 만료
        await client.get_portfolio()
        assert route.call_count == 2
    finally:
@@ -137,7 +137,7 @@ async def test_get_portfolio_falls_back_to_stale_on_all_failures(
    # Patch time.monotonic BEFORE first call so cached timestamp uses fake clock
    fake_time = [0.0]
    monkeypatch.setattr(
-        "signal_v2.stock_client.time.monotonic", lambda: fake_time[0]
+        "ai_trade.stock_client.time.monotonic", lambda: fake_time[0]
    )

    # First call succeeds
@@ -152,13 +152,13 @@ async def test_get_portfolio_falls_back_to_stale_on_all_failures(
        first = await client.get_portfolio()
        assert first["holdings"][0]["ticker"] == "005930"

-        # Advance fake clock past TTL (60s) so cache is stale
-        fake_time[0] = 61.0
+        # Advance fake clock past TTL (180s) so cache is stale
+        fake_time[0] = 181.0

        # Now mock to return 500s persistently
        route1.mock(return_value=httpx.Response(500, text="server error"))

-        with caplog.at_level(logging.WARNING, logger="signal_v2.stock_client"):
+        with caplog.at_level(logging.WARNING, logger="ai_trade.stock_client"):
            result = await client.get_portfolio()
            assert result["holdings"][0]["ticker"] == "005930"  # stale data returned
            assert any(
--- a/ai_trade/tests/test_stock_client_ttl.py
+++ b/ai_trade/tests/test_stock_client_ttl.py
@@ -0,0 +1,18 @@
+# tests/test_stock_client_ttl.py
+"""SP-A1 회귀 — _TTL이 NAS 부담 완화를 위한 값으로 설정되어 있어야 함."""
+from ai_trade.stock_client import _TTL
+
+
+def test_portfolio_ttl_is_180s():
+    """portfolio TTL은 180초 이상 (3분 폴링에서 1회 fetch가 3 폴링 커버)."""
+    assert _TTL["portfolio"] >= 180.0
+
+
+def test_news_sentiment_ttl_is_600s():
+    """news-sentiment TTL은 600초 이상 (10분, 뉴스 sentiment는 자주 안 바뀜)."""
+    assert _TTL["news-sentiment"] >= 600.0
+
+
+def test_screener_preview_ttl_is_300s():
+    """screener-preview TTL은 300초 이상 (5분, Top-20은 분 단위로 거의 안 바뀜)."""
+    assert _TTL["screener-preview"] >= 300.0
--- a/legacy/signal_v1/CLAUDE.md
+++ b/legacy/signal_v1/CLAUDE.md
--- a/legacy/signal_v1/DEPRECATED.md
+++ b/legacy/signal_v1/DEPRECATED.md
@@ -0,0 +1,26 @@
+# signal_v1 — DEPRECATED
+
+> **2026-05-19부터 사용 안 함.** 신규 작업 금지. 모든 트레이딩은 `web-ai/ai_trade/` (구 `signal_v2`) 에서 진행.
+
+## 폐기 사유
+
+- V2 (`ai_trade`) Phase 4 완료 — Chronos-2 zero-shot 1일 수익률 + 분봉 모멘텀 + 5-state classifier + sell-first 우선순위 + 매수 hard gate가 V1 (LSTM 7-features + Gemini Flash) 보다 정확도·확장성·해석가능성에서 우위
+- V1 + V2 동시 운영 시 KIS API rate limit 충돌
+- NAS 인바운드 polling 부담 (web-ai → NAS API) 의 50% 차지
+
+## 향후 처리
+
+- 디렉토리를 `legacy/signal_v1/`로 이동 예정 (현재 file lock 풀린 후 처리)
+- `start.bat` 진입점은 이미 `legacy/start_v1.bat`으로 이동 → 자동 시작 차단됨
+- DSM Scheduler 등 외부 trigger에 V1 startup 등록되어 있다면 해제 필요 (박재오 확인)
+
+## 활용 (필요 시)
+
+- 코드 참고용 (LSTM 모델 구조, Telegram bot 인터페이스, KIS 자동주문 패턴)
+- 별도 backtest 실행은 가능 (`backtest_runner.py`) — 단 운영 자동 실행 X
+
+## 관련 문서
+
+- 신 운영 가이드: `../ai_trade/`
+- web-ai 통합 가이드: `../CLAUDE.md`
+- V1 vs V2 진단: `../CHECK_POINT.md`
--- a/legacy/signal_v1/README.md
+++ b/legacy/signal_v1/README.md
--- a/legacy/signal_v1/backtest_runner.py
+++ b/legacy/signal_v1/backtest_runner.py
--- a/legacy/signal_v1/backtester.py
+++ b/legacy/signal_v1/backtester.py
--- a/legacy/signal_v1/main_server.py
+++ b/legacy/signal_v1/main_server.py
--- a/legacy/signal_v1/modules/init.py
+++ b/legacy/signal_v1/modules/init.py
--- a/legacy/signal_v1/modules/analysis/ai_council.py
+++ b/legacy/signal_v1/modules/analysis/ai_council.py
--- a/legacy/signal_v1/modules/analysis/backtest.py
+++ b/legacy/signal_v1/modules/analysis/backtest.py
--- a/legacy/signal_v1/modules/analysis/deep_learning.py
+++ b/legacy/signal_v1/modules/analysis/deep_learning.py
--- a/legacy/signal_v1/modules/analysis/ensemble.py
+++ b/legacy/signal_v1/modules/analysis/ensemble.py
--- a/legacy/signal_v1/modules/analysis/evaluator.py
+++ b/legacy/signal_v1/modules/analysis/evaluator.py
--- a/legacy/signal_v1/modules/analysis/macro.py
+++ b/legacy/signal_v1/modules/analysis/macro.py
--- a/legacy/signal_v1/modules/analysis/market_regime.py
+++ b/legacy/signal_v1/modules/analysis/market_regime.py
--- a/legacy/signal_v1/modules/analysis/model_validator.py
+++ b/legacy/signal_v1/modules/analysis/model_validator.py
--- a/legacy/signal_v1/modules/analysis/technical.py
+++ b/legacy/signal_v1/modules/analysis/technical.py
--- a/legacy/signal_v1/modules/bot.py
+++ b/legacy/signal_v1/modules/bot.py
--- a/legacy/signal_v1/modules/config.py
+++ b/legacy/signal_v1/modules/config.py
--- a/legacy/signal_v1/modules/services/kis.py
+++ b/legacy/signal_v1/modules/services/kis.py
--- a/legacy/signal_v1/modules/services/llm_client.py
+++ b/legacy/signal_v1/modules/services/llm_client.py
--- a/legacy/signal_v1/modules/services/news.py
+++ b/legacy/signal_v1/modules/services/news.py
--- a/legacy/signal_v1/modules/services/news_snapshot.py
+++ b/legacy/signal_v1/modules/services/news_snapshot.py
--- a/legacy/signal_v1/modules/services/ollama.py
+++ b/legacy/signal_v1/modules/services/ollama.py
--- a/legacy/signal_v1/modules/services/telegram.py
+++ b/legacy/signal_v1/modules/services/telegram.py
--- a/legacy/signal_v1/modules/services/telegram_bot/runner.py
+++ b/legacy/signal_v1/modules/services/telegram_bot/runner.py
--- a/legacy/signal_v1/modules/services/telegram_bot/server.py
+++ b/legacy/signal_v1/modules/services/telegram_bot/server.py
--- a/legacy/signal_v1/modules/services/telegram_bot/skill_runner.py
+++ b/legacy/signal_v1/modules/services/telegram_bot/skill_runner.py
--- a/legacy/signal_v1/modules/strategy/daily_ledger.py
+++ b/legacy/signal_v1/modules/strategy/daily_ledger.py
--- a/legacy/signal_v1/modules/strategy/process.py
+++ b/legacy/signal_v1/modules/strategy/process.py
--- a/legacy/signal_v1/modules/strategy/risk_gate.py
+++ b/legacy/signal_v1/modules/strategy/risk_gate.py
--- a/legacy/signal_v1/modules/utils/ipc.py
+++ b/legacy/signal_v1/modules/utils/ipc.py
--- a/legacy/signal_v1/modules/utils/market_calendar.py
+++ b/legacy/signal_v1/modules/utils/market_calendar.py
--- a/legacy/signal_v1/modules/utils/monitor.py
+++ b/legacy/signal_v1/modules/utils/monitor.py
--- a/legacy/signal_v1/modules/utils/performance_db.py
+++ b/legacy/signal_v1/modules/utils/performance_db.py
--- a/legacy/signal_v1/modules/utils/process_tracker.py
+++ b/legacy/signal_v1/modules/utils/process_tracker.py
--- a/legacy/signal_v1/theme_manager.py
+++ b/legacy/signal_v1/theme_manager.py
--- a/legacy/signal_v1/warmup_and_restart.py
+++ b/legacy/signal_v1/warmup_and_restart.py
--- a/legacy/signal_v1/watchlist_manager.py
+++ b/legacy/signal_v1/watchlist_manager.py
--- a/legacy/start_v1.bat
+++ b/legacy/start_v1.bat
--- a/services/docker-compose.yml
+++ b/services/docker-compose.yml
@@ -0,0 +1,124 @@
+name: web-ai-services
+
+services:
+  insta-render:
+    build:
+      context: ./insta-render
+    container_name: insta-render
+    restart: unless-stopped
+    ports:
+      - "18710:8000"
+    environment:
+      - TZ=Asia/Seoul
+      - REDIS_URL=${REDIS_URL:-redis://192.168.45.54:6379}
+      - NAS_BASE_URL=${NAS_BASE_URL:-http://192.168.45.54:18700}
+      - INTERNAL_API_KEY=${INTERNAL_API_KEY:-}
+      - INSTA_MEDIA_ROOT=${INSTA_MEDIA_ROOT:-/mnt/nas/webpage/data/insta}
+      - INSTA_MEDIA_URL_PREFIX=${INSTA_MEDIA_URL_PREFIX:-/media/insta}
+      - CARD_TEMPLATE_DIR=/app/templates
+    volumes:
+      - /mnt/nas/webpage/data/insta:/mnt/nas/webpage/data/insta
+    healthcheck:
+      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')"]
+      interval: 60s
+      timeout: 5s
+      retries: 3
+
+  music-render:
+    build:
+      context: ./music-render
+    container_name: music-render
+    restart: unless-stopped
+    ports:
+      - "18711:8000"
+    environment:
+      - TZ=Asia/Seoul
+      - REDIS_URL=${REDIS_URL:-redis://192.168.45.54:6379}
+      - NAS_BASE_URL=${NAS_BASE_URL:-http://192.168.45.54:18600}
+      - INTERNAL_API_KEY=${INTERNAL_API_KEY:-}
+      - SUNO_API_KEY=${SUNO_API_KEY:-}
+      - MUSIC_AI_SERVER_URL=${MUSIC_AI_SERVER_URL:-http://host.docker.internal:8765}
+      - MUSIC_MEDIA_ROOT=${MUSIC_MEDIA_ROOT:-/mnt/nas/webpage/data/music}
+      - MUSIC_MEDIA_URL_PREFIX=${MUSIC_MEDIA_URL_PREFIX:-/media/music}
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    volumes:
+      - /mnt/nas/webpage/data/music:/mnt/nas/webpage/data/music
+    healthcheck:
+      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')"]
+      interval: 60s
+      timeout: 5s
+      retries: 3
+
+  video-render:
+    build:
+      context: ./video-render
+    container_name: video-render
+    restart: unless-stopped
+    ports:
+      - "18712:8000"
+    environment:
+      - TZ=Asia/Seoul
+      - REDIS_URL=${REDIS_URL:-redis://192.168.45.54:6379}
+      - NAS_BASE_URL=${NAS_BASE_URL:-http://192.168.45.54:18801}
+      - INTERNAL_API_KEY=${INTERNAL_API_KEY:-}
+      - OPENAI_API_KEY=${OPENAI_API_KEY:-}
+      - GEMINI_API_KEY=${GEMINI_API_KEY:-}
+      - KLING_ACCESS_KEY=${KLING_ACCESS_KEY:-}
+      - KLING_SECRET_KEY=${KLING_SECRET_KEY:-}
+      - SEEDANCE_API_KEY=${SEEDANCE_API_KEY:-}
+      - VIDEO_MEDIA_ROOT=${VIDEO_MEDIA_ROOT:-/mnt/nas/webpage/data/video}
+      - VIDEO_MEDIA_URL_PREFIX=${VIDEO_MEDIA_URL_PREFIX:-/media/video}
+    volumes:
+      - /mnt/nas/webpage/data/video:/mnt/nas/webpage/data/video
+    healthcheck:
+      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')"]
+      interval: 60s
+      timeout: 5s
+      retries: 3
+
+  task-watcher:
+    build:
+      context: ./task-watcher
+    container_name: task-watcher
+    restart: unless-stopped
+    ports:
+      - "18713:8000"
+    environment:
+      - TZ=Asia/Seoul
+      - REDIS_URL=${REDIS_URL:-redis://192.168.45.54:6379}
+      - STOCK_BASE_URL=${STOCK_BASE_URL:-http://192.168.45.54:18500}
+      - TRADING_START=${TRADING_START:-07:00}
+      - TRADING_END=${TRADING_END:-16:30}
+    healthcheck:
+      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')"]
+      interval: 60s
+      timeout: 5s
+      retries: 3
+
+  image-render:
+    build:
+      context: ./image-render
+    container_name: image-render
+    restart: unless-stopped
+    ports:
+      - "18714:8000"
+    environment:
+      - TZ=Asia/Seoul
+      - REDIS_URL=${REDIS_URL:-redis://192.168.45.54:6379}
+      - NAS_BASE_URL=${NAS_BASE_URL:-http://192.168.45.54:18802}
+      - INTERNAL_API_KEY=${INTERNAL_API_KEY:-}
+      - OPENAI_API_KEY=${OPENAI_API_KEY:-}
+      - GEMINI_API_KEY=${GEMINI_API_KEY:-}
+      - COMFYUI_URL=${COMFYUI_URL:-http://host.docker.internal:8188}
+      - FLUX_BLOCK_TRADING_HOURS=${FLUX_BLOCK_TRADING_HOURS:-1}
+      - IMAGE_MEDIA_ROOT=${IMAGE_MEDIA_ROOT:-/mnt/nas/webpage/data/image}
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    volumes:
+      - /mnt/nas/webpage/data/image:/mnt/nas/webpage/data/image
+    healthcheck:
+      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')"]
+      interval: 60s
+      timeout: 5s
+      retries: 3
--- a/services/image-render/Dockerfile
+++ b/services/image-render/Dockerfile
@@ -0,0 +1,16 @@
+FROM python:3.12-slim-bookworm
+ENV PYTHONUNBUFFERED=1
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates \
+ && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir --timeout 600 --retries 5 -r requirements.txt
+
+COPY . .
+
+EXPOSE 8000
+CMD ["python", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "1"]
--- a/services/image-render/env.example
+++ b/services/image-render/env.example
@@ -0,0 +1,18 @@
+# Redis (NAS)
+REDIS_URL=redis://192.168.45.54:6379
+
+# NAS image-lab webhook
+NAS_BASE_URL=http://192.168.45.54:18802
+INTERNAL_API_KEY=replace-me
+
+# API provider keys (worker reports failed if missing)
+OPENAI_API_KEY=
+GEMINI_API_KEY=
+# Seedance key not used by image-render
+
+# FLUX local
+COMFYUI_URL=http://host.docker.internal:8188
+FLUX_BLOCK_TRADING_HOURS=1
+
+# NAS SMB mount target (image-render writes to this, NAS reads via /media/image/)
+IMAGE_MEDIA_ROOT=/mnt/nas/webpage/data/image
--- a/services/image-render/main.py
+++ b/services/image-render/main.py
@@ -0,0 +1,36 @@
+"""image-render FastAPI entry — health + lifespan (worker loop spawn)."""
+from __future__ import annotations
+
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+
+import worker
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(name)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    worker_task = asyncio.create_task(worker.worker_loop())
+    logger.info("image-render lifespan 시작")
+    try:
+        yield
+    finally:
+        worker_task.cancel()
+        try:
+            await worker_task
+        except asyncio.CancelledError:
+            pass
+        logger.info("image-render lifespan 종료")
+
+
+app = FastAPI(lifespan=lifespan)
+
+
+@app.get("/health")
+def health():
+    return {"ok": True, "service": "image-render"}
--- a/services/image-render/nas_client.py
+++ b/services/image-render/nas_client.py
@@ -0,0 +1,54 @@
+"""NAS webhook 어댑터 — Windows worker → NAS image-lab HTTP 위임.
+
+video-render nas_client 복제 (call-time os.getenv으로 테스트 격리).
+"""
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any, Dict, Optional
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+_TIMEOUT = 10.0
+
+
+def _post(payload: Dict[str, Any]) -> None:
+    nas_base_url = os.getenv("NAS_BASE_URL", "http://192.168.45.54:18802")
+    internal_api_key = os.getenv("INTERNAL_API_KEY", "")
+    url = f"{nas_base_url}/api/internal/image/update"
+    try:
+        r = httpx.post(
+            url,
+            headers={"X-Internal-Key": internal_api_key},
+            json=payload,
+            timeout=_TIMEOUT,
+        )
+        if r.status_code != 200:
+            logger.error("webhook %s returned %d: %s",
+                         payload.get("task_id"), r.status_code, r.text[:200])
+    except Exception:
+        logger.exception("webhook %s 호출 실패", payload.get("task_id"))
+
+
+def webhook_update_task(
+    task_id: str,
+    status: str,
+    progress: int,
+    message: str = "",
+    image_url: Optional[str] = None,
+    error: Optional[str] = None,
+) -> None:
+    payload: Dict[str, Any] = {
+        "task_id": task_id,
+        "status": status,
+        "progress": progress,
+        "message": message,
+    }
+    if image_url is not None:
+        payload["image_url"] = image_url
+    if error is not None:
+        payload["error"] = error
+    _post(payload)
--- a/services/image-render/providers/init.py
+++ b/services/image-render/providers/init.py
--- a/services/image-render/providers/_media.py
+++ b/services/image-render/providers/_media.py
@@ -0,0 +1,18 @@
+"""b64 이미지 → NAS SMB 경로 저장 → /media/image URL 반환."""
+from __future__ import annotations
+
+import base64
+import os
+import uuid
+
+IMAGE_MEDIA_ROOT = os.getenv("IMAGE_MEDIA_ROOT", "/mnt/nas/webpage/data/image")
+IMAGE_MEDIA_URL_PREFIX = os.getenv("IMAGE_MEDIA_URL_PREFIX", "/media/image")
+
+
+def save_b64_png(task_id: str, b64_data: str) -> str:
+    os.makedirs(IMAGE_MEDIA_ROOT, exist_ok=True)
+    fname = f"{task_id}-{uuid.uuid4().hex[:8]}.png"
+    path = os.path.join(IMAGE_MEDIA_ROOT, fname)
+    with open(path, "wb") as f:
+        f.write(base64.b64decode(b64_data))
+    return f"{IMAGE_MEDIA_URL_PREFIX}/{fname}"
--- a/services/image-render/providers/flux.py
+++ b/services/image-render/providers/flux.py
@@ -0,0 +1,79 @@
+"""FLUX 로컬 — ComfyUI HTTP API.
+
+POST {COMFYUI_URL}/prompt  (workflow JSON) → prompt_id
+GET  {COMFYUI_URL}/history/{prompt_id} → outputs → image filename
+GET  {COMFYUI_URL}/view?filename=... → PNG bytes → b64
+
+워크플로우 JSON은 `flux_workflow.json` (ComfyUI UI에서 "Save (API Format)"로 export, CLIPTextEncode 노드 text를 "%PROMPT%"로 수동 치환). 박재오 산출물.
+"""
+from __future__ import annotations
+
+import base64, json, logging, os, time
+from datetime import datetime, timezone, timedelta
+import requests
+
+from nas_client import webhook_update_task
+from providers._media import save_b64_png
+
+logger = logging.getLogger(__name__)
+COMFYUI_URL = os.getenv("COMFYUI_URL", "http://127.0.0.1:8188")
+WORKFLOW_PATH = os.path.join(os.path.dirname(__file__), "flux_workflow.json")
+POLL_INTERVAL = 2
+POLL_MAX = 120
+
+
+def _is_trading_hours() -> bool:
+    kst = timezone(timedelta(hours=9))
+    now = datetime.now(kst)
+    if now.weekday() >= 5:
+        return False
+    return (now.hour, now.minute) >= (9, 0) and (now.hour, now.minute) <= (15, 30)
+
+
+def _load_workflow(prompt: str, size: str) -> dict:
+    with open(WORKFLOW_PATH, encoding="utf-8") as f:
+        wf = json.load(f)
+    # CLIPTextEncode 노드의 text를 prompt로 치환 (workflow에 "%PROMPT%" placeholder 사용)
+    raw = json.dumps(wf).replace("%PROMPT%", prompt.replace('"', "'"))
+    return json.loads(raw)
+
+
+def _submit_prompt(workflow: dict) -> str:
+    r = requests.post(f"{COMFYUI_URL}/prompt", json={"prompt": workflow}, timeout=30)
+    r.raise_for_status()
+    return r.json()["prompt_id"]
+
+
+def _poll_image_b64(prompt_id: str):
+    for _ in range(POLL_MAX):
+        h = requests.get(f"{COMFYUI_URL}/history/{prompt_id}", timeout=10)
+        data = h.json().get(prompt_id)
+        if data and data.get("outputs"):
+            for node_out in data["outputs"].values():
+                for img in node_out.get("images", []):
+                    view = requests.get(f"{COMFYUI_URL}/view",
+                                        params={"filename": img["filename"], "subfolder": img.get("subfolder", ""), "type": img.get("type", "output")},
+                                        timeout=30)
+                    view.raise_for_status()
+                    return base64.b64encode(view.content).decode()
+        time.sleep(POLL_INTERVAL)
+    return None
+
+
+def run_flux_generation(task_id: str, params: dict) -> None:
+    try:
+        if os.getenv("FLUX_BLOCK_TRADING_HOURS") == "1" and _is_trading_hours():
+            webhook_update_task(task_id, "failed", 0, "", error="장중 GPU 보호 — FLUX 거부 (API provider 사용 권장)")
+            return
+        webhook_update_task(task_id, "processing", 10, "FLUX (ComfyUI) 생성 중...")
+        wf = _load_workflow(params["prompt"], params.get("size") or "1024x1024")
+        pid = _submit_prompt(wf)
+        b64 = _poll_image_b64(pid)
+        if not b64:
+            webhook_update_task(task_id, "failed", 0, "", error="ComfyUI 타임아웃 또는 출력 없음")
+            return
+        url = save_b64_png(task_id, b64)
+        webhook_update_task(task_id, "succeeded", 100, "완료", image_url=url)
+    except Exception as e:
+        logger.exception("flux task=%s 실패", task_id)
+        webhook_update_task(task_id, "failed", 0, "", error=str(e))
--- a/services/image-render/providers/gpt_image.py
+++ b/services/image-render/providers/gpt_image.py
@@ -0,0 +1,47 @@
+"""GPT Image 2.0 — OpenAI Images API.
+
+POST https://api.openai.com/v1/images/generations
+body {model:"gpt-image-1", prompt, size, n:1} → data[0].b64_json
+"""
+from __future__ import annotations
+
+import logging
+import os
+
+import requests
+
+from nas_client import webhook_update_task
+from providers._media import save_b64_png
+
+logger = logging.getLogger(__name__)
+OPENAI_URL = "https://api.openai.com/v1/images/generations"
+DEFAULT_MODEL = "gpt-image-1"
+
+
+def run_gpt_image_generation(task_id: str, params: dict) -> None:
+    try:
+        if not os.getenv("OPENAI_API_KEY"):
+            webhook_update_task(task_id, "failed", 0, "", error="OPENAI_API_KEY 미설정 (Windows .env)")
+            return
+        webhook_update_task(task_id, "processing", 10, "GPT Image 호출 중...")
+        body = {
+            "model": params.get("model") or DEFAULT_MODEL,
+            "prompt": params["prompt"],
+            "size": params.get("size") or "1024x1024",
+            "n": 1,
+        }
+        resp = requests.post(
+            OPENAI_URL,
+            headers={"Authorization": f"Bearer {os.getenv('OPENAI_API_KEY')}", "Content-Type": "application/json"},
+            json=body,
+            timeout=120,
+        )
+        if resp.status_code != 200:
+            webhook_update_task(task_id, "failed", 0, "", error=f"OpenAI {resp.status_code}: {resp.text[:200]}")
+            return
+        b64 = resp.json()["data"][0]["b64_json"]
+        url = save_b64_png(task_id, b64)
+        webhook_update_task(task_id, "succeeded", 100, "완료", image_url=url)
+    except Exception as e:
+        logger.exception("gpt_image task=%s 실패", task_id)
+        webhook_update_task(task_id, "failed", 0, "", error=str(e))
--- a/services/image-render/providers/nano_banana.py
+++ b/services/image-render/providers/nano_banana.py
@@ -0,0 +1,52 @@
+"""Nano Banana — Gemini 2.5 Flash Image (generativelanguage API).
+
+POST /v1beta/models/{MODEL}:generateContent
+→ candidates[0].content.parts[*].inlineData.data (b64 png)
+"""
+from __future__ import annotations
+
+import logging, os
+import requests
+
+from nas_client import webhook_update_task
+from providers._media import save_b64_png
+
+logger = logging.getLogger(__name__)
+GEMINI_BASE = "https://generativelanguage.googleapis.com/v1beta"
+DEFAULT_MODEL = "gemini-2.5-flash-image"
+
+
+def _extract_b64(data: dict):
+    for cand in data.get("candidates", []):
+        for part in cand.get("content", {}).get("parts", []):
+            inline = part.get("inlineData") or part.get("inline_data")
+            if inline and inline.get("data"):
+                return inline["data"]
+    return None
+
+
+def run_nano_banana_generation(task_id: str, params: dict) -> None:
+    try:
+        if not os.getenv("GEMINI_API_KEY"):
+            webhook_update_task(task_id, "failed", 0, "", error="GEMINI_API_KEY 미설정 (Windows .env)")
+            return
+        webhook_update_task(task_id, "processing", 10, "Nano Banana (Gemini) 호출 중...")
+        model_id = params.get("model") or DEFAULT_MODEL
+        body = {"contents": [{"parts": [{"text": params["prompt"]}]}]}
+        resp = requests.post(
+            f"{GEMINI_BASE}/models/{model_id}:generateContent",
+            headers={"x-goog-api-key": os.getenv("GEMINI_API_KEY"), "Content-Type": "application/json"},
+            json=body, timeout=120,
+        )
+        if resp.status_code != 200:
+            webhook_update_task(task_id, "failed", 0, "", error=f"Gemini {resp.status_code}: {resp.text[:200]}")
+            return
+        b64 = _extract_b64(resp.json())
+        if not b64:
+            webhook_update_task(task_id, "failed", 0, "", error="Gemini 응답에 이미지 없음")
+            return
+        url = save_b64_png(task_id, b64)
+        webhook_update_task(task_id, "succeeded", 100, "완료", image_url=url)
+    except Exception as e:
+        logger.exception("nano_banana task=%s 실패", task_id)
+        webhook_update_task(task_id, "failed", 0, "", error=str(e))
--- a/services/image-render/requirements.txt
+++ b/services/image-render/requirements.txt
@@ -0,0 +1,9 @@
+fastapi==0.115.6
+uvicorn[standard]==0.34.0
+requests==2.32.3
+redis>=5.0
+httpx>=0.27
+openai>=1.50.0
+pytest>=8.0
+pytest-asyncio>=0.24
+respx>=0.21
--- a/services/image-render/tests/init.py
+++ b/services/image-render/tests/init.py
--- a/services/image-render/tests/test_flux.py
+++ b/services/image-render/tests/test_flux.py
@@ -0,0 +1,21 @@
+import providers.flux as fx
+
+def test_blocked_during_trading_hours(monkeypatch):
+    monkeypatch.setenv("FLUX_BLOCK_TRADING_HOURS", "1")
+    monkeypatch.setattr(fx, "_is_trading_hours", lambda: True)
+    calls = []
+    monkeypatch.setattr(fx, "webhook_update_task", lambda *a, **k: calls.append((a, k)))
+    fx.run_flux_generation("t1", {"prompt": "a cat"})
+    assert calls[-1][0][1] == "failed"
+    assert "장중" in calls[-1][1]["error"]
+
+def test_success_polls_history_and_saves(monkeypatch):
+    monkeypatch.setattr(fx, "_is_trading_hours", lambda: False)
+    calls = []
+    monkeypatch.setattr(fx, "webhook_update_task", lambda *a, **k: calls.append((a, k)))
+    monkeypatch.setattr(fx, "_load_workflow", lambda prompt, size: {"3": {}})
+    monkeypatch.setattr(fx, "_submit_prompt", lambda wf: "pid-1")
+    monkeypatch.setattr(fx, "_poll_image_b64", lambda pid: "ZmFrZQ==")
+    monkeypatch.setattr(fx, "save_b64_png", lambda tid, b64: "/media/image/t1.png")
+    fx.run_flux_generation("t1", {"prompt": "a cat"})
+    assert [c for c in calls if c[0][1] == "succeeded"]
--- a/services/image-render/tests/test_gpt_image.py
+++ b/services/image-render/tests/test_gpt_image.py
@@ -0,0 +1,32 @@
+import providers.gpt_image as gi
+
+
+def test_missing_key_reports_failed(monkeypatch):
+    monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+    calls = []
+    monkeypatch.setattr(gi, "webhook_update_task", lambda *a, **k: calls.append((a, k)))
+    gi.run_gpt_image_generation("t1", {"prompt": "a cat"})
+    # 마지막 호출이 failed
+    assert calls[-1][0][1] == "failed"
+
+
+def test_success_saves_and_reports_url(monkeypatch):
+    monkeypatch.setenv("OPENAI_API_KEY", "sk-test")
+    calls = []
+    monkeypatch.setattr(gi, "webhook_update_task", lambda *a, **k: calls.append((a, k)))
+    monkeypatch.setattr(gi, "save_b64_png", lambda tid, b64: "/media/image/t1.png")
+
+    class FakeResp:
+        status_code = 200
+
+        def json(self):
+            return {"data": [{"b64_json": "ZmFrZQ=="}]}
+
+        def raise_for_status(self):
+            pass
+
+    monkeypatch.setattr(gi.requests, "post", lambda *a, **k: FakeResp())
+
+    gi.run_gpt_image_generation("t1", {"prompt": "a cat"})
+    succeeded = [c for c in calls if c[0][1] == "succeeded"]
+    assert succeeded and succeeded[-1][1]["image_url"] == "/media/image/t1.png"
--- a/services/image-render/tests/test_nano_banana.py
+++ b/services/image-render/tests/test_nano_banana.py
@@ -0,0 +1,25 @@
+import providers.nano_banana as nb
+
+def test_missing_key_reports_failed(monkeypatch):
+    monkeypatch.delenv("GEMINI_API_KEY", raising=False)
+    calls = []
+    monkeypatch.setattr(nb, "webhook_update_task", lambda *a, **k: calls.append((a, k)))
+    nb.run_nano_banana_generation("t1", {"prompt": "a cat"})
+    assert calls[-1][0][1] == "failed"
+
+def test_success_extracts_inline_data(monkeypatch):
+    monkeypatch.setenv("GEMINI_API_KEY", "g-test")
+    calls = []
+    monkeypatch.setattr(nb, "webhook_update_task", lambda *a, **k: calls.append((a, k)))
+    monkeypatch.setattr(nb, "save_b64_png", lambda tid, b64: "/media/image/t1.png")
+
+    class FakeResp:
+        status_code = 200
+        def json(self):
+            return {"candidates": [{"content": {"parts": [
+                {"inlineData": {"mimeType": "image/png", "data": "ZmFrZQ=="}}
+            ]}}]}
+    monkeypatch.setattr(nb.requests, "post", lambda *a, **k: FakeResp())
+
+    nb.run_nano_banana_generation("t1", {"prompt": "a cat"})
+    assert [c for c in calls if c[0][1] == "succeeded"]
--- a/Show More
+++ b/Show More