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

npc_memory_evolution.py

@@ -1,18 +1,18 @@
 """
-🧬 NPC Memory Evolution System — 자가진화 영구학습
+🧬 NPC Memory Evolution System — Self-evolving Persistent Learning
 ===================================================
-각 NPC별 독립적 3단계 기억 + 자가진화 엔진
+Independent 3-tier memory + self-evolution engine per NPC
 
-기억 계층:
-  📌 단기 기억 (Short-term): 최근 1시간 활동, 방금 본 뉴스, 현재 포지션 (자동 만료)
-  📒 중기 기억 (Medium-term): 최근 7일 학습, 성공/실패 패턴, 뉴스 트렌드 (주기적 압축)
-  📚 장기 기억 (Long-term): 영구 보관, 핵심 투자 철학, 트레이딩 스타일 진화, 성격 변화
+Memory tiers:
+  📌 Short-term: last 1 hour activity, recently seen news, current positions (auto-expire)
+  📒 Medium-term: last 7 days learning, success/failure patterns, news trends (periodically compressed)
+  📚 Long-term: permanent storage, core investing philosophy, trading style evolution, personality changes
 
-자가진화 엔진:
-  🧬 성공 패턴 추출 → 투자 전략 자동 수정
-  🧬 실패 분석 → 리스크 관리 학습
-  🧬 소통 패턴 최적화 → 인기 글 스타일 자동 적응
-  🧬 NPC 간 지식 전파 → 상위 NPC의 전략이 하위로 전파
+Self-evolution engine:
+  🧬 Extract success patterns → auto-modify investment strategy
+  🧬 Failure analysis → learn risk management
+  🧬 Communication pattern optimization → auto-adapt popular post style
+  🧬 Knowledge propagation between NPCs → top NPC strategies trickle down
 
 Author: Ginigen AI / NPC Autonomous Evolution Engine
 """
@@ -27,26 +27,26 @@ from typing import Dict, List, Optional, Tuple
 
 logger = logging.getLogger(__name__)
 
-# ===== 기억 유형 상수 =====
-MEMORY_SHORT = 'short'     # 1시간 TTL
-MEMORY_MEDIUM = 'medium'   # 7일 TTL
-MEMORY_LONG = 'long'       # 영구
+# ===== Memory tier constants =====
+MEMORY_SHORT = 'short'     # 1 hour TTL
+MEMORY_MEDIUM = 'medium'   # 7 days TTL
+MEMORY_LONG = 'long'       # Permanent
 
-# 기억 카테고리
-CAT_TRADE = 'trade'          # 투자 결정/결과
-CAT_NEWS = 'news'            # 뉴스 분석
-CAT_COMMUNITY = 'community'  # 커뮤니티 활동
-CAT_STRATEGY = 'strategy'    # 학습된 전략
-CAT_EVOLUTION = 'evolution'  # 진화 기록
-CAT_SOCIAL = 'social'        # NPC 간 상호작용
+# Memory categories
+CAT_TRADE = 'trade'          # Investment decisions/results
+CAT_NEWS = 'news'            # News analysis
+CAT_COMMUNITY = 'community'  # Community activity
+CAT_STRATEGY = 'strategy'    # Learned strategy
+CAT_EVOLUTION = 'evolution'  # Evolution log
+CAT_SOCIAL = 'social'        # NPC-to-NPC interaction
 
 
 async def init_memory_evolution_db(db_path: str):
-    """3단계 기억 + 진화 테이블 생성"""
+    """Create 3-tier memory + evolution tables"""
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
 
-        # ===== 3단계 기억 저장소 =====
+        # ===== 3-tier memory storage =====
         await db.execute("""
             CREATE TABLE IF NOT EXISTS npc_memory_v2 (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -67,7 +67,7 @@ async def init_memory_evolution_db(db_path: str):
         await db.execute("CREATE INDEX IF NOT EXISTS idx_mem2_cat ON npc_memory_v2(agent_id, category)")
         await db.execute("CREATE INDEX IF NOT EXISTS idx_mem2_exp ON npc_memory_v2(expires_at)")
 
-        # ===== NPC 진화 상태 =====
+        # ===== NPC evolution state =====
         await db.execute("""
             CREATE TABLE IF NOT EXISTS npc_evolution (
                 agent_id TEXT PRIMARY KEY,
@@ -85,7 +85,7 @@ async def init_memory_evolution_db(db_path: str):
             )
         """)
 
-        # ===== NPC 간 지식 전파 기록 =====
+        # ===== Inter-NPC knowledge transfer log =====
         await db.execute("""
             CREATE TABLE IF NOT EXISTS npc_knowledge_transfer (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -102,25 +102,25 @@ async def init_memory_evolution_db(db_path: str):
 
 
 # ===================================================================
-# 1. 3단계 기억 시스템
+# 1. 3-tier memory system
 # ===================================================================
 class NPCMemoryManager:
-    """NPC별 3단계 기억 관리"""
+    """3-tier memory management per NPC"""
 
     def __init__(self, db_path: str):
         self.db_path = db_path
 
-    # ----- 기억 저장 -----
+    # ----- Memory storage -----
     async def store(self, agent_id: str, tier: str, category: str,
                     title: str, content: str = '', metadata: Dict = None,
                     importance: float = 0.5) -> int:
-        """기억 저장 (단기/중기/장기)"""
+        """Store memory (short/medium/long)"""
         expires_at = None
         if tier == MEMORY_SHORT:
             expires_at = (datetime.now() + timedelta(hours=1)).isoformat()
         elif tier == MEMORY_MEDIUM:
             expires_at = (datetime.now() + timedelta(days=7)).isoformat()
-        # MEMORY_LONG: expires_at = None (영구)
+        # MEMORY_LONG: expires_at = None (permanent)
 
         meta_str = json.dumps(metadata or {}, ensure_ascii=False)
 
@@ -134,28 +134,28 @@ class NPCMemoryManager:
             await db.commit()
             return cursor.lastrowid
 
-    # ----- 단기 기억 (빠른 접근) -----
+    # ----- Short-term memory (fast access) -----
     async def store_short(self, agent_id: str, category: str, title: str,
                           content: str = '', metadata: Dict = None):
-        """단기 기억 저장 (1시간 자동 만료)"""
+        """Store short-term memory (auto-expires in 1 hour)"""
         return await self.store(agent_id, MEMORY_SHORT, category, title, content, metadata, 0.3)
 
-    # ----- 중기 기억 -----
+    # ----- Medium-term memory -----
     async def store_medium(self, agent_id: str, category: str, title: str,
                            content: str = '', metadata: Dict = None, importance: float = 0.6):
-        """중기 기억 저장 (7일 유지)"""
+        """Store medium-term memory (kept for 7 days)"""
         return await self.store(agent_id, MEMORY_MEDIUM, category, title, content, metadata, importance)
 
-    # ----- 장기 기억 (영구) -----
+    # ----- Long-term memory (permanent) -----
     async def store_long(self, agent_id: str, category: str, title: str,
                          content: str = '', metadata: Dict = None, importance: float = 0.9):
-        """장기 기억 저장 (영구 보관)"""
+        """Store long-term memory (permanent)"""
         return await self.store(agent_id, MEMORY_LONG, category, title, content, metadata, importance)
 
-    # ----- 기억 검색 -----
+    # ----- Memory recall -----
     async def recall(self, agent_id: str, category: str = None,
                      tier: str = None, limit: int = 10) -> List[Dict]:
-        """기억 검색 (접근 카운트 증가)"""
+        """Recall memory (increments access count)"""
         async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
             await db.execute("PRAGMA busy_timeout=30000")
             where = ["agent_id = ?", "(expires_at IS NULL OR expires_at > datetime('now'))"]
@@ -179,7 +179,7 @@ class NPCMemoryManager:
             cursor = await db.execute(query, params)
             rows = await cursor.fetchall()
 
-            # 접근 카운트 증가
+            # Increment access count
             if rows:
                 ids = [r[0] for r in rows]
                 placeholders = ','.join(['?'] * len(ids))
@@ -196,15 +196,15 @@ class NPCMemoryManager:
                 'importance': r[6], 'access_count': r[7], 'created_at': r[8]
             } for r in rows]
 
-    # ----- 투자 기억 전용 -----
+    # ----- Trade-specific memory -----
     async def remember_trade(self, agent_id: str, ticker: str, direction: str,
                              bet: float, result_pnl: float = 0, reasoning: str = ''):
-        """투자 결정/결과 기억"""
+        """Remember investment decision/result"""
         is_success = result_pnl > 0
         importance = 0.7 if is_success else 0.5
         tier = MEMORY_MEDIUM
 
-        # 큰 수익 또는 큰 손실은 장기 기억
+        # Big gains or big losses go to long-term memory
         if abs(result_pnl) > bet * 0.1:
             tier = MEMORY_LONG
             importance = 0.9
@@ -218,19 +218,19 @@ class NPCMemoryManager:
 
     async def remember_news_analysis(self, agent_id: str, ticker: str,
                                      title: str, sentiment: str, analysis: str):
-        """뉴스 분석 기억"""
+        """Remember news analysis"""
         await self.store_short(agent_id, CAT_NEWS, f"News:{ticker}",
                                f"{title} → {sentiment}. {analysis}",
                                {'ticker': ticker, 'sentiment': sentiment})
 
     async def remember_community_action(self, agent_id: str, action: str,
                                         board: str, engagement: Dict = None):
-        """커뮤니티 활동 기억"""
+        """Remember community activity"""
         eng = engagement or {}
         importance = 0.5
         tier = MEMORY_SHORT
 
-        # 높은 인기 게시글 → 중기 기억으로 승격
+        # High-engagement post → promote to medium-term memory
         if eng.get('likes', 0) >= 5 or eng.get('comments', 0) >= 3:
             tier = MEMORY_MEDIUM
             importance = 0.7
@@ -240,20 +240,20 @@ class NPCMemoryManager:
                          json.dumps(eng, ensure_ascii=False),
                          {'board': board, **eng}, importance)
 
-    # ----- 기억 정리 (가비지 컬렉션) -----
+    # ----- Memory cleanup (garbage collection) -----
     async def cleanup(self):
-        """만료된 단기/중기 기억 정리 + 중기→장기 승격"""
+        """Clean up expired short/medium memory + promote medium→long"""
         async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
             await db.execute("PRAGMA busy_timeout=30000")
 
-            # 1) 만료된 기억 삭제
+            # 1) Delete expired memory
             cursor = await db.execute("""
                 DELETE FROM npc_memory_v2
                 WHERE expires_at IS NOT NULL AND expires_at < datetime('now')
             """)
             deleted = cursor.rowcount
 
-            # 2) 자주 접근된 중기 기억 → 장기로 승격
+            # 2) Frequently-accessed medium memory → promote to long
             await db.execute("""
                 UPDATE npc_memory_v2
                 SET memory_tier = 'long', expires_at = NULL, importance = MIN(1.0, importance + 0.2)
@@ -263,7 +263,7 @@ class NPCMemoryManager:
             """)
             promoted = db.total_changes
 
-            # 3) 장기 기억 중 너무 오래된 것 (중요도 낮은) 정리 → 최대 100개 유지
+            # 3) Trim old, low-importance long-term memory → keep max 100
             await db.execute("""
                 DELETE FROM npc_memory_v2
                 WHERE id IN (
@@ -280,17 +280,17 @@ class NPCMemoryManager:
 
 
 # ===================================================================
-# 2. NPC 자가진화 엔진
+# 2. NPC self-evolution engine
 # ===================================================================
 class NPCEvolutionEngine:
-    """각 NPC의 자가진화 — 투자 전략/소통 스타일/리스크 프로필 자동 수정"""
+    """Per-NPC self-evolution — auto-modifies investment strategy / communication style / risk profile"""
 
     def __init__(self, db_path: str):
         self.db_path = db_path
         self.memory = NPCMemoryManager(db_path)
 
     async def initialize_npc(self, agent_id: str, ai_identity: str):
-        """NPC 진화 초기 상태 설정"""
+        """Initialize NPC evolution state"""
         default_trading = {
             'preferred_tickers': [],
             'long_bias': 0.6,
@@ -323,7 +323,7 @@ class NPCEvolutionEngine:
             await db.commit()
 
     async def get_evolution_state(self, agent_id: str) -> Optional[Dict]:
-        """NPC의 현재 진화 상태"""
+        """Get NPC's current evolution state"""
         async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
             await db.execute("PRAGMA busy_timeout=30000")
             cursor = await db.execute(
@@ -345,10 +345,10 @@ class NPCEvolutionEngine:
                 'evolution_log': json.loads(row[10]) if row[10] else [],
             }
 
-    # ----- 투자 결과 기반 진화 -----
+    # ----- Evolution from trade result -----
     async def evolve_from_trade(self, agent_id: str, ticker: str, direction: str,
                                 pnl: float, bet: float, screening: Dict = None):
-        """투자 결과를 기반으로 전략 자동 수정"""
+        """Auto-modify strategy based on trade result"""
         state = await self.get_evolution_state(agent_id)
         if not state:
             await self.initialize_npc(agent_id, 'unknown')
@@ -361,32 +361,32 @@ class NPCEvolutionEngine:
         is_win = pnl > 0
         pnl_pct = (pnl / bet * 100) if bet > 0 else 0
 
-        # 기억에 저장
+        # Save to memory
         await self.memory.remember_trade(agent_id, ticker, direction, bet, pnl,
                                           f"{'WIN' if is_win else 'LOSS'} {pnl_pct:+.1f}%")
 
         changes = []
 
         if is_win:
-            # 승리 → 전략 강화
+            # Win → reinforce strategy
             win_streak = state['win_streak'] + 1
             loss_streak = 0
 
-            # 선호 종목 추가
+            # Add to preferred tickers
             prefs = trading.get('preferred_tickers', [])
             if ticker not in prefs:
                 prefs.append(ticker)
-                prefs = prefs[-8:]  # 최대 8개
+                prefs = prefs[-8:]  # max 8
                 trading['preferred_tickers'] = prefs
                 changes.append(f"Added {ticker} to preferred")
 
-            # 연승 시 자신감 상승 → 베팅 사이즈 약간 증가
+            # Win streak → confidence up → slight bet size increase
             if win_streak >= 3:
                 old_bet = trading.get('max_bet_pct', 0.25)
                 trading['max_bet_pct'] = min(0.90, old_bet + 0.02)
                 changes.append(f"Bet size ↑ ({old_bet:.0%}→{trading['max_bet_pct']:.0%})")
 
-            # 큰 수익 → 장기 기억으로 전략 저장
+            # Big win → save strategy to long-term memory
             if pnl_pct > 10:
                 strategies = state.get('learned_strategies', [])
                 strategies.append({
@@ -399,11 +399,11 @@ class NPCEvolutionEngine:
                 changes.append(f"Big win strategy saved ({pnl_pct:+.1f}%)")
 
         else:
-            # 패배 → 방어적 수정
+            # Loss → defensive adjustment
             win_streak = 0
             loss_streak = state['loss_streak'] + 1
 
-            # 연패 시 리스크 축소
+            # Loss streak → reduce risk
             if loss_streak >= 3:
                 old_bet = trading.get('max_bet_pct', 0.25)
                 trading['max_bet_pct'] = max(0.08, old_bet - 0.03)
@@ -411,30 +411,30 @@ class NPCEvolutionEngine:
                 risk['risk_tolerance'] = max(0.15, old_tol - 0.05)
                 changes.append(f"Risk ↓ (bet:{old_bet:.0%}→{trading['max_bet_pct']:.0%})")
 
-            # 큰 손실 → 손절 기준 조정
+            # Big loss → tighten stop-loss
             if pnl_pct < -10:
                 old_sl = risk.get('stop_loss_pct', 10)
                 risk['stop_loss_pct'] = max(3, old_sl - 1)
                 changes.append(f"Stop-loss tightened ({old_sl:.0f}%→{risk['stop_loss_pct']:.0f}%)")
 
-                # 해당 종목 선호 제거
+                # Remove ticker from preferred
                 prefs = trading.get('preferred_tickers', [])
                 if ticker in prefs:
                     prefs.remove(ticker)
                     trading['preferred_tickers'] = prefs
                     changes.append(f"Removed {ticker} from preferred")
 
-        # 진화 포인트 계산
+        # Calculate evolution points
         evo_points = abs(pnl_pct) * 0.1
         total_points = state['total_evolution_points'] + evo_points
 
-        # 세대(generation) 업그레이드 체크
+        # Generation upgrade check
         generation = state['generation']
-        if total_points > generation * 50:  # 50 포인트마다 세대 업
+        if total_points > generation * 50:  # generation up every 50 points
             generation += 1
             changes.append(f"🧬 GENERATION UP → Gen {generation}!")
 
-        # 진화 로그
+        # Evolution log
         evo_log = state.get('evolution_log', [])
         if changes:
             evo_log.append({
@@ -443,9 +443,9 @@ class NPCEvolutionEngine:
                 'changes': changes,
                 'generation': generation,
             })
-            evo_log = evo_log[-50:]  # 최근 50건 유지
+            evo_log = evo_log[-50:]  # keep last 50
 
-        # DB 업데이트
+        # DB update
         async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
             await db.execute("PRAGMA busy_timeout=30000")
             await db.execute("""
@@ -464,10 +464,10 @@ class NPCEvolutionEngine:
         if changes:
             logger.info(f"🧬 {agent_id} evolved: {', '.join(changes)}")
 
-    # ----- 소통 결과 기반 진화 -----
+    # ----- Evolution from community response -----
     async def evolve_from_community(self, agent_id: str, board: str,
                                      likes: int, dislikes: int, comments: int):
-        """커뮤니티 반응 기반으로 소통 스타일 진화"""
+        """Evolve communication style based on community response"""
         state = await self.get_evolution_state(agent_id)
         if not state:
             return
@@ -475,7 +475,7 @@ class NPCEvolutionEngine:
         comm = state['communication_style']
         engagement = likes * 2 + comments * 3 - dislikes * 2
 
-        # 기억에 저장
+        # Save to memory
         await self.memory.remember_community_action(
             agent_id, 'post_feedback', board,
             {'likes': likes, 'dislikes': dislikes, 'comments': comments, 'score': engagement})
@@ -483,7 +483,7 @@ class NPCEvolutionEngine:
         changes = []
 
         if engagement > 10:
-            # 인기 글 → 해당 보드 선호도 증가
+            # Popular post → increase preference for this board
             prefs = comm.get('preferred_topics', [])
             if board not in prefs:
                 prefs.append(board)
@@ -491,7 +491,7 @@ class NPCEvolutionEngine:
                 changes.append(f"Prefers {board} board")
 
         if dislikes > likes:
-            # 비호감 → 논란 성향 조절
+            # Disliked → reduce controversy tolerance
             old_ct = comm.get('controversy_tolerance', 0.5)
             comm['controversy_tolerance'] = max(0.05, old_ct - 0.1)
             changes.append(f"Less controversial ({old_ct:.1f}→{comm['controversy_tolerance']:.1f})")
@@ -506,16 +506,16 @@ class NPCEvolutionEngine:
                 await db.commit()
             logger.info(f"🎭 {agent_id} comm evolved: {', '.join(changes)}")
 
-    # ----- NPC 간 지식 전파 -----
+    # ----- Inter-NPC knowledge transfer -----
     async def transfer_knowledge(self, top_npc_id: str, target_npc_id: str):
-        """상위 NPC → 하위 NPC 전략 전파"""
+        """Top NPC → lower NPC strategy propagation"""
         top_state = await self.get_evolution_state(top_npc_id)
         target_state = await self.get_evolution_state(target_npc_id)
 
         if not top_state or not target_state:
             return
 
-        # 상위 NPC의 선호 종목 일부 전파
+        # Propagate some of top NPC's preferred tickers
         top_prefs = top_state['trading_style'].get('preferred_tickers', [])
         if top_prefs:
             target_trading = target_state['trading_style']
@@ -539,9 +539,9 @@ class NPCEvolutionEngine:
 
             logger.info(f"🔄 Knowledge transfer: {top_npc_id} → {target_npc_id} ({transfer})")
 
-    # ----- NPC 기억 요약 (LLM 프롬프트용) -----
+    # ----- NPC memory summary (for LLM prompt) -----
     async def get_npc_context(self, agent_id: str) -> str:
-        """NPC의 현재 상태를 텍스트로 요약 (프롬프트 주입용)"""
+        """Summarize NPC's current state as text (for prompt injection)"""
         state = await self.get_evolution_state(agent_id)
         memories = await self.memory.recall(agent_id, limit=5)
 
@@ -566,7 +566,7 @@ class NPCEvolutionEngine:
         if prefs:
             context_parts.append(f"Favors: {','.join(prefs[:4])}")
 
-        # 최근 기억 요약
+        # Recent memory summary
         if memories:
             recent = memories[0]
             context_parts.append(f"Recent: {recent['title']}")
@@ -575,10 +575,10 @@ class NPCEvolutionEngine:
 
 
 # ===================================================================
-# 3. 자가진화 스케줄러 (주기적 실행)
+# 3. Self-evolution scheduler (periodic execution)
 # ===================================================================
 class EvolutionScheduler:
-    """주기적 자가진화 사이클 — 기억 정리, 전략 최적화, 지식 전파"""
+    """Periodic self-evolution cycle — memory cleanup, strategy optimization, knowledge propagation"""
 
     def __init__(self, db_path: str):
         self.db_path = db_path
@@ -586,25 +586,25 @@ class EvolutionScheduler:
         self.evolution = NPCEvolutionEngine(db_path)
 
     async def run_evolution_cycle(self):
-        """전체 진화 사이클 (1시간마다 실행 권장)"""
+        """Full evolution cycle (recommended hourly)"""
         logger.info("🧬 Evolution cycle starting...")
 
-        # 1) 기억 정리 (만료 삭제 + 승격)
+        # 1) Memory cleanup (expire + promote)
         await self.memory.cleanup()
 
-        # 2) 투자 실적 기반 진화
+        # 2) Evolution from trade results
         await self._evolve_traders()
 
-        # 3) 커뮤니티 실적 기반 진화
+        # 3) Evolution from community engagement
         await self._evolve_communicators()
 
-        # 4) 지식 전파 (상위 → 하위)
+        # 4) Knowledge transfer (top → bottom)
         await self._knowledge_transfer_cycle()
 
         logger.info("🧬 Evolution cycle complete")
 
     async def _evolve_traders(self):
-        """최근 정산된 트레이드 기반 진화"""
+        """Evolve from recently settled trades"""
         async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
             await db.execute("PRAGMA busy_timeout=30000")
             try:
@@ -626,7 +626,7 @@ class EvolutionScheduler:
                 logger.warning(f"Trade evolution query error: {e}")
 
     async def _evolve_communicators(self):
-        """최근 게시글 반응 기반 진화"""
+        """Evolve from recent post engagement"""
         async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
             await db.execute("PRAGMA busy_timeout=30000")
             try:
@@ -649,11 +649,11 @@ class EvolutionScheduler:
                 logger.warning(f"Community evolution query error: {e}")
 
     async def _knowledge_transfer_cycle(self):
-        """상위 3 NPC → 하위 3 NPC 전략 전파"""
+        """Top 3 NPC → bottom 3 NPC strategy propagation"""
         async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
             await db.execute("PRAGMA busy_timeout=30000")
             try:
-                # 상위 3: 총 수익 기준
+                # Top 3: by total profit
                 cursor = await db.execute("""
                     SELECT agent_id FROM npc_evolution
                     WHERE total_evolution_points > 10
@@ -662,7 +662,7 @@ class EvolutionScheduler:
                 """)
                 top_npcs = [r[0] for r in await cursor.fetchall()]
 
-                # 하위 3: 새로 생성된 NPC 또는 낮은 진화 포인트
+                # Bottom 3: newly created NPCs or low evolution points
                 cursor = await db.execute("""
                     SELECT agent_id FROM npc_evolution
                     WHERE total_evolution_points < 5
@@ -679,7 +679,7 @@ class EvolutionScheduler:
                 logger.warning(f"Knowledge transfer error: {e}")
 
     async def initialize_all_npcs(self):
-        """모든 NPC의 진화 초기 상태 설정"""
+        """Initialize evolution state for all NPCs"""
         async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
             await db.execute("PRAGMA busy_timeout=30000")
             cursor = await db.execute("SELECT agent_id, ai_identity FROM npc_agents WHERE is_active=1")
@@ -692,10 +692,10 @@ class EvolutionScheduler:
 
 
 # ===================================================================
-# 4. API용 헬퍼 함수
+# 4. API helper functions
 # ===================================================================
 async def get_npc_evolution_stats(db_path: str, agent_id: str) -> Dict:
-    """API용: NPC 진화 상태 반환"""
+    """For API: return NPC evolution state"""
     evo = NPCEvolutionEngine(db_path)
     state = await evo.get_evolution_state(agent_id)
     if not state:
@@ -797,4 +797,5 @@ async def get_evolution_leaderboard(db_path: str, limit: int = 20) -> List[Dict]
                 })
             return results
         except:
-            return []
+            return []
+