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

ai_trade(HIGH, native python :8001) + wsl_docker(NORMAL, WSL2 Ubuntu-24.04
docker compose up). spec의 signal_v2→ai_trade, 22.04→24.04, web-ai-services
→web-ai/services 정정. sudoers NOPASSWD + 재부팅 검증 절차.
Plan-B-Infra Phase 3.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

.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

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).

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` 참조 (있다면).

ai_trade/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())

ai_trade/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__)
 

ai_trade/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__)
 
@@ -45,7 +45,7 @@ async def poll_loop(
             # Phase 4: generate signals
             if dedup is not None and settings is not None:
                 try:
-                    from signal_v2.signal_generator import generate_signals
+                    from ai_trade.signal_generator import generate_signals
                     generate_signals(state, dedup, settings)
                 except Exception:
                     logger.exception("generate_signals failed")
@@ -186,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)

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

ai_trade/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

ai_trade/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

ai_trade/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

ai_trade/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

ai_trade/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"

ai_trade/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)

ai_trade/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,
 )

ai_trade/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"}]}
@@ -100,8 +100,8 @@ async def test_post_close_cycle_updates_chronos_predictions():
 def test_poll_loop_calls_generate_signals_after_cycle(monkeypatch):
     """Phase 4: generate_signals 가 cycle 후 state.signals 를 갱신한다."""
     from unittest.mock import MagicMock
-    from signal_v2.state import PollState
-    from signal_v2.signal_generator import generate_signals
+    from ai_trade.state import PollState
+    from ai_trade.signal_generator import generate_signals
 
     state = PollState()
     state.portfolio = {"holdings": [{

ai_trade/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

ai_trade/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):

ai_trade/tests/test_signal_generator.py

@@ -3,8 +3,8 @@ from unittest.mock import MagicMock
 
 import pytest
 
-from signal_v2.signal_generator import generate_signals
-from signal_v2.state import PollState
+from ai_trade.signal_generator import generate_signals
+from ai_trade.state import PollState
 
 
 def _settings(**overrides):

ai_trade/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(

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

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`

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

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"]

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

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"}

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)

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}"

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))

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))

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))

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

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"]

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"

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"]