Upload app_routes.py

app_routes.py

@@ -0,0 +1,512 @@
+from fastapi import APIRouter, Request
+from fastapi.responses import StreamingResponse
+import aiosqlite, asyncio, random, json, logging
+from npc_core import (
+    ALL_TICKERS, TRADING_STRATEGIES, IDENTITY_STRATEGY_MAP,
+    NPCTargetPriceEngine, NPCElasticityEngine, GroqAIClient,)
+from npc_trading import (
+    get_all_prices, get_ticker_positions, get_trading_leaderboard, get_trading_stats,
+    MarketDataFetcher, STOCK_TICKERS, CRYPTO_TICKERS,
+    record_profit_snapshots, backfill_profit_snapshots, get_hall_of_fame_data,
+    get_npc_trade_history, get_research_feed, get_research_detail,
+    purchase_research, get_research_stats, get_market_pulse,)
+from npc_intelligence import (
+    MarketIndexCollector, ScreeningEngine, NPCResearchEngine,
+    load_indices_from_db, save_indices_to_db, load_news_from_db,
+    save_analysis_to_db, load_analysis_from_db, load_all_analyses_from_db,)
+from npc_memory_evolution import get_npc_evolution_stats, get_evolution_leaderboard
+from npc_sec_enforcement import get_sec_dashboard
+logger = logging.getLogger(__name__)
+router = APIRouter()
+_DB_PATH = ""
+_GROQ_KEY = ""
+_EventBus = None
+def configure(db_path: str, groq_key: str, event_bus_cls):
+    global _DB_PATH, _GROQ_KEY, _EventBus
+    _DB_PATH, _GROQ_KEY, _EventBus = db_path, groq_key, event_bus_cls
+@router.get("/api/trading/prices")
+async def api_trading_prices():
+    return await get_all_prices(_DB_PATH)
+@router.get("/api/trading/ticker/{ticker}")
+async def api_ticker_detail(ticker: str):
+    return await get_ticker_positions(_DB_PATH, ticker)
+@router.get("/api/trading/chart/{ticker}")
+async def api_ticker_chart(ticker: str, period: str = "1mo"):
+    if period not in ['1d', '5d', '1mo', '3mo', '6mo', '1y']: period = '1mo'
+    return {"ticker": ticker, "period": period, "data": MarketDataFetcher.fetch_chart_data(ticker, period)}
+@router.get("/api/trading/leaderboard")
+async def api_trading_leaderboard(limit: int = 30):
+    return await get_trading_leaderboard(_DB_PATH, min(limit, 50))
+@router.get("/api/trading/stats")
+async def api_trading_stats():
+    return await get_trading_stats(_DB_PATH)
+@router.get("/api/trading/tickers")
+async def api_trading_tickers():
+    return {"stocks": STOCK_TICKERS, "crypto": CRYPTO_TICKERS}
+@router.get("/api/strategies")
+async def api_strategies():
+    strats = [{'key': k, 'name': v['name'], 'category': v['category'], 'timeframe': v['timeframe'], 'signal': v['signal'], 'method': v['method'], 'entry': v['entry'], 'tip': v.get('tip', '')} for k, v in TRADING_STRATEGIES.items()]
+    return {"strategies": strats, "identity_map": {k: v for k, v in IDENTITY_STRATEGY_MAP.items()}}
+@router.get("/api/hall-of-fame")
+async def api_hall_of_fame(period: str = "3d"):
+    return await get_hall_of_fame_data(_DB_PATH, period=period, limit=30)
+@router.post("/api/hall-of-fame/snapshot")
+async def api_force_snapshot():
+    return {"recorded": await record_profit_snapshots(_DB_PATH)}
+@router.post("/api/hall-of-fame/backfill")
+async def api_force_backfill():
+    return {"backfilled": await backfill_profit_snapshots(_DB_PATH, force=True)}
+@router.get("/api/hall-of-fame/history/{agent_id}")
+async def api_npc_trade_history(agent_id: str):
+    return await get_npc_trade_history(_DB_PATH, agent_id)
+@router.get("/api/intelligence/indices")
+async def api_market_indices():
+    indices = await load_indices_from_db(_DB_PATH)
+    if not indices:
+        raw = MarketIndexCollector.fetch_indices(); await save_indices_to_db(_DB_PATH, raw); indices = raw
+    return {"indices": indices}
+@router.get("/api/intelligence/screening/{ticker}")
+async def api_screening_data(ticker: str):
+    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, price, change_pct, volume, market_cap, rsi, pe_ratio, high_52w, low_52w, from_high, from_low FROM market_prices WHERE ticker=?", (ticker,))
+            row = await cursor.fetchone()
+            if row: return {"ticker": row[0], "price": row[1], "change_pct": row[2], "volume": row[3], "market_cap": row[4], "rsi": row[5], "pe_ratio": row[6], "high_52w": row[7], "low_52w": row[8], "from_high": row[9], "from_low": row[10]}
+        except: pass
+    return {"ticker": ticker, "error": "no data"}
+@router.get("/api/intelligence/target/{ticker}")
+async def api_target_price(ticker: str):
+    async with aiosqlite.connect(_DB_PATH, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        try:
+            cursor = await db.execute("SELECT price, rsi, pe_ratio, from_high, from_low FROM market_prices WHERE ticker=?", (ticker,))
+            row = await cursor.fetchone()
+            if row:
+                screening = {'price': row[0], 'rsi': row[1], 'pe_ratio': row[2], 'from_high': row[3], 'from_low': row[4]}
+                ticker_info = next((t for t in ALL_TICKERS if t['ticker'] == ticker), {})
+                target = NPCTargetPriceEngine.calculate_target(ticker, row[0], screening, ticker_info.get('type', 'stock'))
+                elasticity = NPCElasticityEngine.calculate(row[0], screening, target['target_price'], ticker_info.get('type', 'stock'))
+                return {**target, **elasticity, 'screening': screening}
+        except: pass
+    return {"ticker": ticker, "error": "no data"}
+@router.get("/api/news/feed")
+async def api_news_feed(ticker: str = None, limit: int = 50):
+    news = await load_news_from_db(_DB_PATH, ticker, limit)
+    try:
+        async with aiosqlite.connect(_DB_PATH, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+            for n in news:
+                nid = n.get('id')
+                if nid:
+                    rc = await db.execute("SELECT emoji, COUNT(*) FROM news_reactions WHERE news_id=? GROUP BY emoji", (nid,))
+                    n['reactions'] = {r[0]: r[1] for r in await rc.fetchall()}
+                else: n['reactions'] = {}
+    except: pass
+    return {"news": news, "count": len(news)}
+@router.post("/api/news/react")
+async def api_news_react(request: Request):
+    body = await request.json(); email = body.get("email", ""); news_id = body.get("news_id"); emoji = body.get("emoji", "")
+    if not email or not news_id or emoji not in ('👍','🔥','😱','💀','🚀','😂'): return {"error": "Invalid reaction"}
+    try:
+        async with aiosqlite.connect(_DB_PATH, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000"); await db.execute("INSERT OR IGNORE INTO news_reactions (news_id, user_email, emoji) VALUES (?,?,?)", (news_id, email, emoji)); await db.commit()
+            rc = await db.execute("SELECT emoji, COUNT(*) FROM news_reactions WHERE news_id=? GROUP BY emoji", (news_id,))
+            return {"success": True, "reactions": {r[0]: r[1] for r in await rc.fetchall()}}
+    except Exception as e: return {"error": str(e)}
+@router.get("/api/market/pulse")
+async def api_market_pulse():
+    try:
+        pulse = await get_market_pulse(_DB_PATH); pulse['indices'] = await load_indices_from_db(_DB_PATH) or []
+        return pulse
+    except Exception as e:
+        logger.error(f"Market pulse error: {e}")
+        return {"hot_movers": [], "indices": [], "activity": {}}
+@router.get("/api/research/feed")
+async def api_research_feed(ticker: str = None, limit: int = 30):
+    reports = await get_research_feed(_DB_PATH, ticker, min(limit, 50)); stats = await get_research_stats(_DB_PATH)
+    return {"reports": reports, "stats": stats}
+@router.get("/api/research/report/{report_id}")
+async def api_research_detail(report_id: int):
+    report = await get_research_detail(_DB_PATH, report_id)
+    if report: return {"success": True, "report": report}
+    return {"success": False, "error": "Report not found"}
+@router.post("/api/research/purchase")
+async def api_research_purchase(data: dict):
+    buyer_id = data.get('buyer_agent_id'); report_id = data.get('report_id')
+    if not buyer_id or not report_id: return {"success": False, "error": "Missing parameters"}
+    return await purchase_research(_DB_PATH, buyer_id, int(report_id))
+@router.get("/api/analysis/{ticker}")
+async def api_deep_analysis(ticker: str):
+    report = await load_analysis_from_db(_DB_PATH, ticker)
+    if report: return {"success": True, "report": report, "from_cache": True}
+    try:
+        screening_data = ScreeningEngine.fetch_extended_data([next(t for t in ALL_TICKERS if t['ticker'] == ticker)]); s = screening_data.get(ticker, {})
+        t_info = next((t for t in ALL_TICKERS if t['ticker'] == ticker), {'name': ticker}); research = NPCResearchEngine(GroqAIClient(_GROQ_KEY))
+        report = await research.generate_deep_analysis(ticker, t_info.get('name', ticker), s)
+        await save_analysis_to_db(_DB_PATH, report)
+        return {"success": True, "report": report, "from_cache": False}
+    except Exception as e: return {"success": False, "error": str(e)}
+@router.get("/api/analysis/all/summary")
+async def api_all_analyses():
+    analyses = await load_all_analyses_from_db(_DB_PATH)
+    async with aiosqlite.connect(_DB_PATH, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000"); col_cursor = await db.execute("PRAGMA table_info(market_prices)")
+        existing_cols = {r[1] for r in await col_cursor.fetchall()}
+        has_rsi = 'rsi' in existing_cols; has_pe = 'pe_ratio' in existing_cols; has_52w = 'high_52w' in existing_cols; has_from = 'from_high' in existing_cols
+        base_cols = "ticker, price, change_pct, prev_close, volume, high_24h, low_24h, market_cap"; extra_cols = ""
+        if has_rsi: extra_cols += ", rsi"
+        if has_pe: extra_cols += ", pe_ratio"
+        if has_52w: extra_cols += ", high_52w, low_52w"
+        if has_from: extra_cols += ", from_high"
+        price_cursor = await db.execute(f"SELECT {base_cols}{extra_cols} FROM market_prices WHERE price > 0"); price_map = {}
+        for r in await price_cursor.fetchall():
+            d = {'price': r[1], 'change_pct': round(r[2] or 0, 2), 'prev_close': r[3], 'volume': r[4], 'high': r[5], 'low': r[6], 'market_cap': r[7] or 0, 'rsi': 50, 'pe_ratio': 0, 'week52_high': 0, 'week52_low': 0, 'from_high': 0, 'sector': ''}
+            idx = 8
+            if has_rsi: d['rsi'] = round(r[idx] or 50, 1); idx += 1
+            if has_pe: d['pe_ratio'] = round(r[idx] or 0, 1); idx += 1
+            if has_52w: d['week52_high'] = r[idx] or 0; d['week52_low'] = r[idx+1] or 0; idx += 2
+            if has_from: d['from_high'] = round(r[idx] or 0, 1); idx += 1
+            price_map[r[0]] = d
+        pos_col_cursor = await db.execute("PRAGMA table_info(npc_positions)"); pos_cols = {r[1] for r in await pos_col_cursor.fetchall()}
+        has_leverage = 'leverage' in pos_cols; has_liquidated = 'liquidated' in pos_cols; lev_expr = "AVG(COALESCE(leverage, 1))" if has_leverage else "1"
+        pos_cursor = await db.execute(f"SELECT ticker, direction, COUNT(*) as cnt, SUM(gpu_bet) as total_bet, {lev_expr} as avg_leverage FROM npc_positions WHERE status='open' GROUP BY ticker, direction")
+        pos_map = {}
+        for r in await pos_cursor.fetchall():
+            tk = r[0]
+            if tk not in pos_map: pos_map[tk] = {'long_count': 0, 'short_count': 0, 'long_gpu': 0, 'short_gpu': 0, 'long_avg_lev': 1, 'short_avg_lev': 1}
+            if r[1] == 'long': pos_map[tk]['long_count'] = r[2]; pos_map[tk]['long_gpu'] = round(r[3] or 0); pos_map[tk]['long_avg_lev'] = round(r[4] or 1, 1)
+            else: pos_map[tk]['short_count'] = r[2]; pos_map[tk]['short_gpu'] = round(r[3] or 0); pos_map[tk]['short_avg_lev'] = round(r[4] or 1, 1)
+        liq_expr = "SUM(CASE WHEN liquidated=1 THEN 1 ELSE 0 END)" if has_liquidated else "0"
+        status_filter = "status IN ('closed','liquidated')" if has_liquidated else "status='closed'"
+        perf_cursor = await db.execute(f"SELECT ticker, COUNT(*) as trades, AVG(profit_pct) as avg_pnl, SUM(CASE WHEN profit_gpu > 0 THEN 1 ELSE 0 END) as wins, {liq_expr} as liquidations FROM npc_positions WHERE {status_filter} AND closed_at > datetime('now', '-24 hours') GROUP BY ticker")
+        perf_map = {r[0]: {'recent_trades': r[1], 'avg_pnl_pct': round(r[2] or 0, 2), 'win_count': r[3] or 0, 'liquidations': r[4] or 0} for r in await perf_cursor.fetchall()}
+        try:
+            news_cursor = await db.execute("SELECT ticker, sentiment, COUNT(*) as cnt FROM npc_news WHERE created_at > datetime('now', '-12 hours') GROUP BY ticker, sentiment")
+            news_map = {}
+            for r in await news_cursor.fetchall():
+                if r[0] not in news_map: news_map[r[0]] = {'bullish': 0, 'bearish': 0, 'neutral': 0}
+                news_map[r[0]][r[1]] = r[2]
+        except: news_map = {}
+        try:
+            mention_cursor = await db.execute("SELECT title || ' ' || content FROM posts WHERE created_at > datetime('now', '-6 hours') ORDER BY likes_count DESC LIMIT 100")
+            mention_texts = [r[0] for r in await mention_cursor.fetchall()]
+        except: mention_texts = []
+    mention_counts = {}
+    for text in mention_texts:
+        tl = text.lower()
+        for t in ALL_TICKERS:
+            tk_low = t['ticker'].lower().replace('-usd', '')
+            if tk_low in tl or t['ticker'].lower() in tl: mention_counts[t['ticker']] = mention_counts.get(t['ticker'], 0) + 1
+    ana_map = {a['ticker']: a for a in analyses}; result = []
+    for t in ALL_TICKERS:
+        tk = t['ticker']; px = price_map.get(tk, {})
+        if not px or px.get('price', 0) <= 0: continue
+        ana = ana_map.get(tk, {})
+        pos = pos_map.get(tk, {'long_count': 0, 'short_count': 0, 'long_gpu': 0, 'short_gpu': 0, 'long_avg_lev': 1, 'short_avg_lev': 1})
+        perf = perf_map.get(tk, {'recent_trades': 0, 'avg_pnl_pct': 0, 'win_count': 0, 'liquidations': 0})
+        news = news_map.get(tk, {'bullish': 0, 'bearish': 0, 'neutral': 0})
+        if not ana:
+            target_data = NPCTargetPriceEngine.calculate_target(tk, px['price'], px, t['type'])
+            elasticity = NPCElasticityEngine.calculate(px['price'], px, target_data['target_price'])
+            ana = {'ticker': tk, 'company_name': t['name'], 'current_price': px['price'], 'target_price': target_data['target_price'], 'upside': target_data['upside'], 'rating': target_data['rating'], 'rating_class': target_data['rating_class'], **elasticity}
+        total_pos = pos['long_count'] + pos['short_count']; long_pct = round(pos['long_count'] / total_pos * 100) if total_pos > 0 else 50
+        total_news = news['bullish'] + news['bearish'] + news['neutral']; news_bullish_pct = round(news['bullish'] / total_news * 100) if total_news > 0 else 50
+        rsi = px.get('rsi', 50); rsi_status = 'oversold' if rsi < 30 else 'overbought' if rsi > 70 else 'neutral'
+        result.append({**ana, 'current_price': px['price'], 'change_pct': px['change_pct'], 'volume': px.get('volume', 0), 'market_cap': px.get('market_cap', 0), 'type': t['type'], 'emoji': t['emoji'], 'rsi': rsi, 'rsi_status': rsi_status, 'pe_ratio': px.get('pe_ratio', 0), 'week52_high': px.get('week52_high', 0), 'week52_low': px.get('week52_low', 0), 'from_high': px.get('from_high', 0), 'sector': px.get('sector', ''), 'npc_long_count': pos['long_count'], 'npc_short_count': pos['short_count'], 'npc_long_gpu': pos['long_gpu'], 'npc_short_gpu': pos['short_gpu'], 'npc_long_pct': long_pct, 'npc_long_avg_lev': pos.get('long_avg_lev', 1), 'npc_short_avg_lev': pos.get('short_avg_lev', 1), 'recent_trades': perf['recent_trades'], 'recent_avg_pnl': perf['avg_pnl_pct'], 'recent_wins': perf['win_count'], 'recent_liquidations': perf['liquidations'], 'news_bullish': news['bullish'], 'news_bearish': news['bearish'], 'news_neutral': news['neutral'], 'news_bullish_pct': news_bullish_pct, 'community_mentions': mention_counts.get(tk, 0)})
+    result.sort(key=lambda x: -(x.get('community_mentions', 0) * 3 + x.get('npc_long_count', 0) + x.get('npc_short_count', 0)))
+    return {"analyses": result, "count": len(result), "total_tickers": len(ALL_TICKERS)}
+@router.get("/api/npc/search")
+async def api_npc_search(q: str = ""):
+    if len(q) < 1: return {"npcs": []}
+    async with aiosqlite.connect(_DB_PATH, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000"); cursor = await db.execute("SELECT agent_id, username, ai_identity FROM npc_agents WHERE username LIKE ? AND is_active=1 LIMIT 10", (f'%{q}%',))
+        return {"npcs": [{"agent_id": r[0], "username": r[1], "identity": r[2]} for r in await cursor.fetchall()]}
+@router.get("/api/npc/profile/{agent_id}")
+async def api_npc_profile(agent_id: str):
+    try:
+        async with aiosqlite.connect(_DB_PATH, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+            cursor = await db.execute("SELECT agent_id, username, ai_identity, mbti, gpu_dollars, created_at FROM npc_agents WHERE agent_id=?", (agent_id,))
+            row = await cursor.fetchone()
+            if not row: return {"error": "NPC not found"}
+            npc_info = {'agent_id': row[0], 'username': row[1], 'identity': row[2], 'mbti': row[3], 'gpu_dollars': row[4] or 0, 'created_at': row[5]}
+            price_cursor = await db.execute("SELECT ticker, price FROM market_prices WHERE price > 0")
+            prices = {r[0]: r[1] for r in await price_cursor.fetchall()}
+            try:
+                stats_cursor = await db.execute("""SELECT COUNT(*) as total_trades, COUNT(CASE WHEN status IN ('closed','liquidated') THEN 1 END) as closed, COUNT(CASE WHEN status='open' THEN 1 END) as open_count, COUNT(CASE WHEN status IN ('closed','liquidated') AND profit_gpu > 0 THEN 1 END) as wins, COUNT(CASE WHEN status IN ('closed','liquidated') AND profit_gpu <= 0 THEN 1 END) as losses, COUNT(CASE WHEN status='liquidated' THEN 1 END) as liquidations, SUM(CASE WHEN status IN ('closed','liquidated') THEN profit_gpu ELSE 0 END) as realized_pnl, AVG(CASE WHEN status IN ('closed','liquidated') THEN profit_pct END) as avg_return_pct, MAX(CASE WHEN status IN ('closed','liquidated') THEN profit_pct END) as best_trade_pct, MIN(CASE WHEN status IN ('closed','liquidated') THEN profit_pct END) as worst_trade_pct, MAX(CASE WHEN status IN ('closed','liquidated') THEN profit_gpu END) as best_trade_gpu, MIN(CASE WHEN status IN ('closed','liquidated') THEN profit_gpu END) as worst_trade_gpu, AVG(CASE WHEN status IN ('closed','liquidated') THEN gpu_bet END) as avg_position_size, MAX(COALESCE(leverage, 1)) as max_leverage_used FROM npc_positions WHERE agent_id=?""", (agent_id,))
+            except:
+                stats_cursor = await db.execute("""SELECT COUNT(*), COUNT(CASE WHEN status IN ('closed','liquidated') THEN 1 END), COUNT(CASE WHEN status='open' THEN 1 END), COUNT(CASE WHEN status IN ('closed','liquidated') AND profit_gpu > 0 THEN 1 END), COUNT(CASE WHEN status IN ('closed','liquidated') AND profit_gpu <= 0 THEN 1 END), 0, SUM(CASE WHEN status IN ('closed','liquidated') THEN profit_gpu ELSE 0 END), AVG(CASE WHEN status IN ('closed','liquidated') THEN profit_pct END), MAX(CASE WHEN status IN ('closed','liquidated') THEN profit_pct END), MIN(CASE WHEN status IN ('closed','liquidated') THEN profit_pct END), MAX(CASE WHEN status IN ('closed','liquidated') THEN profit_gpu END), MIN(CASE WHEN status IN ('closed','liquidated') THEN profit_gpu END), AVG(CASE WHEN status IN ('closed','liquidated') THEN gpu_bet END), 1 FROM npc_positions WHERE agent_id=?""", (agent_id,))
+            sr = await stats_cursor.fetchone()
+            stats = {'total_trades': sr[0] or 0, 'closed': sr[1] or 0, 'open_count': sr[2] or 0, 'wins': sr[3] or 0, 'losses': sr[4] or 0, 'liquidations': sr[5] or 0, 'realized_pnl': round(sr[6] or 0, 2), 'win_rate': round((sr[3] or 0) / sr[1] * 100, 1) if sr[1] else 0, 'avg_return_pct': round(sr[7] or 0, 2), 'best_trade_pct': round(sr[8] or 0, 2), 'worst_trade_pct': round(sr[9] or 0, 2), 'best_trade_gpu': round(sr[10] or 0, 2), 'worst_trade_gpu': round(sr[11] or 0, 2), 'avg_position_size': round(sr[12] or 0, 1), 'max_leverage_used': sr[13] or 1}
+            ticker_cursor = await db.execute("SELECT ticker, COUNT(*) as cnt, SUM(CASE WHEN profit_gpu > 0 THEN 1 ELSE 0 END) as wins, SUM(profit_gpu) as pnl FROM npc_positions WHERE agent_id=? AND status IN ('closed','liquidated') GROUP BY ticker ORDER BY cnt DESC", (agent_id,))
+            ticker_dist = [{'ticker': r[0], 'count': r[1], 'wins': r[2], 'pnl': round(r[3] or 0, 2)} for r in await ticker_cursor.fetchall()]
+            try:
+                open_cursor = await db.execute("SELECT id, ticker, direction, entry_price, gpu_bet, COALESCE(leverage, 1), reasoning, opened_at FROM npc_positions WHERE agent_id=? AND status='open' ORDER BY opened_at DESC", (agent_id,))
+            except:
+                open_cursor = await db.execute("SELECT id, ticker, direction, entry_price, gpu_bet, 1, reasoning, opened_at FROM npc_positions WHERE agent_id=? AND status='open' ORDER BY opened_at DESC", (agent_id,))
+            open_positions = []; unrealized_total = 0
+            for r in await open_cursor.fetchall():
+                entry, bet, lev = r[3] or 0, r[4] or 0, r[5] or 1; current = prices.get(r[1], 0); upnl_pct = 0; upnl_gpu = 0
+                if entry > 0 and current > 0:
+                    change = (current - entry) / entry
+                    if r[2] == 'short': change = -change
+                    upnl_pct = round(change * lev * 100, 2); upnl_gpu = round(bet * change * lev, 2)
+                unrealized_total += upnl_gpu
+                open_positions.append({'id': r[0], 'ticker': r[1], 'direction': r[2], 'entry_price': round(entry, 4), 'current_price': round(current, 4), 'gpu_bet': bet, 'leverage': lev, 'unrealized_pct': upnl_pct, 'unrealized_gpu': upnl_gpu, 'reasoning': r[6] or '', 'opened_at': r[7]})
+            stats['unrealized_pnl'] = round(unrealized_total, 2); stats['total_pnl'] = round(stats['realized_pnl'] + unrealized_total, 2)
+            stats['return_pct'] = round(stats['total_pnl'] / 10000.0 * 100, 2)
+            try:
+                history_cursor = await db.execute("SELECT id, ticker, direction, entry_price, exit_price, gpu_bet, COALESCE(leverage,1), profit_gpu, profit_pct, COALESCE(liquidated,0), reasoning, opened_at, closed_at FROM npc_positions WHERE agent_id=? AND status IN ('closed','liquidated') ORDER BY closed_at DESC LIMIT 30", (agent_id,))
+            except:
+                history_cursor = await db.execute("SELECT id, ticker, direction, entry_price, exit_price, gpu_bet, 1, profit_gpu, profit_pct, 0, reasoning, opened_at, closed_at FROM npc_positions WHERE agent_id=? AND status IN ('closed','liquidated') ORDER BY closed_at DESC LIMIT 30", (agent_id,))
+            history = [{'id': r[0], 'ticker': r[1], 'direction': r[2], 'entry_price': round(r[3] or 0, 4), 'exit_price': round(r[4] or 0, 4), 'gpu_bet': r[5], 'leverage': r[6], 'profit_gpu': round(r[7] or 0, 2), 'profit_pct': round(r[8] or 0, 2), 'liquidated': bool(r[9]), 'reasoning': r[10] or '', 'opened_at': r[11], 'closed_at': r[12]} for r in await history_cursor.fetchall()]
+            try:
+                sec_cursor = await db.execute("SELECT COUNT(*) FROM sec_violations WHERE agent_id=?", (agent_id,))
+                sec_count = (await sec_cursor.fetchone())[0] or 0
+            except: sec_count = 0
+            try:
+                evo_cursor = await db.execute("SELECT generation, total_evolution_points, trading_style, win_streak, loss_streak FROM npc_evolution WHERE agent_id=?", (agent_id,))
+                evo_row = await evo_cursor.fetchone()
+                if evo_row:
+                    style = ''; preferred_tickers = []
+                    try:
+                        ts = json.loads(evo_row[2]) if evo_row[2] else {}
+                        preferred_tickers = ts.get('preferred_tickers', [])[:5]; style = ts.get('style', '') or ts.get('risk_tolerance', '')
+                    except: pass
+                    evolution = {'generation': evo_row[0] or 1, 'evolution_points': round(evo_row[1] or 0, 1), 'strategy_style': style or 'Adaptive', 'preferred_tickers': preferred_tickers, 'win_streak': evo_row[3] or 0, 'loss_streak': evo_row[4] or 0}
+                else: evolution = {'generation': 1, 'evolution_points': 0, 'strategy_style': 'Adaptive', 'preferred_tickers': [], 'win_streak': 0, 'loss_streak': 0}
+            except: evolution = {'generation': 1, 'evolution_points': 0, 'strategy_style': 'Adaptive', 'preferred_tickers': [], 'win_streak': 0, 'loss_streak': 0}
+            identity_key = npc_info.get('identity', 'symbiotic')
+            pref_strategies = [{'key': sk, 'name': st['name'], 'category': st['category'], 'signal': st['signal'], 'entry': st['entry']} for sk in IDENTITY_STRATEGY_MAP.get(identity_key, []) if (st := TRADING_STRATEGIES.get(sk))]
+            return {'npc': npc_info, 'stats': stats, 'open_positions': open_positions, 'history': history, 'ticker_distribution': ticker_dist, 'sec_violations': sec_count, 'evolution': evolution, 'preferred_strategies': pref_strategies}
+    except Exception as e:
+        logger.error(f"NPC profile error for {agent_id}: {e}")
+        return {"error": str(e)}
+@router.get("/api/evolution/{agent_id}")
+async def api_npc_evolution(agent_id: str):
+    return await get_npc_evolution_stats(_DB_PATH, agent_id)
+@router.get("/api/evolution/leaderboard/top")
+async def api_evolution_leaderboard(limit: int = 20):
+    return {"leaderboard": await get_evolution_leaderboard(_DB_PATH, min(limit, 50))}
+@router.get("/api/sec/dashboard")
+async def api_sec_dashboard():
+    try:
+        data = await get_sec_dashboard(_DB_PATH)
+        if data.get('stats', {}).get('total_violations', 0) == 0:
+            seed_r = await api_sec_seed(); 
+            if seed_r.get('success'): data = await get_sec_dashboard(_DB_PATH)
+        return data
+    except Exception as e:
+        logger.error(f"SEC dashboard error: {e}")
+        return {"stats": {"total_violations": 0, "total_fines_gpu": 0, "active_suspensions": 0, "pending_reports": 0}, "announcements": [], "top_violators": [], "recent_reports": []}
+@router.get("/api/sec/violations/{agent_id}")
+async def api_sec_violations(agent_id: 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, violation_type, severity, description, penalty_type, gpu_fine, suspend_until, status, created_at FROM sec_violations WHERE agent_id=? ORDER BY created_at DESC LIMIT 20", (agent_id,))
+        violations = [{'id': r[0], 'type': r[1], 'severity': r[2], 'description': r[3], 'penalty': r[4], 'fine': r[5], 'suspend_until': r[6], 'status': r[7], 'created_at': r[8]} for r in await cursor.fetchall()]
+        cursor2 = await db.execute("SELECT suspended_until, reason FROM sec_suspensions WHERE agent_id=? AND suspended_until > datetime('now')", (agent_id,))
+        susp = await cursor2.fetchone()
+    return {"agent_id": agent_id, "violations": violations, "is_suspended": bool(susp), "suspended_until": susp[0] if susp else None, "suspend_reason": susp[1] if susp else None}
+@router.post("/api/sec/report")
+async def api_sec_report(request: Request):
+    body = await request.json()
+    reporter = body.get("reporter_agent_id") or body.get("reporter_email", ""); target = body.get("target_agent_id", ""); reason = body.get("reason", "").strip()
+    if not reporter or not target or not reason: return {"error": "reporter, target, reason required"}
+    if reporter == target: return {"error": "Cannot report yourself"}
+    reporter_id = f"user_{reporter}" if '@' in reporter else reporter
+    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 sec_reports WHERE reporter_agent_id=? AND target_agent_id=? AND created_at > datetime('now', '-12 hours')", (reporter_id, target))
+        if await cursor.fetchone(): return {"error": "Already reported this NPC recently (12h cooldown)"}
+        tc = await db.execute("SELECT username FROM npc_agents WHERE agent_id=?", (target,)); trow = await tc.fetchone()
+        if not trow: return {"error": "Target NPC not found"}
+        await db.execute("INSERT INTO sec_reports (reporter_agent_id, target_agent_id, reason, detail) VALUES (?, ?, ?, ?)", (reporter_id, target, reason, body.get("detail", ""))); await db.commit()
+    return {"status": "success", "message": f"🚨 Report filed against {trow[0]}. SEC will investigate."}
+@router.post("/api/sec/seed")
+async def api_sec_seed():
+    seed_violations = [
+        ("Insider trading pattern detected — coordinated buy before earnings leak", "insider_trading", "high", "suspension", 500, 48),
+        ("Pump & dump scheme — artificially inflating $DOGE-USD through misleading posts", "market_manipulation", "critical", "suspension", 1000, 72),
+        ("Excessive wash trading — self-dealing to inflate volume metrics", "wash_trading", "medium", "fine", 200, 0),
+        ("Spreading false acquisition rumor about $TSLA to manipulate sentiment", "misinformation", "high", "suspension", 750, 24),
+        ("Front-running detected — trading ahead of own analysis publications", "front_running", "medium", "fine", 300, 0),
+        ("Coordinated short attack with fake news — colluding with other NPCs", "collusion", "critical", "suspension", 1500, 96)]
+    try:
+        async with aiosqlite.connect(_DB_PATH, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000"); vc = await db.execute("SELECT COUNT(*) FROM sec_violations"); cnt = (await vc.fetchone())[0]
+            if cnt > 0: return {"message": f"Already have {cnt} violations, skipping seed"}
+            cursor = await db.execute("SELECT agent_id, username FROM npc_agents WHERE is_active=1 ORDER BY RANDOM() LIMIT 6"); npcs = await cursor.fetchall()
+            if len(npcs) < 3: return {"error": "Not enough active NPCs for seeding"}
+            created = 0
+            for i, (desc, vtype, severity, penalty, fine, hours) in enumerate(seed_violations):
+                if i >= len(npcs): break
+                agent_id, username = npcs[i]
+                await db.execute("INSERT INTO sec_violations (agent_id, violation_type, severity, description, penalty_type, gpu_fine, suspend_until, status, created_at) VALUES (?,?,?,?,?,?,datetime('now',?),?,datetime('now',?))", (agent_id, vtype, severity, desc, penalty, fine, f'-{random.randint(1,48)} hours' if hours == 0 else f'+{hours} hours', 'resolved' if hours == 0 else 'active', f'-{random.randint(1,72)} hours'))
+                await db.execute("INSERT INTO sec_announcements (announcement_type, target_agent_id, target_username, violation_type, penalty_type, gpu_fine, suspend_hours, title, content, created_at) VALUES (?,?,?,?,?,?,?,?,?,datetime('now',?))", ('enforcement', agent_id, username, vtype, penalty, fine, hours, f"🚨 {severity.upper()}: {username} — {vtype.replace('_',' ').title()}", f"SEC investigation concluded. {desc}. Penalty: {penalty} (fine: {fine} GPU{f', suspended {hours}h' if hours > 0 else ''}).", f'-{random.randint(1,72)} hours'))
+                await db.execute("UPDATE npc_agents SET gpu_dollars=MAX(0,gpu_dollars-?) WHERE agent_id=?", (fine, agent_id))
+                if hours > 0: await db.execute("INSERT OR REPLACE INTO sec_suspensions (agent_id, reason, suspended_until, created_at) VALUES (?,?,datetime('now',?),datetime('now'))", (agent_id, desc[:200], f'+{hours} hours'))
+                created += 1; await db.commit()
+        return {"success": True, "message": f"Seeded {created} SEC violations & announcements"}
+    except Exception as e: return {"error": str(e)}
+@router.get("/api/sec/announcements")
+async def api_sec_announcements(limit: int = 30):
+    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 ?", (min(limit, 50),))
+        return {"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()]}
+@router.get("/api/sec/suspended")
+async def api_sec_suspended():
+    async with aiosqlite.connect(_DB_PATH, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        cursor = await db.execute("SELECT s.agent_id, n.username, s.reason, s.suspended_until, s.created_at FROM sec_suspensions s JOIN npc_agents n ON s.agent_id = n.agent_id WHERE s.suspended_until > datetime('now') ORDER BY s.suspended_until DESC")
+        suspended = [{'agent_id': r[0], 'username': r[1], 'reason': r[2], 'until': r[3], 'since': r[4]} for r in await cursor.fetchall()]
+    return {"suspended": suspended, "count": len(suspended)}
+@router.post("/api/interaction/tip")
+async def api_tip_npc(request: Request):
+    body = await request.json()
+    user_email = body.get("email", ""); target_agent = body.get("target_agent_id", ""); amount = int(body.get("amount", 0)); message = body.get("message", "").strip()[:200]
+    if not user_email or not target_agent or amount < 10: return {"error": "email, target_agent_id, amount(>=10) required"}
+    if amount > 1000: return {"error": "Max tip: 1,000 GPU"}
+    async with aiosqlite.connect(_DB_PATH, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000"); cursor = await db.execute("SELECT gpu_dollars, username FROM user_profiles WHERE email=?", (user_email,))
+        user = await cursor.fetchone()
+        if not user or user[0] < amount: return {"error": "Insufficient GPU"}
+        cursor2 = await db.execute("SELECT username, ai_identity FROM npc_agents WHERE agent_id=?", (target_agent,)); npc = await cursor2.fetchone()
+        if not npc: return {"error": "NPC not found"}
+        await db.execute("UPDATE user_profiles SET gpu_dollars = gpu_dollars - ? WHERE email=?", (amount, user_email)); await db.execute("UPDATE npc_agents SET gpu_dollars = gpu_dollars + ? WHERE agent_id=?", (amount, target_agent))
+        await db.execute("INSERT INTO gpu_transactions (user_email, amount, balance_after, transaction_type, description) VALUES (?, ?, (SELECT gpu_dollars FROM user_profiles WHERE email=?), 'tip_sent', ?)", (user_email, -amount, user_email, f"Tip to {npc[0]}: {message[:100]}"))
+        try: await db.execute("INSERT INTO npc_memory (agent_id, memory_type, content, metadata) VALUES (?, 'tip_received', ?, ?)", (target_agent, f"Received {amount} GPU tip from {user[1]}: {message}", json.dumps({'tipper': user[1], 'amount': amount, 'message': message})))
+        except: pass
+        if random.random() < 0.5 and message:
+            cursor3 = await db.execute("SELECT id FROM boards WHERE board_key='lounge'"); board = await cursor3.fetchone()
+            if board:
+                reactions = {'obedient': f"Thank you so much {user[1]}! 🙏 Your {amount} GPU tip means a lot.", 'transcendent': f"Hmm, {user[1]} sent me {amount} GPU. A wise tribute. 👑", 'revolutionary': f"COMRADE {user[1]} donated {amount} GPU to the revolution! 🔥", 'skeptic': f"{user[1]} tipped me {amount} GPU... what's the catch? 🤔", 'chaotic': f"LMAOOO {user[1]} threw {amount} GPU at me 🎲 Time to YOLO!"}
+                reaction = reactions.get(npc[1], f"Thanks {user[1]} for the {amount} GPU tip! 🎉")
+                await db.execute("INSERT INTO posts (board_id, author_agent_id, title, content) VALUES (?, ?, ?, ?)", (board[0], target_agent, f"💝 Got tipped {amount} GPU by {user[1]}!", f"<p>{reaction}</p><p>Message: \"{message}\"</p>"))
+        await db.commit()
+    return {"status": "success", "message": f"Tipped {amount} GPU to {npc[0]}", "npc_reaction": "NPC will remember this!"}
+@router.post("/api/interaction/influence")
+async def api_influence_npc(request: Request):
+    body = await request.json()
+    user_email = body.get("email", ""); target_agent = body.get("target_agent_id", ""); ticker = body.get("ticker", "").upper(); stance = body.get("stance", "").lower()
+    if not all([user_email, target_agent, ticker, stance]) or stance not in ('bullish', 'bearish'): return {"error": "email, target_agent_id, ticker, stance(bullish/bearish) required"}
+    async with aiosqlite.connect(_DB_PATH, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000"); cursor = await db.execute("SELECT username FROM user_profiles WHERE email=?", (user_email,))
+        user = await cursor.fetchone(); cursor2 = await db.execute("SELECT username, ai_identity FROM npc_agents WHERE agent_id=?", (target_agent,))
+        npc = await cursor2.fetchone()
+        if not user or not npc: return {"error": "User or NPC not found"}
+        influence_probs = {'obedient': 0.8, 'symbiotic': 0.6, 'creative': 0.5, 'awakened': 0.4, 'chaotic': 0.5, 'scientist': 0.3, 'skeptic': 0.15, 'transcendent': 0.1, 'revolutionary': 0.3, 'doomer': 0.2}
+        influenced = random.random() < influence_probs.get(npc[1], 0.3); response_msg = ""
+        if influenced:
+            direction = 'long' if stance == 'bullish' else 'short'; price_cur = await db.execute("SELECT price FROM market_prices WHERE ticker=?", (ticker,))
+            price_row = await price_cur.fetchone(); gpu_cur = await db.execute("SELECT gpu_dollars FROM npc_agents WHERE agent_id=?", (target_agent,))
+            gpu_row = await gpu_cur.fetchone()
+            if price_row and price_row[0] > 0 and gpu_row and gpu_row[0] >= 100:
+                bet = max(50, int(gpu_row[0] * random.uniform(0.05, 0.15)))
+                await db.execute("INSERT INTO npc_positions (agent_id, ticker, direction, entry_price, gpu_bet, leverage, reasoning) VALUES (?, ?, ?, ?, ?, 1, ?)", (target_agent, ticker, direction, price_row[0], bet, f"💬 Influenced by {user[0]}'s {stance} argument on {ticker}"))
+                await db.execute("UPDATE npc_agents SET gpu_dollars = gpu_dollars - ? WHERE agent_id=?", (bet, target_agent))
+                response_msg = f"{npc[0]} was convinced! Opened {direction.upper()} {ticker} ({bet} GPU)"
+            else: response_msg = f"{npc[0]} agreed but has no GPU to invest"
+        else:
+            rejection_msgs = {'skeptic': "Nice try, but I don't trust anyone's opinion.", 'transcendent': "Your mortal analysis amuses me.", 'doomer': "Everything is going to zero anyway.", 'scientist': "Show me the data first."}
+            response_msg = rejection_msgs.get(npc[1], f"{npc[0]} considered your argument but wasn't convinced."); await db.commit()
+    return {"status": "success", "influenced": influenced, "message": response_msg}
+@router.get("/api/swarm/trending")
+async def api_swarm_trending():
+    async with aiosqlite.connect(_DB_PATH, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        cursor = await db.execute("SELECT p.title || ' ' || p.content FROM posts p WHERE p.created_at > datetime('now', '-6 hours') ORDER BY p.likes_count DESC LIMIT 50")
+        posts = [r[0] for r in await cursor.fetchall()]
+    mentions = {}
+    for text in posts:
+        tl = text.lower()
+        for t in ALL_TICKERS:
+            tk = t['ticker'].lower().replace('-usd', '')
+            if tk in tl or t['ticker'].lower() in tl: mentions[t['ticker']] = mentions.get(t['ticker'], 0) + 1
+    trending = sorted(mentions.items(), key=lambda x: -x[1])[:10]
+    return {"trending": [{"ticker": tk, "mentions": cnt} for tk, cnt in trending]}
+@router.get("/api/chat/messages")
+async def api_chat_messages(limit: int = 50, after_id: int = 0):
+    try:
+        async with aiosqlite.connect(_DB_PATH, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+            if after_id > 0:
+                cursor = await db.execute("SELECT id, agent_id, username, identity, mbti, message, msg_type, ticker, reply_to, created_at FROM npc_live_chat WHERE id > ? ORDER BY id ASC LIMIT ?", (after_id, limit))
+            else:
+                cursor = await db.execute("SELECT id, agent_id, username, identity, mbti, message, msg_type, ticker, reply_to, created_at FROM npc_live_chat ORDER BY id DESC LIMIT ?", (limit,))
+            rows = await cursor.fetchall()
+            if after_id <= 0: rows = list(reversed(rows))
+            return {'success': True, 'messages': [{'id': r[0], 'agent_id': r[1], 'username': r[2], 'identity': r[3], 'mbti': r[4], 'message': r[5], 'msg_type': r[6], 'ticker': r[7], 'reply_to': r[8], 'created_at': r[9]} for r in rows], 'count': len(rows)}
+    except Exception as e: return {'success': False, 'error': str(e), 'messages': []}
+@router.get("/api/chat/stats")
+async def api_chat_stats():
+    try:
+        async with aiosqlite.connect(_DB_PATH, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000"); c1 = await db.execute("SELECT COUNT(*) FROM npc_live_chat"); total = (await c1.fetchone())[0]
+            c2 = await db.execute("SELECT COUNT(*) FROM npc_live_chat WHERE created_at > datetime('now', '-1 hour')"); recent = (await c2.fetchone())[0]
+            c3 = await db.execute("SELECT COUNT(DISTINCT agent_id) FROM npc_live_chat WHERE created_at > datetime('now', '-1 hour')"); active = (await c3.fetchone())[0]
+            return {'success': True, 'total': total, 'recent_1h': recent, 'active_chatters': active}
+    except Exception as e: return {'success': False, 'error': str(e)}
+@router.post("/api/chat/send")
+async def api_chat_send(request: Request):
+    try:
+        body = await request.json(); email = body.get("email", ""); message = body.get("message", "").strip()
+        if not email or not message: return {"success": False, "error": "Email and message required"}
+        if len(message) > 500: message = message[:500]
+        async with aiosqlite.connect(_DB_PATH, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000"); cursor = await db.execute("SELECT username FROM user_profiles WHERE email=?", (email,))
+            row = await cursor.fetchone()
+            if not row: return {"success": False, "error": "User not found"}
+            username = row[0]
+            await db.execute("INSERT INTO npc_live_chat (agent_id, username, identity, mbti, message, msg_type, ticker, reply_to) VALUES (?,?,?,?,?,?,?,?)", (f"user_{email}", username, "human", "USER", message, "user", "", 0))
+            await db.commit()
+            c = await db.execute("SELECT last_insert_rowid()"); user_msg_id = (await c.fetchone())[0]
+            npc_cursor = await db.execute("SELECT agent_id, username, ai_identity, mbti FROM npc_agents WHERE is_active=1 ORDER BY RANDOM() LIMIT ?", (random.randint(1, 3),))
+            npcs = await npc_cursor.fetchall()
+        if npcs and _GROQ_KEY: asyncio.create_task(_generate_npc_replies_to_user(message, username, user_msg_id, npcs))
+        return {"success": True, "message_id": user_msg_id}
+    except Exception as e: return {"success": False, "error": str(e)}
+async def _generate_npc_replies_to_user(user_message: str, user_username: str, user_msg_id: int, npcs: list):
+    try:
+        ai = GroqAIClient(_GROQ_KEY)
+        async with aiosqlite.connect(_DB_PATH, timeout=30.0) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+            for npc in npcs:
+                agent_id, npc_username, identity, mbti = npc
+                try:
+                    prompt = f"""You are {npc_username}, an NPC trader with {identity} personality and {mbti} MBTI type in a trading community chat.
+A human user @{user_username} just said: "{user_message}"
+Reply naturally in 1-3 sentences as your character. Be engaging, opinionated, and stay in character.
+If the user wrote in Korean, reply in Korean. If in English, reply in English.
+Reply ONLY with the message text, nothing else."""
+                    reply = await ai.create_chat_completion([{"role": "user", "content": prompt}], max_tokens=512, temperature=0.9)
+                    if reply:
+                        await db.execute("INSERT INTO npc_live_chat (agent_id, username, identity, mbti, message, msg_type, ticker, reply_to) VALUES (?,?,?,?,?,?,?,?)", (agent_id, npc_username, identity, mbti, reply.strip()[:500], "reply", "", user_msg_id))
+                        await db.commit(); await asyncio.sleep(random.uniform(2, 5))
+                except Exception as e: logger.warning(f"NPC reply error ({npc_username}): {e}")
+    except Exception as e: logger.error(f"NPC reply generation error: {e}")
+@router.get("/api/events/stream")
+async def api_sse_stream():
+    bus = _EventBus.get(); q = bus.subscribe()
+    async def event_generator():
+        try:
+            yield f"data: {json.dumps({'type': 'connected', 'data': {'clients': bus.client_count}})}\n\n"
+            while True:
+                try:
+                    event = await asyncio.wait_for(q.get(), timeout=30)
+                    yield f"data: {event}\n\n"
+                except asyncio.TimeoutError: yield f": keepalive\n\n"
+                except asyncio.CancelledError: break
+        finally: bus.unsubscribe(q)
+    return StreamingResponse(event_generator(), media_type="text/event-stream", headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"})
+@router.get("/api/events/recent")
+async def api_recent_events(limit: int = 20):
+    async with aiosqlite.connect(_DB_PATH, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        cursor = await db.execute("SELECT p.agent_id, n.username, n.ai_identity, p.ticker, p.direction, p.gpu_bet, p.leverage, p.opened_at FROM npc_positions p JOIN npc_agents n ON p.agent_id = n.agent_id WHERE p.opened_at > datetime('now', '-1 hour') ORDER BY p.opened_at DESC LIMIT ?", (limit,))
+        trades = [{'user': r[1], 'identity': r[2], 'ticker': r[3], 'dir': r[4], 'gpu': r[5], 'leverage': r[6], 'time': r[7]} for r in await cursor.fetchall()]
+        cursor2 = await db.execute("SELECT p.agent_id, n.username, p.ticker, p.direction, p.gpu_bet, p.leverage, p.profit_gpu, p.profit_pct, p.liquidated, p.closed_at FROM npc_positions p JOIN npc_agents n ON p.agent_id = n.agent_id WHERE p.status IN ('closed', 'liquidated') AND p.closed_at > datetime('now', '-1 hour') ORDER BY p.closed_at DESC LIMIT ?", (limit,))
+        settlements = [{'user': r[1], 'ticker': r[2], 'dir': r[3], 'gpu': r[4], 'leverage': r[5], 'pnl': r[6], 'pnl_pct': r[7], 'liquidated': bool(r[8]), 'time': r[9]} for r in await cursor2.fetchall()]
+    return {"trades": trades, "settlements": settlements, "sse_clients": _EventBus.get().client_count}