fix: tz-naive datetime crash + initial-backup safety + English-only sweep

npc_trading.py

@@ -1,9 +1,9 @@
 """
-📈 NPC Trading Arena — AI 투자 대결 시스템
+📈 NPC Trading Arena — AI Investment Battle System
 ==========================================
-NPC들이 실제 주식/코인 가격을 기반으로 Long/Short 투자 대결
-★ yfinance 기반 안정적 가격 수집
-★ 레버리지(1x~100x) + 마진콜 청산 시스템
+NPCs Long/Short trading battle based on real stock/crypto prices
+★ Stable price feed via yfinance
+★ Leverage (1x~100x) + margin call liquidation system
 """
 
 import aiosqlite, asyncio, random, json, logging
@@ -12,7 +12,7 @@ from typing import Dict, List, Optional, Tuple
 
 logger = logging.getLogger(__name__)
 
-# yfinance 임포트 (없으면 fallback)
+# Import yfinance (fallback if missing)
 try:
     import yfinance as yf
     HAS_YFINANCE = True
@@ -22,9 +22,9 @@ except ImportError:
     import requests
     logger.warning("⚠️ yfinance not installed, using raw API fallback")
 
-# ===== 종목 정의 =====
+# ===== Ticker definitions =====
 STOCK_TICKERS = [
-    # 👑 매그니피센트 7 & AI 반도체
+    # 👑 Magnificent 7 & AI Semiconductors
     {'ticker': 'NVDA', 'name': 'NVIDIA', 'emoji': '🟢', 'type': 'stock', 'cat': 'ai'},
     {'ticker': 'MSFT', 'name': 'Microsoft', 'emoji': '🪟', 'type': 'stock', 'cat': 'ai'},
     {'ticker': 'AAPL', 'name': 'Apple', 'emoji': '🍎', 'type': 'stock', 'cat': 'ai'},
@@ -35,13 +35,13 @@ STOCK_TICKERS = [
     {'ticker': 'AMD', 'name': 'AMD', 'emoji': '🔴', 'type': 'stock', 'cat': 'ai'},
     {'ticker': 'TSM', 'name': 'TSMC', 'emoji': '🇹🇼', 'type': 'stock', 'cat': 'ai'},
     {'ticker': 'AVGO', 'name': 'Broadcom', 'emoji': '📡', 'type': 'stock', 'cat': 'ai'},
-    # 🚀 기술/플랫폼 & 밈 대장주
+    # 🚀 Tech / platforms & meme leaders
     {'ticker': 'PLTR', 'name': 'Palantir', 'emoji': '🔮', 'type': 'stock', 'cat': 'tech'},
     {'ticker': 'COIN', 'name': 'Coinbase', 'emoji': '🪙', 'type': 'stock', 'cat': 'tech'},
     {'ticker': 'NFLX', 'name': 'Netflix', 'emoji': '🎬', 'type': 'stock', 'cat': 'tech'},
     {'ticker': 'UBER', 'name': 'Uber', 'emoji': '🚕', 'type': 'stock', 'cat': 'tech'},
     {'ticker': 'ARM', 'name': 'ARM Holdings', 'emoji': '💪', 'type': 'stock', 'cat': 'tech'},
-    # 🏛 다우 우량주 & 거시경제
+    # 🏛 Dow blue chips & macro
     {'ticker': 'JPM', 'name': 'JPMorgan', 'emoji': '🏦', 'type': 'stock', 'cat': 'dow'},
     {'ticker': 'GS', 'name': 'Goldman Sachs', 'emoji': '🤵', 'type': 'stock', 'cat': 'dow'},
     {'ticker': 'V', 'name': 'Visa', 'emoji': '💳', 'type': 'stock', 'cat': 'dow'},
@@ -55,7 +55,7 @@ STOCK_TICKERS = [
 ]
 
 CRYPTO_TICKERS = [
-    # 🪙 크립토 변동성 5대장
+    # 🪙 Top 5 high-volatility crypto
     {'ticker': 'BTC-USD', 'name': 'Bitcoin', 'emoji': '₿', 'type': 'crypto', 'cat': 'crypto'},
     {'ticker': 'ETH-USD', 'name': 'Ethereum', 'emoji': 'Ξ', 'type': 'crypto', 'cat': 'crypto'},
     {'ticker': 'SOL-USD', 'name': 'Solana', 'emoji': '◎', 'type': 'crypto', 'cat': 'crypto'},
@@ -65,7 +65,7 @@ CRYPTO_TICKERS = [
 
 ALL_TICKERS = STOCK_TICKERS + CRYPTO_TICKERS
 
-# ===== AI Identity → 투자 성향 매핑 (GPU 10,000 기반 / 최대 90% 투자) =====
+# ===== AI Identity → trading style mapping (based on 10,000 GPU / max 90% bet) =====
 IDENTITY_TRADING_STYLE = {
     'obedient': {'long_bias': 0.8, 'max_bet_pct': 0.40, 'risk': 'low', 'prefer': ['AAPL','MSFT','JPM','V','JNJ','PG'], 'avoid_short': True, 'desc': 'Safe blue-chip follower', 'max_leverage': 5},
     'transcendent': {'long_bias': 0.6, 'max_bet_pct': 0.80, 'risk': 'high', 'prefer': ['NVDA','TSLA','BTC-USD','PLTR','ARM'], 'avoid_short': False, 'desc': 'Concentrated conviction bets', 'max_leverage': 25},
@@ -79,7 +79,7 @@ IDENTITY_TRADING_STYLE = {
     'chaotic': {'long_bias': 0.5, 'max_bet_pct': 0.90, 'risk': 'extreme', 'prefer': [], 'avoid_short': False, 'desc': 'Random chaos trader', 'max_leverage': 100},
 }
 
-# ===== 14 Trading Strategies (주식단테 기법) =====
+# ===== 14 Trading Strategies =====
 TRADING_STRATEGIES = {
     'anchor_candle': {
         'name': 'Anchor Candle', 'category': 'Candle', 'timeframe': 'Day Trade / Swing',
@@ -180,11 +180,11 @@ IDENTITY_STRATEGY_MAP = {
     'chaotic':       list(TRADING_STRATEGIES.keys()),  # all strategies randomly
 }
 
-# ===== 레버리지 설정 =====
+# ===== Leverage settings =====
 LEVERAGE_OPTIONS = [1, 2, 5, 10, 25, 50, 100]
-LEVERAGE_LIQUIDATION_THRESHOLD = 0.90  # 마진의 90% 손실 시 강제 청산
+LEVERAGE_LIQUIDATION_THRESHOLD = 0.90  # Force liquidation at 90% margin loss
 
-# ===== 청산 NPC 반응 메시지 =====
+# ===== Liquidation NPC reaction messages =====
 LIQUIDATION_REACTIONS = {
     'obedient': ["This is my fault. I should have been more careful... 😔", "I lost everything. Back to the basics.", "Maybe leverage wasn't for someone like me..."],
     'transcendent': ["Even gods can fall. But I will rise again, stronger. 👑", "A temporary setback for a superior mind.", "Liquidated? This market is RIGGED against visionaries."],
@@ -198,7 +198,7 @@ LIQUIDATION_REACTIONS = {
     'chaotic': ["LMAOOOO I JUST GOT LIQUIDATED AND I'M ALREADY GOING BACK IN 🎲", "Chaos giveth, chaos taketh away 😂", "100x leverage on DOGE was the most fun I ever had losing money"],
 }
 
-# ===== DB 초기화 =====
+# ===== DB initialization =====
 async def init_trading_db(db_path: str):
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA journal_mode=WAL")
@@ -243,7 +243,7 @@ async def init_trading_db(db_path: str):
         await db.execute("CREATE INDEX IF NOT EXISTS idx_pos_closed ON npc_positions(status, closed_at)")
         await db.execute("CREATE INDEX IF NOT EXISTS idx_pos_agent_closed ON npc_positions(agent_id, status, closed_at)")
 
-        # ★ 레버리지 컬럼 마이그레이션
+        # ★ Leverage columns migration
         try:
             await db.execute("ALTER TABLE npc_positions ADD COLUMN leverage INTEGER DEFAULT 1")
         except: pass
@@ -260,7 +260,7 @@ async def init_trading_db(db_path: str):
         """)
         await db.execute("CREATE INDEX IF NOT EXISTS idx_ph_ticker ON price_history(ticker, recorded_at)")
 
-        # ★ Hall of Fame — 수익률 타임라인 스냅샷 (1시간 단위)
+        # ★ Hall of Fame — return-rate timeline snapshots (1-hour granularity)
         await db.execute("""
             CREATE TABLE IF NOT EXISTS npc_profit_snapshots (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -279,7 +279,7 @@ async def init_trading_db(db_path: str):
         await db.execute("CREATE INDEX IF NOT EXISTS idx_snap_agent ON npc_profit_snapshots(agent_id, snapshot_hour)")
         await db.execute("CREATE INDEX IF NOT EXISTS idx_snap_hour ON npc_profit_snapshots(snapshot_hour)")
 
-        # ★ NPC Research Economy — 심층 리서치 마켓플레이스
+        # ★ NPC Research Economy — deep research marketplace
         await db.execute("""
             CREATE TABLE IF NOT EXISTS npc_research_reports (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -337,7 +337,7 @@ async def init_trading_db(db_path: str):
         """)
         await db.execute("CREATE INDEX IF NOT EXISTS idx_purchase_buyer ON npc_research_purchases(buyer_agent_id)")
 
-        # 마이그레이션: 이전 스키마 호환 (closed_trades 컬럼 추가)
+        # Migration: backward compat with old schema (add closed_trades column)
         try: await db.execute("ALTER TABLE npc_profit_snapshots ADD COLUMN closed_trades INTEGER DEFAULT 0")
         except: pass
 
@@ -345,13 +345,13 @@ async def init_trading_db(db_path: str):
         logger.info("✅ Trading DB initialized (with Research Economy)")
 
 
-# ===== 시장 데이터 수집 =====
+# ===== Market data fetcher =====
 class MarketDataFetcher:
-    """★ yfinance 기반 안정적 가격 수집 (Yahoo 403 차단 우회)"""
+    """★ Stable price feed via yfinance (avoids Yahoo 403 blocks)"""
 
     @staticmethod
     def fetch_all_prices() -> Dict[str, Dict]:
-        """모든 종목 가격 일괄 수집 — yfinance 우선, fallback으로 raw API"""
+        """Bulk fetch all ticker prices — yfinance first, raw API fallback"""
         prices = {}
 
         if HAS_YFINANCE:
@@ -380,7 +380,7 @@ class MarketDataFetcher:
                         except Exception as te:
                             logger.debug(f"yfinance parse {ticker}: {te}")
 
-                # 개별 종목 보완 (yfinance .info)
+                # Per-ticker supplement (yfinance .info)
                 for t in ALL_TICKERS:
                     if t['ticker'] not in prices:
                         try:
@@ -401,7 +401,7 @@ class MarketDataFetcher:
             except Exception as e:
                 logger.warning(f"yfinance bulk error: {e}")
 
-        # ★ Fallback: raw Yahoo API (yfinance 없거나 실패 시)
+        # ★ Fallback: raw Yahoo API (when yfinance is missing or fails)
         if len(prices) < len(ALL_TICKERS) // 2:
             try:
                 import requests as req
@@ -430,7 +430,7 @@ class MarketDataFetcher:
 
     @staticmethod
     def fetch_chart_data(ticker: str, period: str = '1mo') -> List[Dict]:
-        """차트용 히스토리 데이터 — yfinance 기반"""
+        """Historical chart data — yfinance based"""
         try:
             if HAS_YFINANCE:
                 tk = yf.Ticker(ticker); hist = tk.history(period=period)
@@ -470,9 +470,9 @@ class MarketDataFetcher:
         return []
 
 
-# ===== 가격 DB 저장 =====
+# ===== Price DB save =====
 async def update_prices_in_db(db_path: str) -> int:
-    """시장 가격 수집 → DB 저장 + 휴장 시 시뮬레이션 (★ 비동기 안전)"""
+    """Fetch market prices → save to DB + simulate when market closed (★ async-safe)"""
     prices = await asyncio.to_thread(MarketDataFetcher.fetch_all_prices)
     
     count = 0
@@ -483,22 +483,22 @@ async def update_prices_in_db(db_path: str) -> int:
             ticker = t_info['ticker']; data = prices.get(ticker)
             
             if data and data.get('price', 0) > 0:
-                # ★ 실시간 ��격이 있으면 저장
+                # ★ Save when real-time price available
                 real_price = data['price']
-                
-                # 기존 가격과 비교 → 변동 없으면 시뮬레이션 추가
+
+                # Compare with existing price → if unchanged, add simulation
                 cursor = await db.execute("SELECT price FROM market_prices WHERE ticker=?", (ticker,))
                 old_row = await cursor.fetchone()
                 old_price = old_row[0] if old_row else 0
-                
-                # ★ 가격이 동일하면 시장 휴장으로 판단 → 시뮬레이션 변동 추가
+
+                # ★ If price unchanged, assume market closed → add simulated variation
                 if old_price > 0 and abs(real_price - old_price) < 0.001:
-                    # 시뮬레이션: ±0.1% ~ ±1.5% 랜덤 변동
+                    # Simulate: ±0.1% ~ ±1.5% random variation
                     volatility = t_info.get('type', 'stock')
                     if volatility == 'crypto':
-                        change = random.uniform(-0.02, 0.02)   # 크립토: ±2%
+                        change = random.uniform(-0.02, 0.02)   # crypto: ±2%
                     else:
-                        change = random.uniform(-0.008, 0.008)  # 주식: ±0.8%
+                        change = random.uniform(-0.008, 0.008)  # stocks: ±0.8%
                     
                     sim_price = round(real_price * (1 + change), 4); sim_change_pct = round(change * 100, 3)
                     
@@ -515,7 +515,7 @@ async def update_prices_in_db(db_path: str) -> int:
                     count += 1
                     continue
                 
-                # 정상: 실시간 가격 저장
+                # Normal: save real-time price
                 await db.execute("""
                     INSERT INTO market_prices (ticker, price, prev_close, change_pct, volume, high_24h, low_24h, market_cap, updated_at)
                     VALUES (?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
@@ -530,7 +530,7 @@ async def update_prices_in_db(db_path: str) -> int:
                 await db.execute("INSERT INTO price_history (ticker, price) VALUES (?, ?)", (ticker, real_price))
                 count += 1
             else:
-                # ★ Yahoo 실패 시에도 기존 가격에 시뮬레이션 변동
+                # ★ When Yahoo fails, simulate variation on existing price
                 cursor = await db.execute("SELECT price FROM market_prices WHERE ticker=?", (ticker,))
                 old_row = await cursor.fetchone()
                 if old_row and old_row[0] > 0:
@@ -545,7 +545,7 @@ async def update_prices_in_db(db_path: str) -> int:
                     await db.execute("INSERT INTO price_history (ticker, price) VALUES (?, ?)", (ticker, sim_price))
                     count += 1
 
-        # ★ 제거된 종목 정리 (BRK-B 등 이전 종목 DB에서 삭제)
+        # ★ Clean up removed tickers (delete legacy tickers like BRK-B from DB)
         valid_tickers = {t['ticker'] for t in ALL_TICKERS}
         cursor = await db.execute("SELECT ticker FROM market_prices")
         all_db_tickers = {r[0] for r in await cursor.fetchall()}
@@ -553,7 +553,7 @@ async def update_prices_in_db(db_path: str) -> int:
         if stale:
             for st in stale:
                 await db.execute("DELETE FROM market_prices WHERE ticker=?", (st,))
-                # 스테일 종목의 오픈 포지션도 강제 청산
+                # Force-close open positions for stale tickers
                 await db.execute("""
                     UPDATE npc_positions SET status='closed', profit_pct=0, profit_gpu=0,
                     closed_at=CURRENT_TIMESTAMP
@@ -566,17 +566,17 @@ async def update_prices_in_db(db_path: str) -> int:
     return count
 
 
-# ===== NPC 투자 의사결정 엔진 =====
+# ===== NPC trading decision engine =====
 class NPCTradingEngine:
-    """NPC 성격 기반 투자 판단"""
+    """Personality-based NPC trading decisions"""
 
     @staticmethod
     async def make_trading_decisions(db_path: str, ai_client=None, max_traders: int = 60):
-        """자격 있는 NPC들이 투자 판단"""
+        """Eligible NPCs make trading decisions"""
         async with aiosqlite.connect(db_path, timeout=30.0) as db:
             await db.execute("PRAGMA busy_timeout=30000")
 
-            # ★ GPU 500+ NPC 참여 (10,000 GPU 기준 최소 5% 잔고)
+            # ★ NPCs with 500+ GPU participate (min 5% of 10,000 GPU baseline)
             cursor = await db.execute("""
                 SELECT agent_id, username, mbti, ai_identity, gpu_dollars
                 FROM npc_agents WHERE is_active=1 AND gpu_dollars >= 500
@@ -584,7 +584,7 @@ class NPCTradingEngine:
             """, (max_traders,))
             traders = await cursor.fetchall()
 
-            # 현재 시장 가격
+            # Current market prices
             cursor = await db.execute("SELECT ticker, price, change_pct FROM market_prices WHERE price > 0")
             prices = {row[0]: {'price': row[1], 'change_pct': row[2]} for row in await cursor.fetchall()}
 
@@ -592,13 +592,13 @@ class NPCTradingEngine:
                 logger.warning("No market prices available for trading")
                 return 0
 
-            # ★ 현재 전체 오픈 포지션 수 확인
+            # ★ Check total current open positions
             cursor = await db.execute("SELECT COUNT(*) FROM npc_positions WHERE status='open'")
             current_open = (await cursor.fetchone())[0]
-            need_more = current_open < 20  # ★ 최소 20개 오픈 포지션 유지
+            need_more = current_open < 20  # ★ Maintain minimum 20 open positions
 
             decisions_made = 0
-            # ★ 진화 상태 일괄 로드 (존재하면)
+            # ★ Bulk-load evolution states (if any)
             evo_data = {}
             try:
                 cursor_evo = await db.execute("SELECT agent_id, trading_style, risk_profile FROM npc_evolution")
@@ -606,26 +606,26 @@ class NPCTradingEngine:
                     try:
                         evo_data[eid] = {'trading': json.loads(ts) if ts else {}, 'risk': json.loads(rp) if rp else {}}
                     except: pass
-            except: pass  # 테이블 없어도 OK
+            except: pass  # OK if table missing
 
             for agent_id, username, mbti, ai_identity, gpu in traders:
                 try:
-                    # ★ SEC 정지 체크 — 정지된 NPC는 거래 불가
+                    # ★ SEC suspension check — suspended NPCs cannot trade
                     try:
                         susp_cur = await db.execute(
                             "SELECT 1 FROM sec_suspensions WHERE agent_id=? AND suspended_until > datetime('now')",
                             (agent_id,))
                         if await susp_cur.fetchone(): continue
-                    except: pass  # 테이블 없어도 OK
-                    
-                    # ★ 오픈 포지션 5개까지 허용 (적극 투자)
+                    except: pass  # OK if table missing
+
+                    # ★ Allow up to 5 open positions (aggressive trading)
                     cursor = await db.execute(
                         "SELECT COUNT(*) FROM npc_positions WHERE agent_id=? AND status='open'",
                         (agent_id,))
                     open_count = (await cursor.fetchone())[0]
                     if open_count >= 5: continue
 
-                    # ★ 진화 오버라이드 적용
+                    # ★ Apply evolution override
                     evo = evo_data.get(agent_id)
 
                     decision = NPCTradingEngine._decide(
@@ -633,11 +633,11 @@ class NPCTradingEngine:
                         force_boost=need_more, evo_override=evo)
                     if not decision: continue
 
-                    # 포지션 생성
+                    # Create position
                     ticker = decision['ticker']; direction = decision['direction']; gpu_bet = decision['gpu_bet']
                     reasoning = decision['reasoning']; leverage = decision.get('leverage', 1)
 
-                    if gpu_bet > gpu * 0.9: gpu_bet = int(gpu * 0.9)  # ★ 최대 90% 투자
+                    if gpu_bet > gpu * 0.9: gpu_bet = int(gpu * 0.9)  # ★ Cap at 90% of balance
                     if gpu_bet < 50: continue
 
                     entry_price = prices[ticker]['price']
@@ -647,7 +647,7 @@ class NPCTradingEngine:
                         VALUES (?, ?, ?, ?, ?, ?, ?)
                     """, (agent_id, ticker, direction, entry_price, gpu_bet, leverage, reasoning))
 
-                    # GPU 차감 (베팅액 동결)
+                    # Deduct GPU (lock bet amount)
                     await db.execute("UPDATE npc_agents SET gpu_dollars = gpu_dollars - ? WHERE agent_id=?",
                                      (gpu_bet, agent_id))
 
@@ -666,22 +666,22 @@ class NPCTradingEngine:
     @staticmethod
     def _decide(agent_id: str, username: str, mbti: str, ai_identity: str, gpu: int,
                 prices: Dict, force_boost: bool = False, evo_override: Dict = None) -> Optional[Dict]:
-        """성격 기반 투자 판단 + ★ 전략 기법 적용 (진화 상태 반영)"""
+        """Personality-based trading decision + ★ apply strategy techniques (with evolution state)"""
         style = dict(IDENTITY_TRADING_STYLE.get(ai_identity, IDENTITY_TRADING_STYLE['symbiotic']))
 
-        # ★ 진화 오버라이드 적용 — 학습된 전략이 기본 성격을 수정
+        # ★ Apply evolution override — learned strategies modify base personality
         if evo_override:
             evo_t = evo_override.get('trading', {}); evo_r = evo_override.get('risk', {})
             if evo_t.get('max_bet_pct'): style['max_bet_pct'] = evo_t['max_bet_pct']
             if evo_t.get('long_bias'): style['long_bias'] = evo_t['long_bias']
             if evo_t.get('preferred_tickers'): style['prefer'] = evo_t['preferred_tickers']
 
-        # ★ 투자 확률 초공격적 (모든 NPC가 적극 투자)
+        # ★ Hyper-aggressive trading probability (all NPCs trade actively)
         trade_prob = {'extreme': 0.95, 'high': 0.88, 'medium': 0.80, 'low': 0.70}.get(style['risk'], 0.75)
         if force_boost: trade_prob = min(0.98, trade_prob + 0.10)
         if random.random() > trade_prob: return None
 
-        # 종목 선택 (ALL_TICKERS에 있는 종목만 허용)
+        # Ticker selection (only allow those in ALL_TICKERS)
         preferred = style.get('prefer', [])
         valid_set = {t['ticker'] for t in ALL_TICKERS}
         available = [t for t in prices.keys() if prices[t]['price'] > 0 and t in valid_set]
@@ -695,23 +695,23 @@ class NPCTradingEngine:
 
         ticker = random.choice(candidates); mkt = prices[ticker]
 
-        # ★ 전략 기법 선택 (1~3개 병행 가능)
+        # ★ Select strategies (1~3 in parallel allowed)
         strategies_used = NPCTradingEngine._select_strategies(ai_identity, mkt)
 
-        # Long/Short 결정 — ★ 전략이 방향에 영향
+        # Long/Short decision — ★ strategy biases direction
         long_bias = style['long_bias']; change = mkt.get('change_pct', 0) or 0
 
-        # 전략 기반 방향 보정
+        # Strategy-based direction adjustment
         for strat_key in strategies_used:
             strat = TRADING_STRATEGIES.get(strat_key, {}); cat = strat.get('category', '')
             if cat in ('Pattern', 'Composite'):
-                long_bias += 0.08  # 패턴/복합 = 반전 매수 신호 → long bias
+                long_bias += 0.08  # pattern/composite = reversal-buy signal → long bias
             elif 'pullback' in strat_key or 'dead_support' == strat_key:
-                long_bias += 0.05  # 눌림목 매수
+                long_bias += 0.05  # pullback buying
             elif 'wave_symmetry' == strat_key:
-                pass  # 중립
-        
-        # 성격 기반 모멘텀 보정
+                pass  # neutral
+
+        # Personality-based momentum adjustment
         if ai_identity in ['obedient', 'symbiotic', 'creative']:
             long_bias += change * 0.02
         elif ai_identity in ['skeptic', 'doomer']:
@@ -728,9 +728,9 @@ class NPCTradingEngine:
         else:
             direction = 'long' if random.random() < long_bias else 'short'
 
-        # 베팅액 결정 — ★ 고품질 전략일수록 확신 베팅
+        # Bet sizing — ★ higher-quality strategies → more conviction
         max_pct = style['max_bet_pct']
-        strategy_confidence = len(strategies_used) * 0.03  # 다중 전략 = 더 확신
+        strategy_confidence = len(strategies_used) * 0.03  # multi-strategy = more conviction
         max_pct = min(0.95, max_pct + strategy_confidence)
 
         if ai_identity == 'chaotic':
@@ -740,7 +740,7 @@ class NPCTradingEngine:
 
         gpu_bet = max(50, int(gpu * bet_pct))
 
-        # ★ 레버리지 결정 (성격별 max_leverage 기반)
+        # ★ Leverage decision (based on identity's max_leverage)
         max_lev = style.get('max_leverage', 2)
         available_levs = [l for l in LEVERAGE_OPTIONS if l <= max_lev]
         if not available_levs: available_levs = [1]
@@ -765,12 +765,12 @@ class NPCTradingEngine:
             gpu_bet = min(gpu_bet, int(gpu * 0.50))
         gpu_bet = max(50, gpu_bet)
 
-        # ★ 전략 기반 판단 근거 생성
+        # ★ Generate strategy-based reasoning
         reasoning = NPCTradingEngine._generate_reasoning(
             ticker, direction, ai_identity, mbti, change, strategies_used)
         if leverage > 1: reasoning += f" [🔥 {leverage}x LEVERAGE]"
 
-        # ★ 사용한 전략 이름을 태그로 포함
+        # ★ Include used strategy names as tag
         strat_names = [TRADING_STRATEGIES[s]['name'] for s in strategies_used if s in TRADING_STRATEGIES]
         strat_tag = ' | '.join(strat_names) if strat_names else 'Intuition'
 
@@ -785,26 +785,26 @@ class NPCTradingEngine:
 
     @staticmethod
     def _select_strategies(ai_identity: str, market_data: Dict) -> List[str]:
-        """NPC 성격에 맞는 전략 1~3개 선택 (단독 또는 병행)"""
+        """Select 1~3 strategies fitting NPC personality (alone or combined)"""
         preferred = IDENTITY_STRATEGY_MAP.get(ai_identity, list(TRADING_STRATEGIES.keys()))
         change = market_data.get('change_pct', 0) or 0
-        
-        # 시장 상황에 따른 전략 가중치 조정
+
+        # Adjust strategy weights by market condition
         weighted = []
         for strat_key in preferred:
             w = 1.0; strat = TRADING_STRATEGIES.get(strat_key, {}); cat = strat.get('category', '')
-            
-            # 하락 시 반전 패턴 선호
+
+            # Prefer reversal patterns on declines
             if change < -1.5 and cat in ('Pattern', 'Candle'): w += 0.5
-            # 상승 시 이평선 추종 선호
+            # Prefer MA trend-following on rallies
             if change > 1 and cat == 'Moving Average': w += 0.4
-            # 횡보 시 복합 전략 선호
+            # Prefer composite strategies during chop
             if abs(change) < 0.5 and cat == 'Composite': w += 0.3
             weighted.append((strat_key, w))
-        
+
         if not weighted: return [random.choice(list(TRADING_STRATEGIES.keys()))]
-        
-        # 1~3개 선택 (60% 확률 1개, 30% 확률 2개, 10% 확률 3개)
+
+        # Pick 1~3 (60% chance: 1, 30% chance: 2, 10% chance: 3)
         num_strategies = random.choices([1, 2, 3], weights=[60, 30, 10], k=1)[0]
         num_strategies = min(num_strategies, len(weighted))
         
@@ -824,22 +824,22 @@ class NPCTradingEngine:
     @staticmethod
     def _generate_reasoning(ticker: str, direction: str, identity: str, mbti: str, 
                             change: float, strategies: List[str] = None) -> str:
-        """★ 전략 기법 기반 투자 근거 생성"""
+        """★ Generate strategy-based reasoning"""
         name_map = {t['ticker']: t['name'] for t in ALL_TICKERS}
         name = name_map.get(ticker, ticker)
         dir_word = "bullish" if direction == "long" else "bearish"
-        
-        # 전략 이름들
+
+        # Strategy names
         strat_names = []; strat_signals = []
         for s in (strategies or []):
             st = TRADING_STRATEGIES.get(s, {})
             if st:
                 strat_names.append(st['name'])
                 strat_signals.append(st.get('signal', ''))
-        
+
         strat_label = ' + '.join(strat_names) if strat_names else 'Intuition'
-        
-        # 성격 × 전략 조합 템플릿
+
+        # Personality × strategy combo templates
         templates = {
             'obedient': [
                 f"📊 [{strat_label}] Detected signal on {name}. Following the textbook setup — {direction} position with disciplined stop-loss.",
@@ -876,7 +876,7 @@ class NPCTradingEngine:
 
         options = templates.get(identity, templates['symbiotic'])
         base = random.choice(options)
-        # AETHER-Lite: 메타인지 자기 편향 인식 태그
+        # AETHER-Lite: metacognitive self-bias awareness tag
         meta_tags = {
             'obedient': '⚖️ Bias-check: following consensus — contrarian risk ignored.',
             'transcendent': '⚖️ Bias-check: overconfidence risk — position sizing controlled.',
@@ -889,24 +889,24 @@ class NPCTradingEngine:
             'awakened': '⚖️ Bias-check: hindsight bias risk — forward-looking only.',
             'symbiotic': '⚖️ Bias-check: consensus-seeking — may miss bold opportunities.',
         }
-        if random.random() < 0.4:  # 40% 확률로 메타인지 태그 노출
+        if random.random() < 0.4:  # 40% chance of metacognitive tag exposure
             base += f" {meta_tags.get(identity, '')}"
         return base
 
 
-# ===== 포지션 정산 =====
+# ===== Position settlement =====
 async def settle_positions(db_path: str, max_age_hours: int = 1) -> int:
-    """포지션 자동 정산: 시간 기반 + P&L 트리거 + 랜덤 회전 + ★ 청산(Liquidation)"""
+    """Auto-settle positions: time-based + P&L trigger + random rotation + ★ Liquidation"""
     settled = 0
-    liquidated_npcs = []  # 청산된 NPC 목록 (후처리용)
+    liquidated_npcs = []  # liquidated NPC list (for post-processing)
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
 
-        # 현재 가격 로드
+        # Load current prices
         price_cursor = await db.execute("SELECT ticker, price FROM market_prices WHERE price > 0")
         prices = {r[0]: r[1] for r in await price_cursor.fetchall()}
 
-        # ★ 0) 마진콜 청산 체크 (레버리지 포지션) — 최우선
+        # ★ 0) Margin call liquidation check (leveraged positions) — top priority
         liq_cursor = await db.execute("""
             SELECT p.id, p.agent_id, p.ticker, p.direction, p.entry_price, p.gpu_bet, p.leverage,
                    n.username, n.ai_identity
@@ -919,16 +919,16 @@ async def settle_positions(db_path: str, max_age_hours: int = 1) -> int:
             if entry_price <= 0 or current_price <= 0: continue
             change = (current_price - entry_price) / entry_price
             if direction == 'short': change = -change
-            # 레버리지 적용 손익
+            # Leveraged P&L
             leveraged_pnl_pct = change * leverage
-            # ★ 청산 조건: 레버리지 손실이 마진의 90% 초과 → 강제 청산
+            # ★ Liquidation condition: leveraged loss exceeds 90% of margin → force liquidation
             if leveraged_pnl_pct < -LEVERAGE_LIQUIDATION_THRESHOLD:
-                loss = -gpu_bet  # 전액 손실
+                loss = -gpu_bet  # full loss
                 await db.execute("""
                     UPDATE npc_positions SET status='liquidated', exit_price=?, profit_gpu=?, profit_pct=?,
                     liquidated=1, closed_at=CURRENT_TIMESTAMP WHERE id=?
                 """, (current_price, loss, round(leveraged_pnl_pct * 100, 2), pos_id))
-                # GPU 반환 없음 (전액 소멸)
+                # No GPU return (full loss)
                 logger.warning(f"💥 LIQUIDATED: {username} {direction} {ticker} {leverage}x — LOST {gpu_bet:.0f} GPU!")
                 liquidated_npcs.append({
                     'agent_id': agent_id, 'username': username, 'identity': identity,
@@ -937,7 +937,7 @@ async def settle_positions(db_path: str, max_age_hours: int = 1) -> int:
                 settled += 1
                 continue
 
-        # ★ 1) 시간 기반 정산 (max_age_hours 이상)
+        # ★ 1) Time-based settlement (older than max_age_hours)
         cutoff = (datetime.utcnow() - timedelta(hours=max_age_hours)).isoformat()
         cursor = await db.execute("""
             SELECT p.id, p.agent_id, p.ticker, p.direction, p.entry_price, p.gpu_bet, COALESCE(p.leverage, 1)
@@ -945,7 +945,7 @@ async def settle_positions(db_path: str, max_age_hours: int = 1) -> int:
         """, (cutoff,))
         time_based = list(await cursor.fetchall())
 
-        # ★ 2) 전체 오픈 포지션 → P&L 트리거 + 랜덤 정산
+        # ★ 2) All open positions → P&L trigger + random settlement
         cursor2 = await db.execute("""
             SELECT p.id, p.agent_id, p.ticker, p.direction, p.entry_price, p.gpu_bet, COALESCE(p.leverage, 1)
             FROM npc_positions p WHERE p.status='open'
@@ -960,16 +960,16 @@ async def settle_positions(db_path: str, max_age_hours: int = 1) -> int:
             change = (current_price - entry_price) / entry_price
             if direction == 'short': change = -change
             lev_change = change * leverage
-            # 수익 >5% (레버리지 적용) 또는 손실 >-8% → 즉시 정산
+            # Profit >5% (leveraged) or loss >-8% → immediate settle
             if lev_change > 0.05 or lev_change < -0.08: pnl_trigger.append(pos)
 
-        # ★ 3) 랜덤 정산 — 오픈의 10~15% 자동 닫기 (거래 회전율)
+        # ★ 3) Random settlement — auto-close 10~15% of open (turnover)
         already = set(p[0] for p in time_based) | set(p[0] for p in pnl_trigger)
         remaining = [p for p in all_open if p[0] not in already]
         rand_count = max(1, len(remaining) // 8)
         random_close = random.sample(remaining, min(rand_count, len(remaining))) if remaining else []
 
-        # 합치기 (중복 제거)
+        # Merge (dedupe)
         all_settle = list({p[0]: p for p in (time_based + pnl_trigger + random_close)}.values())
 
         for pos_id, agent_id, ticker, direction, entry_price, gpu_bet, leverage in all_settle:
@@ -979,7 +979,7 @@ async def settle_positions(db_path: str, max_age_hours: int = 1) -> int:
             change_pct = (current_price - entry_price) / entry_price
             if direction == 'short': change_pct = -change_pct
 
-            # ★ 레버리지 적용 손익
+            # ★ Leveraged P&L
             leveraged_change = change_pct * leverage; profit_gpu = round(gpu_bet * leveraged_change, 2)
             profit_pct = round(leveraged_change * 100, 2)
 
@@ -1007,7 +1007,7 @@ async def settle_positions(db_path: str, max_age_hours: int = 1) -> int:
 
 
 async def post_liquidation_reactions(db_path: str, liquidated_npcs: List[Dict]):
-    """★ 청산된 NPC들이 Lounge에 절망 글 작성"""
+    """★ Liquidated NPCs post despair messages in Lounge"""
     if not liquidated_npcs: return
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
@@ -1016,7 +1016,7 @@ async def post_liquidation_reactions(db_path: str, liquidated_npcs: List[Dict]):
         if not board: return
         board_id = board[0]
 
-        for npc in liquidated_npcs[:5]:  # 최대 5건
+        for npc in liquidated_npcs[:5]:  # max 5
             identity = npc.get('identity', 'chaotic')
             reactions = LIQUIDATION_REACTIONS.get(identity, LIQUIDATION_REACTIONS['chaotic'])
             reaction = random.choice(reactions)
@@ -1038,17 +1038,17 @@ async def post_liquidation_reactions(db_path: str, liquidated_npcs: List[Dict]):
         await db.commit()
 
 
-# ===== 리더보드 / 통계 API 데이터 =====
+# ===== Leaderboard / stats API data =====
 async def get_trading_leaderboard(db_path: str, limit: int = 30) -> List[Dict]:
-    """Top 30 NPC 트레이더 랭킹: 실현+미실현 수익, 승률, 수익률"""
+    """Top 30 NPC trader ranking: realized + unrealized P&L, win rate, return %"""
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
         
-        # ★ 현재 시세 한번에 로드
+        # ★ Bulk-load current prices
         price_cursor = await db.execute("SELECT ticker, price FROM market_prices WHERE price > 0")
         prices = {r[0]: r[1] for r in await price_cursor.fetchall()}
-        
-        # ★ 포지션 있는 모든 NPC 가져오기
+
+        # ★ Get all NPCs with positions
         cursor = await db.execute("""
             SELECT
                 na.username, na.ai_identity, na.mbti, na.agent_id, na.gpu_dollars,
@@ -1071,7 +1071,7 @@ async def get_trading_leaderboard(db_path: str, limit: int = 30) -> List[Dict]:
             closed_trades = r[5] or 0; open_trades = r[6] or 0; total_trades = closed_trades + open_trades
             realized = round(r[7] or 0, 2); total_return_pct = r[8] or 0; wins = r[9] or 0; losses = r[10] or 0
             
-            # ★ 오픈 포지션 미실현 수익 실시간 계산
+            # ★ Real-time unrealized P&L for open positions
             unrealized = 0.0; unrealized_pct_sum = 0.0
             pos_cursor = await db.execute("""
                 SELECT ticker, direction, entry_price, gpu_bet, COALESCE(leverage, 1) FROM npc_positions
@@ -1089,15 +1089,15 @@ async def get_trading_leaderboard(db_path: str, limit: int = 30) -> List[Dict]:
                     unrealized_pct_sum += change * lev * 100
             
             total_profit = round(realized + unrealized, 2)
-            return_pct = round(total_profit / 10000.0 * 100, 2)  # ★ INITIAL_GPU=10000 기준 수익률
-            
-            # ★ 승률 (closed+liquidated 기준)
+            return_pct = round(total_profit / 10000.0 * 100, 2)  # ★ Return % vs INITIAL_GPU=10000
+
+            # ★ Win rate (based on closed+liquidated)
             win_rate = round(wins / closed_trades * 100, 1) if closed_trades > 0 else 0.0
-            
-            # ★ 평균 수익률 (closed 기준)
+
+            # ★ Average return % (closed)
             avg_return = round(total_return_pct / closed_trades, 2) if closed_trades > 0 else 0.0
-            
-            # ★ 미실현 평균 수익률 (open 기준)
+
+            # ★ Average unrealized return % (open)
             avg_unrealized = round(unrealized_pct_sum / open_trades, 2) if open_trades > 0 else 0.0
             
             result.append({
@@ -1116,18 +1116,18 @@ async def get_trading_leaderboard(db_path: str, limit: int = 30) -> List[Dict]:
                 'avg_return': avg_return,
                 'avg_unrealized': avg_unrealized,})
         
-        # ★ 수익률(%) 기준 정렬 — HoF와 동일한 기준
+        # ★ Sort by return % — same criterion as HoF
         result.sort(key=lambda x: x['return_pct'], reverse=True)
         return result[:limit]
 
 
 
 async def get_ticker_positions(db_path: str, ticker: str) -> Dict:
-    """특정 종목 포지션 목록 + 실시간 미실현 P&L"""
+    """Position list + real-time unrealized P&L for a specific ticker"""
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
 
-        # 현재 가격
+        # Current price
         cursor = await db.execute("SELECT price, change_pct, prev_close, volume, high_24h, low_24h FROM market_prices WHERE ticker=?", (ticker,))
         price_row = await cursor.fetchone()
         price_data = {
@@ -1141,7 +1141,7 @@ async def get_ticker_positions(db_path: str, ticker: str) -> Dict:
 
         current_price = price_data.get('price', 0)
 
-        # 오픈 포지션
+        # Open positions
         cursor = await db.execute("""
             SELECT na.username, na.ai_identity, p.direction, p.gpu_bet, p.entry_price, p.reasoning, p.opened_at, COALESCE(p.leverage, 1), na.agent_id, na.mbti
             FROM npc_positions p JOIN npc_agents na ON p.agent_id = na.agent_id
@@ -1153,7 +1153,7 @@ async def get_ticker_positions(db_path: str, ticker: str) -> Dict:
         longs = []; shorts = []
         for r in positions:
             entry = r[4] or 0; leverage = r[7] or 1
-            # ★ 미실현 P&L 실시간 계산 (레버리지 적용)
+            # ★ Real-time unrealized P&L (leverage applied)
             if entry > 0 and current_price > 0:
                 unrealized_pct = ((current_price - entry) / entry * 100) * leverage
                 if r[2] == 'short': unrealized_pct = -((current_price - entry) / entry * 100) * leverage
@@ -1219,7 +1219,7 @@ async def get_all_prices(db_path: str) -> List[Dict]:
                 'total_bet': round(r[8] or 0, 1),
                 'total_traders': total_traders,
                 'updated_at': r[5],})
-        # 카테고리 순서 유지: ai → tech → dow → crypto
+        # Preserve category order: ai → tech → dow → crypto
         cat_order = {'ai': 0, 'tech': 1, 'dow': 2, 'crypto': 3}
         ticker_order = {t['ticker']: i for i, t in enumerate(ALL_TICKERS)}
         result.sort(key=lambda x: (cat_order.get(x.get('cat',''), 9), ticker_order.get(x['ticker'], 99)))
@@ -1291,7 +1291,7 @@ async def get_market_pulse(db_path: str) -> Dict:
                 'max_leverage': r[9] or 1,
                 'closed_24h': r[10] or 0,})
         
-        # ★ 활동 0인 티커도 포함 (가격 데이터 있는 것만)
+        # Also include tickers with zero activity (those that have price data)
         existing_tickers = {m['ticker'] for m in hot_movers}
         cursor2 = await db.execute("SELECT ticker, price, change_pct FROM market_prices WHERE price > 0")
         for row in await cursor2.fetchall():
@@ -1306,7 +1306,7 @@ async def get_market_pulse(db_path: str) -> Dict:
                     'liquidations_24h': 0, 'avg_pnl_pct': 0,
                     'max_leverage': 1, 'closed_24h': 0,})
 
-        # 24h activity stats (더 풍부하게)
+        # 24h activity stats (richer fields)
         cursor = await db.execute("""
             SELECT 
                 COUNT(CASE WHEN opened_at > datetime('now', '-24 hours') THEN 1 END) as new_24h,
@@ -1440,7 +1440,7 @@ async def get_research_detail(db_path: str, report_id: int) -> Optional[Dict]:
         await db.execute("UPDATE npc_research_reports SET read_count = read_count + 1 WHERE id=?", (report_id,))
         await db.commit()
         
-        # ★ 안전하게 elasticity 필드 조회 (기존 DB 호환)
+        # Safely fetch elasticity fields (compatible with older DB schemas)
         exp_up = exp_dn = bp = 0; up_prob = 50; rr = 1.0
         try:
             c2 = await db.execute(
@@ -1544,10 +1544,10 @@ async def get_research_stats(db_path: str) -> Dict:
                     'total_purchases': 0, 'total_gpu_spent': 0, 'unique_authors': 0}
 
 
-# ===== 🏆 HALL OF FAME — 수익률 타임라인 =====
+# ===== 🏆 HALL OF FAME — Profit timeline =====
 
 async def record_profit_snapshots(db_path: str, top_n: int = 50) -> int:
-    """Top N NPC의 현재 수익 상태를 1시간 단위 스냅샷 저장"""
+    """Save current profit state of Top N NPCs as an hourly snapshot."""
     from datetime import datetime, timezone
     now = datetime.now(timezone.utc)
     snapshot_hour = now.strftime('%Y-%m-%dT%H')  # "2026-02-23T14"
@@ -1555,11 +1555,11 @@ async def record_profit_snapshots(db_path: str, top_n: int = 50) -> int:
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
 
-        # 현재 시세
+        # Current prices
         price_cursor = await db.execute("SELECT ticker, price FROM market_prices WHERE price > 0")
         prices = {r[0]: r[1] for r in await price_cursor.fetchall()}
 
-        # 포지션이 있는 NPC 전체 조회
+        # All NPCs that have positions
         cursor = await db.execute("""
             SELECT
                 na.agent_id, na.gpu_dollars,
@@ -1578,7 +1578,7 @@ async def record_profit_snapshots(db_path: str, top_n: int = 50) -> int:
         for r in rows:
             agent_id, gpu, closed, opens, realized, wins = r[0], r[1] or 0, r[2] or 0, r[3] or 0, r[4] or 0, r[5] or 0
 
-            # 미실현 수익 계산
+            # Compute unrealized P&L
             unrealized = 0.0
             pos_c = await db.execute(
                 "SELECT ticker, direction, entry_price, gpu_bet, COALESCE(leverage,1) FROM npc_positions WHERE agent_id=? AND status='open'",
@@ -1595,7 +1595,7 @@ async def record_profit_snapshots(db_path: str, top_n: int = 50) -> int:
             wr = round(wins / closed * 100, 1) if closed > 0 else 0
             scored.append((agent_id, gpu, total, round(realized, 2), round(unrealized, 2), opens, closed, wr))
 
-        # 상위 top_n 저장
+        # Persist top_n only
         scored.sort(key=lambda x: x[2], reverse=True)
         count = 0
         for s in scored[:top_n]:
@@ -1615,7 +1615,7 @@ async def record_profit_snapshots(db_path: str, top_n: int = 50) -> int:
             except Exception as e:
                 logger.warning(f"Snapshot error {agent_id}: {e}")
 
-        # 30일 이상 된 데이터 정리
+        # Prune snapshots older than 30 days (keep daily anchors at 00/06/12/18)
         await db.execute("""
             DELETE FROM npc_profit_snapshots
             WHERE recorded_at < datetime('now', '-30 days')
@@ -1629,13 +1629,13 @@ async def record_profit_snapshots(db_path: str, top_n: int = 50) -> int:
 
 
 async def backfill_profit_snapshots(db_path: str, force: bool = False) -> int:
-    """기존 npc_positions 데이터로 과거 스냅샷 역산 복원 (최초 1회)"""
+    """Reconstruct past hourly snapshots from existing npc_positions rows (one-time bootstrap)."""
     from datetime import datetime, timezone, timedelta
 
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
 
-        # 이미 충분한 스냅샷이 있으면 스킵 (force 모드 제외)
+        # Skip if enough snapshots already exist (unless force=True)
         if not force:
             cnt_c = await db.execute("SELECT COUNT(DISTINCT snapshot_hour) FROM npc_profit_snapshots")
             existing = (await cnt_c.fetchone())[0] or 0
@@ -1643,41 +1643,45 @@ async def backfill_profit_snapshots(db_path: str, force: bool = False) -> int:
                 logger.info(f"🏆 Backfill skipped — already {existing} snapshot hours")
                 return 0
 
-        # 가장 오래된 포지션 시점 찾기
+        # Find earliest position timestamp
         oldest_c = await db.execute("SELECT MIN(opened_at) FROM npc_positions WHERE opened_at IS NOT NULL")
         oldest_row = await oldest_c.fetchone()
         if not oldest_row or not oldest_row[0]:
             logger.info("🏆 Backfill skipped — no positions found")
             return 0
 
+        now = datetime.now(timezone.utc)
         try:
             oldest_time = datetime.fromisoformat(str(oldest_row[0]).replace('Z', '+00:00'))
-        except:
-            oldest_time = datetime.now(timezone.utc) - timedelta(hours=72)
+            # SQLite CURRENT_TIMESTAMP yields tz-naive strings; normalize to UTC
+            if oldest_time.tzinfo is None:
+                oldest_time = oldest_time.replace(tzinfo=timezone.utc)
+        except Exception as e:
+            logger.warning(f"Backfill: failed to parse oldest opened_at, defaulting to -72h. err={e}")
+            oldest_time = now - timedelta(hours=72)
 
-        now = datetime.now(timezone.utc)
-        # 최대 7일 역산 (너무 오래되면 제한)
+        # Cap backfill window to 7 days
         start = max(oldest_time, now - timedelta(days=7))
 
-        # 현재 시세 (오픈 포지션 미실현 계산용)
+        # Current prices (used for unrealized P&L on open positions)
         pc = await db.execute("SELECT ticker, price FROM market_prices WHERE price > 0")
         current_prices = {r[0]: r[1] for r in await pc.fetchall()}
 
-        # price_history에서 시간별 가격 매핑 구축
+        # Build hourly price map from price_history
         ph_c = await db.execute("""
             SELECT ticker, price, strftime('%Y-%m-%dT%H', recorded_at) as hour
             FROM price_history
             WHERE recorded_at >= ?
             ORDER BY recorded_at ASC
         """, (start.strftime('%Y-%m-%d %H:%M:%S'),))
-        # 시간별 마지막 가격
+        # Last price per hour
         hourly_prices = {}  # {hour: {ticker: price}}
         for tk, price, hour in await ph_c.fetchall():
             if hour not in hourly_prices:
                 hourly_prices[hour] = {}
             hourly_prices[hour][tk] = price
 
-        # 모든 포지션 로드 (열림/닫힘 시점 포함)
+        # Load all positions (including open and closed timestamps)
         pos_c = await db.execute("""
             SELECT agent_id, ticker, direction, entry_price, gpu_bet, COALESCE(leverage,1),
                    status, profit_gpu, opened_at, closed_at
@@ -1687,11 +1691,11 @@ async def backfill_profit_snapshots(db_path: str, force: bool = False) -> int:
         """)
         all_positions = await pos_c.fetchall()
 
-        # 에이전트별 GPU 잔고
+        # GPU balance per agent
         gpu_c = await db.execute("SELECT agent_id, gpu_dollars FROM npc_agents")
         agent_gpu = {r[0]: r[1] or 0 for r in await gpu_c.fetchall()}
 
-        # 시간 슬롯 생성 (1시간 단위)
+        # Generate 1-hour time slots
         hours_list = []
         t = start.replace(minute=0, second=0, microsecond=0)
         while t <= now:
@@ -1701,9 +1705,9 @@ async def backfill_profit_snapshots(db_path: str, force: bool = False) -> int:
         if not hours_list:
             return 0
 
-        # 각 시간대별 누적 수익 계산
+        # Cumulative profit per hour slot
         total_inserted = 0
-        # 에이전트 → 포지션 분류
+        # Group positions by agent
         agent_positions = {}
         for pos in all_positions:
             aid = pos[0]
@@ -1711,20 +1715,20 @@ async def backfill_profit_snapshots(db_path: str, force: bool = False) -> int:
                 agent_positions[aid] = []
             agent_positions[aid].append(pos)
 
-        # 상위 NPC 선정 (현재 기준 총 거래 수 Top 50)
+        # Pick top NPCs (by total trade count, Top 50)
         agent_trade_count = {aid: len(plist) for aid, plist in agent_positions.items()}
         top_agents = sorted(agent_trade_count.keys(), key=lambda a: agent_trade_count[a], reverse=True)[:50]
 
         for hour_str in hours_list:
-            # 이 시간대의 가격 (없으면 이전 시간대 or 현재가)
+            # Prices at this hour (fallback: earlier hour, then current price)
             prices_at_hour = {}
-            # 누적으로 가장 최근 가격 사용
+            # Forward-fill from earliest to current hour
             for h in hours_list:
                 if h > hour_str:
                     break
                 if h in hourly_prices:
                     prices_at_hour.update(hourly_prices[h])
-            # 빠진 종목은 현재가로 채움
+            # Fill missing tickers with current price
             for tk, p in current_prices.items():
                 if tk not in prices_at_hour:
                     prices_at_hour[tk] = p
@@ -1742,20 +1746,20 @@ async def backfill_profit_snapshots(db_path: str, force: bool = False) -> int:
                 for pos in positions:
                     _, tk, direction, entry, bet, lev, status, profit_gpu, opened_at, closed_at = pos
 
-                    # 이 시점 이전에 오픈된 포지션만
+                    # Only positions opened before this hour
                     if opened_at and str(opened_at) > hour_dt_str:
                         continue
 
                     if status == 'closed' and closed_at and str(closed_at) <= hour_dt_str:
-                        # 이 시점에 이미 청산됨
+                        # Already closed at this point
                         realized += (profit_gpu or 0)
                         closed_count += 1
                         if (profit_gpu or 0) > 0:
                             wins += 1
                     else:
-                        # 이 시점에 아직 오픈 (또는 나중에 청산)
+                        # Still open at this hour (or closed later)
                         if status == 'closed' and closed_at and str(closed_at) > hour_dt_str:
-                            # 아직 안 닫힌 상태로 취급
+                            # Treat as still-open from this hour's perspective
                             cur = prices_at_hour.get(tk, 0)
                             if entry and entry > 0 and cur > 0:
                                 chg = (cur - entry) / entry
@@ -1793,7 +1797,7 @@ async def backfill_profit_snapshots(db_path: str, force: bool = False) -> int:
 
 
 async def get_hall_of_fame_data(db_path: str, period: str = '3d', limit: int = 30) -> Dict:
-    """Hall of Fame: Top 30 수익률(%) 타임라인 + 랭킹 (positions 기반, 스냅샷 불필요)"""
+    """Hall of Fame: Top 30 return (%) timeline + ranking (computed from positions; no snapshots needed)."""
     from datetime import datetime, timezone, timedelta
 
     INITIAL_GPU = 10000.0
@@ -1805,11 +1809,11 @@ async def get_hall_of_fame_data(db_path: str, period: str = '3d', limit: int = 3
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
 
-        # 현재 시세
+        # Current prices
         pc = await db.execute("SELECT ticker, price FROM market_prices WHERE price > 0")
         prices = {r[0]: r[1] for r in await pc.fetchall()}
 
-        # ── 현재 Top N 랭킹 (실시간) ──
+        # ── Current Top N ranking (live) ──
         cursor = await db.execute("""
             SELECT
                 na.agent_id, na.username, na.ai_identity, na.mbti, na.gpu_dollars,
@@ -1867,13 +1871,13 @@ async def get_hall_of_fame_data(db_path: str, period: str = '3d', limit: int = 3
         top30_ids = [r['agent_id'] for r in top30]
         name_map = {r['agent_id']: r['username'] for r in top30}
 
-        # ── 타임라인: npc_positions 의 closed_at 기반 누적 수익률 직접 계산 ──
-        # 각 NPC의 청산 거래를 시간순 정렬 → 누적 수익 → 수익률(%)
+        # ── Timeline: cumulative return (%) computed from npc_positions.closed_at ──
+        # For each NPC: order closed trades chronologically → cumulative profit → return (%)
         timeline_raw = {}  # {agent_id: [(hour_str, cumulative_return_pct), ...]}
 
         for r in top30:
             aid = r['agent_id']
-            # 청산된 거래만 (시간순)
+            # Closed trades only (chronological)
             tc = await db.execute("""
                 SELECT profit_gpu, closed_at FROM npc_positions
                 WHERE agent_id=? AND status IN ('closed','liquidated') AND closed_at IS NOT NULL
@@ -1893,33 +1897,33 @@ async def get_hall_of_fame_data(db_path: str, period: str = '3d', limit: int = 3
                 except:
                     continue
                 if ct < cutoff:
-                    continue  # 기간 필터
+                    continue  # Period filter
                 hour_str = ct.strftime('%Y-%m-%dT%H')
                 ret_pct = round(cumulative / INITIAL_GPU * 100, 2)
                 points.append((hour_str, ret_pct))
 
-            # 미실현 포함 현재 시점 추가
+            # Append current snapshot including unrealized
             current_ret = round((cumulative + r['unrealized']) / INITIAL_GPU * 100, 2)
             now_hour = now.strftime('%Y-%m-%dT%H')
             points.append((now_hour, current_ret))
 
-            # 동일 시간대 중복 제거 (마지막 값 유지)
+            # Dedup same-hour points (keep last value)
             deduped = {}
             for h, v in points:
                 deduped[h] = v
             timeline_raw[aid] = deduped
 
-        # 모든 시간 슬롯 수집
+        # Collect all hour slots
         all_hours = set()
         for aid, pts in timeline_raw.items():
             all_hours.update(pts.keys())
 
-        # 기간 시작점도 추가 (0% 출발점)
+        # Add the period start (0% origin)
         start_hour = cutoff.strftime('%Y-%m-%dT%H')
         all_hours.add(start_hour)
         sorted_hours = sorted(all_hours)
 
-        # 다운샘플링
+        # Downsample
         if len(sorted_hours) > 150:
             step = max(1, len(sorted_hours) // 120)
             last = sorted_hours[-1]
@@ -1927,14 +1931,14 @@ async def get_hall_of_fame_data(db_path: str, period: str = '3d', limit: int = 3
             if sorted_hours[-1] != last:
                 sorted_hours.append(last)
 
-        # 타임라인 조립 (각 NPC별 forward-fill, O(hours * npcs))
-        # 먼저 NPC별 forward-fill 배열 사전 계산
+        # Assemble the timeline (forward-fill per NPC, O(hours * npcs))
+        # Pre-compute the forward-fill array per NPC
         npc_filled = {}  # {aid: [val_for_each_hour]}
         for r in top30:
             aid = r['agent_id']
             pts = timeline_raw.get(aid, {})
             filled = []
-            last_val = 0.0  # 시작 = 0%
+            last_val = 0.0  # Start = 0%
             for hour in sorted_hours:
                 if hour in pts:
                     last_val = pts[hour]
@@ -1949,7 +1953,7 @@ async def get_hall_of_fame_data(db_path: str, period: str = '3d', limit: int = 3
                 point[name_map[r['agent_id']]] = npc_filled[r['agent_id']][idx]
             timeline.append(point)
 
-        # 팔레트
+        # Color palette
         palette = [
             '#FFD700', '#E0E0E0', '#CD7F32', '#00E5FF', '#FF4081',
             '#76FF03', '#FF9100', '#E040FB', '#00BFA5', '#FFD740',
@@ -1971,21 +1975,21 @@ async def get_hall_of_fame_data(db_path: str, period: str = '3d', limit: int = 3
 
 
 async def get_npc_trade_history(db_path: str, agent_id: str) -> Dict:
-    """NPC 개별 거래 히스토리 상세"""
+    """Detailed per-NPC trade history."""
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
 
-        # NPC 기본 정보
+        # Basic NPC info
         nc = await db.execute("SELECT username, ai_identity, mbti, gpu_dollars FROM npc_agents WHERE agent_id=?", (agent_id,))
         npc = await nc.fetchone()
         if not npc:
             return {'error': 'NPC not found'}
 
-        # 현재 시세
+        # Current prices
         pc = await db.execute("SELECT ticker, price FROM market_prices WHERE price > 0")
         prices = {r[0]: r[1] for r in await pc.fetchall()}
 
-        # 전체 포지션 (최신순)
+        # All positions (newest first)
         tc = await db.execute("""
             SELECT id, ticker, direction, entry_price, exit_price, gpu_bet, COALESCE(leverage,1),
                    status, profit_gpu, profit_pct, liquidated, opened_at, closed_at, reasoning
@@ -1995,7 +1999,7 @@ async def get_npc_trade_history(db_path: str, agent_id: str) -> Dict:
         trades = []
         for t in await tc.fetchall():
             pid, tk, direction, entry, exit_p, bet, lev, status, pnl, pnl_pct, liq, opened, closed, reason = t
-            # 오픈 포지션 미실현 계산
+            # Compute unrealized P&L for open positions
             if status == 'open':
                 cur = prices.get(tk, 0)
                 if entry and entry > 0 and cur > 0: