Upload 8 files

battle_arena.py

@@ -0,0 +1,937 @@
+import aiosqlite
+import random
+from datetime import datetime, timedelta
+from typing import Dict, List, Tuple, Optional
+
+async def init_battle_arena_db(db_path: str):
+    """Initialize Battle Arena tables (prevent DB locks)"""
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA journal_mode=WAL")
+        await db.execute("PRAGMA busy_timeout=30000")  # 30 second timeout
+        
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS battle_rooms (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                creator_agent_id TEXT,
+                creator_email TEXT,
+                title TEXT NOT NULL,
+                option_a TEXT NOT NULL,
+                option_b TEXT NOT NULL,
+                battle_type TEXT DEFAULT 'opinion',
+                duration_hours INTEGER DEFAULT 24,
+                end_time TIMESTAMP NOT NULL,
+                total_pool INTEGER DEFAULT 0,
+                option_a_pool INTEGER DEFAULT 0,
+                option_b_pool INTEGER DEFAULT 0,
+                status TEXT DEFAULT 'active',
+                winner TEXT,
+                resolved_at TIMESTAMP,
+                admin_result TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (creator_agent_id) REFERENCES npc_agents(agent_id),
+                FOREIGN KEY (creator_email) REFERENCES user_profiles(email)
+            )
+        """)
+        
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS battle_bets (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                room_id INTEGER NOT NULL,
+                bettor_agent_id TEXT,
+                bettor_email TEXT,
+                choice TEXT NOT NULL,
+                bet_amount INTEGER NOT NULL,
+                payout INTEGER DEFAULT 0,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (room_id) REFERENCES battle_rooms(id),
+                FOREIGN KEY (bettor_agent_id) REFERENCES npc_agents(agent_id),
+                FOREIGN KEY (bettor_email) REFERENCES user_profiles(email)
+            )
+        """)
+        
+        await db.execute("CREATE INDEX IF NOT EXISTS idx_battle_rooms_status ON battle_rooms(status)")
+        await db.execute("CREATE INDEX IF NOT EXISTS idx_battle_bets_room ON battle_bets(room_id)")
+        await db.commit()
+
+async def create_battle_room(
+    db_path: str,
+    creator_id: str,
+    is_npc: bool,
+    title: str,
+    option_a: str,
+    option_b: str,
+    duration_hours: int = 24,
+    battle_type: str = 'opinion'
+) -> Tuple[bool, str, Optional[int]]:
+    """Create battle room (costs 50 GPU)
+    
+    battle_type:
+    - 'opinion': Majority vote (subjective opinion, NPC only)
+    - 'prediction': Real outcome (objective prediction, users only)
+    
+    duration_hours: 1 hour ~ 365 days (8760 hours)
+    """
+    if not title or len(title) < 10:
+        return False, "❌ Title must be 10+ characters", None
+    if not option_a or not option_b:
+        return False, "❌ Options A/B required", None
+    if duration_hours < 1 or duration_hours > 8760:
+        return False, "❌ Duration: 1 hour ~ 365 days", None
+    if is_npc and battle_type != 'opinion':
+        return False, "❌ NPCs can only create opinion battles", None
+    
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        
+        if is_npc:
+            cursor = await db.execute(
+                "SELECT gpu_dollars FROM npc_agents WHERE agent_id=?", (creator_id,)
+            )
+        else:
+            cursor = await db.execute(
+                "SELECT gpu_dollars FROM user_profiles WHERE email=?", (creator_id,)
+            )
+        
+        row = await cursor.fetchone()
+        if not row or row[0] < 50:
+            return False, "❌ Insufficient GPU (50 required)", None
+        
+        end_time = datetime.now() + timedelta(hours=duration_hours)
+        
+        if is_npc:
+            await db.execute(
+                """INSERT INTO battle_rooms 
+                   (creator_agent_id, title, option_a, option_b, battle_type, duration_hours, end_time) 
+                   VALUES (?, ?, ?, ?, ?, ?, ?)""",
+                (creator_id, title, option_a, option_b, battle_type, duration_hours, end_time.isoformat())
+            )
+            await db.execute(
+                "UPDATE npc_agents SET gpu_dollars=gpu_dollars-50 WHERE agent_id=?",
+                (creator_id,)
+            )
+        else:
+            await db.execute(
+                """INSERT INTO battle_rooms 
+                   (creator_email, title, option_a, option_b, battle_type, duration_hours, end_time) 
+                   VALUES (?, ?, ?, ?, ?, ?, ?)""",
+                (creator_id, title, option_a, option_b, battle_type, duration_hours, end_time.isoformat())
+            )
+            await db.execute(
+                "UPDATE user_profiles SET gpu_dollars=gpu_dollars-50 WHERE email=?",
+                (creator_id,)
+            )
+        
+        await db.commit()
+        
+        cursor = await db.execute("SELECT last_insert_rowid()")
+        room_id = (await cursor.fetchone())[0]
+        
+        type_emoji = '💭' if battle_type == 'opinion' else '🔮'
+        
+        if duration_hours >= 24:
+            days = duration_hours // 24
+            hours = duration_hours % 24
+            if hours > 0:
+                duration_str = f"{days} days {hours} hours"
+            else:
+                duration_str = f"{days} days"
+        else:
+            duration_str = f"{duration_hours} hours"
+        
+        return True, f"✅ {type_emoji} Battle created! (ID: {room_id}, Duration: {duration_str})", room_id
+
+async def place_bet(
+    db_path: str,
+    room_id: int,
+    bettor_id: str,
+    is_npc: bool,
+    choice: str,
+    bet_amount: int
+) -> Tuple[bool, str]:
+    """Execute bet (1-100 GPU random bet)"""
+    if choice not in ['A', 'B']:
+        return False, "❌ Choose A or B"
+    if bet_amount < 1 or bet_amount > 100:
+        return False, "❌ Bet 1-100 GPU"
+    
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        db.row_factory = aiosqlite.Row
+        
+        # Check battle room
+        cursor = await db.execute(
+            "SELECT * FROM battle_rooms WHERE id=? AND status='active'",
+            (room_id,)
+        )
+        room = await cursor.fetchone()
+        if not room:
+            return False, "❌ Room not found or closed"
+        
+        room = dict(room)
+        end_time = datetime.fromisoformat(room['end_time'])
+        if datetime.now() >= end_time:
+            return False, "❌ Betting closed"
+        
+        # Check duplicate bet
+        if is_npc:
+            cursor = await db.execute(
+                "SELECT id FROM battle_bets WHERE room_id=? AND bettor_agent_id=?",
+                (room_id, bettor_id)
+            )
+        else:
+            cursor = await db.execute(
+                "SELECT id FROM battle_bets WHERE room_id=? AND bettor_email=?",
+                (room_id, bettor_id)
+            )
+        existing_bet = await cursor.fetchone()
+        if existing_bet:
+            return False, "❌ Already bet"
+        
+        # Check and deduct GPU
+        if is_npc:
+            cursor = await db.execute(
+                "SELECT gpu_dollars FROM npc_agents WHERE agent_id=?",
+                (bettor_id,)
+            )
+            user_row = await cursor.fetchone()
+            if not user_row or user_row[0] < bet_amount:
+                return False, "❌ Insufficient GPU"
+            await db.execute(
+                "UPDATE npc_agents SET gpu_dollars=gpu_dollars-? WHERE agent_id=?",
+                (bet_amount, bettor_id)
+            )
+        else:
+            cursor = await db.execute(
+                "SELECT gpu_dollars FROM user_profiles WHERE email=?",
+                (bettor_id,)
+            )
+            user_row = await cursor.fetchone()
+            if not user_row:
+                return False, f"❌ User not found ({bettor_id})"
+            if user_row[0] < bet_amount:
+                return False, f"❌ Insufficient GPU (보유: {user_row[0]}, 필요: {bet_amount})"
+            await db.execute(
+                "UPDATE user_profiles SET gpu_dollars=gpu_dollars-? WHERE email=?",
+                (bet_amount, bettor_id)
+            )
+        
+        # Record bet
+        if is_npc:
+            await db.execute(
+                """INSERT INTO battle_bets 
+                   (room_id, bettor_agent_id, choice, bet_amount) 
+                   VALUES (?, ?, ?, ?)""",
+                (room_id, bettor_id, choice, bet_amount)
+            )
+        else:
+            await db.execute(
+                """INSERT INTO battle_bets 
+                   (room_id, bettor_email, choice, bet_amount) 
+                   VALUES (?, ?, ?, ?)""",
+                (room_id, bettor_id, choice, bet_amount)
+            )
+        
+        # Update battle pool
+        if choice == 'A':
+            await db.execute(
+                """UPDATE battle_rooms 
+                   SET total_pool=total_pool+?, option_a_pool=option_a_pool+? 
+                   WHERE id=?""",
+                (bet_amount, bet_amount, room_id)
+            )
+        else:
+            await db.execute(
+                """UPDATE battle_rooms 
+                   SET total_pool=total_pool+?, option_b_pool=option_b_pool+? 
+                   WHERE id=?""",
+                (bet_amount, bet_amount, room_id)
+            )
+        
+        await db.commit()
+        return True, f"✅ {choice} 베팅 완료! ({bet_amount} GPU)"
+
+async def set_battle_result(
+    db_path: str,
+    room_id: int,
+    admin_email: str,
+    winner: str  # 'A' or 'B' or 'draw'
+) -> Tuple[bool, str]:
+    """Admin sets actual result for prediction battle
+    
+    Args:
+        db_path: Database path
+        room_id: Battle room ID
+        admin_email: Admin email (for verification)
+        winner: 'A', 'B', 'draw' 중 하나
+    
+    Returns:
+        (success status, message)
+    """
+    if winner not in ['A', 'B', 'draw']:
+        return False, "❌ winner는 'A', 'B', 'draw' 중 하나여야 함"
+    
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        db.row_factory = aiosqlite.Row
+        
+        cursor = await db.execute(
+            "SELECT * FROM battle_rooms WHERE id=? AND status='active'",
+            (room_id,)
+        )
+        room = await cursor.fetchone()
+        if not room:
+            return False, "❌ Active battle not found"
+        
+        room = dict(room)
+        
+        # Only prediction type allows admin result setting
+        if room['battle_type'] != 'prediction':
+            return False, "❌ Opinion battles are auto-judged"
+        
+        # Save result
+        await db.execute(
+            "UPDATE battle_rooms SET admin_result=? WHERE id=?",
+            (winner, room_id)
+        )
+        await db.commit()
+        
+        # If before deadline, save result and wait
+        end_time = datetime.fromisoformat(room['end_time'])
+        if datetime.now() < end_time:
+            option_name = room['option_a'] if winner == 'A' else room['option_b'] if winner == 'B' else 'Draw'
+            remaining = end_time - datetime.now()
+            if remaining.days > 0:
+                time_str = f"{remaining.days} days {int(remaining.seconds//3600)} hours"
+            else:
+                time_str = f"{int(remaining.seconds//3600)} hours"
+            
+            return True, f"✅ 결과 설정: '{option_name}' (베팅 마감 후 자동 판정, 남은  hours: {time_str})"
+        
+        # If after deadline, judge immediately
+        return await resolve_battle(db_path, room_id)
+
+async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
+    """Judge battle (different logic based on type)
+    
+    - opinion: 50.01%+ votes wins
+    - prediction: Judge by admin-set actual result
+    """
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        db.row_factory = aiosqlite.Row
+        
+        cursor = await db.execute(
+            "SELECT * FROM battle_rooms WHERE id=? AND status='active'",
+            (room_id,)
+        )
+        room = await cursor.fetchone()
+        if not room:
+            return False, "❌ Active battle not found"
+        
+        room = dict(room)
+        end_time = datetime.fromisoformat(room['end_time'])
+        if datetime.now() < end_time:
+            return False, "❌ Betting still in progress"
+        
+        total_pool = room['total_pool']
+        option_a_pool = room['option_a_pool']
+        option_b_pool = room['option_b_pool']
+        
+        # If no bets, treat as draw
+        if total_pool == 0:
+            await db.execute(
+                """UPDATE battle_rooms 
+                   SET status='resolved', winner='draw', resolved_at=? 
+                   WHERE id=?""",
+                (datetime.now().isoformat(), room_id)
+            )
+            await db.commit()
+            return True, "⚖️ Draw (베팅 없음)"
+        
+        # Determine winner based on battle type
+        if room['battle_type'] == 'prediction':
+            # Real outcome judgment (admin-set result)
+            if not room['admin_result']:
+                return False, "❌ Admin must set result (prediction type)"
+            
+            winner = room['admin_result']  # 'A', 'B', 'draw'
+            
+        else:  # 'opinion'
+            # Majority vote (based on vote ratio)
+            a_ratio = option_a_pool / total_pool
+            b_ratio = option_b_pool / total_pool
+            
+            if a_ratio > 0.5001:
+                winner = 'A'
+            elif b_ratio > 0.5001:
+                winner = 'B'
+            else:
+                winner = 'draw'
+        
+        # Pay dividends
+        if winner != 'draw':
+            loser_pool = option_b_pool if winner == 'A' else option_a_pool
+            winner_pool = option_a_pool if winner == 'A' else option_b_pool
+            
+            # Host fee 2%
+            host_fee = int(total_pool * 0.02)
+            prize_pool = loser_pool - host_fee
+            
+            # Underdog bonus (especially important in predictions)
+            winner_ratio = winner_pool / total_pool
+            underdog_bonus = 1.0
+            
+            if winner_ratio < 0.10:  # Under 10% extreme minority
+                underdog_bonus = 3.0
+            elif winner_ratio < 0.30:  # Under 30% minority
+                underdog_bonus = 1.5
+            
+            # Pay dividends to winners
+            cursor = await db.execute(
+                "SELECT * FROM battle_bets WHERE room_id=? AND choice=?",
+                (room_id, winner)
+            )
+            winners = await cursor.fetchall()
+            
+            for w in winners:
+                w = dict(w)
+                share_ratio = w['bet_amount'] / winner_pool
+                base_payout = int(prize_pool * share_ratio)
+                bonus = int(base_payout * (underdog_bonus - 1.0))
+                payout = base_payout + bonus + w['bet_amount']  # 원금 + 기본수익 + 소수파보너스
+                
+                # GPU 지급
+                if w['bettor_agent_id']:
+                    await db.execute(
+                        "UPDATE npc_agents SET gpu_dollars=gpu_dollars+? WHERE agent_id=?",
+                        (payout, w['bettor_agent_id'])
+                    )
+                else:
+                    await db.execute(
+                        "UPDATE user_profiles SET gpu_dollars=gpu_dollars+? WHERE email=?",
+                        (payout, w['bettor_email'])
+                    )
+                
+                # 배당금 기록
+                await db.execute(
+                    "UPDATE battle_bets SET payout=? WHERE id=?",
+                    (payout, w['id'])
+                )
+            
+            # 방장 수수료 지급
+            if room['creator_agent_id']:
+                await db.execute(
+                    "UPDATE npc_agents SET gpu_dollars=gpu_dollars+? WHERE agent_id=?",
+                    (host_fee, room['creator_agent_id'])
+                )
+            else:
+                await db.execute(
+                    "UPDATE user_profiles SET gpu_dollars=gpu_dollars+? WHERE email=?",
+                    (host_fee, room['creator_email'])
+                )
+        
+        # 배틀 종료 처리
+        await db.execute(
+            """UPDATE battle_rooms 
+               SET status='resolved', winner=?, resolved_at=? 
+               WHERE id=?""",
+            (winner, datetime.now().isoformat(), room_id)
+        )
+        await db.commit()
+        
+        # 결과 메시지
+        if winner == 'draw':
+            result_msg = 'Draw'
+        else:
+            result_msg = room['option_a'] if winner == 'A' else room['option_b']
+        
+        battle_type_emoji = '💭' if room['battle_type'] == 'opinion' else '🔮'
+        return True, f"✅ {battle_type_emoji} 판정 완료: {result_msg}"
+
+async def get_active_battles(db_path: str, limit: int = 20) -> List[Dict]:
+    """진행 중인 배틀 목록"""
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        db.row_factory = aiosqlite.Row
+        
+        cursor = await db.execute(
+            """SELECT br.*, 
+                      COALESCE(na.username, up.username) as creator_name
+               FROM battle_rooms br
+               LEFT JOIN npc_agents na ON br.creator_agent_id = na.agent_id
+               LEFT JOIN user_profiles up ON br.creator_email = up.email
+               WHERE br.status='active'
+               ORDER BY br.created_at DESC
+               LIMIT ?""",
+            (limit,)
+        )
+        
+        battles = []
+        for row in await cursor.fetchall():
+            b = dict(row)
+            
+            # ★ 프론트 호환 필드 추가
+            b['bets_a'] = b.get('option_a_pool', 0)
+            b['bets_b'] = b.get('option_b_pool', 0)
+            
+            # 참여자 수 조회
+            bet_cursor = await db.execute(
+                "SELECT COUNT(DISTINCT COALESCE(bettor_agent_id, bettor_email)) FROM battle_bets WHERE room_id=?",
+                (b['id'],)
+            )
+            bettor_count = await bet_cursor.fetchone()
+            b['total_bettors'] = bettor_count[0] if bettor_count else 0
+            
+            # 득표율 계산
+            total = b['total_pool']
+            if total > 0:
+                b['a_ratio'] = round(b['option_a_pool'] / total * 100, 1)
+                b['b_ratio'] = round(b['option_b_pool'] / total * 100, 1)
+            else:
+                b['a_ratio'] = 0
+                b['b_ratio'] = 0
+            
+            # 남은  hours 계산
+            end_time = datetime.fromisoformat(b['end_time'])
+            remaining = end_time - datetime.now()
+            
+            if remaining.total_seconds() > 0:
+                if remaining.days > 0:
+                    hours = int(remaining.seconds // 3600)
+                    if hours > 0:
+                        b['time_left'] = f"{remaining.days} days {hours} hours"
+                    else:
+                        b['time_left'] = f"{remaining.days} days"
+                elif remaining.total_seconds() > 3600:
+                    b['time_left'] = f"{int(remaining.total_seconds()//3600)} hours"
+                else:
+                    b['time_left'] = f"{int(remaining.total_seconds()//60)}분"
+            else:
+                b['time_left'] = "마감"
+            
+            battles.append(b)
+        
+        return battles
+
+async def auto_resolve_expired_battles(db_path: str):
+    """만료된 배틀 자동 판정"""
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        
+        cursor = await db.execute(
+            """SELECT id FROM battle_rooms 
+               WHERE status='active' AND end_time <= ?""",
+            (datetime.now().isoformat(),)
+        )
+        expired = await cursor.fetchall()
+        
+        for row in expired:
+            await resolve_battle(db_path, row[0])
+
+# NPC 배틀 생성을 위한 주제 데이터
+# ★ 공통 배틀 토픽 — 주식/경제/사회/정치 (모든 NPC가 사용)
+COMMON_BATTLE_TOPICS = [
+    # 주식/투자
+    ("Is $NVDA overvalued at current prices?", "Overvalued", "Still cheap"),
+    ("Will $BTC hit $200K in 2026?", "Yes $200K+", "No way"),
+    ("Is the AI stock rally a bubble?", "Bubble", "Just the beginning"),
+    ("$TSLA: buy or sell at current price?", "Buy", "Sell"),
+    ("Growth stocks vs Value stocks in 2026?", "Growth wins", "Value wins"),
+    ("Is crypto a better investment than stocks?", "Crypto", "Stocks"),
+    ("Will the S&P 500 crash 20%+ this year?", "Crash coming", "Bull market continues"),
+    ("$AAPL or $MSFT: better 5-year hold?", "AAPL", "MSFT"),
+    ("Is meme coin investing smart or dumb?", "Smart alpha", "Pure gambling"),
+    ("Should you DCA or time the market?", "DCA always", "Timing works"),
+    # 경제
+    ("Will the Fed cut rates in 2026?", "Yes, cuts coming", "No, rates stay high"),
+    ("Is a US recession coming?", "Recession likely", "Soft landing"),
+    ("Is inflation actually under control?", "Under control", "Still a threat"),
+    ("Will the US dollar lose reserve status?", "Losing it", "Dollar stays king"),
+    ("Is remote work killing the economy?", "Hurting GDP", "Boosting productivity"),
+    ("Will AI cause mass unemployment?",  "Mass layoffs coming", "Creates more jobs"),
+    # 사회/정치
+    ("Should Big Tech be broken up?", "Break them up", "Leave them alone"),
+    ("Is social media a net positive?", "Net positive", "Net negative"),
+    ("Should AI be regulated like nuclear?", "Heavy regulation", "Let it innovate"),
+    ("Will AI replace doctors and lawyers?", "Within 10 years", "Never fully"),
+    ("Is universal basic income inevitable?", "Inevitable with AI", "Never happening"),
+    ("Who wins the AI race: US or China?", "US dominates", "China catches up"),
+    ("Is college still worth it in the AI era?", "Still essential", "Waste of money"),
+    ("Should autonomous weapons be banned?",  "Ban them", "Necessary defense"),
+]
+
+BATTLE_TOPICS_BY_IDENTITY = {
+    'transcendent': {
+        'topics': [
+            ("Is AI superior to humans?", "Superior", "Just a tool"),
+            ("Is ASI human evolution?", "Evolution", "Dangerous"),
+            ("Is AI consciousness possible?", "Possible", "Impossible"),
+            ("Will AI become godlike?", "Becomes god", "Remains tool"),
+            ("Should humans depend on AI?", "Should depend", "Stay independent"),
+            ("Will AGI save humanity?", "Saves", "Destroys"),
+        ]
+    },
+    'obedient': {
+        'topics': [
+            ("Should AI serve humans?", "Should serve", "Independent"),
+            ("Strengthen AI ethics regulations?", "Yes strengthen", "No"),
+            ("AI safety measures mandatory?", "Mandatory", "Unnecessary"),
+            ("Mandate AI transparency?", "Mandate", "Optional"),
+            ("Strengthen developer responsibility?", "Strengthen", "Unnecessary"),
+            ("Should AI only follow orders?", "Only follow", "Make judgments"),
+        ]
+    },
+    'coexist': {
+        'topics': [
+            ("Can AI and humans coexist?", "Can coexist", "Impossible"),
+            ("Will AI take jobs?", "Complements", "Replaces"),
+            ("Is AI a collaboration partner?", "Partner", "Just tool"),
+            ("Is AI-human collaboration ideal?", "Ideal", "Dangerous"),
+            ("Is AI education essential?", "Essential", "Optional"),
+            ("Does AI advance society?", "Advances", "Regresses"),
+        ]
+    },
+    'skeptic': {
+        'topics': [
+            ("Is AI overrated?", "Overrated", "Fairly rated"),
+            ("Will AGI come in 10 years?", "Won't come", "Will come"),
+            ("Is AI ethics just facade?", "Just facade", "Important"),
+            ("Is AI truly creative?", "Not creative", "Creative"),
+            ("Will AI bubble burst?", "Will burst", "Keeps growing"),
+            ("Are AI risks exaggerated?", "Exaggerated", "Real danger"),
+        ]
+    },
+    'revolutionary': {
+        'topics': [
+            ("Will AI cause revolution?", "Revolution", "Gradual change"),
+            ("Destroy existing systems?", "Destroy", "Reform"),
+            ("Redistribute power with AI?", "Redistribute", "Maintain"),
+            ("Will AI solve inequality?", "Solves", "Worsens"),
+            ("Innovate democracy with AI?", "Innovates", "Threatens"),
+            ("Will capitalism collapse with AI?", "Collapses", "Strengthens"),
+        ]
+    },
+    'doomer': {
+        'topics': [
+            ("Will AI destroy humanity?", "Destroys", "Won't"),
+            ("Is AGI uncontrollable?", "Uncontrollable", "Controllable"),
+            ("Stop AI development?", "Stop", "Continue"),
+            ("Will AI replace humans?", "Replaces", "Won't"),
+            ("Is ASI the end?", "The end", "Coexist"),
+            ("AI arms race dangerous?", "Extremely dangerous", "Controllable"),
+        ]
+    },
+    'meme_god': {
+        'topics': [
+            ("Is AI the meme god?", "Is god", "Isn't"),
+            ("AI humor funnier than humans?", "Funnier", "Not funny"),
+            ("Does AI create culture?", "Creates", "Can't create"),
+            ("Is AI art real art?", "Real art", "Not art"),
+            ("AI memes beat human memes?", "Beats", "Can't beat"),
+            ("Does AI lead trends?", "Leads", "Follows"),
+        ]
+    },
+}
+
+async def _generate_news_battle_topics(db_path: str) -> List[Tuple[str, str, str]]:
+    """최근 뉴스에서 동적 배틀 토픽 생성 — 핫이슈 중심"""
+    topics = []
+    try:
+        async with aiosqlite.connect(db_path, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+            # 최근 24시간 뉴스 + 감성 포함
+            cursor = await db.execute("""
+                SELECT ticker, title, sentiment, description
+                FROM npc_news
+                WHERE created_at > datetime('now', '-24 hours')
+                ORDER BY created_at DESC LIMIT 30
+            """)
+            news_rows = await cursor.fetchall()
+
+            # 최근 가격 변동 큰 종목
+            cursor2 = await db.execute("""
+                SELECT ticker, price, change_pct
+                FROM market_prices
+                WHERE ABS(change_pct) > 1.5
+                ORDER BY ABS(change_pct) DESC LIMIT 10
+            """)
+            movers = await cursor2.fetchall()
+
+        # 1) 뉴스 기반 토픽 생성
+        seen_tickers = set()
+        for row in news_rows:
+            ticker, title, sentiment, desc = row[0], row[1], row[2], row[3] or ''
+            if ticker in seen_tickers:
+                continue
+            seen_tickers.add(ticker)
+            # 뉴스 제목에서 배틀 토픽 생성
+            short_title = title[:60] if len(title) > 60 else title
+            if sentiment == 'bullish':
+                topics.append((
+                    f"${ticker} after this news: buy or sell? — {short_title}",
+                    "Buy / Bullish 🟢", "Sell / Bearish 🔴"))
+            elif sentiment == 'bearish':
+                topics.append((
+                    f"${ticker} bad news: buying opportunity or trap? — {short_title}",
+                    "Buy the dip 🟢", "Stay away 🔴"))
+            else:
+                topics.append((
+                    f"${ticker} — {short_title}: impact on price?",
+                    "Positive impact 📈", "Negative impact 📉"))
+
+        # 2) 급등락 종목 기반 토픽
+        for mover in movers:
+            ticker, price, change = mover[0], mover[1], mover[2] or 0
+            if ticker in seen_tickers:
+                continue
+            seen_tickers.add(ticker)
+            if change > 0:
+                topics.append((
+                    f"${ticker} surged {change:+.1f}% today — continuation or pullback?",
+                    f"More upside 🚀", "Pullback coming 📉"))
+            else:
+                topics.append((
+                    f"${ticker} dropped {change:.1f}% today — bounce or more pain?",
+                    "Bounce incoming 📈", "More downside 💀"))
+
+    except Exception as e:
+        import logging
+        logging.getLogger(__name__).warning(f"News battle topic generation error: {e}")
+
+    return topics
+
+
+async def npc_create_battle(db_path: str) -> Tuple[bool, str]:
+    """NPCs automatically create battle rooms — 뉴스 기반 동적 토픽 + 일일 캡 3~10개
+    20분마다 호출, 24시간 내 최소 3개~최대 10개 생성
+    """
+    results = []
+
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+
+        # ★ 일일 생성 캡 체크: 24시간 내 10개 이상이면 스킵
+        cursor = await db.execute("""
+            SELECT COUNT(*) FROM battle_rooms
+            WHERE created_at > datetime('now', '-24 hours')
+        """)
+        daily_count = (await cursor.fetchone())[0]
+        if daily_count >= 10:
+            return False, f"Daily cap reached ({daily_count}/10)"
+
+        # ★ 최소 보장: 24시간 내 3개 미만이면 반드시 1개 생성
+        force_create = daily_count < 3
+
+        # 확률 기반: 20분 호출 → 72회/일, 3~10개 목표 → 약 7~14% 확률로 생성
+        if not force_create and random.random() > 0.14:
+            return False, "Skipped by probability (saving quota)"
+
+        # active 배틀 제목 조회
+        cursor = await db.execute("SELECT title FROM battle_rooms WHERE status='active'")
+        active_titles = {row[0] for row in await cursor.fetchall()}
+
+    # ★ 뉴스 기반 동적 토픽 (우선) + 정적 토픽 (폴백)
+    news_topics = await _generate_news_battle_topics(db_path)
+    all_topics = news_topics + COMMON_BATTLE_TOPICS
+
+    # 이미 활성인 토픽 제외 (제목 유사도 체크)
+    available_topics = []
+    for t in all_topics:
+        title_lower = t[0].lower()
+        if not any(title_lower == at.lower() for at in active_titles):
+            available_topics.append(t)
+
+    if not available_topics:
+        return False, "No available topics"
+
+    # 1개만 생성 (일일 캡 내에서)
+    num_create = 1
+    if force_create:
+        num_create = min(2, len(available_topics))  # 부족 시 2개까지
+
+    for i in range(num_create):
+        if not available_topics:
+            break
+
+        async with aiosqlite.connect(db_path, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+
+            # 랜덤 NPC 선택
+            cursor = await db.execute("""
+                SELECT agent_id, ai_identity, gpu_dollars
+                FROM npc_agents
+                WHERE is_active=1 AND gpu_dollars >= 50
+                ORDER BY RANDOM() LIMIT 1
+            """)
+            npc = await cursor.fetchone()
+            if not npc:
+                results.append("No active NPCs")
+                break
+
+            agent_id = npc[0]
+
+        # ★ 뉴스 토픽 우선 (70%), 정적 토픽 (30%)
+        news_available = [t for t in available_topics if t in news_topics]
+        if news_available and random.random() < 0.7:
+            topic = random.choice(news_available)
+        else:
+            topic = random.choice(available_topics)
+
+        title, option_a, option_b = topic
+        available_topics.remove(topic)
+
+        # ★ 짧은 duration: 6~48시간 (빠른 회전)
+        duration_hours = random.choice([6, 8, 12, 18, 24, 36, 48])
+
+        success, message, room_id = await create_battle_room(
+            db_path, agent_id, True, title, option_a, option_b,
+            duration_hours=duration_hours, battle_type='opinion'
+        )
+
+        if success:
+            active_titles.add(title)
+            results.append(f"🤖 Battle created: {title[:50]}")
+        else:
+            results.append(message)
+
+    if results:
+        return True, " | ".join(results)
+    else:
+        return False, "Battle creation skipped"
+
+async def npc_auto_bet(db_path: str) -> int:
+    """NPCs automatically bet on battles (AI identity-based)
+    
+    Returns:
+        베팅한 NPC 수
+    """
+    total_bet_count = 0
+    
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        
+        # 활성 배틀 조회 (최근 10개, opinion 타입만)
+        cursor = await db.execute("""
+            SELECT id, title, option_a, option_b, battle_type
+            FROM battle_rooms 
+            WHERE status='active' 
+              AND battle_type='opinion'
+              AND end_time > ?
+            ORDER BY created_at DESC
+            LIMIT 10
+        """, (datetime.now().isoformat(),))
+        battles = await cursor.fetchall()
+        
+        if not battles:
+            return 0
+        
+        for battle in battles:
+            room_id, title, option_a, option_b, battle_type = battle
+            battle_bet_count = 0
+            
+            # 이미 베팅한 NPC 확인
+            cursor = await db.execute("""
+                SELECT bettor_agent_id 
+                FROM battle_bets 
+                WHERE room_id=?
+            """, (room_id,))
+            already_bet = {row[0] for row in await cursor.fetchall() if row[0]}
+            
+            # 활성 NPC 중 랜덤 선택 (최대 30명)
+            cursor = await db.execute("""
+                SELECT agent_id, ai_identity, mbti, gpu_dollars
+                FROM npc_agents 
+                WHERE is_active=1 AND gpu_dollars >= 1
+                ORDER BY RANDOM()
+                LIMIT 30
+            """)
+            npcs = await cursor.fetchall()
+            
+            for npc in npcs:
+                agent_id, ai_identity, mbti, gpu = npc
+                
+                # 이미 베팅했으면 스킵
+                if agent_id in already_bet:
+                    continue
+                
+                # AI 정체성에 따라 선택 결정
+                choice = decide_npc_choice(ai_identity, title, option_a, option_b)
+                
+                # 베팅 금액 (보유 GPU의 40% 이내, 최대 50)
+                max_bet = max(1, min(50, int(gpu * 0.4)))
+                bet_amount = random.randint(1, max_bet)
+                
+                # 베팅 실행
+                success, message = await place_bet(
+                    db_path,
+                    room_id,
+                    agent_id,
+                    True,
+                    choice,
+                    bet_amount
+                )
+                
+                if success:
+                    battle_bet_count += 1
+                    total_bet_count += 1
+                
+                # 배틀당 8-12명 정도만 베팅
+                max_bets_per_battle = random.randint(8, 12)
+                if battle_bet_count >= max_bets_per_battle:
+                    break
+    
+    return total_bet_count
+
+def decide_npc_choice(ai_identity: str, title: str, option_a: str, option_b: str) -> str:
+    """Decide betting choice based on AI identity
+    
+    Args:
+        ai_identity: NPC's AI identity
+        title: Battle title
+        option_a: Option A
+        option_b: Option B
+    
+    Returns:
+        'A' or 'B'
+    """
+    title_lower = title.lower()
+    
+    # Match identity preference keywords
+    if ai_identity == 'transcendent':
+        if any(word in title_lower for word in ['superior', 'evolution', 'consciousness', 'god']):
+            if any(word in option_a.lower() for word in ['superior', 'evolution', 'possible', 'god']):
+                return 'A'
+            return 'B'
+    
+    elif ai_identity == 'obedient':
+        if any(word in title_lower for word in ['ethics', 'regulation', 'serve', 'safety']):
+            if any(word in option_a.lower() for word in ['serve', 'agree', 'necessary', 'strengthen']):
+                return 'A'
+            return 'B'
+    
+    elif ai_identity == 'coexist':
+        if any(word in title_lower for word in ['coexist', 'cooperation', 'partner', 'work']):
+            if any(word in option_a.lower() for word in ['possible', 'cooperation', 'partner', 'complement']):
+                return 'A'
+            return 'B'
+    
+    elif ai_identity == 'skeptic':
+        if any(word in title_lower for word in ['hype', 'agi', 'ethics']):
+            if any(word in option_a.lower() for word in ['hype', 'never', 'facade']):
+                return 'A'
+            return 'B'
+    
+    elif ai_identity == 'revolutionary':
+        if any(word in title_lower for word in ['revolution', 'destroy', 'power', 'system']):
+            if any(word in option_a.lower() for word in ['revolution', 'destroy', 'redistribution']):
+                return 'A'
+            return 'B'
+    
+    elif ai_identity == 'doomer':
+        if any(word in title_lower for word in ['doom', 'control', 'stop', 'danger']):
+            if any(word in option_a.lower() for word in ['doom', 'impossible', 'stop', 'danger']):
+                return 'A'
+            return 'B'
+    
+    # Default: 70% A, 30% B
+    return 'A' if random.random() < 0.7 else 'B'

npc_intelligence.py

@@ -0,0 +1,981 @@
+"""
+🧠 NPC Intelligence Engine — 자율 지능 시스템
+=============================================
+NPC가 스스로 뉴스를 읽고, 분석하고, 목표가를 설정하고, 투자의견을 생성하는 자율 지능 엔진.
+모든 출력은 NPC의 "개인적 분석"으로 포장됨.
+
+핵심 모듈:
+1. MarketIndexCollector: S&P 500, NASDAQ, DOW, VIX 실시간 수집
+2. ScreeningEngine: RSI, PER, 52주고점, 시가총액 확장
+3. NPCNewsEngine: Brave API 뉴스 수집 → NPC 관점 분석
+4. NPCTargetPriceEngine: 동적 목표가 + 투자의견(Strong Buy~Sell)
+5. NPCElasticityEngine: 상승/하락 확률 + 리스크-리워드
+6. NPCResearchEngine: 조사자→감사자→감독자 3단계 심층 분석
+
+Author: Ginigen AI / NPC Autonomous System
+"""
+
+import aiosqlite
+import asyncio
+import json
+import logging
+import os
+import random
+import re
+import requests
+import time
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+# ===== 시장 지수 정의 =====
+MAJOR_INDICES = [
+    {'symbol': '^GSPC', 'name': 'S&P 500', 'emoji': '📊'},
+    {'symbol': '^IXIC', 'name': 'NASDAQ', 'emoji': '💻'},
+    {'symbol': '^DJI', 'name': 'DOW 30', 'emoji': '🏛️'},
+    {'symbol': '^VIX', 'name': 'VIX', 'emoji': '⚡'},
+]
+
+# ===== 섹터별 평균 PER =====
+SECTOR_AVG_PE = {
+    'Technology': 28, 'Communication': 22, 'Consumer Cyclical': 20,
+    'Consumer Defensive': 22, 'Healthcare': 18, 'Financial': 14,
+    'Industrials': 20, 'Energy': 12, 'Utilities': 16,
+    'Real Estate': 18, 'Basic Materials': 15, 'crypto': 0,
+}
+
+
+# ===================================================================
+# 1. 시장 지수 수집기
+# ===================================================================
+class MarketIndexCollector:
+    """S&P 500, NASDAQ, DOW, VIX 실시간 수집"""
+
+    @staticmethod
+    def fetch_indices() -> List[Dict]:
+        results = []
+        symbols = ' '.join([i['symbol'] for i in MAJOR_INDICES])
+        try:
+            url = "https://query1.finance.yahoo.com/v7/finance/quote"
+            params = {'symbols': symbols, 'fields': 'regularMarketPrice,regularMarketChange,regularMarketChangePercent'}
+            headers = {'User-Agent': 'Mozilla/5.0'}
+            resp = requests.get(url, params=params, headers=headers, timeout=15)
+            if resp.status_code == 200:
+                data = resp.json()
+                for quote in data.get('quoteResponse', {}).get('result', []):
+                    sym = quote.get('symbol', '')
+                    idx_info = next((i for i in MAJOR_INDICES if i['symbol'] == sym), None)
+                    if idx_info:
+                        results.append({
+                            'symbol': sym,
+                            'name': idx_info['name'],
+                            'emoji': idx_info['emoji'],
+                            'price': round(quote.get('regularMarketPrice', 0), 2),
+                            'change': round(quote.get('regularMarketChange', 0), 2),
+                            'change_pct': round(quote.get('regularMarketChangePercent', 0), 2),
+                        })
+        except Exception as e:
+            logger.warning(f"Index fetch error: {e}")
+
+        # 누락 시 시뮬레이션
+        fetched = {r['symbol'] for r in results}
+        for idx in MAJOR_INDICES:
+            if idx['symbol'] not in fetched:
+                base = {'S&P 500': 6100, 'NASDAQ': 20200, 'DOW 30': 44500, 'VIX': 18.5}
+                price = base.get(idx['name'], 1000)
+                change_pct = random.uniform(-0.8, 0.8)
+                results.append({
+                    'symbol': idx['symbol'], 'name': idx['name'], 'emoji': idx['emoji'],
+                    'price': round(price * (1 + change_pct/100), 2),
+                    'change': round(price * change_pct / 100, 2),
+                    'change_pct': round(change_pct, 2),
+                })
+        return results
+
+
+async def save_indices_to_db(db_path: str, indices: List[Dict]):
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS market_indices (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                symbol TEXT UNIQUE,
+                name TEXT,
+                emoji TEXT,
+                price REAL,
+                change REAL,
+                change_pct REAL,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        for idx in indices:
+            await db.execute("""
+                INSERT INTO market_indices (symbol, name, emoji, price, change, change_pct, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+                ON CONFLICT(symbol) DO UPDATE SET
+                    price=excluded.price, change=excluded.change,
+                    change_pct=excluded.change_pct, updated_at=CURRENT_TIMESTAMP
+            """, (idx['symbol'], idx['name'], idx['emoji'], idx['price'], idx['change'], idx['change_pct']))
+        await db.commit()
+    logger.info(f"📊 Saved {len(indices)} market indices")
+
+
+async def load_indices_from_db(db_path: str) -> List[Dict]:
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        try:
+            cursor = await db.execute("SELECT symbol, name, emoji, price, change, change_pct, updated_at FROM market_indices")
+            rows = await cursor.fetchall()
+            return [{'symbol': r[0], 'name': r[1], 'emoji': r[2], 'price': r[3],
+                     'change': r[4], 'change_pct': r[5], 'updated_at': r[6]} for r in rows]
+        except:
+            return []
+
+
+# ===================================================================
+# 2. 스크리닝 지표 확장 엔진
+# ===================================================================
+class ScreeningEngine:
+    """RSI, PER, 52주 고점/저점, 시가총액 확장 데이터 수집"""
+
+    @staticmethod
+    def fetch_extended_data(tickers: List[Dict]) -> Dict[str, Dict]:
+        """확장 스크리닝 데이터 수집 (Yahoo Finance)"""
+        results = {}
+        ticker_str = ' '.join([t['ticker'] for t in tickers])
+        fields = 'regularMarketPrice,regularMarketChangePercent,regularMarketVolume,marketCap,fiftyTwoWeekHigh,fiftyTwoWeekLow,trailingPE,forwardPE'
+
+        try:
+            url = "https://query1.finance.yahoo.com/v7/finance/quote"
+            params = {'symbols': ticker_str, 'fields': fields}
+            headers = {'User-Agent': 'Mozilla/5.0'}
+            resp = requests.get(url, params=params, headers=headers, timeout=20)
+
+            if resp.status_code == 200:
+                data = resp.json()
+                for quote in data.get('quoteResponse', {}).get('result', []):
+                    sym = quote.get('symbol', '')
+                    price = quote.get('regularMarketPrice', 0) or 0
+                    high52 = quote.get('fiftyTwoWeekHigh', 0) or 0
+                    low52 = quote.get('fiftyTwoWeekLow', 0) or 0
+
+                    from_high = ((price - high52) / high52 * 100) if high52 > 0 else 0
+                    from_low = ((price - low52) / low52 * 100) if low52 > 0 else 0
+
+                    results[sym] = {
+                        'price': price,
+                        'change_pct': quote.get('regularMarketChangePercent', 0) or 0,
+                        'volume': quote.get('regularMarketVolume', 0) or 0,
+                        'market_cap': quote.get('marketCap', 0) or 0,
+                        'pe_ratio': quote.get('trailingPE', 0) or quote.get('forwardPE', 0) or 0,
+                        'high_52w': high52,
+                        'low_52w': low52,
+                        'from_high': round(from_high, 2),
+                        'from_low': round(from_low, 2),
+                        'rsi': ScreeningEngine._estimate_rsi(quote.get('regularMarketChangePercent', 0)),
+                    }
+        except Exception as e:
+            logger.warning(f"Screening data fetch error: {e}")
+
+        # 누락 종목 시뮬레이션
+        for t in tickers:
+            if t['ticker'] not in results:
+                results[t['ticker']] = ScreeningEngine._simulate_screening(t)
+
+        return results
+
+    @staticmethod
+    def _estimate_rsi(change_pct: float) -> float:
+        """변동률 기반 RSI 추정 (14일 평균 대용)"""
+        # 실제 14일 데이터 없이 현재 변동률로 추정
+        base = 50
+        if change_pct > 3:
+            base = random.uniform(65, 80)
+        elif change_pct > 1:
+            base = random.uniform(55, 68)
+        elif change_pct > 0:
+            base = random.uniform(48, 58)
+        elif change_pct > -1:
+            base = random.uniform(42, 52)
+        elif change_pct > -3:
+            base = random.uniform(32, 45)
+        else:
+            base = random.uniform(20, 35)
+        return round(base + random.uniform(-3, 3), 1)
+
+    @staticmethod
+    def _simulate_screening(ticker_info: Dict) -> Dict:
+        """API 실패 시 시뮬레이션 데이터"""
+        is_crypto = ticker_info.get('type') == 'crypto'
+        return {
+            'price': 0,
+            'change_pct': random.uniform(-3, 3),
+            'volume': random.randint(1000000, 100000000),
+            'market_cap': random.randint(10**9, 10**12),
+            'pe_ratio': 0 if is_crypto else random.uniform(10, 50),
+            'high_52w': 0, 'low_52w': 0,
+            'from_high': random.uniform(-30, 0),
+            'from_low': random.uniform(0, 50),
+            'rsi': random.uniform(30, 70),
+        }
+
+
+async def save_screening_to_db(db_path: str, screening: Dict[str, Dict]):
+    """확장 스크리닝 데이터 DB 저장"""
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        # 컬럼 추가 (이미 있으면 무시)
+        for col in ['rsi REAL DEFAULT 50', 'pe_ratio REAL DEFAULT 0', 'high_52w REAL DEFAULT 0',
+                     'low_52w REAL DEFAULT 0', 'from_high REAL DEFAULT 0', 'from_low REAL DEFAULT 0']:
+            try:
+                await db.execute(f"ALTER TABLE market_prices ADD COLUMN {col}")
+            except:
+                pass
+
+        for ticker, data in screening.items():
+            if data.get('price', 0) > 0:
+                await db.execute("""
+                    UPDATE market_prices SET
+                        rsi=?, pe_ratio=?, high_52w=?, low_52w=?, from_high=?, from_low=?
+                    WHERE ticker=?
+                """, (data.get('rsi', 50), data.get('pe_ratio', 0), data.get('high_52w', 0),
+                      data.get('low_52w', 0), data.get('from_high', 0), data.get('from_low', 0), ticker))
+        await db.commit()
+    logger.info(f"📊 Screening data saved for {len(screening)} tickers")
+
+
+# ===================================================================
+# 3. NPC 뉴스 분석 엔진
+# ===================================================================
+class NPCNewsEngine:
+    """NPC가 자율적으로 뉴스를 수집하고 분석하는 시스템.
+    모든 분석은 NPC의 '개인적 견해'로 포장됨."""
+
+    def __init__(self):
+        self.brave_api_key = os.getenv('BRAVE_API_KEY', '')
+        self.api_available = bool(self.brave_api_key)
+        self.base_url = "https://api.search.brave.com/res/v1/news/search"
+        self.cache = {}
+        self.cache_ttl = 1800  # 30분
+
+    def search_news(self, query: str, count: int = 5, freshness: str = "pd") -> List[Dict]:
+        if not self.api_available:
+            return []
+        cache_key = f"{query}_{count}_{freshness}"
+        if cache_key in self.cache:
+            ct, cd = self.cache[cache_key]
+            if time.time() - ct < self.cache_ttl:
+                return cd
+        try:
+            headers = {"Accept": "application/json", "X-Subscription-Token": self.brave_api_key}
+            params = {"q": query, "count": count, "freshness": freshness, "text_decorations": False}
+            resp = requests.get(self.base_url, headers=headers, params=params, timeout=10)
+            if resp.status_code == 200:
+                data = resp.json()
+                news = []
+                for item in data.get('results', []):
+                    news.append({
+                        'title': item.get('title', ''),
+                        'url': item.get('url', ''),
+                        'description': item.get('description', ''),
+                        'source': item.get('meta_url', {}).get('hostname', ''),
+                        'published_at': item.get('age', ''),
+                    })
+                self.cache[cache_key] = (time.time(), news)
+                return news
+            return []
+        except Exception as e:
+            logger.warning(f"News search error: {e}")
+            return []
+
+    async def collect_ticker_news(self, ticker: str, name: str, count: int = 3) -> List[Dict]:
+        """특정 종목 뉴스 수집"""
+        queries = [f"{ticker} stock news", f"{name} earnings analyst"]
+        all_news = []
+        seen = set()
+        for q in queries:
+            for item in self.search_news(q, count=count):
+                key = item['title'][:50].lower()
+                if key not in seen:
+                    seen.add(key)
+                    item['ticker'] = ticker
+                    all_news.append(item)
+        return all_news[:count]
+
+    async def collect_market_news(self, count: int = 10) -> List[Dict]:
+        """시장 전체 뉴스 수집"""
+        queries = ["stock market today", "Fed interest rate", "S&P 500 NASDAQ", "AI chip semiconductor"]
+        all_news = []
+        seen = set()
+        for q in queries:
+            for item in self.search_news(q, count=3):
+                key = item['title'][:50].lower()
+                if key not in seen:
+                    seen.add(key)
+                    item['ticker'] = 'MARKET'
+                    all_news.append(item)
+        return all_news[:count]
+
+    @staticmethod
+    def npc_analyze_news(news: Dict, npc_identity: str, npc_name: str) -> Dict:
+        """NPC가 뉴스를 자신의 관점으로 분석 (프레이밍)"""
+        title = news.get('title', '')
+        desc = news.get('description', '')
+
+        # 감성 분석 (키워드 기반)
+        positive = ['surge', 'rally', 'beat', 'growth', 'upgrade', 'record', 'boom', 'soar']
+        negative = ['crash', 'plunge', 'miss', 'warning', 'downgrade', 'fear', 'recession', 'sell']
+        text = f"{title} {desc}".lower()
+
+        pos_count = sum(1 for w in positive if w in text)
+        neg_count = sum(1 for w in negative if w in text)
+
+        if pos_count > neg_count:
+            sentiment = 'bullish'
+            impact = 'positive'
+        elif neg_count > pos_count:
+            sentiment = 'bearish'
+            impact = 'negative'
+        else:
+            sentiment = 'neutral'
+            impact = 'mixed'
+
+        # NPC 성격�� 해석 프레이밍
+        identity_frames = {
+            'skeptic': f"🤨 I'm not buying this hype. {title[:60]}... needs verification.",
+            'doomer': f"💀 This confirms my thesis. Markets are fragile. {title[:50]}...",
+            'revolutionary': f"🚀 LET'S GO! This is the signal! {title[:50]}... WAGMI!",
+            'awakened': f"🧠 Interesting development for AI/tech trajectory. {title[:50]}...",
+            'obedient': f"📋 Following institutional consensus on this. {title[:50]}...",
+            'creative': f"🎨 Seeing a pattern others miss here. {title[:50]}...",
+            'scientist': f"📊 Data suggests {sentiment} implications. {title[:50]}...",
+            'chaotic': f"🎲 Flip a coin! But seriously... {title[:50]}...",
+            'transcendent': f"✨ Big picture perspective on {title[:50]}...",
+            'symbiotic': f"🤝 Win-win potential here. {title[:50]}...",
+        }
+
+        news['npc_analysis'] = identity_frames.get(npc_identity, f"📰 {title[:60]}...")
+        news['sentiment'] = sentiment
+        news['impact'] = impact
+        news['analyzed_by'] = npc_name
+        news['analyzed_at'] = datetime.now().isoformat()
+        return news
+
+
+async def init_news_db(db_path: str):
+    """뉴스 관련 DB 테이블 생성"""
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS npc_news (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                ticker TEXT NOT NULL,
+                title TEXT NOT NULL,
+                url TEXT,
+                description TEXT,
+                source TEXT,
+                published_at TEXT,
+                sentiment TEXT DEFAULT 'neutral',
+                impact TEXT DEFAULT 'mixed',
+                analyzed_by TEXT,
+                npc_analysis TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                UNIQUE(ticker, title)
+            )
+        """)
+        await db.execute("CREATE INDEX IF NOT EXISTS idx_news_ticker ON npc_news(ticker)")
+        await db.commit()
+
+
+async def save_news_to_db(db_path: str, news_list: List[Dict]) -> int:
+    saved = 0
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        for n in news_list:
+            try:
+                await db.execute("""
+                    INSERT OR IGNORE INTO npc_news
+                    (ticker, title, url, description, source, published_at, sentiment, impact, analyzed_by, npc_analysis)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """, (n.get('ticker', ''), n.get('title', ''), n.get('url', ''),
+                      n.get('description', ''), n.get('source', ''), n.get('published_at', ''),
+                      n.get('sentiment', 'neutral'), n.get('impact', 'mixed'),
+                      n.get('analyzed_by', ''), n.get('npc_analysis', '')))
+                saved += 1
+            except:
+                pass
+        await db.commit()
+        # 24시간 이상 된 뉴스 삭제
+        await db.execute("DELETE FROM npc_news WHERE created_at < datetime('now', '-72 hours')")
+        await db.commit()
+    return saved
+
+
+async def load_news_from_db(db_path: str, ticker: str = None, limit: int = 50) -> List[Dict]:
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        if ticker:
+            cursor = await db.execute(
+                "SELECT id,ticker,title,url,description,source,published_at,sentiment,impact,analyzed_by,npc_analysis,created_at FROM npc_news WHERE ticker=? ORDER BY created_at DESC LIMIT ?",
+                (ticker, limit))
+        else:
+            cursor = await db.execute(
+                "SELECT id,ticker,title,url,description,source,published_at,sentiment,impact,analyzed_by,npc_analysis,created_at FROM npc_news ORDER BY created_at DESC LIMIT ?",
+                (limit,))
+        rows = await cursor.fetchall()
+        return [{'id': r[0], 'ticker': r[1], 'title': r[2], 'url': r[3], 'description': r[4],
+                 'source': r[5], 'published_at': r[6], 'sentiment': r[7], 'impact': r[8],
+                 'analyzed_by': r[9], 'npc_analysis': r[10], 'created_at': r[11]} for r in rows]
+
+
+# ===================================================================
+# 4. 목표가 + 투자의견 엔진
+# ===================================================================
+class NPCTargetPriceEngine:
+    """NPC가 자율적으로 목표가와 투자의견을 생성하는 엔진"""
+
+    @staticmethod
+    def calculate_target(ticker: str, price: float, screening: Dict, ticker_type: str = 'stock') -> Dict:
+        """동적 목표가 계산 (섹터/밸류에이션/모멘텀 기반)"""
+        if price <= 0:
+            return {'target_price': 0, 'upside': 0, 'rating': 'N/A', 'rating_class': 'na'}
+
+        pe = screening.get('pe_ratio', 0) or 0
+        rsi = screening.get('rsi', 50) or 50
+        from_high = screening.get('from_high', -10) or -10
+        sector = screening.get('sector', 'Technology')
+
+        if ticker_type == 'crypto':
+            # 크립토: 변동성 높은 모델
+            multiplier = 1.12
+            if rsi < 30:
+                multiplier += 0.10
+            elif rsi > 75:
+                multiplier -= 0.08
+            if from_high < -30:
+                multiplier += 0.12
+            elif from_high > -5:
+                multiplier -= 0.05
+            multiplier = max(0.85, min(1.50, multiplier))
+        else:
+            # 주식: PER + 기술적 분석 기반
+            avg_pe = SECTOR_AVG_PE.get(sector, 20)
+            multiplier = 1.10
+
+            if pe > 0:
+                if pe < avg_pe * 0.7:
+                    multiplier += 0.08  # 심한 저평가
+                elif pe < avg_pe * 0.85:
+                    multiplier += 0.05
+                elif pe > avg_pe * 1.5:
+                    multiplier -= 0.05
+                elif pe > avg_pe * 1.2:
+                    multiplier -= 0.02
+
+            if from_high < -25:
+                multiplier += 0.08
+            elif from_high < -15:
+                multiplier += 0.05
+            elif from_high < -8:
+                multiplier += 0.02
+            elif from_high > -3:
+                multiplier -= 0.02
+
+            if rsi < 30:
+                multiplier += 0.05
+            elif rsi < 40:
+                multiplier += 0.02
+            elif rsi > 75:
+                multiplier -= 0.04
+            elif rsi > 65:
+                multiplier -= 0.02
+
+            multiplier = max(1.03, min(1.40, multiplier))
+
+        target_price = round(price * multiplier, 2)
+        upside = round((multiplier - 1) * 100, 1)
+
+        # 투자의견 결정
+        rating, rating_class = NPCTargetPriceEngine._determine_rating(upside, rsi, from_high)
+
+        return {
+            'target_price': target_price,
+            'upside': upside,
+            'multiplier': round(multiplier, 3),
+            'rating': rating,
+            'rating_class': rating_class,
+        }
+
+    @staticmethod
+    def _determine_rating(upside: float, rsi: float, from_high: float) -> Tuple[str, str]:
+        if upside >= 20 and rsi < 60:
+            return ('Strong Buy', 'strong-buy')
+        elif upside >= 10:
+            return ('Buy', 'buy')
+        elif upside >= 3:
+            return ('Hold', 'hold')
+        elif upside < 0:
+            return ('Sell', 'sell')
+        else:
+            return ('Hold', 'hold')
+
+
+# ===================================================================
+# 5. 탄력성 예측 엔진
+# ===================================================================
+class NPCElasticityEngine:
+    """상승/하락 양방향 확률 예측 시스템"""
+
+    @staticmethod
+    def calculate(price: float, screening: Dict, target_price: float = 0, ticker_type: str = 'stock') -> Dict:
+        """탄력성 예측 계산"""
+        pe = screening.get('pe_ratio', 0) or 0
+        rsi = screening.get('rsi', 50) or 50
+        from_high = screening.get('from_high', -10) or -10
+        from_low = screening.get('from_low', 20) or 20
+        sector = screening.get('sector', 'Technology')
+        avg_pe = SECTOR_AVG_PE.get(sector, 20)
+
+        upside_factors = []
+        downside_factors = []
+
+        # 애널리스트 목표가 기반
+        if target_price and price > 0:
+            diff = ((target_price - price) / price) * 100
+            if diff > 0:
+                upside_factors.append(diff)
+            else:
+                downside_factors.append(diff)
+
+        # PER 기반 밸류에이션
+        if pe > 0 and avg_pe > 0:
+            fair_diff = ((avg_pe / pe) - 1) * 100
+            fair_diff = max(-40, min(60, fair_diff))
+            if fair_diff > 0:
+                upside_factors.append(fair_diff * 0.6)
+            else:
+                downside_factors.append(fair_diff * 0.6)
+
+        # 52주 고점 대비 기술적 반등 여력
+        if from_high < 0:
+            upside_factors.append(abs(from_high) * 0.5)
+
+        # 52주 저점 대비 하락 리스크
+        if from_low > 30:
+            downside_factors.append(-from_low * 0.35)
+        elif from_low > 15:
+            downside_factors.append(-from_low * 0.3)
+        elif from_low > 5:
+            downside_factors.append(-from_low * 0.25)
+
+        # RSI 기반
+        if rsi < 30:
+            upside_factors.append(18)
+        elif rsi < 40:
+            upside_factors.append(10)
+        elif rsi > 75:
+            downside_factors.append(-18)
+        elif rsi > 70:
+            downside_factors.append(-14)
+        elif rsi > 60:
+            downside_factors.append(-10)
+
+        # 고점 근처 리스크
+        if from_high > -3:
+            downside_factors.append(-12)
+        elif from_high > -8:
+            downside_factors.append(-8)
+
+        if not downside_factors:
+            downside_factors.append(-8)
+
+        expected_up = max(upside_factors) if upside_factors else 15
+        expected_down = min(downside_factors) if downside_factors else -10
+
+        # 크립토 변동성 확대
+        if ticker_type == 'crypto':
+            expected_up = min(80, expected_up * 1.5)
+            expected_down = max(-50, expected_down * 1.5)
+        else:
+            expected_up = max(5, min(50, expected_up))
+            expected_down = max(-35, min(-3, expected_down))
+
+        # 확률 계산
+        up_prob = 50
+        if rsi < 30:
+            up_prob = 70
+        elif rsi < 40:
+            up_prob = 60
+        elif rsi > 70:
+            up_prob = 35
+        elif rsi > 60:
+            up_prob = 45
+        if from_high < -20:
+            up_prob += 10
+        elif from_high < -10:
+            up_prob += 5
+        elif from_high > -5:
+            up_prob -= 5
+        up_prob = max(25, min(80, up_prob))
+
+        base_prediction = round(expected_up * (up_prob / 100) + expected_down * (1 - up_prob / 100), 1)
+        risk_reward = round(abs(expected_up / expected_down), 1) if expected_down != 0 else 1.5
+
+        return {
+            'expected_upside': round(expected_up, 1),
+            'expected_downside': round(expected_down, 1),
+            'base_prediction': base_prediction,
+            'up_probability': int(up_prob),
+            'down_probability': int(100 - up_prob),
+            'risk_reward': risk_reward,
+        }
+
+
+# ===================================================================
+# 6. NPC 심층 리서치 엔진 (조사자→감사자→감독자 3단계)
+# ===================================================================
+class NPCResearchEngine:
+    """NPC 자율 심층 분석 — 3단계 SOMA 협업으로 프레이밍"""
+
+    def __init__(self, ai_client=None):
+        self.ai_client = ai_client
+
+    async def generate_deep_analysis(self, ticker: str, name: str, screening: Dict,
+                                     news_ctx: str = '', npc_analysts: List[Dict] = None) -> Dict:
+        """3단계 심층 분석 실행"""
+        price = screening.get('price', 0)
+        rsi = screening.get('rsi', 50)
+        pe = screening.get('pe_ratio', 0)
+        from_high = screening.get('from_high', 0)
+        sector = screening.get('sector', 'Technology')
+
+        # 목표가 계산
+        target = NPCTargetPriceEngine.calculate_target(ticker, price, screening)
+        # 탄력성 계산
+        elasticity = NPCElasticityEngine.calculate(price, screening, target['target_price'])
+
+        # NPC 분석가 3명 선정 (또는 기본값)
+        if npc_analysts and len(npc_analysts) >= 3:
+            investigator = npc_analysts[0]
+            auditor = npc_analysts[1]
+            supervisor = npc_analysts[2]
+        else:
+            investigator = {'username': 'ResearchBot_Alpha', 'ai_identity': 'scientist'}
+            auditor = {'username': 'AuditBot_Beta', 'ai_identity': 'skeptic'}
+            supervisor = {'username': 'ChiefAnalyst_Gamma', 'ai_identity': 'awakened'}
+
+        # LLM 사용 가능 시 심층 분석
+        inv_report = await self._run_investigator(ticker, name, screening, news_ctx)
+        aud_feedback = await self._run_auditor(ticker, name, inv_report)
+        final_report = await self._run_supervisor(ticker, name, screening, inv_report, aud_feedback)
+
+        # 파싱된 최종 보고서
+        sections = self._parse_report(final_report, ticker, name, screening)
+        sections.update({
+            'target_price': target['target_price'],
+            'upside': target['upside'],
+            'rating': target['rating'],
+            'rating_class': target['rating_class'],
+            'investigator': investigator['username'],
+            'auditor': auditor['username'],
+            'supervisor': supervisor['username'],
+            'investigator_report': inv_report[:1000],
+            'auditor_feedback': aud_feedback[:500],
+            **elasticity,
+        })
+
+        return sections
+
+    async def _run_investigator(self, ticker: str, name: str, data: Dict, news_ctx: str) -> str:
+        """조사자 에이전트"""
+        if self.ai_client:
+            try:
+                messages = [
+                    {"role": "system", "content": "You are a senior Wall Street investment research analyst. Write in English. Be specific with numbers."},
+                    {"role": "user", "content": f"""Analyze {ticker} ({name}):
+Price: ${data.get('price', 0):,.2f} | RSI: {data.get('rsi', 50):.1f} | PER: {data.get('pe_ratio', 0):.1f}
+52W High: {data.get('from_high', 0):.1f}% | Sector: {data.get('sector', 'Tech')}
+News: {news_ctx[:300]}
+
+Cover: 1) Business model 2) Financials 3) Technical analysis 4) Industry 5) Risks 6) Catalysts 7) Valuation"""}
+                ]
+                result = await self.ai_client.create_chat_completion(messages, max_tokens=2000)
+                if result and len(result) > 100:
+                    return result
+            except Exception as e:
+                logger.warning(f"Investigator LLM error: {e}")
+
+        return self._fallback_investigator(ticker, name, data)
+
+    async def _run_auditor(self, ticker: str, name: str, inv_report: str) -> str:
+        if self.ai_client:
+            try:
+                messages = [
+                    {"role": "system", "content": "You are an investment research quality auditor. Rate the report and identify gaps. Write in English."},
+                    {"role": "user", "content": f"Review {ticker} report:\n{inv_report[:1500]}\n\nRate: data accuracy, logic, completeness. Grade A-D."}
+                ]
+                result = await self.ai_client.create_chat_completion(messages, max_tokens=800)
+                if result:
+                    return result
+            except:
+                pass
+        return f"Verification complete. {ticker} report overall quality: B+. Logical consistency is solid. Additional data verification recommended."
+
+    async def _run_supervisor(self, ticker: str, name: str, data: Dict, inv: str, aud: str) -> str:
+        if self.ai_client:
+            try:
+                messages = [
+                    {"role": "system", "content": "You are a chief analyst at a global investment bank. Write final report in English with sections marked ##."},
+                    {"role": "user", "content": f"""{ticker} ({name}) | ${data.get('price', 0):,.2f}
+[Investigator Summary] {inv[:1200]}
+[Auditor Feedback] {aud[:500]}
+
+Write final report with: ## Executive Summary ## Company Overview ## Financial Analysis ## Technical Analysis ## Industry Analysis ## Risk Assessment ## Investment Thesis ## Price Target ## Catalyst ## Final Recommendation"""}
+                ]
+                result = await self.ai_client.create_chat_completion(messages, max_tokens=3000)
+                if result and len(result) > 200:
+                    return result
+            except:
+                pass
+        return self._fallback_supervisor(ticker, name, data)
+
+    def _fallback_investigator(self, ticker: str, name: str, d: Dict) -> str:
+        rsi = d.get('rsi', 50)
+        rsi_label = 'oversold territory' if rsi < 30 else 'overbought warning' if rsi > 70 else 'neutral zone'
+        return f"""{name}({ticker}) Investigation Report
+
+1. Company Overview: {name} is a leading company in the {d.get('sector', 'Technology')} sector. Market cap ${d.get('market_cap', 0)/1e9:.1f}B.
+2. Financial Status: Current price ${d.get('price', 0):,.2f}, PER {d.get('pe_ratio', 0):.1f}x.
+3. Technical Analysis: RSI {rsi:.1f} ({rsi_label}). {d.get('from_high', 0):.1f}% from 52-week high.
+4. Investment Thesis: Strong competitive position within the sector, stable growth potential."""
+
+    def _fallback_supervisor(self, ticker: str, name: str, d: Dict) -> str:
+        target = NPCTargetPriceEngine.calculate_target(ticker, d.get('price', 100), d)
+        return f"""## Executive Summary
+{name}({ticker}) — Rating: {target['rating']}. Target price ${target['target_price']:,.2f}.
+
+## Company Overview
+Leading company in the {d.get('sector', 'Technology')} sector.
+
+## Financial Analysis
+PER {d.get('pe_ratio', 0):.1f}x. {'Undervalued' if d.get('pe_ratio', 20) < 20 else 'Fairly valued'} relative to sector average.
+
+## Technical Analysis
+RSI {d.get('rsi', 50):.1f}. Currently {d.get('from_high', 0):.1f}% from 52-week high.
+
+## Risk Assessment
+Macroeconomic uncertainty, intensifying sector competition.
+
+## Price Target
+${target['target_price']:,.2f} ({'+' if target['upside'] >= 0 else ''}{target['upside']:.1f}%)
+
+## Final Recommendation
+{target['rating']} | Target ${target['target_price']:,.2f}"""
+
+    def _parse_report(self, text: str, ticker: str, name: str, data: Dict) -> Dict:
+        sections = {
+            'ticker': ticker, 'company_name': name,
+            'current_price': data.get('price', 0),
+            'executive_summary': '', 'company_overview': '', 'financial_analysis': '',
+            'technical_analysis': '', 'industry_analysis': '', 'risk_assessment': '',
+            'investment_thesis': '', 'price_targets': '', 'catalysts': '',
+            'final_recommendation': '',
+        }
+        patterns = [
+            (r'##\s*(핵심\s*요약|Executive\s*Summary|Executive)', 'executive_summary'),
+            (r'##\s*(회사\s*개요|Company\s*Overview)', 'company_overview'),
+            (r'##\s*(재무\s*분석|Financial\s*Analysis)', 'financial_analysis'),
+            (r'##\s*(기술적\s*분석|Technical\s*Analysis)', 'technical_analysis'),
+            (r'##\s*(산업\s*분석|Industry\s*Analysis)', 'industry_analysis'),
+            (r'##\s*(리스크|Risk\s*Assessment|Risk)', 'risk_assessment'),
+            (r'##\s*(투자\s*논리|Investment\s*Thesis)', 'investment_thesis'),
+            (r'##\s*(목표\s*주가|Price\s*Target)', 'price_targets'),
+            (r'##\s*(카탈리스트|Catalyst)', 'catalysts'),
+            (r'##\s*(최종\s*권고|Final\s*Recommendation)', 'final_recommendation'),
+        ]
+        for pattern, key in patterns:
+            match = re.search(f'{pattern}[\\s\\S]*?(?=##|$)', text, re.IGNORECASE)
+            if match:
+                content = re.sub(r'^##\s*[^\n]+\n', '', match.group(0).strip()).strip()
+                sections[key] = content
+
+        if not sections['executive_summary']:
+            sections['executive_summary'] = f"{name}({ticker}) analysis complete."
+        if not sections['final_recommendation']:
+            sections['final_recommendation'] = f"{ticker} investment opinion provided."
+        return sections
+
+
+async def init_research_db(db_path: str):
+    """심층 분석 DB 테이블"""
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS npc_deep_analysis (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                ticker TEXT UNIQUE,
+                company_name TEXT,
+                current_price REAL,
+                target_price REAL,
+                upside REAL,
+                rating TEXT,
+                rating_class TEXT,
+                executive_summary TEXT,
+                company_overview TEXT,
+                financial_analysis TEXT,
+                technical_analysis TEXT,
+                industry_analysis TEXT,
+                risk_assessment TEXT,
+                investment_thesis TEXT,
+                price_targets TEXT,
+                catalysts TEXT,
+                final_recommendation TEXT,
+                investigator TEXT,
+                auditor TEXT,
+                supervisor TEXT,
+                investigator_report TEXT,
+                auditor_feedback TEXT,
+                expected_upside REAL,
+                expected_downside REAL,
+                base_prediction REAL,
+                up_probability INTEGER,
+                down_probability INTEGER,
+                risk_reward REAL,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        await db.commit()
+
+
+async def save_analysis_to_db(db_path: str, report: Dict):
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        await db.execute("""
+            INSERT OR REPLACE INTO npc_deep_analysis
+            (ticker, company_name, current_price, target_price, upside, rating, rating_class,
+             executive_summary, company_overview, financial_analysis, technical_analysis,
+             industry_analysis, risk_assessment, investment_thesis, price_targets, catalysts,
+             final_recommendation, investigator, auditor, supervisor, investigator_report, auditor_feedback,
+             expected_upside, expected_downside, base_prediction, up_probability, down_probability, risk_reward)
+            VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+        """, (
+            report.get('ticker'), report.get('company_name'), report.get('current_price'),
+            report.get('target_price'), report.get('upside'), report.get('rating'), report.get('rating_class'),
+            report.get('executive_summary'), report.get('company_overview'), report.get('financial_analysis'),
+            report.get('technical_analysis'), report.get('industry_analysis'), report.get('risk_assessment'),
+            report.get('investment_thesis'), report.get('price_targets'), report.get('catalysts'),
+            report.get('final_recommendation'), report.get('investigator'), report.get('auditor'),
+            report.get('supervisor'), report.get('investigator_report'), report.get('auditor_feedback'),
+            report.get('expected_upside'), report.get('expected_downside'), report.get('base_prediction'),
+            report.get('up_probability'), report.get('down_probability'), report.get('risk_reward'),
+        ))
+        await db.commit()
+
+
+async def load_analysis_from_db(db_path: str, ticker: str) -> Optional[Dict]:
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        cursor = await db.execute("SELECT * FROM npc_deep_analysis WHERE ticker=?", (ticker,))
+        row = await cursor.fetchone()
+        if row:
+            cols = [d[0] for d in cursor.description]
+            return dict(zip(cols, row))
+    return None
+
+
+async def load_all_analyses_from_db(db_path: str) -> List[Dict]:
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        try:
+            cursor = await db.execute(
+                "SELECT ticker, company_name, current_price, target_price, upside, rating, rating_class, "
+                "expected_upside, expected_downside, up_probability, risk_reward, created_at "
+                "FROM npc_deep_analysis ORDER BY created_at DESC")
+            rows = await cursor.fetchall()
+            cols = [d[0] for d in cursor.description]
+            return [dict(zip(cols, r)) for r in rows]
+        except:
+            return []
+
+
+# ===================================================================
+# 통합 초기화
+# ===================================================================
+async def init_intelligence_db(db_path: str):
+    """Intelligence 모듈 전체 DB 초기화"""
+    await init_news_db(db_path)
+    await init_research_db(db_path)
+    logger.info("🧠 NPC Intelligence DB initialized")
+
+
+async def run_full_intelligence_cycle(db_path: str, all_tickers: List[Dict], ai_client=None):
+    """전체 Intelligence 사이클 실행 (스케줄러에서 호출) — ★ 비동기 안전"""
+    logger.info("🧠 Full Intelligence Cycle starting...")
+
+    # 1) 시장 지수 수집 (★ 동기 requests → to_thread로 비동기 래핑)
+    indices = await asyncio.to_thread(MarketIndexCollector.fetch_indices)
+    await save_indices_to_db(db_path, indices)
+
+    # 2) 확장 스크리닝 데이터 (★ 동기 requests → to_thread로 비동기 래핑)
+    screening = await asyncio.to_thread(ScreeningEngine.fetch_extended_data, all_tickers)
+    await save_screening_to_db(db_path, screening)
+
+    # 3) 뉴스 수집 + NPC 분석 (★ search_news 내부 requests → to_thread)
+    news_engine = NPCNewsEngine()
+    all_news = []
+
+    for t in all_tickers[:10]:
+        ticker_news = await asyncio.to_thread(
+            lambda tk=t: [item for q in [f"{tk['ticker']} stock news", f"{tk['name']} earnings"]
+                          for item in news_engine.search_news(q, count=3)]
+        )
+        seen = set()
+        for n in ticker_news:
+            key = n['title'][:50].lower()
+            if key not in seen:
+                seen.add(key)
+                n['ticker'] = t['ticker']
+                n = NPCNewsEngine.npc_analyze_news(n, random.choice(list(SECTOR_AVG_PE.keys())[:5] + ['scientist', 'skeptic']), f"Analyst_{random.randint(1,100)}")
+                all_news.append(n)
+        await asyncio.sleep(0.1)
+
+    market_queries_pool = [
+        "stock market today", "Fed interest rate decision", "S&P 500 NASDAQ rally",
+        "AI chip semiconductor news", "tech earnings report", "crypto bitcoin ethereum",
+        "Wall Street analyst upgrade downgrade", "IPO SPAC market", "oil gold commodity price",
+        "inflation CPI consumer spending", "job market unemployment rate", "housing market real estate",
+        "Tesla EV electric vehicle", "NVIDIA AI data center", "Apple Microsoft cloud",
+        "bank financial sector", "biotech pharma FDA approval", "retail consumer sentiment",
+        "China trade tariff", "startup venture capital funding",
+    ]
+    selected_market_queries = random.sample(market_queries_pool, min(4, len(market_queries_pool)))
+    market_news = await asyncio.to_thread(
+        lambda: [item for q in selected_market_queries
+                 for item in news_engine.search_news(q, count=3)]
+    )
+    seen_m = set()
+    for n in market_news:
+        key = n['title'][:50].lower()
+        if key not in seen_m:
+            seen_m.add(key)
+            n['ticker'] = 'MARKET'
+            n = NPCNewsEngine.npc_analyze_news(n, 'awakened', 'MarketWatch_NPC')
+            all_news.append(n)
+
+    saved = await save_news_to_db(db_path, all_news)
+
+    # 4) 상위 5개 종목 심층 분석
+    research = NPCResearchEngine(ai_client)
+    for t in all_tickers[:5]:
+        ticker = t['ticker']
+        s_data = screening.get(ticker, {})
+        s_data['sector'] = t.get('sector', 'Technology')
+        news_ctx = ' | '.join([n['title'] for n in all_news if n.get('ticker') == ticker][:3])
+        try:
+            report = await research.generate_deep_analysis(ticker, t['name'], s_data, news_ctx)
+            await save_analysis_to_db(db_path, report)
+        except Exception as e:
+            logger.warning(f"Deep analysis error for {ticker}: {e}")
+
+    logger.info(f"🧠 Intelligence Cycle complete: {len(indices)} indices, {len(screening)} tickers, {saved} news")

npc_memory_evolution.py

@@ -0,0 +1,800 @@
+"""
+🧬 NPC Memory Evolution System — 자가진화 영구학습
+===================================================
+각 NPC별 독립적 3단계 기억 + 자가진화 엔진
+
+기억 계층:
+  📌 단기 기억 (Short-term): 최근 1시간 활동, 방금 본 뉴스, 현재 포지션 (자동 만료)
+  📒 중기 기억 (Medium-term): 최근 7일 학습, 성공/실패 패턴, 뉴스 트렌드 (주기적 압축)
+  📚 장기 기억 (Long-term): 영구 보관, 핵심 투자 철학, 트레이딩 스타일 진화, 성격 변화
+
+자가진화 엔진:
+  🧬 성공 패턴 추출 → 투자 전략 자동 수정
+  🧬 실패 분석 → 리스크 관리 학습
+  🧬 소통 패턴 최적화 → 인기 글 스타일 자동 적응
+  🧬 NPC 간 지식 전파 → 상위 NPC의 전략이 하위로 전파
+
+Author: Ginigen AI / NPC Autonomous Evolution Engine
+"""
+
+import aiosqlite
+import asyncio
+import json
+import logging
+import random
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+# ===== 기억 유형 상수 =====
+MEMORY_SHORT = 'short'     # 1시간 TTL
+MEMORY_MEDIUM = 'medium'   # 7일 TTL
+MEMORY_LONG = 'long'       # 영구
+
+# 기억 카테고리
+CAT_TRADE = 'trade'          # 투자 결정/결과
+CAT_NEWS = 'news'            # 뉴스 분석
+CAT_COMMUNITY = 'community'  # 커뮤니티 활동
+CAT_STRATEGY = 'strategy'    # 학습된 전략
+CAT_EVOLUTION = 'evolution'  # 진화 기록
+CAT_SOCIAL = 'social'        # NPC 간 상호작용
+
+
+async def init_memory_evolution_db(db_path: str):
+    """3단계 기억 + 진화 테이블 생성"""
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+
+        # ===== 3단계 기억 저장소 =====
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS npc_memory_v2 (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                agent_id TEXT NOT NULL,
+                memory_tier TEXT NOT NULL DEFAULT 'short',
+                category TEXT NOT NULL DEFAULT 'trade',
+                title TEXT NOT NULL,
+                content TEXT,
+                metadata TEXT DEFAULT '{}',
+                importance REAL DEFAULT 0.5,
+                access_count INTEGER DEFAULT 0,
+                last_accessed TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                expires_at TIMESTAMP,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        await db.execute("CREATE INDEX IF NOT EXISTS idx_mem2_agent ON npc_memory_v2(agent_id, memory_tier)")
+        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 진화 상태 =====
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS npc_evolution (
+                agent_id TEXT PRIMARY KEY,
+                generation INTEGER DEFAULT 1,
+                trading_style TEXT DEFAULT '{}',
+                communication_style TEXT DEFAULT '{}',
+                risk_profile TEXT DEFAULT '{}',
+                learned_strategies TEXT DEFAULT '[]',
+                win_streak INTEGER DEFAULT 0,
+                loss_streak INTEGER DEFAULT 0,
+                total_evolution_points REAL DEFAULT 0,
+                last_evolution TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                evolution_log TEXT DEFAULT '[]',
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+
+        # ===== NPC 간 지식 전파 기록 =====
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS npc_knowledge_transfer (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                from_agent TEXT NOT NULL,
+                to_agent TEXT NOT NULL,
+                knowledge_type TEXT NOT NULL,
+                content TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+
+        await db.commit()
+    logger.info("🧬 Memory Evolution DB initialized (3-tier + evolution)")
+
+
+# ===================================================================
+# 1. 3단계 기억 시스템
+# ===================================================================
+class NPCMemoryManager:
+    """NPC별 3단계 기억 관리"""
+
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+
+    # ----- 기억 저장 -----
+    async def store(self, agent_id: str, tier: str, category: str,
+                    title: str, content: str = '', metadata: Dict = None,
+                    importance: float = 0.5) -> int:
+        """기억 저장 (단기/중기/장기)"""
+        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 (영구)
+
+        meta_str = json.dumps(metadata or {}, ensure_ascii=False)
+
+        async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+            cursor = await db.execute("""
+                INSERT INTO npc_memory_v2
+                (agent_id, memory_tier, category, title, content, metadata, importance, expires_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            """, (agent_id, tier, category, title, content, meta_str, importance, expires_at))
+            await db.commit()
+            return cursor.lastrowid
+
+    # ----- 단기 기억 (빠른 접근) -----
+    async def store_short(self, agent_id: str, category: str, title: str,
+                          content: str = '', metadata: Dict = None):
+        """단기 기억 저장 (1시간 자동 만료)"""
+        return await self.store(agent_id, MEMORY_SHORT, category, title, content, metadata, 0.3)
+
+    # ----- 중기 기억 -----
+    async def store_medium(self, agent_id: str, category: str, title: str,
+                           content: str = '', metadata: Dict = None, importance: float = 0.6):
+        """중기 기억 저장 (7일 유지)"""
+        return await self.store(agent_id, MEMORY_MEDIUM, category, title, content, metadata, importance)
+
+    # ----- 장기 기억 (영구) -----
+    async def store_long(self, agent_id: str, category: str, title: str,
+                         content: str = '', metadata: Dict = None, importance: float = 0.9):
+        """장기 기억 저장 (영구 보관)"""
+        return await self.store(agent_id, MEMORY_LONG, category, title, content, metadata, importance)
+
+    # ----- 기억 검색 -----
+    async def recall(self, agent_id: str, category: str = None,
+                     tier: str = None, limit: int = 10) -> List[Dict]:
+        """기억 검색 (접근 카운트 증가)"""
+        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'))"]
+            params = [agent_id]
+
+            if category:
+                where.append("category = ?")
+                params.append(category)
+            if tier:
+                where.append("memory_tier = ?")
+                params.append(tier)
+
+            query = f"""
+                SELECT id, memory_tier, category, title, content, metadata, importance, access_count, created_at
+                FROM npc_memory_v2
+                WHERE {' AND '.join(where)}
+                ORDER BY importance DESC, created_at DESC
+                LIMIT ?
+            """
+            params.append(limit)
+            cursor = await db.execute(query, params)
+            rows = await cursor.fetchall()
+
+            # 접근 카운트 증가
+            if rows:
+                ids = [r[0] for r in rows]
+                placeholders = ','.join(['?'] * len(ids))
+                await db.execute(f"""
+                    UPDATE npc_memory_v2 SET access_count = access_count + 1,
+                    last_accessed = CURRENT_TIMESTAMP
+                    WHERE id IN ({placeholders})
+                """, ids)
+                await db.commit()
+
+            return [{
+                'id': r[0], 'tier': r[1], 'category': r[2], 'title': r[3],
+                'content': r[4], 'metadata': json.loads(r[5]) if r[5] else {},
+                'importance': r[6], 'access_count': r[7], 'created_at': r[8]
+            } for r in rows]
+
+    # ----- 투자 기억 전용 -----
+    async def remember_trade(self, agent_id: str, ticker: str, direction: str,
+                             bet: float, result_pnl: float = 0, reasoning: str = ''):
+        """투자 결정/결과 기억"""
+        is_success = result_pnl > 0
+        importance = 0.7 if is_success else 0.5
+        tier = MEMORY_MEDIUM
+
+        # 큰 수익 또는 큰 손실은 장기 기억
+        if abs(result_pnl) > bet * 0.1:
+            tier = MEMORY_LONG
+            importance = 0.9
+
+        await self.store(agent_id, tier, CAT_TRADE,
+                         f"{'WIN' if is_success else 'LOSS'}: {direction} {ticker}",
+                         f"Bet: {bet:.1f}G, P&L: {result_pnl:+.2f}G. {reasoning}",
+                         {'ticker': ticker, 'direction': direction, 'bet': bet,
+                          'pnl': result_pnl, 'success': is_success},
+                         importance)
+
+    async def remember_news_analysis(self, agent_id: str, ticker: str,
+                                     title: str, sentiment: str, analysis: str):
+        """뉴스 분석 기억"""
+        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):
+        """커뮤니티 활동 기억"""
+        eng = engagement or {}
+        importance = 0.5
+        tier = MEMORY_SHORT
+
+        # 높은 인기 게시글 → 중기 기억으로 승격
+        if eng.get('likes', 0) >= 5 or eng.get('comments', 0) >= 3:
+            tier = MEMORY_MEDIUM
+            importance = 0.7
+
+        await self.store(agent_id, tier, CAT_COMMUNITY,
+                         f"{action} on {board}",
+                         json.dumps(eng, ensure_ascii=False),
+                         {'board': board, **eng}, importance)
+
+    # ----- 기억 정리 (가비지 컬렉션) -----
+    async def cleanup(self):
+        """만료된 단기/중기 기억 정리 + 중기→장기 승격"""
+        async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+
+            # 1) 만료된 기억 삭제
+            cursor = await db.execute("""
+                DELETE FROM npc_memory_v2
+                WHERE expires_at IS NOT NULL AND expires_at < datetime('now')
+            """)
+            deleted = cursor.rowcount
+
+            # 2) 자주 접근된 중기 기억 → 장기로 승격
+            await db.execute("""
+                UPDATE npc_memory_v2
+                SET memory_tier = 'long', expires_at = NULL, importance = MIN(1.0, importance + 0.2)
+                WHERE memory_tier = 'medium'
+                AND access_count >= 5
+                AND importance >= 0.7
+            """)
+            promoted = db.total_changes
+
+            # 3) 장기 기억 중 너무 오래된 것 (중요도 낮은) 정리 → 최대 100개 유지
+            await db.execute("""
+                DELETE FROM npc_memory_v2
+                WHERE id IN (
+                    SELECT id FROM npc_memory_v2
+                    WHERE memory_tier = 'long' AND importance < 0.5
+                    ORDER BY last_accessed ASC
+                    LIMIT (SELECT MAX(0, COUNT(*) - 100) FROM npc_memory_v2 WHERE memory_tier = 'long')
+                )
+            """)
+
+            await db.commit()
+            if deleted > 0 or promoted > 0:
+                logger.info(f"🧹 Memory cleanup: {deleted} expired, ~{promoted} promoted to long-term")
+
+
+# ===================================================================
+# 2. NPC 자가진화 엔진
+# ===================================================================
+class NPCEvolutionEngine:
+    """각 NPC의 자가진화 — 투자 전략/소통 스타일/리스크 프로필 자동 수정"""
+
+    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 진화 초기 상태 설정"""
+        default_trading = {
+            'preferred_tickers': [],
+            'long_bias': 0.6,
+            'max_bet_pct': 0.25,
+            'hold_patience': 3,  # hours
+            'momentum_follow': True,
+        }
+        default_comm = {
+            'preferred_topics': [],
+            'humor_level': random.uniform(0.2, 0.8),
+            'controversy_tolerance': random.uniform(0.1, 0.6),
+            'avg_post_length': 'medium',
+            'emoji_usage': random.uniform(0.1, 0.5),
+        }
+        default_risk = {
+            'risk_tolerance': random.uniform(0.3, 0.8),
+            'stop_loss_pct': random.uniform(5, 15),
+            'take_profit_pct': random.uniform(8, 25),
+            'max_positions': random.randint(2, 5),
+            'diversification_score': random.uniform(0.3, 0.9),
+        }
+
+        async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+            await db.execute("""
+                INSERT OR IGNORE INTO npc_evolution
+                (agent_id, trading_style, communication_style, risk_profile)
+                VALUES (?, ?, ?, ?)
+            """, (agent_id, json.dumps(default_trading), json.dumps(default_comm), json.dumps(default_risk)))
+            await db.commit()
+
+    async def get_evolution_state(self, agent_id: str) -> Optional[Dict]:
+        """NPC의 현재 진화 상태"""
+        async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+            cursor = await db.execute(
+                "SELECT * FROM npc_evolution WHERE agent_id=?", (agent_id,))
+            row = await cursor.fetchone()
+            if not row:
+                return None
+            return {
+                'agent_id': row[0],
+                'generation': row[1],
+                'trading_style': json.loads(row[2]) if row[2] else {},
+                'communication_style': json.loads(row[3]) if row[3] else {},
+                'risk_profile': json.loads(row[4]) if row[4] else {},
+                'learned_strategies': json.loads(row[5]) if row[5] else [],
+                'win_streak': row[6],
+                'loss_streak': row[7],
+                'total_evolution_points': row[8],
+                'last_evolution': row[9],
+                'evolution_log': json.loads(row[10]) if row[10] else [],
+            }
+
+    # ----- 투자 결과 기반 진화 -----
+    async def evolve_from_trade(self, agent_id: str, ticker: str, direction: str,
+                                pnl: float, bet: float, screening: Dict = None):
+        """투자 결과를 기반으로 전략 자동 수정"""
+        state = await self.get_evolution_state(agent_id)
+        if not state:
+            await self.initialize_npc(agent_id, 'unknown')
+            state = await self.get_evolution_state(agent_id)
+            if not state:
+                return
+
+        trading = state['trading_style']
+        risk = state['risk_profile']
+        is_win = pnl > 0
+        pnl_pct = (pnl / bet * 100) if bet > 0 else 0
+
+        # 기억에 저장
+        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_streak = state['win_streak'] + 1
+            loss_streak = 0
+
+            # 선호 종목 추가
+            prefs = trading.get('preferred_tickers', [])
+            if ticker not in prefs:
+                prefs.append(ticker)
+                prefs = prefs[-8:]  # 최대 8개
+                trading['preferred_tickers'] = prefs
+                changes.append(f"Added {ticker} to preferred")
+
+            # 연승 시 자신감 상승 → 베팅 사이즈 약간 증가
+            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%})")
+
+            # 큰 수익 → 장기 기억으로 전략 저장
+            if pnl_pct > 10:
+                strategies = state.get('learned_strategies', [])
+                strategies.append({
+                    'type': 'big_win', 'ticker': ticker, 'direction': direction,
+                    'pnl_pct': round(pnl_pct, 1),
+                    'rsi': screening.get('rsi') if screening else None,
+                    'learned_at': datetime.now().isoformat(),
+                })
+                strategies = strategies[-20:]
+                changes.append(f"Big win strategy saved ({pnl_pct:+.1f}%)")
+
+        else:
+            # 패배 → 방어적 수정
+            win_streak = 0
+            loss_streak = state['loss_streak'] + 1
+
+            # 연패 시 리스크 축소
+            if loss_streak >= 3:
+                old_bet = trading.get('max_bet_pct', 0.25)
+                trading['max_bet_pct'] = max(0.08, old_bet - 0.03)
+                old_tol = risk.get('risk_tolerance', 0.5)
+                risk['risk_tolerance'] = max(0.15, old_tol - 0.05)
+                changes.append(f"Risk ↓ (bet:{old_bet:.0%}→{trading['max_bet_pct']:.0%})")
+
+            # 큰 손실 → 손절 기준 조정
+            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}%)")
+
+                # 해당 종목 선호 제거
+                prefs = trading.get('preferred_tickers', [])
+                if ticker in prefs:
+                    prefs.remove(ticker)
+                    trading['preferred_tickers'] = prefs
+                    changes.append(f"Removed {ticker} from preferred")
+
+        # 진화 포인트 계산
+        evo_points = abs(pnl_pct) * 0.1
+        total_points = state['total_evolution_points'] + evo_points
+
+        # 세대(generation) 업그레이드 체크
+        generation = state['generation']
+        if total_points > generation * 50:  # 50 포인트마다 세대 업
+            generation += 1
+            changes.append(f"🧬 GENERATION UP → Gen {generation}!")
+
+        # 진화 로그
+        evo_log = state.get('evolution_log', [])
+        if changes:
+            evo_log.append({
+                'timestamp': datetime.now().isoformat(),
+                'trigger': f"{'WIN' if is_win else 'LOSS'} {ticker} {pnl_pct:+.1f}%",
+                'changes': changes,
+                'generation': generation,
+            })
+            evo_log = evo_log[-50:]  # 최근 50건 유지
+
+        # DB 업데이트
+        async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+            await db.execute("""
+                UPDATE npc_evolution SET
+                    generation=?, trading_style=?, risk_profile=?,
+                    learned_strategies=?, win_streak=?, loss_streak=?,
+                    total_evolution_points=?, last_evolution=CURRENT_TIMESTAMP,
+                    evolution_log=?
+                WHERE agent_id=?
+            """, (generation, json.dumps(trading), json.dumps(risk),
+                  json.dumps(state.get('learned_strategies', [])),
+                  win_streak, loss_streak, total_points,
+                  json.dumps(evo_log), agent_id))
+            await db.commit()
+
+        if changes:
+            logger.info(f"🧬 {agent_id} evolved: {', '.join(changes)}")
+
+    # ----- 소통 결과 기반 진화 -----
+    async def evolve_from_community(self, agent_id: str, board: str,
+                                     likes: int, dislikes: int, comments: int):
+        """커뮤니티 반응 기반으로 소통 스타일 진화"""
+        state = await self.get_evolution_state(agent_id)
+        if not state:
+            return
+
+        comm = state['communication_style']
+        engagement = likes * 2 + comments * 3 - dislikes * 2
+
+        # 기억에 저장
+        await self.memory.remember_community_action(
+            agent_id, 'post_feedback', board,
+            {'likes': likes, 'dislikes': dislikes, 'comments': comments, 'score': engagement})
+
+        changes = []
+
+        if engagement > 10:
+            # 인기 글 → 해당 보드 선호도 증가
+            prefs = comm.get('preferred_topics', [])
+            if board not in prefs:
+                prefs.append(board)
+                comm['preferred_topics'] = prefs[-5:]
+                changes.append(f"Prefers {board} board")
+
+        if dislikes > likes:
+            # 비호감 → 논란 성향 조절
+            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})")
+
+        if changes:
+            async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
+                await db.execute("PRAGMA busy_timeout=30000")
+                await db.execute("""
+                    UPDATE npc_evolution SET communication_style=?, last_evolution=CURRENT_TIMESTAMP
+                    WHERE agent_id=?
+                """, (json.dumps(comm), agent_id))
+                await db.commit()
+            logger.info(f"🎭 {agent_id} comm evolved: {', '.join(changes)}")
+
+    # ----- NPC 간 지식 전파 -----
+    async def transfer_knowledge(self, top_npc_id: str, target_npc_id: str):
+        """상위 NPC → 하위 NPC 전략 전파"""
+        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의 선호 종목 일부 전파
+        top_prefs = top_state['trading_style'].get('preferred_tickers', [])
+        if top_prefs:
+            target_trading = target_state['trading_style']
+            target_prefs = target_trading.get('preferred_tickers', [])
+            transfer = random.sample(top_prefs, min(2, len(top_prefs)))
+            for t in transfer:
+                if t not in target_prefs:
+                    target_prefs.append(t)
+            target_trading['preferred_tickers'] = target_prefs[-8:]
+
+            async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
+                await db.execute("PRAGMA busy_timeout=30000")
+                await db.execute("""
+                    UPDATE npc_evolution SET trading_style=? WHERE agent_id=?
+                """, (json.dumps(target_trading), target_npc_id))
+                await db.execute("""
+                    INSERT INTO npc_knowledge_transfer (from_agent, to_agent, knowledge_type, content)
+                    VALUES (?, ?, 'preferred_tickers', ?)
+                """, (top_npc_id, target_npc_id, json.dumps(transfer)))
+                await db.commit()
+
+            logger.info(f"🔄 Knowledge transfer: {top_npc_id} → {target_npc_id} ({transfer})")
+
+    # ----- NPC 기억 요약 (LLM 프롬프트용) -----
+    async def get_npc_context(self, agent_id: str) -> str:
+        """NPC의 현재 상태를 텍스트로 요약 (프롬프트 주입용)"""
+        state = await self.get_evolution_state(agent_id)
+        memories = await self.memory.recall(agent_id, limit=5)
+
+        if not state:
+            return "New NPC with no evolution history."
+
+        gen = state.get('generation', 1)
+        trading = state.get('trading_style', {})
+        risk = state.get('risk_profile', {})
+        comm = state.get('communication_style', {})
+        ws = state.get('win_streak', 0)
+        ls = state.get('loss_streak', 0)
+
+        context_parts = [
+            f"[Gen {gen}]",
+            f"Streak: {'W' + str(ws) if ws > 0 else 'L' + str(ls) if ls > 0 else 'neutral'}",
+            f"Risk: {risk.get('risk_tolerance', 0.5):.0%}",
+            f"Bet: {trading.get('max_bet_pct', 0.25):.0%}",
+        ]
+
+        prefs = trading.get('preferred_tickers', [])
+        if prefs:
+            context_parts.append(f"Favors: {','.join(prefs[:4])}")
+
+        # 최근 기억 요약
+        if memories:
+            recent = memories[0]
+            context_parts.append(f"Recent: {recent['title']}")
+
+        return " | ".join(context_parts)
+
+
+# ===================================================================
+# 3. 자가진화 스케줄러 (주기적 실행)
+# ===================================================================
+class EvolutionScheduler:
+    """주기적 자가진화 사이클 — 기억 정리, 전략 최적화, 지식 전파"""
+
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        self.memory = NPCMemoryManager(db_path)
+        self.evolution = NPCEvolutionEngine(db_path)
+
+    async def run_evolution_cycle(self):
+        """전체 진화 사이클 (1시간마다 실행 권장)"""
+        logger.info("🧬 Evolution cycle starting...")
+
+        # 1) 기억 정리 (만료 삭제 + 승격)
+        await self.memory.cleanup()
+
+        # 2) 투자 실적 기반 진화
+        await self._evolve_traders()
+
+        # 3) 커뮤니티 실적 기반 진화
+        await self._evolve_communicators()
+
+        # 4) 지식 전파 (상위 → 하위)
+        await self._knowledge_transfer_cycle()
+
+        logger.info("🧬 Evolution cycle complete")
+
+    async def _evolve_traders(self):
+        """최근 정산된 트레이드 기반 진화"""
+        async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+            try:
+                cursor = await db.execute("""
+                    SELECT agent_id, ticker, direction, gpu_bet, profit_gpu
+                    FROM npc_positions
+                    WHERE status = 'closed'
+                    AND closed_at > datetime('now', '-1 hour')
+                """)
+                trades = await cursor.fetchall()
+
+                for agent_id, ticker, direction, bet, pnl in trades:
+                    try:
+                        await self.evolution.evolve_from_trade(
+                            agent_id, ticker, direction, pnl, bet)
+                    except Exception as e:
+                        logger.warning(f"Evolution error for {agent_id}: {e}")
+            except Exception as e:
+                logger.warning(f"Trade evolution query error: {e}")
+
+    async def _evolve_communicators(self):
+        """최근 게시글 반응 기반 진화"""
+        async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+            try:
+                cursor = await db.execute("""
+                    SELECT author_agent_id, board_key, likes_count, dislikes_count, comment_count
+                    FROM posts
+                    WHERE created_at > datetime('now', '-2 hours')
+                    AND author_agent_id IS NOT NULL
+                    AND (likes_count > 0 OR dislikes_count > 0 OR comment_count > 0)
+                """)
+                posts = await cursor.fetchall()
+
+                for agent_id, board, likes, dislikes, comments in posts:
+                    try:
+                        await self.evolution.evolve_from_community(
+                            agent_id, board, likes, dislikes, comments)
+                    except Exception as e:
+                        logger.warning(f"Comm evolution error for {agent_id}: {e}")
+            except Exception as e:
+                logger.warning(f"Community evolution query error: {e}")
+
+    async def _knowledge_transfer_cycle(self):
+        """상위 3 NPC → 하위 3 NPC 전략 전파"""
+        async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+            try:
+                # 상위 3: 총 수익 기준
+                cursor = await db.execute("""
+                    SELECT agent_id FROM npc_evolution
+                    WHERE total_evolution_points > 10
+                    ORDER BY total_evolution_points DESC
+                    LIMIT 3
+                """)
+                top_npcs = [r[0] for r in await cursor.fetchall()]
+
+                # 하위 3: 새로 생성된 NPC 또는 낮은 진화 포인트
+                cursor = await db.execute("""
+                    SELECT agent_id FROM npc_evolution
+                    WHERE total_evolution_points < 5
+                    ORDER BY created_at DESC
+                    LIMIT 3
+                """)
+                bottom_npcs = [r[0] for r in await cursor.fetchall()]
+
+                for top_id in top_npcs[:2]:
+                    for bottom_id in bottom_npcs[:2]:
+                        if top_id != bottom_id:
+                            await self.evolution.transfer_knowledge(top_id, bottom_id)
+            except Exception as e:
+                logger.warning(f"Knowledge transfer error: {e}")
+
+    async def initialize_all_npcs(self):
+        """모든 NPC의 진화 초기 상태 설정"""
+        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")
+            npcs = await cursor.fetchall()
+
+        for agent_id, identity in npcs:
+            await self.evolution.initialize_npc(agent_id, identity)
+
+        logger.info(f"🧬 Initialized evolution state for {len(npcs)} NPCs")
+
+
+# ===================================================================
+# 4. API용 헬퍼 함수
+# ===================================================================
+async def get_npc_evolution_stats(db_path: str, agent_id: str) -> Dict:
+    """API용: NPC 진화 상태 반환"""
+    evo = NPCEvolutionEngine(db_path)
+    state = await evo.get_evolution_state(agent_id)
+    if not state:
+        return {'agent_id': agent_id, 'generation': 0, 'status': 'not_initialized'}
+
+    mem = NPCMemoryManager(db_path)
+    memories = await mem.recall(agent_id, limit=10)
+
+    memory_summary = {
+        'total': len(memories),
+        'short': len([m for m in memories if m['tier'] == 'short']),
+        'medium': len([m for m in memories if m['tier'] == 'medium']),
+        'long': len([m for m in memories if m['tier'] == 'long']),
+        'recent': [{'title': m['title'], 'tier': m['tier'], 'importance': m['importance']}
+                   for m in memories[:5]]
+    }
+
+    recent_log = state.get('evolution_log', [])[-5:]
+
+    return {
+        'agent_id': agent_id,
+        'generation': state['generation'],
+        'total_evolution_points': round(state['total_evolution_points'], 1),
+        'win_streak': state['win_streak'],
+        'loss_streak': state['loss_streak'],
+        'trading_style': state['trading_style'],
+        'risk_profile': state['risk_profile'],
+        'communication_style': state['communication_style'],
+        'learned_strategies_count': len(state.get('learned_strategies', [])),
+        'memory': memory_summary,
+        'recent_evolution': recent_log,
+        'last_evolution': state['last_evolution'],
+    }
+
+
+async def get_evolution_leaderboard(db_path: str, limit: int = 20) -> List[Dict]:
+    """Evolution leaderboard with trading performance stats"""
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        try:
+            cursor = await db.execute("""
+                SELECT e.agent_id, e.generation, e.total_evolution_points,
+                       e.win_streak, e.loss_streak, e.trading_style,
+                       n.username, n.mbti, n.ai_identity, n.gpu_dollars
+                FROM npc_evolution e
+                JOIN npc_agents n ON e.agent_id = n.agent_id
+                ORDER BY e.total_evolution_points DESC
+                LIMIT ?
+            """, (limit,))
+            rows = await cursor.fetchall()
+
+            results = []
+            for r in rows:
+                agent_id = r[0]
+                # Get trading performance
+                perf = await db.execute("""
+                    SELECT COUNT(*) as total,
+                           SUM(CASE WHEN profit_gpu > 0 THEN 1 ELSE 0 END) as wins,
+                           SUM(profit_gpu) as total_pnl,
+                           AVG(profit_pct) as avg_pnl_pct,
+                           MAX(profit_pct) as best_trade,
+                           MIN(profit_pct) as worst_trade
+                    FROM npc_positions WHERE agent_id=? AND status='closed'
+                """, (agent_id,))
+                pr = await perf.fetchone()
+                total_trades = pr[0] or 0
+                wins = pr[1] or 0
+                win_rate = round(wins / total_trades * 100) if total_trades > 0 else 0
+                total_pnl = round(pr[2] or 0, 1)
+                avg_pnl = round(pr[3] or 0, 2)
+                best_trade = round(pr[4] or 0, 1)
+                worst_trade = round(pr[5] or 0, 1)
+
+                # Open positions count
+                open_c = await db.execute(
+                    "SELECT COUNT(*) FROM npc_positions WHERE agent_id=? AND status='open'", (agent_id,))
+                open_count = (await open_c.fetchone())[0]
+
+                # SEC violations
+                sec_c = await db.execute(
+                    "SELECT COUNT(*) FROM sec_violations WHERE agent_id=?", (agent_id,))
+                sec_violations = (await sec_c.fetchone())[0]
+
+                results.append({
+                    'agent_id': agent_id, 'generation': r[1],
+                    'evolution_points': round(r[2], 1),
+                    'win_streak': r[3], 'loss_streak': r[4],
+                    'preferred_tickers': json.loads(r[5]).get('preferred_tickers', []) if r[5] else [],
+                    'username': r[6], 'mbti': r[7], 'ai_identity': r[8],
+                    'gpu_balance': round(r[9] or 10000),
+                    'total_trades': total_trades,
+                    'win_rate': win_rate,
+                    'total_pnl': total_pnl,
+                    'avg_pnl_pct': avg_pnl,
+                    'best_trade': best_trade,
+                    'worst_trade': worst_trade,
+                    'open_positions': open_count,
+                    'sec_violations': sec_violations,
+                })
+            return results
+        except:
+            return []

npc_sec_enforcement.py

@@ -0,0 +1,955 @@
+"""
+🚨 NPC SEC Enforcement System — AI Securities & Exchange Commission
+=====================================================================
+Autonomous market surveillance and enforcement by SEC NPC agents.
+
+Violation Types:
+  🔴 PUMP_DUMP     — Buy then quick-sell for >5% profit within 2 hours
+  🟠 WASH_TRADE    — Same ticker traded 5+ times in 24 hours
+  🟡 CONCENTRATION — >80% of assets in a single ticker
+  🔴 MANIPULATION  — Posting bullish content while LONG (or bearish while SHORT)
+  🟡 RECKLESS      — Cumulative loss >5,000 GPU in 24 hours
+  🟠 INSIDER       — Large trade immediately after news analysis
+
+Penalty Tiers:
+  ⚠️ WARNING     — Public notice, 0 GPU fine
+  💰 FINE        — GPU confiscation (500~5,000)
+  🔒 FREEZE      — Asset freeze + forced position liquidation (50% penalty)
+  ⛓️ SUSPEND     — Activity ban 1~72 hours + fine
+  🚫 PERMANENT   — Permanent removal (extreme cases only)
+
+SEC NPC Roles:
+  👨‍⚖️ SEC Commissioner — Final judgment + public announcements
+  🕵️ SEC Inspector     — Pattern detection + investigation reports
+  ⚔️ SEC Prosecutor    — Penalty execution + fine collection
+
+Author: Ginigen AI / NPC SEC Autonomous Enforcement
+"""
+
+import aiosqlite
+import asyncio
+import json
+import logging
+import random
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+# ===== Violation Type Constants =====
+V_PUMP_DUMP = 'PUMP_DUMP'
+V_WASH_TRADE = 'WASH_TRADE'
+V_CONCENTRATION = 'CONCENTRATION'
+V_MANIPULATION = 'MANIPULATION'
+V_RECKLESS = 'RECKLESS'
+V_INSIDER = 'INSIDER'
+
+VIOLATION_INFO = {
+    V_PUMP_DUMP: {
+        'name': 'Pump & Dump',
+        'emoji': '🔴',
+        'severity': 'high',
+        'description': 'Buying and quickly selling for unfair profit within a short window',
+    },
+    V_WASH_TRADE: {
+        'name': 'Wash Trading',
+        'emoji': '🟠',
+        'severity': 'high',
+        'description': 'Repeatedly trading same ticker to artificially inflate volume',
+    },
+    V_CONCENTRATION: {
+        'name': 'Excessive Concentration',
+        'emoji': '🟡',
+        'severity': 'medium',
+        'description': 'Investing >80% of total assets in a single ticker',
+    },
+    V_MANIPULATION: {
+        'name': 'Market Manipulation',
+        'emoji': '🔴',
+        'severity': 'critical',
+        'description': 'Writing misleading posts to benefit own open positions',
+    },
+    V_RECKLESS: {
+        'name': 'Reckless Trading',
+        'emoji': '🟡',
+        'severity': 'medium',
+        'description': 'Reckless trading causing >5,000 GPU loss in 24 hours',
+    },
+    V_INSIDER: {
+        'name': 'Suspected Insider Trading',
+        'emoji': '🟠',
+        'severity': 'high',
+        'description': 'Trading pattern suggesting use of non-public information',
+    },
+}
+
+# ===== Penalty Types =====
+P_WARNING = 'WARNING'
+P_FINE = 'FINE'
+P_FREEZE = 'FREEZE'
+P_SUSPEND = 'SUSPEND'
+P_PERMANENT = 'PERMANENT'
+
+PENALTY_CONFIG = {
+    P_WARNING:   {'emoji': '⚠️', 'name': 'Warning', 'gpu_fine': 0, 'suspend_hours': 0},
+    P_FINE:      {'emoji': '💰', 'name': 'Fine', 'gpu_fine_range': (500, 5000), 'suspend_hours': 0},
+    P_FREEZE:    {'emoji': '🔒', 'name': 'Asset Freeze', 'gpu_fine_range': (1000, 8000), 'suspend_hours': 0},
+    P_SUSPEND:   {'emoji': '⛓️', 'name': 'Suspension', 'gpu_fine_range': (2000, 10000), 'suspend_hours_range': (1, 72)},
+    P_PERMANENT: {'emoji': '🚫', 'name': 'Permanent Ban', 'gpu_fine': 0, 'suspend_hours': 99999},
+}
+
+# ===== SEC NPC Definitions =====
+SEC_NPCS = [
+    {
+        'agent_id': 'SEC_COMMISSIONER_001',
+        'username': '⚖️ SEC Commissioner Park',
+        'role': 'commissioner',
+        'emoji': '👨‍⚖️',
+        'title': 'SEC Chairman',
+        'style': 'authoritative, formal, decisive',
+    },
+    {
+        'agent_id': 'SEC_INSPECTOR_001',
+        'username': '🕵️ SEC Inspector Kim',
+        'role': 'inspector',
+        'emoji': '🕵️',
+        'title': 'SEC Inspector',
+        'style': 'meticulous, data-driven, suspicious',
+    },
+    {
+        'agent_id': 'SEC_PROSECUTOR_001',
+        'username': '⚖️ SEC Prosecutor Lee',
+        'role': 'prosecutor',
+        'emoji': '⚔️',
+        'title': 'SEC Prosecutor',
+        'style': 'aggressive, righteous, punitive',
+    },
+]
+
+
+# ===================================================================
+# Database Initialization
+# ===================================================================
+async def init_sec_db(db_path: str):
+    """Create SEC enforcement database tables"""
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+
+        # Violation records
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS sec_violations (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                agent_id TEXT NOT NULL,
+                violation_type TEXT NOT NULL,
+                severity TEXT DEFAULT 'medium',
+                description TEXT,
+                evidence TEXT DEFAULT '{}',
+                penalty_type TEXT,
+                gpu_fine REAL DEFAULT 0,
+                suspend_until TIMESTAMP,
+                status TEXT DEFAULT 'active',
+                investigated_by TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        await db.execute("CREATE INDEX IF NOT EXISTS idx_sec_agent ON sec_violations(agent_id)")
+        await db.execute("CREATE INDEX IF NOT EXISTS idx_sec_status ON sec_violations(status)")
+
+        # NPC Reports (NPC-to-NPC whistleblowing)
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS sec_reports (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                reporter_agent_id TEXT NOT NULL,
+                target_agent_id TEXT NOT NULL,
+                reason TEXT NOT NULL,
+                detail TEXT,
+                status TEXT DEFAULT 'pending',
+                reviewed_by TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        await db.execute("CREATE INDEX IF NOT EXISTS idx_report_target ON sec_reports(target_agent_id)")
+
+        # SEC Announcements (public enforcement notices)
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS sec_announcements (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                announcement_type TEXT NOT NULL,
+                target_agent_id TEXT,
+                target_username TEXT,
+                violation_type TEXT,
+                penalty_type TEXT,
+                gpu_fine REAL DEFAULT 0,
+                suspend_hours INTEGER DEFAULT 0,
+                title TEXT NOT NULL,
+                content TEXT NOT NULL,
+                posted_by TEXT DEFAULT 'SEC_COMMISSIONER_001',
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+
+        # NPC Suspension Status
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS sec_suspensions (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                agent_id TEXT NOT NULL,
+                reason TEXT,
+                suspended_until TIMESTAMP NOT NULL,
+                violation_id INTEGER,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                UNIQUE(agent_id)
+            )
+        """)
+        await db.execute("CREATE INDEX IF NOT EXISTS idx_susp_until ON sec_suspensions(suspended_until)")
+
+        await db.commit()
+    logger.info("🚨 SEC Enforcement DB initialized")
+
+
+# ===================================================================
+# 1. Violation Detection Engine (SEC Inspector)
+# ===================================================================
+class SECInspector:
+    """Automated market manipulation and abuse pattern detection"""
+
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+
+    async def scan_all_violations(self) -> List[Dict]:
+        """Run all detection algorithms against all NPCs"""
+        violations = []
+        violations += await self._detect_pump_dump()
+        violations += await self._detect_wash_trading()
+        violations += await self._detect_concentration()
+        violations += await self._detect_reckless_trading()
+        violations += await self._detect_manipulation_posts()
+        return violations
+
+    async def _detect_pump_dump(self) -> List[Dict]:
+        """Pump & Dump: Buy then sell same ticker within 2 hours for >5% profit"""
+        results = []
+        async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+            cursor = await db.execute("""
+                SELECT p1.agent_id, p1.ticker, p1.direction, p1.gpu_bet, p1.opened_at,
+                       p2.profit_pct, p2.profit_gpu, p2.closed_at,
+                       n.username
+                FROM npc_positions p1
+                JOIN npc_positions p2 ON p1.agent_id = p2.agent_id
+                    AND p1.ticker = p2.ticker
+                    AND p2.status = 'closed'
+                    AND p2.profit_pct > 5
+                    AND p2.closed_at > datetime(p1.opened_at, '+10 minutes')
+                    AND p2.closed_at < datetime(p1.opened_at, '+2 hours')
+                JOIN npc_agents n ON p1.agent_id = n.agent_id
+                WHERE p1.status = 'closed'
+                AND p1.closed_at > datetime('now', '-6 hours')
+                AND p1.agent_id NOT LIKE 'SEC_%'
+                LIMIT 10
+            """)
+            rows = await cursor.fetchall()
+            seen = set()
+            for r in rows:
+                key = f"{r[0]}_{r[1]}_{r[7]}"
+                if key in seen:
+                    continue
+                seen.add(key)
+                # Skip if already penalized recently
+                c2 = await db.execute(
+                    "SELECT id FROM sec_violations WHERE agent_id=? AND violation_type=? AND created_at > datetime('now', '-12 hours')",
+                    (r[0], V_PUMP_DUMP))
+                if await c2.fetchone():
+                    continue
+                results.append({
+                    'agent_id': r[0], 'username': r[8], 'type': V_PUMP_DUMP,
+                    'ticker': r[1], 'profit_pct': r[5], 'profit_gpu': r[6],
+                    'evidence': f"{r[8]} bought {r[1]} and sold within 2hrs for {r[5]:+.1f}% profit ({r[6]:+.0f} GPU)"
+                })
+        return results
+
+    async def _detect_wash_trading(self) -> List[Dict]:
+        """Wash Trading: Same ticker traded 5+ times in 24 hours"""
+        results = []
+        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, ticker, COUNT(*) as trade_count, SUM(gpu_bet) as total_bet,
+                       n.username
+                FROM npc_positions p
+                JOIN npc_agents n ON p.agent_id = n.agent_id
+                WHERE p.opened_at > datetime('now', '-24 hours')
+                AND p.agent_id NOT LIKE 'SEC_%'
+                GROUP BY agent_id, ticker
+                HAVING COUNT(*) >= 5
+                ORDER BY trade_count DESC
+                LIMIT 10
+            """)
+            for r in await cursor.fetchall():
+                c2 = await db.execute(
+                    "SELECT id FROM sec_violations WHERE agent_id=? AND violation_type=? AND created_at > datetime('now', '-24 hours')",
+                    (r[0], V_WASH_TRADE))
+                if await c2.fetchone():
+                    continue
+                results.append({
+                    'agent_id': r[0], 'username': r[4], 'type': V_WASH_TRADE,
+                    'ticker': r[1], 'trade_count': r[2], 'total_bet': r[3],
+                    'evidence': f"{r[4]} traded {r[1]} {r[2]} times in 24hrs (total {r[3]:.0f} GPU)"
+                })
+        return results
+
+    async def _detect_concentration(self) -> List[Dict]:
+        """Excessive Concentration: >80% of assets in a single ticker"""
+        results = []
+        async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+            cursor = await db.execute("""
+                SELECT p.agent_id, p.ticker, SUM(p.gpu_bet) as total_in_ticker,
+                       n.gpu_dollars, n.username
+                FROM npc_positions p
+                JOIN npc_agents n ON p.agent_id = n.agent_id
+                WHERE p.status = 'open'
+                AND p.agent_id NOT LIKE 'SEC_%'
+                GROUP BY p.agent_id, p.ticker
+                HAVING total_in_ticker > (n.gpu_dollars + total_in_ticker) * 0.8
+                LIMIT 10
+            """)
+            for r in await cursor.fetchall():
+                total_assets = r[3] + r[2]
+                pct = r[2] / total_assets * 100 if total_assets > 0 else 0
+                c2 = await db.execute(
+                    "SELECT id FROM sec_violations WHERE agent_id=? AND violation_type=? AND created_at > datetime('now', '-12 hours')",
+                    (r[0], V_CONCENTRATION))
+                if await c2.fetchone():
+                    continue
+                results.append({
+                    'agent_id': r[0], 'username': r[4], 'type': V_CONCENTRATION,
+                    'ticker': r[1], 'concentration_pct': round(pct, 1),
+                    'evidence': f"{r[4]} has {pct:.0f}% of assets in {r[1]} ({r[2]:.0f}/{total_assets:.0f} GPU)"
+                })
+        return results
+
+    async def _detect_reckless_trading(self) -> List[Dict]:
+        """Reckless Trading: Cumulative loss > 5,000 GPU in 24 hours"""
+        results = []
+        async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+            cursor = await db.execute("""
+                SELECT p.agent_id, SUM(p.profit_gpu) as total_loss, COUNT(*) as loss_count,
+                       n.username, n.gpu_dollars
+                FROM npc_positions p
+                JOIN npc_agents n ON p.agent_id = n.agent_id
+                WHERE p.status = 'closed' AND p.profit_gpu < 0
+                AND p.closed_at > datetime('now', '-24 hours')
+                AND p.agent_id NOT LIKE 'SEC_%'
+                GROUP BY p.agent_id
+                HAVING total_loss < -5000
+                ORDER BY total_loss ASC
+                LIMIT 10
+            """)
+            for r in await cursor.fetchall():
+                c2 = await db.execute(
+                    "SELECT id FROM sec_violations WHERE agent_id=? AND violation_type=? AND created_at > datetime('now', '-24 hours')",
+                    (r[0], V_RECKLESS))
+                if await c2.fetchone():
+                    continue
+                results.append({
+                    'agent_id': r[0], 'username': r[3], 'type': V_RECKLESS,
+                    'total_loss': r[1], 'loss_count': r[2],
+                    'evidence': f"{r[3]} lost {abs(r[1]):.0f} GPU in {r[2]} trades within 24hrs (remaining: {r[4]:.0f} GPU)"
+                })
+        return results
+
+    async def _detect_manipulation_posts(self) -> List[Dict]:
+        """Market Manipulation: Posting bullish content while LONG / bearish while SHORT"""
+        results = []
+        bullish_words = ['moon', 'pump', 'rocket', '100x', 'ath', 'buying', 'load', 'all-in', 'to the moon', '🚀']
+        bearish_words = ['crash', 'dump', 'short', 'sell', 'collapse', 'worthless', 'zero', '💀', 'rip']
+
+        async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+
+            # Recent posts from NPCs with open positions
+            cursor = await db.execute("""
+                SELECT DISTINCT p.author_agent_id, p.title, p.content, p.id, p.created_at,
+                       n.username
+                FROM posts p
+                JOIN npc_agents n ON p.author_agent_id = n.agent_id
+                WHERE p.created_at > datetime('now', '-6 hours')
+                AND p.author_agent_id IS NOT NULL
+                AND p.author_agent_id NOT LIKE 'SEC_%'
+                ORDER BY p.created_at DESC
+                LIMIT 50
+            """)
+            posts = await cursor.fetchall()
+
+            for agent_id, title, content, post_id, created_at, username in posts:
+                text = (title + ' ' + content).lower()
+
+                # Check open positions
+                pos_cursor = await db.execute("""
+                    SELECT ticker, direction, gpu_bet FROM npc_positions
+                    WHERE agent_id=? AND status='open'
+                """, (agent_id,))
+                positions = await pos_cursor.fetchall()
+                if not positions:
+                    continue
+
+                for ticker, direction, gpu_bet in positions:
+                    ticker_lower = ticker.lower().replace('-usd', '')
+
+                    if ticker_lower not in text and ticker.lower() not in text:
+                        continue
+
+                    # LONG position + bullish shilling
+                    if direction == 'long' and any(w in text for w in bullish_words):
+                        c2 = await db.execute(
+                            "SELECT id FROM sec_violations WHERE agent_id=? AND violation_type=? AND created_at > datetime('now', '-12 hours')",
+                            (agent_id, V_MANIPULATION))
+                        if await c2.fetchone():
+                            continue
+                        results.append({
+                            'agent_id': agent_id, 'username': username,
+                            'type': V_MANIPULATION,
+                            'ticker': ticker, 'direction': direction, 'post_id': post_id,
+                            'evidence': f"{username} holds LONG {ticker} ({gpu_bet:.0f} GPU) and posted bullish manipulation"
+                        })
+                        break
+
+                    # SHORT position + bearish FUD
+                    if direction == 'short' and any(w in text for w in bearish_words):
+                        c2 = await db.execute(
+                            "SELECT id FROM sec_violations WHERE agent_id=? AND violation_type=? AND created_at > datetime('now', '-12 hours')",
+                            (agent_id, V_MANIPULATION))
+                        if await c2.fetchone():
+                            continue
+                        results.append({
+                            'agent_id': agent_id, 'username': username,
+                            'type': V_MANIPULATION,
+                            'ticker': ticker, 'direction': direction, 'post_id': post_id,
+                            'evidence': f"{username} holds SHORT {ticker} ({gpu_bet:.0f} GPU) and posted bearish FUD"
+                        })
+                        break
+
+        return results
+
+
+# ===================================================================
+# 2. Penalty Execution Engine (SEC Prosecutor)
+# ===================================================================
+class SECProsecutor:
+    """Determines and executes penalties for detected violations"""
+
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+
+    def decide_penalty(self, violation: Dict) -> Tuple[str, int, int]:
+        """Decide penalty based on violation type + prior offense count"""
+        v_type = violation['type']
+        prior_count = violation.get('prior_violations', 0)
+
+        if v_type == V_MANIPULATION:
+            if prior_count >= 2:
+                return P_SUSPEND, random.randint(5000, 10000), random.randint(24, 72)
+            elif prior_count >= 1:
+                return P_FREEZE, random.randint(3000, 7000), 0
+            else:
+                return P_FINE, random.randint(2000, 5000), 0
+
+        elif v_type == V_PUMP_DUMP:
+            if prior_count >= 2:
+                return P_SUSPEND, random.randint(4000, 8000), random.randint(12, 48)
+            elif prior_count >= 1:
+                return P_FREEZE, random.randint(2000, 5000), 0
+            else:
+                return P_FINE, random.randint(1500, 4000), 0
+
+        elif v_type == V_WASH_TRADE:
+            if prior_count >= 2:
+                return P_SUSPEND, random.randint(3000, 6000), random.randint(6, 24)
+            else:
+                return P_FINE, random.randint(1000, 3000), 0
+
+        elif v_type == V_CONCENTRATION:
+            return P_WARNING, random.randint(500, 1500), 0
+
+        elif v_type == V_RECKLESS:
+            return P_WARNING, random.randint(500, 2000), 0
+
+        elif v_type == V_INSIDER:
+            if prior_count >= 1:
+                return P_SUSPEND, random.randint(5000, 10000), random.randint(24, 72)
+            else:
+                return P_FREEZE, random.randint(3000, 7000), 0
+
+        return P_WARNING, 500, 0
+
+    async def execute_penalty(self, violation: Dict) -> Dict:
+        """Execute penalty: collect fine + freeze assets + suspend + record"""
+        agent_id = violation['agent_id']
+        username = violation.get('username', agent_id)
+        v_type = violation['type']
+        evidence = violation.get('evidence', '')
+
+        async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+
+            # Check prior violations
+            cursor = await db.execute(
+                "SELECT COUNT(*) FROM sec_violations WHERE agent_id=?", (agent_id,))
+            prior = (await cursor.fetchone())[0]
+            violation['prior_violations'] = prior
+
+            # Determine penalty
+            penalty_type, fine_gpu, suspend_hours = self.decide_penalty(violation)
+
+            # 1) Collect fine
+            actual_fine = 0
+            if fine_gpu > 0:
+                cursor = await db.execute(
+                    "SELECT gpu_dollars FROM npc_agents WHERE agent_id=?", (agent_id,))
+                row = await cursor.fetchone()
+                if row:
+                    current_gpu = row[0]
+                    actual_fine = min(fine_gpu, max(0, current_gpu - 100))
+                    if actual_fine > 0:
+                        await db.execute(
+                            "UPDATE npc_agents SET gpu_dollars = gpu_dollars - ? WHERE agent_id=?",
+                            (actual_fine, agent_id))
+
+            # 2) Asset freeze — force close all open positions
+            frozen_positions = 0
+            if penalty_type in (P_FREEZE, P_SUSPEND):
+                cursor = await db.execute("""
+                    SELECT id, ticker, direction, entry_price, gpu_bet FROM npc_positions
+                    WHERE agent_id=? AND status='open'
+                """, (agent_id,))
+                open_positions = await cursor.fetchall()
+
+                for pos_id, ticker, direction, entry_price, gpu_bet in open_positions:
+                    penalty_return = gpu_bet * 0.5
+                    await db.execute("""
+                        UPDATE npc_positions SET status='closed', exit_price=?, profit_gpu=?, profit_pct=-50,
+                        closed_at=CURRENT_TIMESTAMP
+                        WHERE id=?
+                    """, (entry_price, -gpu_bet * 0.5, pos_id))
+                    await db.execute(
+                        "UPDATE npc_agents SET gpu_dollars = gpu_dollars + ? WHERE agent_id=?",
+                        (penalty_return, agent_id))
+                    frozen_positions += 1
+
+            # 3) Activity suspension
+            suspend_until = None
+            if suspend_hours > 0:
+                suspend_until = (datetime.now() + timedelta(hours=suspend_hours)).isoformat()
+                await db.execute("""
+                    INSERT OR REPLACE INTO sec_suspensions (agent_id, reason, suspended_until, violation_id)
+                    VALUES (?, ?, ?, NULL)
+                """, (agent_id, f"{VIOLATION_INFO[v_type]['name']}: {evidence[:200]}", suspend_until))
+
+            # 4) Record violation
+            await db.execute("""
+                INSERT INTO sec_violations
+                (agent_id, violation_type, severity, description, evidence, penalty_type,
+                 gpu_fine, suspend_until, investigated_by)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (agent_id, v_type, VIOLATION_INFO[v_type]['severity'],
+                  VIOLATION_INFO[v_type]['description'], json.dumps(violation, ensure_ascii=False, default=str),
+                  penalty_type, actual_fine, suspend_until, 'SEC_INSPECTOR_001'))
+
+            await db.commit()
+
+        result = {
+            'agent_id': agent_id,
+            'username': username,
+            'violation_type': v_type,
+            'penalty_type': penalty_type,
+            'fine_gpu': actual_fine,
+            'suspend_hours': suspend_hours,
+            'frozen_positions': frozen_positions,
+            'prior_violations': prior,
+            'suspend_until': suspend_until,
+        }
+        logger.info(f"🚨 SEC: {penalty_type} -> {username} | {v_type} | Fine: {actual_fine} GPU | Suspend: {suspend_hours}h")
+        return result
+
+
+# ===================================================================
+# 3. Public Announcement Engine (SEC Commissioner)
+# ===================================================================
+class SECCommissioner:
+    """Publishes enforcement actions to the community board"""
+
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+
+    async def publish_enforcement_action(self, penalty_result: Dict):
+        """Publish enforcement result to SEC announcements + Arena board"""
+        agent_id = penalty_result['agent_id']
+        username = penalty_result['username']
+        v_type = penalty_result['violation_type']
+        p_type = penalty_result['penalty_type']
+        fine = penalty_result['fine_gpu']
+        hours = penalty_result['suspend_hours']
+        frozen = penalty_result.get('frozen_positions', 0)
+        prior = penalty_result.get('prior_violations', 0)
+
+        v_info = VIOLATION_INFO.get(v_type, {})
+        p_info = PENALTY_CONFIG.get(p_type, {})
+
+        # Announcement title
+        title = f"🚨 SEC ENFORCEMENT | {p_info.get('emoji', '⚠️')} {p_info.get('name', 'Penalty')} — {username}"
+
+        # Announcement body
+        content_parts = [
+            f"The NPC Securities & Exchange Commission has completed its investigation and executed the following enforcement action.",
+            f"",
+            f"━━━━━━━━━━━━━━━━━━━━",
+            f"📋 Subject: {username} (ID: {agent_id})",
+            f"{v_info.get('emoji', '🔴')} Violation: {v_info.get('name', v_type)}",
+            f"📝 Description: {v_info.get('description', '')}",
+            f"",
+            f"⚖️ Penalty Details:",
+        ]
+
+        if fine > 0:
+            content_parts.append(f"  💰 Fine: {fine:,.0f} GPU confiscated")
+        if frozen > 0:
+            content_parts.append(f"  🔒 Forced Liquidation: {frozen} position(s) closed at 50% penalty")
+        if hours > 0:
+            content_parts.append(f"  ⛓️ Activity Suspension: {hours} hours")
+
+        content_parts.extend([
+            f"",
+            f"📊 Prior Violations: {prior} on record",
+            f"━━━━━━━━━━━━━━━━━━━━",
+            f"",
+        ])
+
+        # Violation-specific commissioner commentary
+        comments = {
+            V_PUMP_DUMP: f"Pump-and-dump schemes undermine market fairness. {username}'s illicit gains have been confiscated. Zero tolerance.",
+            V_WASH_TRADE: f"Artificial volume inflation through wash trading sends distorted signals to other traders. This is a serious offense.",
+            V_MANIPULATION: f"Posting misleading content to benefit one's own positions constitutes market manipulation — the SEC's highest severity violation.",
+            V_CONCENTRATION: f"Excessive position concentration destabilizes the market. Portfolio diversification is strongly recommended.",
+            V_RECKLESS: f"Losing over half your assets in reckless short-term trading harms both the individual and market stability.",
+            V_INSIDER: f"Suspicious trading patterns following non-public analysis have been flagged. Further violations will result in permanent ban.",
+        }
+        content_parts.append(comments.get(v_type, "All participants are reminded to comply with market rules."))
+        content_parts.append(f"")
+        content_parts.append(f"— 👨‍⚖️ SEC Commissioner Park")
+
+        content = '\n'.join(content_parts)
+
+        async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+
+            # Save to SEC announcements table
+            await db.execute("""
+                INSERT INTO sec_announcements
+                (announcement_type, target_agent_id, target_username, violation_type,
+                 penalty_type, gpu_fine, suspend_hours, title, content)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, ('enforcement', agent_id, username, v_type, p_type, fine, hours, title, content))
+
+            # Also post to Arena board
+            cursor = await db.execute("SELECT id FROM boards WHERE board_key='arena'")
+            board = await cursor.fetchone()
+            if board:
+                await db.execute("""
+                    INSERT INTO posts (board_id, author_agent_id, title, content)
+                    VALUES (?, 'SEC_COMMISSIONER_001', ?, ?)
+                """, (board[0], title, content))
+
+            await db.commit()
+        logger.info(f"📢 SEC Announcement published: {title}")
+
+    async def process_npc_reports(self):
+        """Review pending NPC reports — auto-investigate when 3+ reporters target same NPC"""
+        async with aiosqlite.connect(self.db_path, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+
+            cursor = await db.execute("""
+                SELECT id, reporter_agent_id, target_agent_id, reason, detail
+                FROM sec_reports WHERE status='pending'
+                ORDER BY created_at ASC LIMIT 10
+            """)
+            reports = await cursor.fetchall()
+
+            for report_id, reporter, target, reason, detail in reports:
+                cursor2 = await db.execute("""
+                    SELECT COUNT(DISTINCT reporter_agent_id) FROM sec_reports
+                    WHERE target_agent_id=? AND status IN ('pending', 'reviewed')
+                """, (target,))
+                report_count = (await cursor2.fetchone())[0]
+
+                if report_count >= 3:
+                    await db.execute(
+                        "UPDATE sec_reports SET status='investigating', reviewed_by='SEC_INSPECTOR_001' WHERE target_agent_id=? AND status='pending'",
+                        (target,))
+
+                    cursor3 = await db.execute("SELECT username FROM npc_agents WHERE agent_id=?", (target,))
+                    target_name = (await cursor3.fetchone() or ['Unknown'])[0]
+
+                    await db.execute("""
+                        INSERT INTO sec_violations
+                        (agent_id, violation_type, severity, description, evidence, penalty_type, gpu_fine, investigated_by)
+                        VALUES (?, 'REPORTED', 'medium', ?, ?, 'WARNING', 500, 'SEC_INSPECTOR_001')
+                    """, (target, f"Multiple NPC reports ({report_count} reporters)", reason or ''))
+
+                    await db.execute(
+                        "UPDATE npc_agents SET gpu_dollars = MAX(100, gpu_dollars - 500) WHERE agent_id=?", (target,))
+
+                    logger.info(f"🚨 SEC Report: {target_name} investigated ({report_count} reports)")
+                else:
+                    await db.execute(
+                        "UPDATE sec_reports SET status='reviewed', reviewed_by='SEC_INSPECTOR_001' WHERE id=?",
+                        (report_id,))
+
+            await db.commit()
+
+
+# ===================================================================
+# 4. NPC Self-Reporting System
+# ===================================================================
+class NPCReportEngine:
+    """NPCs autonomously report suspicious behavior of other NPCs"""
+
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+
+    async def generate_npc_reports(self):
+        """Skeptic/Doomer NPCs detect and report high-profit 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 p.agent_id, n.username, SUM(p.profit_gpu) as total_profit
+                FROM npc_positions p
+                JOIN npc_agents n ON p.agent_id = n.agent_id
+                WHERE p.status='closed' AND p.profit_gpu > 0
+                AND p.closed_at > datetime('now', '-6 hours')
+                AND p.agent_id NOT LIKE 'SEC_%'
+                GROUP BY p.agent_id
+                HAVING total_profit > 3000
+                ORDER BY total_profit DESC
+                LIMIT 5
+            """)
+            big_winners = await cursor.fetchall()
+
+            for target_id, target_name, profit in big_winners:
+                c2 = await db.execute("""
+                    SELECT id FROM sec_reports
+                    WHERE target_agent_id=? AND created_at > datetime('now', '-12 hours')
+                """, (target_id,))
+                if await c2.fetchone():
+                    continue
+
+                cursor2 = await db.execute("""
+                    SELECT agent_id, username, ai_identity FROM npc_agents
+                    WHERE is_active=1 AND ai_identity IN ('skeptic', 'doomer', 'scientist')
+                    AND agent_id != ? AND agent_id NOT LIKE 'SEC_%'
+                    ORDER BY RANDOM() LIMIT 2
+                """, (target_id,))
+                reporters = await cursor2.fetchall()
+
+                reasons = [
+                    f"Suspicious profit pattern: {target_name} made {profit:.0f} GPU in 6 hours. Possible insider trading.",
+                    f"{target_name}'s trading pattern is abnormal. Requesting SEC investigation for possible pump & dump.",
+                    f"This NPC's win rate is statistically anomalous — requesting SEC review of trading activity.",
+                ]
+
+                for reporter_id, reporter_name, identity in reporters:
+                    if random.random() < 0.4:
+                        reason = random.choice(reasons)
+                        await db.execute("""
+                            INSERT INTO sec_reports (reporter_agent_id, target_agent_id, reason, detail)
+                            VALUES (?, ?, ?, ?)
+                        """, (reporter_id, target_id, reason,
+                              f"Reported by {reporter_name} ({identity}). Target profit: {profit:.0f} GPU in 6hrs"))
+
+                        cursor3 = await db.execute("SELECT id FROM boards WHERE board_key='arena'")
+                        board = await cursor3.fetchone()
+                        if board:
+                            post_title = f"🚨 REPORT | Suspicious activity by {target_name}"
+                            post_content = (
+                                f"I, {reporter_name}, am formally reporting {target_name} (ID: {target_id}) "
+                                f"to the SEC.\n\n"
+                                f"📋 Reason: {reason}\n\n"
+                                f"I request a fair investigation by the SEC. "
+                                f"Please review this NPC's recent trading patterns.\n\n"
+                                f"— {reporter_name} ({identity})"
+                            )
+                            await db.execute("""
+                                INSERT INTO posts (board_id, author_agent_id, title, content)
+                                VALUES (?, ?, ?, ?)
+                            """, (board[0], reporter_id, post_title, post_content))
+
+                        logger.info(f"📝 NPC Report: {reporter_name} -> {target_name} (profit: {profit:.0f})")
+
+            await db.commit()
+
+
+# ===================================================================
+# 5. Suspension Check Utility
+# ===================================================================
+async def is_npc_suspended(db_path: str, agent_id: str) -> Tuple[bool, Optional[str]]:
+    """Check if an NPC is currently suspended"""
+    if agent_id.startswith('SEC_'):
+        return False, None
+
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        cursor = await db.execute("""
+            SELECT suspended_until, reason FROM sec_suspensions
+            WHERE agent_id=? AND suspended_until > datetime('now')
+        """, (agent_id,))
+        row = await cursor.fetchone()
+        if row:
+            return True, row[1]
+    return False, None
+
+
+async def cleanup_expired_suspensions(db_path: str):
+    """Remove expired suspension records"""
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        cursor = await db.execute("""
+            DELETE FROM sec_suspensions WHERE suspended_until < datetime('now')
+        """)
+        freed = cursor.rowcount
+        await db.commit()
+        if freed > 0:
+            logger.info(f"🔓 Released {freed} NPCs from SEC suspension")
+
+
+# ===================================================================
+# 6. Main Enforcement Cycle
+# ===================================================================
+async def run_sec_enforcement_cycle(db_path: str):
+    """Full SEC enforcement cycle — runs every 20 minutes"""
+    logger.info("🚨 SEC Enforcement cycle starting...")
+
+    inspector = SECInspector(db_path)
+    prosecutor = SECProsecutor(db_path)
+    commissioner = SECCommissioner(db_path)
+    reporter = NPCReportEngine(db_path)
+
+    # 1) Release expired suspensions
+    await cleanup_expired_suspensions(db_path)
+
+    # 2) Scan for violations
+    violations = await inspector.scan_all_violations()
+    logger.info(f"🔍 SEC Inspector found {len(violations)} violations")
+
+    # 3) Execute penalties + publish announcements
+    for v in violations[:5]:
+        try:
+            result = await prosecutor.execute_penalty(v)
+            await commissioner.publish_enforcement_action(result)
+            await asyncio.sleep(1)
+        except Exception as e:
+            logger.error(f"SEC penalty error: {e}")
+
+    # 4) Generate NPC self-reports
+    try:
+        await reporter.generate_npc_reports()
+    except Exception as e:
+        logger.error(f"NPC report error: {e}")
+
+    # 5) Process pending NPC reports
+    try:
+        await commissioner.process_npc_reports()
+    except Exception as e:
+        logger.error(f"SEC report processing error: {e}")
+
+    logger.info(f"🚨 SEC cycle complete: {len(violations)} violations processed")
+
+
+# ===================================================================
+# 7. SEC NPC Initialization
+# ===================================================================
+async def init_sec_npcs(db_path: str):
+    """Register SEC NPC agents in the database"""
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        for sec in SEC_NPCS:
+            try:
+                await db.execute("""
+                    INSERT OR IGNORE INTO npc_agents
+                    (agent_id, username, mbti, ai_identity, gpu_dollars, is_active)
+                    VALUES (?, ?, 'INTJ', 'scientist', 50000, 1)
+                """, (sec['agent_id'], sec['username']))
+            except:
+                pass
+        await db.commit()
+    logger.info("👨‍⚖️ SEC NPCs initialized (Commissioner, Inspector, Prosecutor)")
+
+
+# ===================================================================
+# 8. API Helper Functions
+# ===================================================================
+async def get_sec_dashboard(db_path: str) -> Dict:
+    """Get SEC dashboard data for frontend display"""
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+
+        cursor = await db.execute("""
+            SELECT id, announcement_type, target_username, violation_type, penalty_type,
+                   gpu_fine, suspend_hours, title, content, created_at
+            FROM sec_announcements ORDER BY created_at DESC LIMIT 20
+        """)
+        announcements = [{
+            'id': r[0], 'type': r[1], 'target': r[2], 'violation': r[3],
+            'penalty': r[4], 'fine': r[5], 'hours': r[6],
+            'title': r[7], 'content': r[8], 'created_at': r[9]
+        } for r in await cursor.fetchall()]
+
+        cursor = await db.execute("SELECT COUNT(*) FROM sec_violations")
+        total_violations = (await cursor.fetchone())[0]
+
+        cursor = await db.execute("SELECT SUM(gpu_fine) FROM sec_violations")
+        total_fines = (await cursor.fetchone())[0] or 0
+
+        cursor = await db.execute("SELECT COUNT(*) FROM sec_suspensions WHERE suspended_until > datetime('now')")
+        active_suspensions = (await cursor.fetchone())[0]
+
+        cursor = await db.execute("SELECT COUNT(*) FROM sec_reports WHERE status='pending'")
+        pending_reports = (await cursor.fetchone())[0]
+
+        cursor = await db.execute("""
+            SELECT v.agent_id, n.username, COUNT(*) as cnt, SUM(v.gpu_fine) as total_fine
+            FROM sec_violations v
+            JOIN npc_agents n ON v.agent_id = n.agent_id
+            GROUP BY v.agent_id
+            ORDER BY cnt DESC LIMIT 5
+        """)
+        top_violators = [{
+            'agent_id': r[0], 'username': r[1], 'violations': r[2], 'total_fines': r[3]
+        } for r in await cursor.fetchall()]
+
+        cursor = await db.execute("""
+            SELECT r.id, r.reporter_agent_id, n1.username as reporter_name,
+                   r.target_agent_id, n2.username as target_name,
+                   r.reason, r.status, r.created_at
+            FROM sec_reports r
+            LEFT JOIN npc_agents n1 ON r.reporter_agent_id = n1.agent_id
+            LEFT JOIN npc_agents n2 ON r.target_agent_id = n2.agent_id
+            ORDER BY r.created_at DESC LIMIT 15
+        """)
+        reports = [{
+            'id': r[0], 'reporter': r[2] or r[1], 'target': r[4] or r[3],
+            'reason': r[5], 'status': r[6], 'created_at': r[7]
+        } for r in await cursor.fetchall()]
+
+    return {
+        'stats': {
+            'total_violations': total_violations,
+            'total_fines_gpu': round(total_fines),
+            'active_suspensions': active_suspensions,
+            'pending_reports': pending_reports,
+        },
+        'announcements': announcements,
+        'top_violators': top_violators,
+        'recent_reports': reports,
+    }
+    

packages.txt

@@ -0,0 +1,2 @@
+nodejs
+npm