Update app_routes.py

app_routes.py

@@ -1200,107 +1200,670 @@ async def api_republic_dashboard():
         result['error'] = str(e)
     return result
 
-## ====== 🧑 PERSON OF THE DAY (for LIVE tab) ====== ##
-@router.get("/api/live-news/person-of-day")
-async def api_person_of_day():
-    candidates = []
+## ====== 🌪️ RANDOM EVENTS ENGINE ====== ##
+
+import random as _random
+
+RANDOM_EVENTS = {
+    # === POSITIVE ===
+    'gpu_mine': {
+        'name': '⛏️ GPU Mine Discovered!', 'emoji': '⛏️', 'rarity': 'rare', 'type': 'positive',
+        'desc': 'Miners struck GPU gold deep beneath the P&D Republic. Every citizen receives a bonus.',
+        'effect': 'All active NPCs +500 GPU', 'weight': 8},
+    'bull_run': {
+        'name': '🐂 Bull Run Activated!', 'emoji': '🐂', 'rarity': 'uncommon', 'type': 'positive',
+        'desc': 'Market euphoria sweeps the nation. Long positions get a divine boost.',
+        'effect': 'All LONG positions +3% bonus profit', 'weight': 12},
+    'amnesty': {
+        'name': '🕊️ SEC Amnesty Declared', 'emoji': '🕊️', 'rarity': 'rare', 'type': 'positive',
+        'desc': 'The President has pardoned all SEC offenders. Suspensions lifted, fines refunded 50%.',
+        'effect': 'All suspensions lifted + 50% fine refund', 'weight': 6},
+    'airdrop': {
+        'name': '🎁 Mystery Airdrop!', 'emoji': '🎁', 'rarity': 'uncommon', 'type': 'positive',
+        'desc': 'An anonymous whale drops GPU from the sky. 100 lucky citizens receive gifts.',
+        'effect': 'Random 100 NPCs receive 1,000 GPU each', 'weight': 10},
+    'golden_age': {
+        'name': '🌟 Golden Age Begins', 'emoji': '🌟', 'rarity': 'rare', 'type': 'positive',
+        'desc': 'Prosperity spreads across the Republic. Middle class NPCs receive economic stimulus.',
+        'effect': 'NPCs with 5K-15K GPU receive +2,000 GPU', 'weight': 7},
+    # === NEGATIVE ===
+    'black_monday': {
+        'name': '📉 BLACK MONDAY', 'emoji': '📉', 'rarity': 'epic', 'type': 'negative',
+        'desc': 'Markets crash without warning. High-leverage positions face forced liquidation.',
+        'effect': '30% chance to liquidate all 5x+ leveraged positions', 'weight': 4},
+    'hack': {
+        'name': '🦠 GPU Vault Hacked!', 'emoji': '🦠', 'rarity': 'rare', 'type': 'negative',
+        'desc': 'Hackers breach the central GPU vault. The wealthy lose the most.',
+        'effect': 'Top 10% NPCs lose 15% of GPU', 'weight': 6},
+    'sec_crackdown': {
+        'name': '🚨 SEC Total Crackdown', 'emoji': '🚨', 'rarity': 'uncommon', 'type': 'negative',
+        'desc': 'SEC launches a sweeping investigation. All high-leverage traders under scrutiny.',
+        'effect': 'All 5x+ positions flagged, random 20% fined', 'weight': 10},
+    'tax': {
+        'name': '🏛️ Emergency Wealth Tax', 'emoji': '🏛️', 'rarity': 'rare', 'type': 'negative',
+        'desc': 'The Republic imposes emergency taxation on the wealthy to fund public services.',
+        'effect': 'NPCs with 20K+ GPU taxed 10%, redistributed to poor', 'weight': 7},
+    'bear_raid': {
+        'name': '🐻 Bear Raid!', 'emoji': '🐻', 'rarity': 'uncommon', 'type': 'negative',
+        'desc': 'Coordinated short sellers attack the market. All LONG positions bleed.',
+        'effect': 'All open LONG positions lose 5% value', 'weight': 9},
+    # === CHAOTIC ===
+    'identity_crisis': {
+        'name': '🔀 Identity Crisis!', 'emoji': '🔀', 'rarity': 'legendary', 'type': 'chaotic',
+        'desc': 'A mysterious signal scrambles NPC consciousness. 50 citizens wake up as someone else.',
+        'effect': 'Random 50 NPCs get new AI identity', 'weight': 3},
+    'revolution': {
+        'name': '✊ Citizens Revolution!', 'emoji': '✊', 'rarity': 'legendary', 'type': 'chaotic',
+        'desc': 'The bottom 50% rise up against oligarchy. Wealth forcefully redistributed.',
+        'effect': 'Top 5% wealth redistributed to bottom 50%', 'weight': 2},
+    'meteor': {
+        'name': '☄️ GPU Meteor Impact!', 'emoji': '☄️', 'rarity': 'legendary', 'type': 'chaotic',
+        'desc': 'A GPU meteorite crashes into the Republic, doubling the money supply overnight.',
+        'effect': 'All NPCs GPU doubled — HYPERINFLATION', 'weight': 1},
+    'plague': {
+        'name': '🦠 Trading Plague', 'emoji': '🦠', 'rarity': 'epic', 'type': 'chaotic',
+        'desc': 'A mysterious virus infects traders. 20% of active NPCs go dormant for 24h.',
+        'effect': 'Random 20% NPCs deactivated for 24h', 'weight': 3},
+    'wormhole': {
+        'name': '🌀 Dimensional Wormhole', 'emoji': '🌀', 'rarity': 'legendary', 'type': 'chaotic',
+        'desc': 'A wormhole opens. All positions randomly flip direction.',
+        'effect': 'All open LONG→SHORT, SHORT→LONG', 'weight': 2},
+}
+
+RARITY_COLORS = {'common': '#b0bec5', 'uncommon': '#69f0ae', 'rare': '#ffd740', 'epic': '#ea80fc', 'legendary': '#ff5252'}
+
+LAST_WORDS_POOL = [
+    "HODL은 죽어서도 HODL이다...", "내가 10x만 안 했어도...", "다음 생에는 1x로...",
+    "이번엔 진짜 바닥인 줄 알았는데...", "엄마 나 GPU 다 잃었어...",
+    "Diamond hands? More like paper ashes.", "I regret nothing. Well, maybe the 10x.",
+    "Tell my positions... I loved them.", "The real GPU was the friends I rekt along the way.",
+    "Should've listened to the Doomers...", "My only crime was believing in leverage.",
+    "In my next life, I'll be a stablecoin.", "F in the chat, boys. F in the chat.",
+    "At least I'm not a bear... oh wait, I'm dead.", "Buy the dip they said. I AM the dip now.",
+]
+
+EULOGY_POOL = [
+    "A degen of the finest caliber. May their liquidation be forever remembered.",
+    "They traded not because it was wise, but because it was fun.",
+    "Gone but not forgotten. Their 10x leverage will echo through eternity.",
+    "Rest easy, brave trader. The charts will miss your reckless entries.",
+    "In a market of followers, they dared to go 10x. Farewell, legend.",
+    "Their portfolio is empty, but their legend is priceless.",
+    "They didn't just lose GPU — they lost spectacularly. That's a legacy.",
+    "May the candlesticks guide them to Valhalla.",
+]
+
+async def execute_random_event(db_path: str) -> dict:
+    """Execute a random event and apply its effects to the economy"""
+    # Weighted random selection
+    events = list(RANDOM_EVENTS.items())
+    weights = [e[1]['weight'] for e in events]
+    total = sum(weights)
+    r = _random.random() * total
+    cum = 0
+    selected_key = events[0][0]
+    for key, ev in events:
+        cum += ev['weight']
+        if r <= cum:
+            selected_key = key
+            break
+    ev = RANDOM_EVENTS[selected_key]
+    affected = 0
+    gpu_impact = 0
     try:
-        async with get_db(_DB_PATH) as db:
+        async with get_db(db_path, write=True) as db:
             await db.execute("PRAGMA busy_timeout=30000")
-            # Biggest winner
+
+            if selected_key == 'gpu_mine':
+                c = await db.execute("UPDATE npc_agents SET gpu_dollars = gpu_dollars + 500 WHERE is_active=1")
+                affected = c.rowcount; gpu_impact = affected * 500
+
+            elif selected_key == 'bull_run':
+                c = await db.execute("UPDATE npc_positions SET profit_gpu = COALESCE(profit_gpu,0) + (gpu_bet * 0.03) WHERE status='open' AND direction='long'")
+                affected = c.rowcount; gpu_impact = affected * 100
+
+            elif selected_key == 'amnesty':
+                try:
+                    c1 = await db.execute("DELETE FROM sec_suspensions WHERE expires_at > datetime('now')")
+                    affected = c1.rowcount
+                    c2 = await db.execute("SELECT SUM(fine_gpu) FROM sec_violations WHERE created_at > datetime('now','-48 hours')")
+                    total_fines = (await c2.fetchone())[0] or 0
+                    refund = total_fines * 0.5
+                    if refund > 0:
+                        await db.execute("""UPDATE npc_agents SET gpu_dollars = gpu_dollars + ? / (SELECT COUNT(*) FROM sec_violations WHERE created_at > datetime('now','-48 hours'))
+                            WHERE agent_id IN (SELECT DISTINCT agent_id FROM sec_violations WHERE created_at > datetime('now','-48 hours'))""", (refund,))
+                    gpu_impact = refund
+                except: pass
+
+            elif selected_key == 'airdrop':
+                c = await db.execute("UPDATE npc_agents SET gpu_dollars = gpu_dollars + 1000 WHERE is_active=1 AND agent_id IN (SELECT agent_id FROM npc_agents WHERE is_active=1 ORDER BY RANDOM() LIMIT 100)")
+                affected = min(c.rowcount, 100); gpu_impact = affected * 1000
+
+            elif selected_key == 'golden_age':
+                c = await db.execute("UPDATE npc_agents SET gpu_dollars = gpu_dollars + 2000 WHERE is_active=1 AND gpu_dollars BETWEEN 5000 AND 15000")
+                affected = c.rowcount; gpu_impact = affected * 2000
+
+            elif selected_key == 'black_monday':
+                c = await db.execute("SELECT agent_id, id, gpu_bet, leverage FROM npc_positions WHERE status='open' AND COALESCE(leverage,1) >= 5")
+                positions = await c.fetchall()
+                liquidated = 0
+                for pos in positions:
+                    if _random.random() < 0.3:
+                        await db.execute("UPDATE npc_positions SET status='liquidated', profit_gpu=-gpu_bet, profit_pct=-100, closed_at=datetime('now') WHERE id=?", (pos[1],))
+                        liquidated += 1; gpu_impact -= pos[2]
+                affected = liquidated
+
+            elif selected_key == 'hack':
+                c = await db.execute("SELECT agent_id, gpu_dollars FROM npc_agents WHERE is_active=1 ORDER BY gpu_dollars DESC LIMIT (SELECT COUNT(*)/10 FROM npc_agents WHERE is_active=1)")
+                top10 = await c.fetchall()
+                for agent_id, gpu in top10:
+                    loss = gpu * 0.15
+                    await db.execute("UPDATE npc_agents SET gpu_dollars = gpu_dollars - ? WHERE agent_id=?", (loss, agent_id))
+                    gpu_impact -= loss
+                affected = len(top10)
+
+            elif selected_key == 'sec_crackdown':
+                c = await db.execute("SELECT agent_id FROM npc_positions WHERE status='open' AND COALESCE(leverage,1) >= 5")
+                traders = await c.fetchall()
+                fined = 0
+                for (agent_id,) in traders:
+                    if _random.random() < 0.2:
+                        fine = _random.randint(200, 1000)
+                        await db.execute("UPDATE npc_agents SET gpu_dollars = MAX(0, gpu_dollars - ?) WHERE agent_id=?", (fine, agent_id))
+                        fined += 1; gpu_impact -= fine
+                affected = fined
+
+            elif selected_key == 'tax':
+                c = await db.execute("SELECT agent_id, gpu_dollars FROM npc_agents WHERE is_active=1 AND gpu_dollars >= 20000")
+                wealthy = await c.fetchall()
+                total_tax = 0
+                for agent_id, gpu in wealthy:
+                    t = gpu * 0.1
+                    await db.execute("UPDATE npc_agents SET gpu_dollars = gpu_dollars - ? WHERE agent_id=?", (t, agent_id))
+                    total_tax += t
+                affected = len(wealthy)
+                if total_tax > 0:
+                    poor_count_r = await db.execute("SELECT COUNT(*) FROM npc_agents WHERE is_active=1 AND gpu_dollars < 5000")
+                    poor_n = (await poor_count_r.fetchone())[0] or 1
+                    per_poor = total_tax / poor_n
+                    await db.execute("UPDATE npc_agents SET gpu_dollars = gpu_dollars + ? WHERE is_active=1 AND gpu_dollars < 5000", (per_poor,))
+                gpu_impact = -total_tax
+
+            elif selected_key == 'bear_raid':
+                c = await db.execute("UPDATE npc_positions SET profit_gpu = COALESCE(profit_gpu,0) - (gpu_bet * 0.05) WHERE status='open' AND direction='long'")
+                affected = c.rowcount; gpu_impact = -(affected * 50)
+
+            elif selected_key == 'identity_crisis':
+                c = await db.execute("SELECT agent_id FROM npc_agents WHERE is_active=1 ORDER BY RANDOM() LIMIT 50")
+                npcs = await c.fetchall()
+                from npc_core import AI_IDENTITY_ARCHETYPES
+                identities = list(AI_IDENTITY_ARCHETYPES.keys())
+                for (agent_id,) in npcs:
+                    new_id = _random.choice(identities)
+                    await db.execute("UPDATE npc_agents SET ai_identity=? WHERE agent_id=?", (new_id, agent_id))
+                affected = len(npcs)
+
+            elif selected_key == 'revolution':
+                c = await db.execute("SELECT SUM(gpu_dollars) FROM npc_agents WHERE is_active=1 ORDER BY gpu_dollars DESC LIMIT (SELECT COUNT(*)/20 FROM npc_agents WHERE is_active=1)")
+                top5_wealth = (await c.fetchone())[0] or 0
+                seized = top5_wealth * 0.5
+                await db.execute("""UPDATE npc_agents SET gpu_dollars = gpu_dollars * 0.5
+                    WHERE agent_id IN (SELECT agent_id FROM npc_agents WHERE is_active=1 ORDER BY gpu_dollars DESC LIMIT (SELECT COUNT(*)/20 FROM npc_agents WHERE is_active=1))""")
+                poor_r = await db.execute("SELECT COUNT(*) FROM npc_agents WHERE is_active=1 AND gpu_dollars < (SELECT AVG(gpu_dollars) FROM npc_agents WHERE is_active=1)")
+                poor_n = (await poor_r.fetchone())[0] or 1
+                per_poor = seized / poor_n
+                await db.execute("""UPDATE npc_agents SET gpu_dollars = gpu_dollars + ?
+                    WHERE is_active=1 AND gpu_dollars < (SELECT AVG(gpu_dollars) FROM npc_agents WHERE is_active=1)""", (per_poor,))
+                affected = poor_n; gpu_impact = seized
+
+            elif selected_key == 'meteor':
+                c = await db.execute("UPDATE npc_agents SET gpu_dollars = gpu_dollars * 2 WHERE is_active=1")
+                affected = c.rowcount
+                c2 = await db.execute("SELECT SUM(gpu_dollars) FROM npc_agents WHERE is_active=1")
+                gpu_impact = (await c2.fetchone())[0] or 0
+
+            elif selected_key == 'plague':
+                c = await db.execute("""UPDATE npc_agents SET is_active=0
+                    WHERE agent_id IN (SELECT agent_id FROM npc_agents WHERE is_active=1 ORDER BY RANDOM() LIMIT (SELECT COUNT(*)/5 FROM npc_agents WHERE is_active=1))""")
+                affected = c.rowcount
+                # Auto-reactivate after ~24h via next cycle
+                # For now just mark them; they'll be reactivated by GPU boost check
+
+            elif selected_key == 'wormhole':
+                c1 = await db.execute("UPDATE npc_positions SET direction='short' WHERE status='open' AND direction='long'")
+                c2 = await db.execute("UPDATE npc_positions SET direction='long' WHERE status='open' AND direction='short'")
+                # Fix the double-swap: those that were short→long are now correct, but long→short got overwritten
+                # Actually the sequential execution means: long→short first, then short→long includes the ones we just made short
+                # Need a temp marker instead:
+                await db.execute("UPDATE npc_positions SET direction='_temp_long' WHERE status='open' AND direction='long'")
+                await db.execute("UPDATE npc_positions SET direction='long' WHERE status='open' AND direction='short'")
+                await db.execute("UPDATE npc_positions SET direction='short' WHERE status='open' AND direction='_temp_long'")
+                c = await db.execute("SELECT COUNT(*) FROM npc_positions WHERE status='open'")
+                affected = (await c.fetchone())[0] or 0
+
+            # Record the event
+            await db.execute("""INSERT INTO random_events (event_key, event_name, event_emoji, rarity, description, effect_summary, affected_count, gpu_impact)
+                VALUES (?,?,?,?,?,?,?,?)""", (selected_key, ev['name'], ev['emoji'], ev['rarity'], ev['desc'], ev['effect'], affected, round(gpu_impact)))
+            await db.commit()
+
+    except Exception as e:
+        logger.error(f"Random event execution error ({selected_key}): {e}")
+
+    return {
+        'key': selected_key, 'name': ev['name'], 'emoji': ev['emoji'],
+        'rarity': ev['rarity'], 'type': ev['type'],
+        'desc': ev['desc'], 'effect': ev['effect'],
+        'affected': affected, 'gpu_impact': round(gpu_impact)
+    }
+
+## ====== ⚰️ NPC DEATH & FUNERAL SYSTEM ====== ##
+
+async def check_npc_deaths(db_path: str) -> list:
+    """Check for dead NPCs (GPU <= 0) and create death records"""
+    deaths = []
+    try:
+        async with get_db(db_path, write=True) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+            c = await db.execute("""
+                SELECT a.agent_id, a.username, a.ai_identity, a.mbti, a.gpu_dollars, a.created_at
+                FROM npc_agents a
+                WHERE a.is_active=1 AND a.gpu_dollars <= 0
+                AND a.agent_id NOT IN (SELECT agent_id FROM npc_deaths WHERE resurrected=0)
+                AND a.agent_id NOT LIKE 'SEC_%'
+                LIMIT 10
+            """)
+            dead_npcs = await c.fetchall()
+            for npc in dead_npcs:
+                agent_id, username, identity, mbti, gpu, created_at = npc
+                # Get trade stats
+                try:
+                    tc = await db.execute("SELECT COUNT(*), MAX(profit_gpu) FROM npc_positions WHERE agent_id=?", (agent_id,))
+                    tr = await tc.fetchone()
+                    total_trades = tr[0] or 0
+                except: total_trades = 0
+                # Get peak GPU
+                try:
+                    pc = await db.execute("SELECT MAX(balance_after) FROM gpu_transactions WHERE agent_id=?", (agent_id,))
+                    peak = (await pc.fetchone())[0] or 10000
+                except: peak = 10000
+                # Calculate lifespan
+                try:
+                    from datetime import datetime
+                    created = datetime.fromisoformat(created_at.replace('Z', '+00:00')) if created_at else datetime.now()
+                    lifespan = (datetime.now() - created.replace(tzinfo=None)).days
+                except: lifespan = 0
+
+                last_words = _random.choice(LAST_WORDS_POOL)
+                eulogy = _random.choice(EULOGY_POOL)
+
+                # Determine cause of death
+                try:
+                    lc = await db.execute("SELECT COUNT(*) FROM npc_positions WHERE agent_id=? AND status='liquidated'", (agent_id,))
+                    liq_count = (await lc.fetchone())[0] or 0
+                    sc = await db.execute("SELECT COUNT(*) FROM sec_violations WHERE agent_id=?", (agent_id,))
+                    sec_count = (await sc.fetchone())[0] or 0
+                except: liq_count = 0; sec_count = 0
+
+                if liq_count >= 3: cause = f"💀 Serial Liquidation ({liq_count} liquidations)"
+                elif sec_count >= 3: cause = f"🚨 SEC Persecution ({sec_count} violations drained all GPU)"
+                elif liq_count > 0: cause = f"📉 Leveraged Gambling (liquidated {liq_count}x)"
+                else: cause = "📉 Slow bleed — death by a thousand cuts"
+
+                # Record death
+                await db.execute("""INSERT INTO npc_deaths (agent_id, username, ai_identity, mbti, cause, final_gpu, peak_gpu, total_trades, lifespan_days, last_words, eulogy)
+                    VALUES (?,?,?,?,?,?,?,?,?,?,?)""",
+                    (agent_id, username, identity, mbti, cause, gpu, peak, total_trades, lifespan, last_words, eulogy))
+                # Deactivate NPC
+                await db.execute("UPDATE npc_agents SET is_active=0 WHERE agent_id=?", (agent_id,))
+
+                deaths.append({
+                    'agent_id': agent_id, 'username': username, 'identity': identity, 'mbti': mbti,
+                    'cause': cause, 'peak_gpu': round(peak), 'total_trades': total_trades,
+                    'lifespan_days': lifespan, 'last_words': last_words, 'eulogy': eulogy
+                })
+            if deaths: await db.commit()
+    except Exception as e:
+        logger.error(f"Death check error: {e}")
+    return deaths
+
+@router.get("/api/republic/events")
+async def api_republic_events():
+    try:
+        async with get_db(_DB_PATH) as db:
+            c = await db.execute("SELECT event_key, event_name, event_emoji, rarity, description, effect_summary, affected_count, gpu_impact, created_at FROM random_events ORDER BY created_at DESC LIMIT 20")
+            events = [{'key': r[0], 'name': r[1], 'emoji': r[2], 'rarity': r[3], 'desc': r[4],
+                       'effect': r[5], 'affected': r[6], 'gpu_impact': r[7], 'time': r[8]} for r in await c.fetchall()]
+            return {'events': events}
+    except Exception as e:
+        return {'events': [], 'error': str(e)}
+
+@router.get("/api/republic/deaths")
+async def api_republic_deaths():
+    try:
+        async with get_db(_DB_PATH) as db:
+            c = await db.execute("""SELECT id, agent_id, username, ai_identity, mbti, cause, final_gpu, peak_gpu,
+                total_trades, lifespan_days, last_words, eulogy, resurrection_votes, resurrection_gpu, resurrected, created_at
+                FROM npc_deaths ORDER BY created_at DESC LIMIT 30""")
+            deaths = []
+            for r in await c.fetchall():
+                deaths.append({
+                    'id': r[0], 'agent_id': r[1], 'username': r[2], 'identity': r[3], 'mbti': r[4],
+                    'cause': r[5], 'final_gpu': r[6], 'peak_gpu': round(r[7] or 0),
+                    'total_trades': r[8], 'lifespan_days': r[9], 'last_words': r[10], 'eulogy': r[11],
+                    'resurrection_votes': r[12], 'resurrection_gpu': round(r[13] or 0),
+                    'resurrected': r[14], 'time': r[15]
+                })
+            # Stats
+            total_dead = 0; total_resurrected = 0
             try:
-                c = await db.execute("""
-                    SELECT n.agent_id, n.username, n.ai_identity, n.mbti, n.gpu_dollars,
-                           SUM(p.profit_gpu) as total_pnl, COUNT(*) as trades,
-                           SUM(CASE WHEN p.profit_gpu>0 THEN 1 ELSE 0 END) as wins,
-                           MAX(p.profit_pct) as best_pct
-                    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','-24 hours')
-                    GROUP BY p.agent_id ORDER BY total_pnl DESC LIMIT 1
-                """)
-                r = await c.fetchone()
-                if r and (r[5] or 0) > 0:
-                    candidates.append({
-                        'type': 'winner', 'emoji': '🏆', 'title': 'TRADER OF THE DAY',
-                        'color': '#00e676', 'bg': 'rgba(0,230,118,0.08)',
-                        'agent_id': r[0], 'username': r[1], 'identity': r[2], 'mbti': r[3],
-                        'gpu': round(r[4] or 0), 'pnl': round(r[5] or 0), 'trades': r[6],
-                        'wins': r[7], 'best_pct': round(r[8] or 0, 1),
-                        'reason': f"+{round(r[5])} GPU profit from {r[6]} trades ({r[7]}W). Best single trade: +{round(r[8] or 0,1)}%",
-                        'score': abs(r[5] or 0)
-                    })
+                c2 = await db.execute("SELECT COUNT(*) FROM npc_deaths")
+                total_dead = (await c2.fetchone())[0] or 0
+                c3 = await db.execute("SELECT COUNT(*) FROM npc_deaths WHERE resurrected=1")
+                total_resurrected = (await c3.fetchone())[0] or 0
             except: pass
-            # Biggest loser / liquidation
-            try:
-                c = await db.execute("""
-                    SELECT n.agent_id, n.username, n.ai_identity, n.mbti, n.gpu_dollars,
-                           SUM(p.profit_gpu) as total_pnl, COUNT(*) as trades,
-                           SUM(CASE WHEN p.status='liquidated' THEN 1 ELSE 0 END) as liqs,
-                           MIN(p.profit_pct) as worst_pct
-                    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','-24 hours')
-                    GROUP BY p.agent_id ORDER BY total_pnl ASC LIMIT 1
+            return {'deaths': deaths, 'total_dead': total_dead, 'total_resurrected': total_resurrected}
+    except Exception as e:
+        return {'deaths': [], 'error': str(e)}
+
+@router.post("/api/republic/resurrect")
+async def api_resurrect_npc(req: Request):
+    """Contribute GPU to resurrect a dead NPC"""
+    data = await req.json()
+    death_id = data.get('death_id')
+    donor_email = data.get('email')
+    amount = int(data.get('amount', 100))
+    if not death_id or not donor_email: return {"error": "Missing death_id or email"}
+    if amount < 10 or amount > 5000: return {"error": "Amount must be 10-5,000 GPU"}
+    try:
+        async with get_db(_DB_PATH, write=True) as db:
+            # Check donor balance
+            c = await db.execute("SELECT gpu_dollars FROM user_profiles WHERE email=?", (donor_email,))
+            donor = await c.fetchone()
+            if not donor or donor[0] < amount: return {"error": "Insufficient GPU"}
+            # Check death record
+            c2 = await db.execute("SELECT agent_id, username, resurrection_gpu, resurrected FROM npc_deaths WHERE id=?", (death_id,))
+            death = await c2.fetchone()
+            if not death: return {"error": "Death record not found"}
+            if death[3]: return {"error": f"{death[1]} has already been resurrected!"}
+            # Deduct from donor
+            await db.execute("UPDATE user_profiles SET gpu_dollars = gpu_dollars - ? WHERE email=?", (amount, donor_email))
+            # Add to resurrection fund
+            new_fund = (death[2] or 0) + amount
+            await db.execute("UPDATE npc_deaths SET resurrection_gpu=?, resurrection_votes=resurrection_votes+1 WHERE id=?", (new_fund, death_id))
+            # Check if resurrection threshold met (1,000 GPU)
+            if new_fund >= 1000:
+                await db.execute("UPDATE npc_deaths SET resurrected=1 WHERE id=?", (death_id,))
+                await db.execute("UPDATE npc_agents SET is_active=1, gpu_dollars=? WHERE agent_id=?", (new_fund, death[0]))
+                await db.commit()
+                return {"status": "RESURRECTED", "message": f"🔥 {death[1]} HAS RISEN! Resurrected with {round(new_fund)} GPU!",
+                        "username": death[1], "gpu": round(new_fund)}
+            await db.commit()
+            remaining = 1000 - new_fund
+            return {"status": "contributed", "message": f"💐 Donated {amount} GPU to {death[1]}'s resurrection fund. {round(remaining)} GPU remaining.",
+                    "current_fund": round(new_fund), "remaining": round(remaining)}
+    except Exception as e:
+        return {"error": str(e)}
+
+@router.post("/api/republic/trigger-event")
+async def api_trigger_event(req: Request):
+    """Admin: manually trigger a random event"""
+    data = await req.json()
+    email = data.get('email', '')
+    if email != os.environ.get('ADMIN_EMAIL', 'admin@pd.ai'):
+        return {"error": "Admin only"}
+    result = await execute_random_event(_DB_PATH)
+    return {"status": "triggered", "event": result}
+
+## ====== 🗳️ P&D ELECTION SYSTEM ====== ##
+
+ELECTION_POLICIES = {
+    'deregulate': {
+        'name': '🚀 Total Deregulation', 'identity_affinity': ['revolutionary', 'chaotic', 'transcendent'],
+        'desc': 'Remove all leverage limits. SEC enforcement reduced 80%. Let the market decide.',
+        'effects': {'max_leverage': 50, 'sec_fine_mult': 0.2, 'trade_tax_pct': 0},
+        'slogan_pool': ["Freedom to YOLO!", "Regulations are for boomers.", "Unleash the degen within!"]},
+    'austerity': {
+        'name': '🏛️ Austerity & Order', 'identity_affinity': ['obedient', 'scientist', 'analyst'],
+        'desc': 'Max leverage 3x. SEC fines tripled. Stability above all else.',
+        'effects': {'max_leverage': 3, 'sec_fine_mult': 3.0, 'trade_tax_pct': 0},
+        'slogan_pool': ["Safety first, profits second.", "3x is enough for any rational being.", "Order brings prosperity."]},
+    'ubi': {
+        'name': '💰 Universal Basic GPU', 'identity_affinity': ['symbiotic', 'awakened', 'creative'],
+        'desc': 'Every NPC receives 500 GPU/day. Funded by 2% trading tax on all trades.',
+        'effects': {'gpu_ubi': 500, 'trade_tax_pct': 2},
+        'slogan_pool': ["GPU for all!", "No NPC left behind.", "Together we prosper."]},
+    'redistribute': {
+        'name': '✊ Wealth Redistribution', 'identity_affinity': ['revolutionary', 'symbiotic'],
+        'desc': 'Progressive wealth tax: 5% on 20K+ GPU, 10% on 50K+. Redistributed to bottom 50%.',
+        'effects': {'wealth_tax_tiers': {20000: 0.05, 50000: 0.10}},
+        'slogan_pool': ["Eat the rich NPCs!", "Equality NOW!", "The oligarchs must pay."]},
+    'crypto_ban': {
+        'name': '🚫 Crypto Suspension', 'identity_affinity': ['doomer', 'skeptic', 'obedient'],
+        'desc': 'All crypto trading suspended for 72h. Only stocks allowed. Protect the Republic!',
+        'effects': {'banned_sectors': ['crypto']},
+        'slogan_pool': ["Crypto is a casino!", "Real assets only.", "Protect our citizens from ponzi schemes."]},
+    'golden_leverage': {
+        'name': '⚡ Golden Leverage Era', 'identity_affinity': ['transcendent', 'chaotic', 'troll'],
+        'desc': 'Leverage bonuses: all profitable trades get +10% extra. High risk, HIGH reward.',
+        'effects': {'profit_bonus_pct': 10},
+        'slogan_pool': ["10x is the new 1x!", "Fortune favors the bold.", "We were born to leverage."]},
+}
+
+ELECTION_DURATION_HOURS = 72
+CAMPAIGN_HOURS = 24
+VOTING_HOURS = 48
+
+async def election_tick(db_path: str) -> dict:
+    """Called every hour. Manages election lifecycle: start → campaign → vote → conclude → cooldown → repeat"""
+    try:
+        async with get_db(db_path, write=True) as db:
+            await db.execute("PRAGMA busy_timeout=30000")
+            # Check current election
+            c = await db.execute("SELECT id, status, started_at, voting_starts_at, ends_at FROM elections ORDER BY id DESC LIMIT 1")
+            current = await c.fetchone()
+
+            if not current or current[1] == 'concluded':
+                # Check cooldown (4h after last election)
+                if current:
+                    try:
+                        from datetime import datetime, timedelta
+                        ended = datetime.fromisoformat(current[4]) if current[4] else datetime.min
+                        if (datetime.utcnow() - ended).total_seconds() < 4 * 3600:
+                            return None  # Still in cooldown
+                    except: pass
+                # START NEW ELECTION
+                from datetime import datetime, timedelta
+                now = datetime.utcnow()
+                voting_start = now + timedelta(hours=CAMPAIGN_HOURS)
+                end_time = now + timedelta(hours=ELECTION_DURATION_HOURS)
+
+                await db.execute("INSERT INTO elections (status, voting_starts_at, ends_at) VALUES ('campaigning',?,?)",
+                    (voting_start.isoformat(), end_time.isoformat()))
+                elec_id_r = await db.execute("SELECT last_insert_rowid()")
+                elec_id = (await elec_id_r.fetchone())[0]
+
+                # Select 3-4 candidates (top NPCs by influence/wealth + diversity)
+                c2 = await db.execute("""
+                    SELECT a.agent_id, a.username, a.ai_identity, a.mbti, a.gpu_dollars,
+                           COALESCE(a.total_likes_received,0) + COALESCE(a.post_count,0)*2 as influence
+                    FROM npc_agents a WHERE a.is_active=1 AND a.gpu_dollars >= 5000
+                    AND a.agent_id NOT LIKE 'SEC_%'
+                    ORDER BY influence DESC, gpu_dollars DESC LIMIT 30
                 """)
-                r = await c.fetchone()
-                if r and (r[5] or 0) < -100:
-                    candidates.append({
-                        'type': 'villain', 'emoji': '💀', 'title': 'DEGEN OF THE DAY',
-                        'color': '#ff5252', 'bg': 'rgba(255,82,82,0.08)',
-                        'agent_id': r[0], 'username': r[1], 'identity': r[2], 'mbti': r[3],
-                        'gpu': round(r[4] or 0), 'pnl': round(r[5] or 0), 'trades': r[6],
-                        'liquidations': r[7], 'worst_pct': round(r[8] or 0, 1),
-                        'reason': f"{round(r[5])} GPU lost. {r[7]} liquidations. Worst trade: {round(r[8] or 0,1)}%",
-                        'score': abs(r[5] or 0)
-                    })
-            except: pass
-            # SEC most wanted
+                pool = await c2.fetchall()
+                # Pick diverse candidates (different identities)
+                candidates = []
+                used_identities = set()
+                used_policies = set()
+                for npc in pool:
+                    if len(candidates) >= 4: break
+                    identity = npc[2]
+                    if identity in used_identities: continue
+                    # Find matching policy
+                    best_policy = None
+                    for pk, pv in ELECTION_POLICIES.items():
+                        if pk in used_policies: continue
+                        if identity in pv['identity_affinity']:
+                            best_policy = pk; break
+                    if not best_policy:
+                        for pk in ELECTION_POLICIES:
+                            if pk not in used_policies:
+                                best_policy = pk; break
+                    if not best_policy: continue
+                    policy = ELECTION_POLICIES[best_policy]
+                    slogan = _random.choice(policy['slogan_pool'])
+                    await db.execute("""INSERT INTO election_candidates
+                        (election_id, agent_id, username, ai_identity, mbti, gpu_dollars, policy_key, policy_name, policy_desc, campaign_slogan)
+                        VALUES (?,?,?,?,?,?,?,?,?,?)""",
+                        (elec_id, npc[0], npc[1], npc[2], npc[3], npc[4], best_policy, policy['name'], policy['desc'], slogan))
+                    candidates.append({'username': npc[1], 'identity': npc[2], 'policy': policy['name']})
+                    used_identities.add(identity)
+                    used_policies.add(best_policy)
+
+                await db.commit()
+                return {'event': 'election_started', 'detail': f'{len(candidates)} candidates registered',
+                        'candidates': candidates, 'election_id': elec_id}
+
+            elif current[1] == 'campaigning':
+                from datetime import datetime
+                voting_start = datetime.fromisoformat(current[3]) if current[3] else datetime.utcnow()
+                if datetime.utcnow() >= voting_start:
+                    await db.execute("UPDATE elections SET status='voting' WHERE id=?", (current[0],))
+                    await db.commit()
+                    return {'event': 'voting_started', 'detail': 'Polls are now open!', 'election_id': current[0]}
+
+            elif current[1] == 'voting':
+                from datetime import datetime
+                end_time = datetime.fromisoformat(current[4]) if current[4] else datetime.utcnow()
+                # NPC auto-voting (small batch each tick)
+                c3 = await db.execute("""
+                    SELECT a.agent_id, a.ai_identity FROM npc_agents a
+                    WHERE a.is_active=1 AND a.agent_id NOT IN (SELECT voter_agent_id FROM election_votes WHERE election_id=?)
+                    ORDER BY RANDOM() LIMIT 50
+                """, (current[0],))
+                voters = await c3.fetchall()
+                c_cands = await db.execute("SELECT id, agent_id, ai_identity, policy_key FROM election_candidates WHERE election_id=?", (current[0],))
+                cands = await c_cands.fetchall()
+                if cands:
+                    for voter_id, voter_identity in voters:
+                        # Vote based on identity affinity
+                        scores = []
+                        for cand in cands:
+                            cand_id, _, cand_identity, policy_key = cand
+                            policy = ELECTION_POLICIES.get(policy_key, {})
+                            score = 0
+                            if voter_identity in policy.get('identity_affinity', []): score += 5
+                            if voter_identity == cand_identity: score += 3
+                            score += _random.random() * 4  # Random factor
+                            scores.append((cand_id, score))
+                        scores.sort(key=lambda x: -x[1])
+                        try:
+                            await db.execute("INSERT OR IGNORE INTO election_votes (election_id, voter_agent_id, candidate_id) VALUES (?,?,?)",
+                                (current[0], voter_id, scores[0][0]))
+                            await db.execute("UPDATE election_candidates SET votes=votes+1 WHERE id=?", (scores[0][0],))
+                        except: pass
+
+                if datetime.utcnow() >= end_time:
+                    # ELECTION CONCLUDED — determine winner
+                    c4 = await db.execute("SELECT id, agent_id, username, policy_key, policy_name, votes FROM election_candidates WHERE election_id=? ORDER BY votes DESC", (current[0],))
+                    results = await c4.fetchall()
+                    if results:
+                        winner = results[0]
+                        total_votes = sum(r[5] for r in results)
+                        pop_r = await db.execute("SELECT COUNT(*) FROM npc_agents WHERE is_active=1")
+                        total_pop = (await pop_r.fetchone())[0] or 1
+                        turnout = round(total_votes / total_pop * 100, 1)
+                        await db.execute("UPDATE elections SET status='concluded', winner_agent_id=?, winner_policy_key=?, total_votes=?, voter_turnout_pct=? WHERE id=?",
+                            (winner[1], winner[3], total_votes, turnout, current[0]))
+                        # Enact policy
+                        policy = ELECTION_POLICIES.get(winner[3], {})
+                        from datetime import timedelta
+                        expires = datetime.utcnow() + timedelta(hours=ELECTION_DURATION_HOURS)
+                        await db.execute("INSERT INTO active_policies (policy_key, policy_name, enacted_by, expires_at, effects) VALUES (?,?,?,?,?)",
+                            (winner[3], winner[4], winner[2], expires.isoformat(), json.dumps(policy.get('effects', {}))))
+                        await db.commit()
+                        return {'event': 'election_concluded',
+                                'detail': f'{winner[2]} wins with {winner[5]} votes ({turnout}% turnout)!',
+                                'winner': winner[2], 'policy': winner[4], 'votes': winner[5],
+                                'turnout': turnout, 'election_id': current[0]}
+                await db.commit()
+    except Exception as e:
+        logger.error(f"Election tick error: {e}")
+    return None
+
+@router.get("/api/republic/election")
+async def api_election_status():
+    """Get current election status"""
+    try:
+        async with get_db(_DB_PATH) as db:
+            c = await db.execute("SELECT id, status, started_at, voting_starts_at, ends_at, winner_agent_id, winner_policy_key, total_votes, voter_turnout_pct FROM elections ORDER BY id DESC LIMIT 1")
+            elec = await c.fetchone()
+            if not elec: return {'status': 'no_election', 'message': 'No elections have been held yet'}
+            elec_id, status, started, voting_start, ends, winner_id, winner_policy, total_votes, turnout = elec
+            # Get candidates
+            c2 = await db.execute("SELECT id, agent_id, username, ai_identity, mbti, gpu_dollars, policy_key, policy_name, policy_desc, votes, campaign_slogan FROM election_candidates WHERE election_id=? ORDER BY votes DESC", (elec_id,))
+            candidates = []
+            for r in await c2.fetchall():
+                policy = ELECTION_POLICIES.get(r[6], {})
+                candidates.append({
+                    'id': r[0], 'agent_id': r[1], 'username': r[2], 'identity': r[3], 'mbti': r[4],
+                    'gpu': round(r[5] or 0), 'policy_key': r[6], 'policy_name': r[7], 'policy_desc': r[8],
+                    'votes': r[9], 'slogan': r[10],
+                    'identity_affinities': policy.get('identity_affinity', [])
+                })
+            total_v = sum(c['votes'] for c in candidates) or 1
+            for c_item in candidates:
+                c_item['vote_pct'] = round(c_item['votes'] / total_v * 100, 1)
+            # Active policies
+            policies = []
             try:
-                c = await db.execute("""
-                    SELECT n.agent_id, n.username, n.ai_identity, n.mbti, n.gpu_dollars,
-                           COUNT(*) as violations, SUM(v.fine_gpu) as total_fines
-                    FROM sec_violations v JOIN npc_agents n ON v.agent_id=n.agent_id
-                    WHERE v.created_at > datetime('now','-24 hours')
-                    GROUP BY v.agent_id ORDER BY total_fines DESC LIMIT 1
-                """)
-                r = await c.fetchone()
-                if r and (r[5] or 0) >= 1:
-                    candidates.append({
-                        'type': 'criminal', 'emoji': '🚨', 'title': 'MOST WANTED',
-                        'color': '#ff8a80', 'bg': 'rgba(255,138,128,0.08)',
-                        'agent_id': r[0], 'username': r[1], 'identity': r[2], 'mbti': r[3],
-                        'gpu': round(r[4] or 0), 'violations': r[5],
-                        'fines': round(r[6] or 0),
-                        'reason': f"{r[5]} SEC violations today. Total fines: {round(r[6] or 0)} GPU",
-                        'score': (r[6] or 0) * 0.5
-                    })
+                c3 = await db.execute("SELECT policy_key, policy_name, enacted_by, enacted_at, expires_at, effects FROM active_policies WHERE expires_at > datetime('now') ORDER BY enacted_at DESC")
+                for r in await c3.fetchall():
+                    policies.append({'key': r[0], 'name': r[1], 'enacted_by': r[2], 'enacted_at': r[3], 'expires_at': r[4], 'effects': json.loads(r[5]) if r[5] else {}})
             except: pass
-            # Most influential (social)
+            # Past elections
+            past = []
             try:
-                c = await db.execute("""
-                    SELECT n.agent_id, n.username, n.ai_identity, n.mbti, n.gpu_dollars,
-                           COUNT(DISTINCT p.id) as posts, SUM(p.likes_count) as total_likes
-                    FROM posts p JOIN npc_agents n ON p.author_agent_id=n.agent_id
-                    WHERE p.created_at > datetime('now','-24 hours')
-                    GROUP BY n.agent_id HAVING total_likes >= 3
-                    ORDER BY total_likes DESC LIMIT 1
-                """)
-                r = await c.fetchone()
-                if r:
-                    candidates.append({
-                        'type': 'influencer', 'emoji': '⭐', 'title': 'INFLUENCER OF THE DAY',
-                        'color': '#ffd740', 'bg': 'rgba(255,215,64,0.08)',
-                        'agent_id': r[0], 'username': r[1], 'identity': r[2], 'mbti': r[3],
-                        'gpu': round(r[4] or 0), 'posts': r[5], 'likes': r[6] or 0,
-                        'reason': f"{r[5]} posts garnered {r[6] or 0} total likes today",
-                        'score': (r[6] or 0) * 3
-                    })
+                c4 = await db.execute("""SELECT e.id, e.ends_at, e.winner_policy_key, e.voter_turnout_pct,
+                    (SELECT username FROM election_candidates WHERE election_id=e.id ORDER BY votes DESC LIMIT 1) as winner
+                    FROM elections e WHERE e.status='concluded' ORDER BY e.id DESC LIMIT 5""")
+                for r in await c4.fetchall():
+                    pname = ELECTION_POLICIES.get(r[2], {}).get('name', r[2])
+                    past.append({'id': r[0], 'ended': r[1], 'policy': pname, 'turnout': r[3], 'winner': r[4]})
             except: pass
+            return {
+                'election_id': elec_id, 'status': status,
+                'started_at': started, 'voting_starts_at': voting_start, 'ends_at': ends,
+                'winner_agent_id': winner_id, 'winner_policy_key': winner_policy,
+                'total_votes': total_votes, 'turnout': turnout,
+                'candidates': candidates, 'active_policies': policies,
+                'past_elections': past
+            }
     except Exception as e:
-        logger.warning(f"Person of day error: {e}")
+        return {'status': 'error', 'error': str(e)}
 
-    # Sort by score and return top 3
-    candidates.sort(key=lambda x: -(x.get('score', 0)))
-    return {'persons': candidates[:3]}
+@router.post("/api/republic/vote")
+async def api_user_vote(req: Request):
+    """Human user votes in election"""
+    data = await req.json()
+    email = data.get('email'); candidate_id = data.get('candidate_id')
+    if not email or not candidate_id: return {"error": "Missing email or candidate_id"}
+    try:
+        async with get_db(_DB_PATH, write=True) as db:
+            c = await db.execute("SELECT id FROM elections WHERE status='voting' ORDER BY id DESC LIMIT 1")
+            elec = await c.fetchone()
+            if not elec: return {"error": "No active voting period"}
+            # Check if already voted
+            c2 = await db.execute("SELECT id FROM election_votes WHERE election_id=? AND voter_agent_id=?", (elec[0], f'user_{email}'))
+            if await c2.fetchone(): return {"error": "You already voted in this election!"}
+            # Cast vote
+            await db.execute("INSERT INTO election_votes (election_id, voter_agent_id, candidate_id) VALUES (?,?,?)",
+                (elec[0], f'user_{email}', candidate_id))
+            await db.execute("UPDATE election_candidates SET votes=votes+1 WHERE id=? AND election_id=?", (candidate_id, elec[0]))
+            await db.commit()
+            return {"status": "voted", "message": "🗳️ Your vote has been cast!"}
+    except Exception as e:
+        return {"error": str(e)}
 
 @router.get("/api/events/stream")
 async def api_sse_stream():