deploy LivePulse to HF Spaces

.gitattributes

@@ -0,0 +1,4 @@
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -7,8 +7,8 @@ __pycache__/
 venv/
 env/
 
-# ML model weights (too large for git — upload separately or use HF hub)
-new_trained_data/
+# ML model weights tracked via Git LFS (see .gitattributes)
+# new_trained_data/
 
 # Redis data
 *.rdb

Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+CMD ["streamlit", "run", "app.py", "--server.port", "7860", "--server.address", "0.0.0.0"]

README.md

@@ -0,0 +1,33 @@
+---
+title: LivePulse
+emoji: 📡
+colorFrom: purple
+colorTo: indigo
+sdk: streamlit
+sdk_version: "1.35.0"
+app_file: app.py
+pinned: false
+---
+
+# 📡 LivePulse — YouTube Live Chat Analytics
+
+Real-time Hinglish sentiment and topic analysis for YouTube live streams.
+
+## Features
+
+- Real-time chat scraping via pytchat
+- Sentiment classification (Positive / Neutral / Negative) using a 3-model ensemble
+  - Fine-tuned MuRIL (Hinglish-aware)
+  - XLM-RoBERTa (multilingual Twitter model)
+  - Multilingual sentiment model
+- Topic classification (Appreciation / Question / Promo / Spam / MCQ Answer / General)
+- Interactive Streamlit dashboard with live auto-refresh
+- Start/stop scraper directly from the UI
+- Multi-stream comparison (up to 5 streams)
+- Engagement score, word cloud, leaderboard, sentiment heatmap
+
+## Usage
+
+1. Paste a YouTube live video ID or URL in the **Stream Control** section in the sidebar
+2. Click **▶ Start** — the scraper launches in the background
+3. The dashboard auto-refreshes and shows live sentiment + topic data

app.py

@@ -0,0 +1,1485 @@
+# -*- coding: utf-8 -*-
+"""
+app.py — Hugging Face Spaces adaptation of frontend/streamlit_app.py
+All features identical; infrastructure layer uses in-memory deque store
+and threading instead of Redis + subprocess.
+"""
+
+import streamlit as st
+import json
+import pandas as pd
+import plotly.graph_objects as go
+import plotly.express as px
+import time
+import re
+import os
+import threading
+import logging
+from collections import deque, defaultdict
+from datetime import datetime, timedelta
+
+# ── In-memory store (replaces Redis) ─────────────────────────────────────────
+MAX_STORE_MESSAGES = 10000
+
+_STORE_LOCK: threading.Lock = threading.Lock()
+_STORE: dict[str, deque] = {}          # keyed by redis_key string
+_META:  dict[str, str]   = {}          # misc key-value (e.g. "video_title")
+
+# Scraper thread registry
+_SCRAPER_THREADS: dict[str, threading.Thread] = {}
+_SCRAPER_STOP:    dict[str, threading.Event]  = {}
+
+
+def _get_deque(key: str) -> deque:
+    """Return (creating if needed) the deque for a given key."""
+    if key not in _STORE:
+        _STORE[key] = deque(maxlen=MAX_STORE_MESSAGES)
+    return _STORE[key]
+
+
+# Redis-compatible helpers
+def store_lrange(key: str, start: int, end: int) -> list[str]:
+    """Emulate r.lrange(key, start, end)."""
+    with _STORE_LOCK:
+        d = list(_get_deque(key))
+    n = len(d)
+    if n == 0:
+        return []
+    # Normalise negative indices
+    if start < 0:
+        start = max(n + start, 0)
+    if end < 0:
+        end = n + end
+    end = min(end, n - 1)
+    if start > end:
+        return []
+    return d[start : end + 1]
+
+
+def store_llen(key: str) -> int:
+    with _STORE_LOCK:
+        return len(_get_deque(key))
+
+
+def store_delete(key: str) -> None:
+    with _STORE_LOCK:
+        if key in _STORE:
+            _STORE[key].clear()
+
+
+def store_rpush(key: str, value: str) -> None:
+    with _STORE_LOCK:
+        _get_deque(key).append(value)
+
+
+# ── Inline config (replaces backend/config.py) ────────────────────────────────
+VIDEO_ID = os.getenv("VIDEO_ID", "")
+
+# ── ML imports (ml/ is at workspace root) ────────────────────────────────────
+from ml.sentiment_model import predict_sentiment
+from ml.topic_model import predict_topic, VALID_TOPICS
+
+# ── Scraper thread logic (mirrors backend/scraper.py run()) ──────────────────
+logger = logging.getLogger("app.scraper")
+
+
+def _safe_sentiment(text: str):
+    try:
+        return predict_sentiment(text)
+    except Exception as exc:
+        logger.error("predict_sentiment failed: %s", exc)
+        return "Neutral", 0.50
+
+
+def _safe_topic(text: str):
+    try:
+        topic, conf = predict_topic(text)
+        if topic not in VALID_TOPICS:
+            return "General", 0.50
+        return topic, conf
+    except Exception as exc:
+        logger.error("predict_topic failed: %s", exc)
+        return "General", 0.50
+
+
+def _scraper_thread_fn(video_id: str, redis_key: str, stop_event: threading.Event) -> None:
+    """Background thread that scrapes live chat and writes to in-memory store."""
+    import pytchat
+
+    logger.info("Scraper thread starting — video=%s key=%s", video_id, redis_key)
+    try:
+        chat = pytchat.create(video_id=video_id)
+    except Exception as exc:
+        logger.error("pytchat.create failed: %s", exc)
+        return
+
+    if not chat.is_alive():
+        logger.error("Live chat not available for %s", video_id)
+        return
+
+    logger.info("Live chat connected for %s", video_id)
+
+    while chat.is_alive() and not stop_event.is_set():
+        try:
+            for c in chat.get().sync_items():
+                if stop_event.is_set():
+                    break
+                text   = c.message.strip()
+                author = c.author.name
+                if not text:
+                    continue
+
+                sentiment, s_conf = _safe_sentiment(text)
+                topic,     t_conf = _safe_topic(text)
+
+                message_data = {
+                    "author":     author,
+                    "text":       text,
+                    "sentiment":  sentiment,
+                    "confidence": round(s_conf, 3),
+                    "topic":      topic,
+                    "topic_conf": round(t_conf, 3),
+                    "time":       datetime.now().isoformat(),
+                }
+                store_rpush(redis_key, json.dumps(message_data))
+
+        except Exception as exc:
+            if not stop_event.is_set():
+                logger.error("Scraper error: %s", exc, exc_info=True)
+
+        if not stop_event.is_set():
+            time.sleep(1)
+
+    logger.info("Scraper thread ended — key=%s", redis_key)
+
+
+def start_scraper(slot_idx: int, video_id: str, redis_key: str) -> None:
+    """Start a scraper thread for the given slot, stopping any existing one first."""
+    key = str(slot_idx)
+    stop_scraper(slot_idx)
+
+    stop_event = threading.Event()
+    t = threading.Thread(
+        target=_scraper_thread_fn,
+        args=(video_id, redis_key, stop_event),
+        daemon=True,
+        name=f"scraper-{slot_idx}",
+    )
+    _SCRAPER_STOP[key]    = stop_event
+    _SCRAPER_THREADS[key] = t
+    t.start()
+
+
+def stop_scraper(slot_idx: int) -> None:
+    """Signal the scraper thread for this slot to stop."""
+    key = str(slot_idx)
+    ev = _SCRAPER_STOP.get(key)
+    if ev:
+        ev.set()
+    # Don't join — daemon thread will die on its own
+
+
+def is_scraper_running(slot_idx: int) -> bool:
+    key = str(slot_idx)
+    t = _SCRAPER_THREADS.get(key)
+    return t is not None and t.is_alive()
+
+
+# ── Streamlit page config ─────────────────────────────────────────────────────
+st.set_page_config(
+    page_title="LivePulse",
+    layout="wide",
+    page_icon="📡",
+    initial_sidebar_state="expanded"
+)
+
+TOPIC_LABELS = ["Appreciation", "Question", "Promo", "Spam", "General", "MCQ Answer"]
+TOPIC_COLOR  = {
+    "Appreciation": "#f59e0b", "Question": "#3b82f6",
+    "Promo": "#ec4899", "Spam": "#ef4444", "General": "#6b7280",
+    "MCQ Answer": "#10b981"
+}
+SENT_COLORS = {"Positive": "#22c55e", "Neutral": "#eab308", "Negative": "#ef4444"}
+
+# ── JS: detect Streamlit's live theme and set data-livepulse attribute ──
+THEME_JS = """<script>
+(function() {
+  function applyTheme() {
+    const html = window.parent.document.documentElement;
+    const style = window.parent.getComputedStyle(html);
+    const bg = style.getPropertyValue('--background-color').trim();
+    let isDark = true;
+    const m = bg.match(/rgb\((\d+),\s*(\d+),\s*(\d+)\)/);
+    if (m) { isDark = (0.299*m[1] + 0.587*m[2] + 0.114*m[3]) < 128; }
+    else {
+      const bodyBg = window.parent.getComputedStyle(window.parent.document.body).backgroundColor;
+      const m2 = bodyBg.match(/rgb\((\d+),\s*(\d+),\s*(\d+)\)/);
+      if (m2) { isDark = (0.299*m2[1] + 0.587*m2[2] + 0.114*m2[3]) < 128; }
+    }
+    html.setAttribute('data-livepulse', isDark ? 'dark' : 'light');
+  }
+  applyTheme();
+  const obs = new MutationObserver(applyTheme);
+  obs.observe(window.parent.document.documentElement, { attributes: true, attributeFilter: ['style','class'] });
+  obs.observe(window.parent.document.body, { attributes: true, attributeFilter: ['style','class'] });
+})();
+</script>"""
+
+CSS = """<style>
+@import url('https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@400;500;600;700;800&display=swap');
+
+:root, [data-livepulse="dark"] {
+  --bg:#07070f; --bg-card:#0f0f1e; --border:rgba(255,255,255,0.07);
+  --text-1:#f1f5f9; --text-2:#94a3b8; --text-3:#475569;
+  --accent:#7c3aed; --accent2:#4f46e5; --accent-text:#a78bfa;
+  --live:#22c55e; --input-bg:rgba(255,255,255,0.04); --input-border:rgba(255,255,255,0.1);
+  --divider:rgba(255,255,255,0.06); --badge-bg:rgba(255,255,255,0.05);
+  --shadow:0 4px 24px rgba(0,0,0,0.4); --shadow-sm:0 2px 8px rgba(0,0,0,0.3);
+  --pill-bg:rgba(124,58,237,0.15); --pill-border:rgba(124,58,237,0.3); --pill-text:#a78bfa;
+  --plotly-paper:rgba(0,0,0,0); --plotly-plot:rgba(255,255,255,0.015); --plotly-grid:rgba(255,255,255,0.05); --plotly-text:#94a3b8;
+  --alert-bg:rgba(239,68,68,0.1); --alert-border:rgba(239,68,68,0.3);
+  --pin-bg:rgba(234,179,8,0.1); --pin-border:rgba(234,179,8,0.35);
+}
+[data-livepulse="light"] {
+  --bg:#f4f6ff; --bg-card:#ffffff; --border:rgba(99,102,241,0.12);
+  --text-1:#0f172a; --text-2:#475569; --text-3:#94a3b8;
+  --accent:#6d28d9; --accent2:#4338ca; --accent-text:#6d28d9;
+  --live:#16a34a; --input-bg:#ffffff; --input-border:rgba(99,102,241,0.2);
+  --divider:rgba(99,102,241,0.1); --badge-bg:rgba(99,102,241,0.06);
+  --shadow:0 4px 24px rgba(99,102,241,0.12); --shadow-sm:0 2px 8px rgba(99,102,241,0.08);
+  --pill-bg:rgba(109,40,217,0.08); --pill-border:rgba(109,40,217,0.2); --pill-text:#6d28d9;
+  --plotly-paper:rgba(0,0,0,0); --plotly-plot:rgba(255,255,255,0.7); --plotly-grid:rgba(0,0,0,0.06); --plotly-text:#475569;
+  --alert-bg:rgba(239,68,68,0.07); --alert-border:rgba(239,68,68,0.25);
+  --pin-bg:rgba(234,179,8,0.08); --pin-border:rgba(234,179,8,0.3);
+}
+
+html,body,[data-testid="stAppViewContainer"],[data-testid="stMain"],.main .block-container {
+  background:var(--bg)!important; color:var(--text-1)!important;
+  font-family:'Space Grotesk',sans-serif!important; transition:background 0.3s,color 0.3s;
+}
+[data-testid="stSidebar"] { background:var(--bg-card)!important; border-right:1px solid var(--border)!important; transition:background 0.3s; }
+[data-testid="stHeader"] { background:transparent!important; }
+::-webkit-scrollbar{width:4px;} ::-webkit-scrollbar-track{background:var(--bg);}
+::-webkit-scrollbar-thumb{background:linear-gradient(var(--accent),var(--accent2));border-radius:4px;}
+
+[data-testid="metric-container"] {
+  background:var(--bg-card)!important; border:1px solid var(--border)!important;
+  border-radius:16px!important; padding:18px!important; box-shadow:var(--shadow-sm)!important; transition:background 0.3s;
+}
+[data-testid="stMetricLabel"]{color:var(--text-2)!important;font-size:0.8rem!important;}
+[data-testid="stMetricValue"]{color:var(--text-1)!important;font-weight:700!important;}
+[data-testid="stMetricDelta"]{color:var(--accent-text)!important;}
+
+.stTextInput input { background:var(--input-bg)!important; border:1px solid var(--input-border)!important; border-radius:10px!important; color:var(--text-1)!important; }
+.stTextInput input::placeholder { color:var(--text-3)!important; opacity:1!important; }
+[data-testid="stSidebar"] .stTextInput input { background:#1a1a2e!important; border:1px solid rgba(124,58,237,0.4)!important; color:#f1f5f9!important; font-weight:500!important; }
+[data-testid="stSidebar"] .stTextInput input::placeholder { color:#64748b!important; }
+[data-testid="stSidebar"] .stTextInput input:focus { border-color:var(--accent)!important; box-shadow:0 0 0 2px rgba(124,58,237,0.2)!important; outline:none!important; }
+[data-testid="stSidebar"] label { color:var(--text-2)!important; }
+[data-baseweb="select"]>div { background:var(--input-bg)!important; border:1px solid var(--input-border)!important; border-radius:10px!important; color:var(--text-1)!important; }
+.stButton>button { background:linear-gradient(135deg,var(--accent),var(--accent2))!important; color:#fff!important; border:none!important; border-radius:10px!important; font-weight:600!important; font-family:'Space Grotesk',sans-serif!important; box-shadow:0 4px 16px rgba(124,58,237,0.3)!important; transition:all 0.2s!important; }
+.stButton>button:hover{transform:translateY(-2px)!important;}
+hr{border:none!important;border-top:1px solid var(--divider)!important;margin:1.2rem 0!important;}
+[data-testid="stSidebar"] label,[data-testid="stSidebar"] .stMarkdown p{color:var(--text-2)!important;font-size:0.83rem!important;}
+
+[data-testid="stDownloadButton"]>button { background:var(--bg-card)!important; color:var(--text-2)!important; border:1px solid var(--border)!important; border-radius:8px!important; font-size:0.75rem!important; box-shadow:none!important; }
+[data-testid="stDownloadButton"]>button:hover { background:var(--pill-bg)!important; color:var(--accent-text)!important; border-color:var(--pill-border)!important; }
+
+[data-testid="stCheckbox"] label, [data-testid="stCheckbox"] span { color:var(--text-2)!important; font-size:0.82rem!important; }
+[data-testid="stCheckbox"] [data-testid="stWidgetLabel"] { color:var(--text-2)!important; }
+
+@keyframes pulse{0%{box-shadow:0 0 0 0 rgba(34,197,94,0.7);}70%{box-shadow:0 0 0 10px rgba(34,197,94,0);}100%{box-shadow:0 0 0 0 rgba(34,197,94,0);}}
+.live-dot{display:inline-block;width:9px;height:9px;background:var(--live);border-radius:50%;animation:pulse 1.8s infinite;margin-right:6px;vertical-align:middle;}
+
+@keyframes alertPulse{0%{opacity:1;}50%{opacity:0.7;}100%{opacity:1;}}
+.alert-banner{background:var(--alert-bg);border:1px solid var(--alert-border);border-radius:14px;padding:14px 18px;margin:12px 0;display:flex;align-items:center;gap:12px;animation:alertPulse 2s infinite;}
+.alert-icon{font-size:1.4rem;}
+.alert-text{font-size:0.88rem;font-weight:600;color:#ef4444;}
+.alert-sub{font-size:0.75rem;color:var(--text-3);margin-top:2px;}
+
+.stat-grid{display:flex;gap:12px;margin:10px 0 18px;flex-wrap:wrap;}
+.stat-card{flex:1;min-width:130px;background:var(--bg-card);border:1px solid var(--border);border-radius:20px;padding:22px 18px;text-align:center;transition:transform 0.2s,box-shadow 0.2s,background 0.3s;position:relative;overflow:hidden;box-shadow:var(--shadow-sm);}
+.stat-card:hover{transform:translateY(-4px);box-shadow:var(--shadow);}
+.stat-accent{position:absolute;top:0;left:0;right:0;height:3px;border-radius:20px 20px 0 0;}
+.stat-number{font-size:2.6rem;font-weight:800;line-height:1;margin-bottom:6px;letter-spacing:-0.03em;}
+.stat-label{font-size:0.82rem;color:var(--text-2);font-weight:600;text-transform:uppercase;letter-spacing:0.06em;}
+.stat-sub{font-size:0.7rem;color:var(--text-3);margin-top:4px;}
+
+.velocity-card{background:var(--bg-card);border:1px solid var(--border);border-radius:20px;padding:18px 22px;box-shadow:var(--shadow-sm);display:flex;align-items:center;gap:16px;}
+.velocity-arrow{font-size:2rem;line-height:1;}
+.velocity-val{font-size:1.6rem;font-weight:800;letter-spacing:-0.03em;}
+.velocity-label{font-size:0.75rem;color:var(--text-3);font-weight:600;text-transform:uppercase;letter-spacing:0.06em;margin-top:2px;}
+
+.sec-hdr{display:flex;align-items:center;gap:10px;margin:6px 0 14px;}
+.sec-ttl{font-size:1rem;font-weight:700;color:var(--text-1);letter-spacing:-0.01em;}
+.sec-pill{background:var(--pill-bg);border:1px solid var(--pill-border);border-radius:20px;padding:2px 10px;font-size:0.68rem;color:var(--pill-text);font-weight:700;text-transform:uppercase;letter-spacing:0.08em;}
+
+.chart-wrap{background:var(--bg-card);border:1px solid var(--border);border-radius:20px;padding:14px 14px 6px;box-shadow:var(--shadow-sm);transition:background 0.3s,border 0.3s;}
+.chart-title{font-size:0.88rem;font-weight:700;color:var(--text-1);margin-bottom:2px;}
+.chart-sub{font-size:0.72rem;color:var(--text-3);margin-bottom:10px;}
+
+.topic-grid{display:flex;gap:10px;flex-wrap:wrap;margin-bottom:18px;}
+.topic-pill{background:var(--bg-card);border-radius:16px;padding:14px 20px;text-align:center;min-width:110px;box-shadow:var(--shadow-sm);transition:transform 0.2s,box-shadow 0.2s;}
+.topic-pill:hover{transform:translateY(-3px);box-shadow:var(--shadow);}
+.topic-count{font-size:1.4rem;font-weight:800;letter-spacing:-0.02em;}
+.topic-name{font-size:0.7rem;color:var(--text-3);margin-top:3px;font-weight:600;text-transform:uppercase;letter-spacing:0.06em;}
+
+@keyframes slideIn{from{opacity:0;transform:translateY(6px);}to{opacity:1;transform:translateY(0);}}
+.chat-card{background:var(--bg-card);border:1px solid var(--border);border-radius:16px;padding:14px 16px;margin-bottom:10px;border-left:3px solid transparent;animation:slideIn 0.2s ease;transition:background 0.2s,transform 0.15s,box-shadow 0.2s;box-shadow:var(--shadow-sm);}
+.chat-card:hover{transform:translateX(4px);box-shadow:var(--shadow);}
+.chat-positive{border-left-color:#22c55e;} .chat-negative{border-left-color:#ef4444;} .chat-neutral{border-left-color:#eab308;}
+.chat-pinned{border-left-color:#eab308!important;background:var(--pin-bg)!important;border-color:var(--pin-border)!important;}
+.chat-author{font-weight:700;font-size:0.83rem;color:var(--accent-text);margin-bottom:5px;}
+.chat-text{font-size:0.92rem;color:var(--text-2);line-height:1.55;margin-bottom:9px;}
+.chat-badges{display:flex;gap:6px;flex-wrap:wrap;}
+.badge{display:inline-flex;align-items:center;background:var(--badge-bg);border:1px solid var(--border);border-radius:20px;padding:3px 10px;font-size:0.7rem;font-weight:600;color:var(--text-2);}
+.pin-badge{background:rgba(234,179,8,0.15);border-color:rgba(234,179,8,0.4);color:#eab308;}
+
+.compare-label{font-size:0.72rem;font-weight:700;text-transform:uppercase;letter-spacing:0.08em;padding:3px 10px;border-radius:20px;display:inline-block;margin-bottom:8px;}
+
+.engage-card{background:var(--bg-card);border:1px solid var(--border);border-radius:20px;padding:20px 24px;box-shadow:var(--shadow-sm);position:relative;overflow:hidden;}
+.engage-score{font-size:3rem;font-weight:800;letter-spacing:-0.04em;line-height:1;}
+.engage-label{font-size:0.75rem;color:var(--text-3);font-weight:600;text-transform:uppercase;letter-spacing:0.08em;margin-top:4px;}
+.engage-bar-bg{background:var(--border);border-radius:99px;height:6px;margin-top:12px;overflow:hidden;}
+.engage-bar-fill{height:6px;border-radius:99px;transition:width 0.6s ease;}
+.engage-breakdown{display:flex;gap:16px;margin-top:10px;flex-wrap:wrap;}
+.engage-item{font-size:0.72rem;color:var(--text-3);}
+.engage-item span{font-weight:700;color:var(--text-2);}
+
+.leaderboard-row{display:flex;align-items:center;gap:12px;padding:10px 14px;background:var(--bg-card);border:1px solid var(--border);border-radius:14px;margin-bottom:8px;transition:transform 0.15s,box-shadow 0.15s;}
+.leaderboard-row:hover{transform:translateX(4px);box-shadow:var(--shadow);}
+.lb-rank{font-size:1rem;font-weight:800;color:var(--text-3);min-width:28px;}
+.lb-rank.gold{color:#f59e0b;} .lb-rank.silver{color:#94a3b8;} .lb-rank.bronze{color:#b45309;}
+.lb-author{font-size:0.85rem;font-weight:700;color:var(--text-1);flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}
+.lb-count{font-size:0.78rem;color:var(--text-3);min-width:40px;text-align:right;}
+.lb-bar{flex:2;height:5px;background:var(--border);border-radius:99px;overflow:hidden;}
+.lb-bar-fill{height:5px;border-radius:99px;}
+.lb-sent{display:flex;gap:4px;min-width:80px;justify-content:flex-end;}
+.lb-dot{width:8px;height:8px;border-radius:50%;display:inline-block;}
+
+.spam-alert{background:rgba(239,68,68,0.08);border:1px solid rgba(239,68,68,0.25);border-radius:14px;padding:14px 18px;margin:12px 0;display:flex;align-items:center;gap:12px;}
+.spam-alert-text{font-size:0.88rem;font-weight:600;color:#ef4444;}
+.spam-alert-sub{font-size:0.75rem;color:var(--text-3);margin-top:2px;}
+
+.empty-state{text-align:center;padding:80px 20px;background:var(--bg-card);border:1px solid var(--border);border-radius:24px;margin:40px 0;box-shadow:var(--shadow-sm);}
+.empty-icon{font-size:3.5rem;margin-bottom:16px;}
+.empty-title{font-size:1.1rem;color:var(--text-2);font-weight:700;}
+.empty-sub{font-size:0.84rem;color:var(--text-3);margin-top:6px;}
+</style>"""
+
+st.markdown(THEME_JS, unsafe_allow_html=True)
+st.markdown(CSS, unsafe_allow_html=True)
+
+
+# ── HELPERS ──────────────────────────────────────────────────
+def extract_video_id(url_or_id):
+    url_or_id = url_or_id.strip()
+    match = re.search(r"(?:v=|/live/|youtu\.be/)([A-Za-z0-9_-]{11})", url_or_id)
+    if match:
+        return match.group(1)
+    if re.match(r"^[A-Za-z0-9_-]{11}$", url_or_id):
+        return url_or_id
+    return url_or_id
+
+
+def fetch_video_title(video_id):
+    try:
+        import urllib.request
+        url = f"https://www.youtube.com/oembed?url=https://www.youtube.com/watch?v={video_id}&format=json"
+        with urllib.request.urlopen(url, timeout=5) as resp:
+            return json.loads(resp.read())["title"]
+    except Exception:
+        return None
+
+
+def clean_topic(val):
+    if pd.isna(val) or str(val).strip() == "" or str(val).strip().lower() == "nan":
+        return "General"
+    return str(val).strip()
+
+
+def clean_sentiment(val):
+    if str(val).strip() in ("Positive", "Negative", "Neutral"):
+        return str(val).strip()
+    return "Neutral"
+
+
+def plotly_layout(height=280):
+    return dict(
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
+        height=height,
+        margin=dict(l=10, r=10, t=10, b=10),
+        font=dict(family="Space Grotesk"),
+        xaxis=dict(showgrid=False, zeroline=False, showline=False,
+                   tickfont=dict(size=11), title=None),
+        yaxis=dict(showgrid=True, gridcolor="rgba(128,128,128,0.12)",
+                   zeroline=False, showline=False, tickfont=dict(size=11), title=None),
+        showlegend=False,
+        hoverlabel=dict(font_family="Space Grotesk", font_size=12),
+    )
+
+
+def csv_download(df_export, label, filename):
+    csv = df_export.to_csv(index=False).encode("utf-8")
+    st.download_button(label=f"⬇ {label}", data=csv,
+                       file_name=filename, mime="text/csv", key=filename)
+
+
+@st.cache_data(ttl=5, show_spinner=False)
+def load_stream_data(redis_key: str, limit: int | None = None):
+    """Load and parse messages from the in-memory store. Cached for 5s."""
+    if limit:
+        raws = store_lrange(redis_key, -limit, -1)
+    else:
+        raws = store_lrange(redis_key, 0, -1)
+    data = []
+    for raw in raws:
+        try:
+            data.append(json.loads(raw))
+        except Exception:
+            pass
+    return data
+
+
+@st.cache_data(ttl=10, show_spinner=False)
+def compute_velocity(df_all_json: str, window: int = 20) -> dict:
+    """Compute sentiment velocity. Accepts JSON string for cache key compatibility."""
+    import json as _json
+    sentiments = [m.get("sentiment", "Neutral") for m in _json.loads(df_all_json)]
+    n = len(sentiments)
+    if n < window * 2:
+        return {"direction": "→", "delta": 0.0, "label": "Stable", "color": "#eab308"}
+    recent = sentiments[-window:]
+    prev   = sentiments[-window*2:-window]
+    r_pos  = sum(1 for s in recent if s == "Positive") / window
+    p_pos  = sum(1 for s in prev   if s == "Positive") / window
+    delta  = r_pos - p_pos
+    if delta > 0.08:
+        return {"direction": "↑", "delta": delta, "label": "Rising",  "color": "#22c55e"}
+    elif delta < -0.08:
+        return {"direction": "↓", "delta": delta, "label": "Falling", "color": "#ef4444"}
+    return {"direction": "→", "delta": delta, "label": "Stable", "color": "#eab308"}
+
+
+@st.cache_data(ttl=10, show_spinner=False)
+def build_heatmap_data(df_all_json: str, bucket_minutes: int = 1) -> pd.DataFrame:
+    """Bucket messages into time intervals."""
+    import json as _json
+    records = _json.loads(df_all_json)
+    if not records:
+        return pd.DataFrame()
+    df_t = pd.DataFrame(records)
+    if "time" not in df_t.columns:
+        return pd.DataFrame()
+    df_t["time"] = pd.to_datetime(df_t["time"], errors="coerce")
+    df_t = df_t.dropna(subset=["time"])
+    if df_t.empty:
+        return pd.DataFrame()
+    df_t["bucket"] = df_t["time"].dt.floor(f"{bucket_minutes}min")
+    grouped = df_t.groupby(["bucket", "sentiment"]).size().unstack(fill_value=0)
+    for col in ["Positive", "Neutral", "Negative"]:
+        if col not in grouped.columns:
+            grouped[col] = 0
+    grouped = grouped.reset_index()
+    grouped.columns.name = None
+    return grouped[["bucket", "Positive", "Neutral", "Negative"]]
+
+
+def check_alert(df_all: pd.DataFrame, threshold: float = 0.4, window: int = 15) -> dict | None:
+    """Return alert info if negative ratio in last `window` messages exceeds threshold."""
+    if len(df_all) < window:
+        return None
+    recent = df_all.iloc[-window:]
+    neg_ratio = (recent["sentiment"] == "Negative").mean()
+    if neg_ratio >= threshold:
+        return {
+            "neg_ratio": neg_ratio,
+            "count": int((recent["sentiment"] == "Negative").sum()),
+            "window": window,
+        }
+    return None
+
+
+@st.cache_data(ttl=10, show_spinner=False)
+def compute_engagement(all_data_json: str, window: int = 50) -> dict:
+    """Engagement score (0-100) = weighted combo of message rate, positive ratio, question density."""
+    import json as _j
+    msgs = _j.loads(all_data_json)
+    if not msgs:
+        return {"score": 0, "rate": 0.0, "pos_ratio": 0.0, "q_density": 0.0, "grade": "—"}
+
+    recent = msgs[-window:]
+    n = len(recent)
+
+    rate = 0.0
+    try:
+        t0 = datetime.fromisoformat(recent[0]["time"])
+        t1 = datetime.fromisoformat(recent[-1]["time"])
+        elapsed = max((t1 - t0).total_seconds() / 60, 0.1)
+        rate = round(n / elapsed, 1)
+    except Exception:
+        rate = float(n)
+
+    pos_ratio = sum(1 for m in recent if m.get("sentiment") == "Positive") / max(n, 1)
+    q_density = sum(1 for m in recent if m.get("topic") == "Question") / max(n, 1)
+
+    rate_norm = min(rate / 60, 1.0)
+    score = round((rate_norm * 0.4 + pos_ratio * 0.4 + q_density * 0.2) * 100)
+
+    if score >= 70:   grade = "🔥 High"
+    elif score >= 40: grade = "⚡ Medium"
+    else:             grade = "💤 Low"
+
+    return {"score": score, "rate": rate, "pos_ratio": pos_ratio, "q_density": q_density, "grade": grade}
+
+
+@st.cache_data(ttl=10, show_spinner=False)
+def compute_top_contributors(all_data_json: str, top_n: int = 10) -> list[dict]:
+    """Return top N authors by message count with their sentiment breakdown."""
+    import json as _j
+    from collections import Counter
+    msgs = _j.loads(all_data_json)
+    if not msgs:
+        return []
+
+    author_data: dict[str, dict] = {}
+    for m in msgs:
+        a = m.get("author", "Unknown")
+        if a not in author_data:
+            author_data[a] = {"count": 0, "Positive": 0, "Neutral": 0, "Negative": 0}
+        author_data[a]["count"] += 1
+        s = m.get("sentiment", "Neutral")
+        if s in author_data[a]:
+            author_data[a][s] += 1
+
+    sorted_authors = sorted(author_data.items(), key=lambda x: x[1]["count"], reverse=True)[:top_n]
+    result = []
+    for author, d in sorted_authors:
+        total = max(d["count"], 1)
+        result.append({
+            "author":    author,
+            "count":     d["count"],
+            "pos_pct":   round(d["Positive"] / total * 100),
+            "neu_pct":   round(d["Neutral"]  / total * 100),
+            "neg_pct":   round(d["Negative"] / total * 100),
+        })
+    return result
+
+
+@st.cache_data(ttl=10, show_spinner=False)
+def compute_word_freq(all_data_json: str, sentiment_filter: str = "All",
+                      topic_filter: str = "All", top_n: int = 60) -> list[tuple[str, int]]:
+    """Return top N (word, count) pairs after filtering stopwords."""
+    import json as _j
+    from collections import Counter
+
+    STOPWORDS = {
+        "the","a","an","is","it","in","on","at","to","of","and","or","but","for",
+        "with","this","that","are","was","be","as","by","from","have","has","had",
+        "not","no","so","if","do","did","will","can","just","i","you","he","she",
+        "we","they","my","your","his","her","our","their","me","him","us","them",
+        "what","how","why","when","where","who","which","there","here","been",
+        "would","could","should","may","might","shall","than","then","now","also",
+        "more","very","too","up","out","about","into","over","after","before",
+        "yaar","bhi","hai","hain","ho","kar","ke","ki","ka","ko","se","ne","ye",
+        "vo","woh","aur","nahi","nhi","toh","toh","koi","kuch","ab","ek","hi",
+    }
+
+    msgs = _j.loads(all_data_json)
+    words: list[str] = []
+    for m in msgs:
+        if sentiment_filter != "All" and m.get("sentiment") != sentiment_filter:
+            continue
+        if topic_filter != "All" and m.get("topic") != topic_filter:
+            continue
+        text = re.sub(r"[^\w\s]", " ", m.get("text", "").lower())
+        for w in text.split():
+            if len(w) > 2 and w not in STOPWORDS and not w.isdigit():
+                words.append(w)
+
+    return Counter(words).most_common(top_n)
+
+
+def check_spam_alert(df_all: pd.DataFrame, threshold: float = 0.3, window: int = 20) -> dict | None:
+    """Return alert if spam ratio in last `window` messages exceeds threshold."""
+    if "topic" not in df_all.columns or len(df_all) < window:
+        return None
+    recent = df_all.iloc[-window:]
+    spam_ratio = (recent["topic"] == "Spam").mean()
+    if spam_ratio >= threshold:
+        return {
+            "spam_ratio": spam_ratio,
+            "count": int((recent["topic"] == "Spam").sum()),
+            "window": window,
+        }
+    return None
+
+
+# ── SESSION STATE INIT ────────────────────────────────────────
+MAX_STREAMS = 5
+STREAM_COLORS = ["#7c3aed", "#10b981", "#f59e0b", "#3b82f6", "#ec4899"]
+STREAM_NAMES  = ["A", "B", "C", "D", "E"]
+
+if "pinned_messages" not in st.session_state:
+    st.session_state.pinned_messages = []
+if "alert_dismissed" not in st.session_state:
+    st.session_state.alert_dismissed = False
+if "last_alert_count" not in st.session_state:
+    st.session_state.last_alert_count = 0
+# Multi-stream: list of dicts {video_id, redis_key, label, proc}
+# proc stores the Thread object (or None) for running-check compatibility
+if "streams" not in st.session_state:
+    st.session_state.streams = [
+        {"video_id": VIDEO_ID, "redis_key": "chat_messages", "label": "Stream A", "proc": None}
+    ]
+
+# ── SIDEBAR ─────────────────────��────────────────────────────
+with st.sidebar:
+    st.markdown(
+        '<div style="padding:12px 0 20px;">'
+        '<div style="font-size:1.35rem;font-weight:800;color:var(--text-1);letter-spacing:-0.02em;">📡 LivePulse</div>'
+        '<div style="font-size:0.75rem;color:var(--text-3);margin-top:2px;">YouTube Chat Analytics</div>'
+        '</div>', unsafe_allow_html=True
+    )
+    st.divider()
+
+    # ── Display Settings ──
+    st.markdown('<p style="font-size:0.68rem;font-weight:700;color:var(--accent);text-transform:uppercase;letter-spacing:0.1em;margin-bottom:8px;">Display Settings</p>', unsafe_allow_html=True)
+    refresh_rate = st.slider("Refresh interval (s)", 5, 60, 15)
+    msg_limit    = st.slider("Message window", 10, 200, 50)
+    auto_refresh = st.toggle("Live auto-refresh", value=True)
+    st.divider()
+
+    # ── Alert Settings ──
+    st.markdown('<p style="font-size:0.68rem;font-weight:700;color:var(--accent);text-transform:uppercase;letter-spacing:0.1em;margin-bottom:8px;">Alert Settings</p>', unsafe_allow_html=True)
+    alert_enabled    = st.toggle("Negative spike alerts", value=True)
+    alert_threshold  = st.slider("Neg alert threshold (%)", 20, 80, 40) / 100
+    alert_window     = st.slider("Alert window (msgs)", 5, 30, 15)
+    spam_alert_on    = st.toggle("Spam rate alerts", value=True)
+    spam_threshold   = st.slider("Spam alert threshold (%)", 10, 60, 30) / 100
+    st.divider()
+
+    # ── Multi-Stream Scraper Control ──
+    st.markdown('<p style="font-size:0.68rem;font-weight:700;color:var(--accent);text-transform:uppercase;letter-spacing:0.1em;margin-bottom:8px;">Stream Control</p>', unsafe_allow_html=True)
+
+    for idx, stream in enumerate(st.session_state.streams):
+        color = STREAM_COLORS[idx]
+        label = STREAM_NAMES[idx]
+        st.markdown(
+            f'<div style="font-size:0.72rem;font-weight:700;color:{color};text-transform:uppercase;'
+            f'letter-spacing:0.08em;margin:10px 0 4px;border-left:3px solid {color};padding-left:8px;">'
+            f'Stream {label}</div>',
+            unsafe_allow_html=True
+        )
+        vid_skey  = f"vid_{idx}"
+        rkey_skey = f"rkey_{idx}"
+        if vid_skey not in st.session_state:
+            st.session_state[vid_skey]  = stream["video_id"]
+        if rkey_skey not in st.session_state:
+            st.session_state[rkey_skey] = stream["redis_key"]
+
+        st.text_input("Video ID / URL", placeholder="e.g. eFSK2-QRB0A", key=vid_skey)
+        st.text_input("Store key", placeholder=f"chat_messages_{label.lower()}", key=rkey_skey)
+
+        sc1, sc2 = st.columns(2)
+        with sc1:
+            if st.button("▶ Start", key=f"start_{idx}", width='stretch'):
+                vid  = extract_video_id(st.session_state[vid_skey])
+                rkey = st.session_state[rkey_skey].strip() or f"chat_messages_{label.lower()}"
+                if vid:
+                    start_scraper(idx, vid, rkey)
+                    st.session_state.streams[idx]["proc"]      = _SCRAPER_THREADS.get(str(idx))
+                    st.session_state.streams[idx]["video_id"]  = vid
+                    st.session_state.streams[idx]["redis_key"] = rkey
+                    if idx == 0:
+                        title = fetch_video_title(vid)
+                        if title:
+                            _META["video_title"] = title
+                        else:
+                            _META.pop("video_title", None)
+                        st.session_state.alert_dismissed = False
+                    st.success(f"Stream {label} started → `{rkey}`")
+                else:
+                    st.error("Invalid video ID or URL")
+        with sc2:
+            if st.button("⏹ Stop", key=f"stop_{idx}", width='stretch'):
+                if is_scraper_running(idx):
+                    stop_scraper(idx)
+                    st.session_state.streams[idx]["proc"] = None
+                    st.success(f"Stream {label} stopped")
+                else:
+                    st.warning("Not running")
+
+        running   = is_scraper_running(idx)
+        dot_color = "#22c55e" if running else "#ef4444"
+        status    = "running" if running else "stopped"
+        st.markdown(f'<div style="font-size:0.72rem;color:{dot_color};margin-bottom:4px;">● {status}</div>', unsafe_allow_html=True)
+
+    st.divider()
+
+    # ── Add / Remove stream slots ──
+    add_col, rem_col = st.columns(2)
+    with add_col:
+        if len(st.session_state.streams) < MAX_STREAMS:
+            if st.button("＋ Add stream", width='stretch'):
+                n = len(st.session_state.streams)
+                st.session_state.streams.append({
+                    "video_id":  "",
+                    "redis_key": f"chat_messages_{STREAM_NAMES[n].lower()}",
+                    "label":     f"Stream {STREAM_NAMES[n]}",
+                    "proc":      None,
+                })
+                st.rerun()
+    with rem_col:
+        if len(st.session_state.streams) > 1:
+            if st.button("－ Remove last", width='stretch'):
+                removed = st.session_state.streams.pop()
+                removed_idx = len(st.session_state.streams)
+                stop_scraper(removed_idx)
+                st.rerun()
+
+    st.divider()
+
+    # ── Pinned Messages ──
+    st.markdown('<p style="font-size:0.68rem;font-weight:700;color:var(--accent);text-transform:uppercase;letter-spacing:0.1em;margin-bottom:8px;">Pinned Messages</p>', unsafe_allow_html=True)
+    pin_count = len(st.session_state.pinned_messages)
+    st.markdown(f'<div style="font-size:0.78rem;color:var(--text-3);">{pin_count} message{"s" if pin_count != 1 else ""} pinned</div>', unsafe_allow_html=True)
+    if pin_count > 0 and st.button("🗑 Clear pins", width='stretch'):
+        st.session_state.pinned_messages = []
+        st.rerun()
+    st.divider()
+
+    # ── Danger Zone ──
+    st.markdown('<p style="font-size:0.68rem;font-weight:700;color:#ef4444;text-transform:uppercase;letter-spacing:0.1em;margin-bottom:8px;">Danger Zone</p>', unsafe_allow_html=True)
+    if st.button("🗑 Clear all data", width='stretch'):
+        for s in st.session_state.streams:
+            store_delete(s["redis_key"])
+        st.session_state.pinned_messages = []
+        st.session_state.alert_dismissed = False
+        st.success("All stream data cleared.")
+    st.divider()
+    st.markdown(
+        '<div style="font-size:0.72rem;color:var(--text-3);text-align:center;line-height:1.6;">'
+        'Theme follows Streamlit settings<br>'
+        '<span style="font-size:0.65rem;">☰ → Settings → Theme</span>'
+        '</div>', unsafe_allow_html=True
+    )
+
+
+# ── PAGE HEADER ───────────────────────────────────────────────
+_video_title = _META.get("video_title")
+_subtitle = f"▶ {_video_title}" if _video_title else "Real-time sentiment · topic classification · engagement insights"
+
+col_title, col_live = st.columns([7, 1])
+with col_title:
+    st.markdown(
+        '<div style="padding:8px 0 4px;">'
+        '<div style="font-size:2rem;font-weight:800;color:var(--text-1);letter-spacing:-0.04em;">YouTube Live Chat Analytics</div>'
+        f'<div style="font-size:1.25rem;color:var(--accent-text);font-weight:600;margin-top:6px;">{_subtitle}</div>'
+        '</div>', unsafe_allow_html=True
+    )
+with col_live:
+    st.markdown(
+        '<div style="text-align:right;padding-top:22px;">'
+        '<span class="live-dot"></span>'
+        '<span style="font-size:0.78rem;color:var(--live);font-weight:700;letter-spacing:0.05em;">LIVE</span>'
+        '</div>', unsafe_allow_html=True
+    )
+
+st.divider()
+
+# ── DATA LOAD ─────────────────────────────────────────────────
+# Use stream A's redis_key (session state is the source of truth)
+_primary_key = st.session_state.streams[0]["redis_key"]
+all_data = load_stream_data(_primary_key)
+data     = all_data[-msg_limit:] if len(all_data) > msg_limit else all_data
+
+if not all_data:
+    st.markdown(
+        '<div class="empty-state">'
+        '<div class="empty-icon">📭</div>'
+        '<div class="empty-title">No messages yet</div>'
+        '<div class="empty-sub">Set a video ID in the sidebar, then click ▶ Start</div>'
+        '</div>', unsafe_allow_html=True
+    )
+    if auto_refresh:
+        time.sleep(refresh_rate)
+        st.rerun()
+    st.stop()
+
+df     = pd.DataFrame(data)
+all_df = pd.DataFrame(all_data)
+
+df["sentiment"]     = df["sentiment"].apply(clean_sentiment)
+df["topic"]         = df["topic"].apply(clean_topic) if "topic" in df.columns else "General"
+all_df["sentiment"] = all_df["sentiment"].apply(clean_sentiment)
+all_df["topic"]     = all_df["topic"].apply(clean_topic) if "topic" in all_df.columns else "General"
+
+# ── ALERT BANNERS ─────────────────────────────────────────────
+if alert_enabled:
+    alert = check_alert(all_df, threshold=alert_threshold, window=alert_window)
+    total_now = len(all_df)
+    if total_now != st.session_state.last_alert_count:
+        st.session_state.last_alert_count = total_now
+        if alert:
+            st.session_state.alert_dismissed = False
+
+    if alert and not st.session_state.alert_dismissed:
+        a1, a2 = st.columns([8, 1])
+        with a1:
+            st.markdown(
+                f'<div class="alert-banner">'
+                f'<span class="alert-icon">🚨</span>'
+                f'<div>'
+                f'<div class="alert-text">Negative sentiment spike — {alert["neg_ratio"]*100:.0f}% negative in last {alert["window"]} messages</div>'
+                f'<div class="alert-sub">{alert["count"]} of {alert["window"]} messages are negative. Consider moderating.</div>'
+                f'</div></div>',
+                unsafe_allow_html=True
+            )
+        with a2:
+            if st.button("✕ Dismiss", key="dismiss_alert"):
+                st.session_state.alert_dismissed = True
+                st.rerun()
+
+if spam_alert_on:
+    spam_alert = check_spam_alert(all_df, threshold=spam_threshold, window=alert_window)
+    if spam_alert and not st.session_state.get("spam_dismissed", False):
+        s1, s2 = st.columns([8, 1])
+        with s1:
+            st.markdown(
+                f'<div class="spam-alert">'
+                f'<span class="alert-icon">🛡️</span>'
+                f'<div>'
+                f'<div class="spam-alert-text">Spam surge detected — {spam_alert["spam_ratio"]*100:.0f}% spam in last {spam_alert["window"]} messages</div>'
+                f'<div class="spam-alert-sub">{spam_alert["count"]} spam messages detected. Chat may be under flood attack.</div>'
+                f'</div></div>',
+                unsafe_allow_html=True
+            )
+        with s2:
+            if st.button("✕", key="dismiss_spam"):
+                st.session_state.spam_dismissed = True
+                st.rerun()
+    elif not spam_alert:
+        st.session_state.spam_dismissed = False
+
+# ── CUMULATIVE STATS ──────────────────────────────────────────
+all_counts = all_df["sentiment"].value_counts().to_dict()
+c_pos   = all_counts.get("Positive", 0)
+c_neu   = all_counts.get("Neutral",  0)
+c_neg   = all_counts.get("Negative", 0)
+c_total = max(c_pos + c_neu + c_neg, 1)
+
+velocity = compute_velocity(json.dumps([{"sentiment": m.get("sentiment","Neutral")} for m in all_data]))
+
+st.markdown(
+    '<div class="sec-hdr"><span class="sec-ttl">Cumulative Sentiment</span><span class="sec-pill">All Time</span></div>',
+    unsafe_allow_html=True
+)
+
+v1, v2, v3, v4, v5 = st.columns([1, 1, 1, 1, 1])
+with v1:
+    st.markdown(
+        f'<div class="stat-card"><div class="stat-accent" style="background:linear-gradient(90deg,#22c55e,#16a34a);"></div>'
+        f'<div class="stat-number" style="color:#22c55e;">{c_pos}</div><div class="stat-label">Positive</div><div class="stat-sub">{c_pos/c_total*100:.1f}% of total</div></div>',
+        unsafe_allow_html=True
+    )
+with v2:
+    st.markdown(
+        f'<div class="stat-card"><div class="stat-accent" style="background:linear-gradient(90deg,#eab308,#ca8a04);"></div>'
+        f'<div class="stat-number" style="color:#eab308;">{c_neu}</div><div class="stat-label">Neutral</div><div class="stat-sub">{c_neu/c_total*100:.1f}% of total</div></div>',
+        unsafe_allow_html=True
+    )
+with v3:
+    st.markdown(
+        f'<div class="stat-card"><div class="stat-accent" style="background:linear-gradient(90deg,#ef4444,#dc2626);"></div>'
+        f'<div class="stat-number" style="color:#ef4444;">{c_neg}</div><div class="stat-label">Negative</div><div class="stat-sub">{c_neg/c_total*100:.1f}% of total</div></div>',
+        unsafe_allow_html=True
+    )
+with v4:
+    st.markdown(
+        f'<div class="stat-card"><div class="stat-accent" style="background:linear-gradient(90deg,#7c3aed,#4f46e5);"></div>'
+        f'<div class="stat-number" style="color:var(--accent-text);">{c_total}</div><div class="stat-label">Total</div><div class="stat-sub">all time</div></div>',
+        unsafe_allow_html=True
+    )
+with v5:
+    vc = velocity["color"]
+    st.markdown(
+        f'<div class="velocity-card" style="border-color:{vc}44;">'
+        f'<div class="velocity-arrow" style="color:{vc};">{velocity["direction"]}</div>'
+        f'<div>'
+        f'<div class="velocity-val" style="color:{vc};">{velocity["label"]}</div>'
+        f'<div class="velocity-label">Sentiment Velocity<br>'
+        f'<span style="color:{vc};">{velocity["delta"]:+.0%} pos shift</span></div>'
+        f'</div></div>',
+        unsafe_allow_html=True
+    )
+
+
+# ── WINDOW METRICS ────────────────────────────────────────────
+st.divider()
+counts = df["sentiment"].value_counts().to_dict()
+pos    = counts.get("Positive", 0)
+neu    = counts.get("Neutral",  0)
+neg    = counts.get("Negative", 0)
+total  = max(pos + neu + neg, 1)
+
+st.markdown(
+    f'<div class="sec-hdr"><span class="sec-ttl">Window Snapshot</span><span class="sec-pill">Last {msg_limit} msgs</span></div>',
+    unsafe_allow_html=True
+)
+c1, c2, c3, c4 = st.columns(4)
+c1.metric("Messages",  total)
+c2.metric("Positive",  pos,  f"{pos/total*100:.1f}%")
+c3.metric("Neutral",   neu,  f"{neu/total*100:.1f}%")
+c4.metric("Negative",  neg,  f"{neg/total*100:.1f}%")
+
+# ── SENTIMENT CHARTS ──────────────────────────────────────────
+st.divider()
+col_l, col_r = st.columns(2)
+
+with col_l:
+    st.markdown('<div class="chart-wrap">', unsafe_allow_html=True)
+    st.markdown('<div class="chart-title">Sentiment Distribution</div><div class="chart-sub">Message count by sentiment class</div>', unsafe_allow_html=True)
+    fig_bar = go.Figure(go.Bar(
+        x=["Positive", "Neutral", "Negative"],
+        y=[pos, neu, neg],
+        marker_color=["#22c55e", "#eab308", "#ef4444"],
+        marker_line_width=0,
+        text=[pos, neu, neg],
+        textposition="outside",
+        textfont=dict(size=12),
+        hovertemplate="<b>%{x}</b><br>Count: %{y}<extra></extra>",
+    ))
+    fig_bar.update_layout(**plotly_layout(260))
+    st.plotly_chart(fig_bar, width='stretch', config={"displayModeBar": False})
+    bar_hdr, bar_dl = st.columns([1, 1])
+    with bar_hdr:
+        show_bar_data = st.checkbox("View data", key="show_bar")
+    with bar_dl:
+        bar_df = pd.DataFrame({"Sentiment": ["Positive", "Neutral", "Negative"], "Count": [pos, neu, neg]})
+        csv_download(bar_df, "Download CSV", "sentiment_distribution.csv")
+    if show_bar_data:
+        st.dataframe(bar_df, width='stretch', hide_index=True)
+    st.markdown('</div>', unsafe_allow_html=True)
+
+with col_r:
+    st.markdown('<div class="chart-wrap">', unsafe_allow_html=True)
+    st.markdown('<div class="chart-title">Sentiment Breakdown</div><div class="chart-sub">Proportional share per class</div>', unsafe_allow_html=True)
+    fig_pie = go.Figure(go.Pie(
+        labels=["Positive", "Neutral", "Negative"],
+        values=[pos, neu, neg],
+        marker_colors=["#22c55e", "#eab308", "#ef4444"],
+        hole=0.58,
+        textinfo="percent",
+        hovertemplate="<b>%{label}</b><br>%{value} messages (%{percent})<extra></extra>",
+    ))
+    fig_pie.update_layout(
+        **{**plotly_layout(260),
+           "showlegend": True,
+           "legend": dict(orientation="h", y=-0.08, font=dict(size=11))}
+    )
+    st.plotly_chart(fig_pie, width='stretch', config={"displayModeBar": False})
+    pie_hdr, pie_dl = st.columns([1, 1])
+    with pie_hdr:
+        show_pie_data = st.checkbox("View data", key="show_pie")
+    with pie_dl:
+        pie_df = pd.DataFrame({
+            "Sentiment": ["Positive", "Neutral", "Negative"],
+            "Count": [pos, neu, neg],
+            "Percentage": [f"{pos/total*100:.1f}%", f"{neu/total*100:.1f}%", f"{neg/total*100:.1f}%"]
+        })
+        csv_download(pie_df, "Download CSV", "sentiment_breakdown.csv")
+    if show_pie_data:
+        st.dataframe(pie_df, width='stretch', hide_index=True)
+    st.markdown('</div>', unsafe_allow_html=True)
+
+# ── Confidence trend ──────────────────────────────────────────
+if "confidence" in df.columns:
+    st.divider()
+    st.markdown('<div class="chart-wrap">', unsafe_allow_html=True)
+    st.markdown('<div class="chart-title">Confidence Trend</div><div class="chart-sub">Model confidence per message in current window</div>', unsafe_allow_html=True)
+    conf_df = df[["confidence"]].reset_index(drop=True)
+    conf_df.index.name = "message_index"
+    fig_line = go.Figure(go.Scatter(
+        x=conf_df.index,
+        y=conf_df["confidence"],
+        mode="lines",
+        line=dict(color="#7c3aed", width=2),
+        fill="tozeroy",
+        fillcolor="rgba(124,58,237,0.08)",
+        hovertemplate="Msg %{x}: <b>%{y:.2f}</b><extra></extra>",
+    ))
+    fig_line.update_layout(**plotly_layout(180))
+    fig_line.update_yaxes(range=[0, 1])
+    st.plotly_chart(fig_line, width='stretch', config={"displayModeBar": False})
+    conf_hdr, conf_dl = st.columns([1, 1])
+    with conf_hdr:
+        show_conf_data = st.checkbox("View data", key="show_conf")
+    with conf_dl:
+        conf_export = conf_df.reset_index()
+        conf_export.columns = ["message_index", "confidence"]
+        csv_download(conf_export, "Download CSV", "confidence_trend.csv")
+    if show_conf_data:
+        st.dataframe(conf_export, width='stretch', hide_index=True)
+    st.markdown('</div>', unsafe_allow_html=True)
+
+
+# ── SENTIMENT HEATMAP OVER TIME ───────────────────────────────
+st.divider()
+st.markdown(
+    '<div class="sec-hdr"><span class="sec-ttl">Sentiment Heatmap</span><span class="sec-pill">Over Time</span></div>',
+    unsafe_allow_html=True
+)
+heatmap_data = build_heatmap_data(json.dumps([{"time": m.get("time",""), "sentiment": m.get("sentiment","Neutral")} for m in all_data]), bucket_minutes=1)
+
+if not heatmap_data.empty:
+    st.markdown('<div class="chart-wrap">', unsafe_allow_html=True)
+    st.markdown('<div class="chart-title">Sentiment Over Time</div><div class="chart-sub">Message volume per sentiment per minute bucket</div>', unsafe_allow_html=True)
+
+    fig_heat = go.Figure()
+    for sent, color in [("Positive", "#22c55e"), ("Neutral", "#eab308"), ("Negative", "#ef4444")]:
+        fig_heat.add_trace(go.Bar(
+            x=heatmap_data["bucket"],
+            y=heatmap_data[sent],
+            name=sent,
+            marker_color=color,
+            opacity=0.85,
+            hovertemplate=f"<b>{sent}</b><br>%{{x}}<br>Count: %{{y}}<extra></extra>",
+        ))
+
+    layout = plotly_layout(220)
+    layout["barmode"] = "stack"
+    layout["showlegend"] = True
+    layout["legend"] = dict(orientation="h", y=1.08, font=dict(size=11))
+    layout["xaxis"]["tickformat"] = "%H:%M"
+    fig_heat.update_layout(**layout)
+    st.plotly_chart(fig_heat, width='stretch', config={"displayModeBar": False})
+
+    heat_hdr, heat_dl = st.columns([1, 1])
+    with heat_hdr:
+        show_heat_data = st.checkbox("View data", key="show_heat")
+    with heat_dl:
+        csv_download(heatmap_data.rename(columns={"bucket": "time_bucket"}), "Download CSV", "sentiment_heatmap.csv")
+    if show_heat_data:
+        st.dataframe(heatmap_data.rename(columns={"bucket": "time_bucket"}), width='stretch', hide_index=True)
+    st.markdown('</div>', unsafe_allow_html=True)
+else:
+    st.info("Not enough timestamped data for heatmap yet.")
+
+# ── TOPIC DISTRIBUTION ────────────────────────────────────────
+st.divider()
+st.markdown(
+    '<div class="sec-hdr"><span class="sec-ttl">Topic Distribution</span><span class="sec-pill">All Time</span></div>',
+    unsafe_allow_html=True
+)
+
+topic_counts = {
+    label: int((all_df["topic"] == label).sum())
+    for label in TOPIC_LABELS
+}
+
+pills = '<div class="topic-grid">'
+for label in TOPIC_LABELS:
+    color = TOPIC_COLOR[label]
+    count = topic_counts[label]
+    pills += (
+        f'<div class="topic-pill" style="border:1px solid {color}44;">'
+        f'<div class="topic-count" style="color:{color};">{count}</div>'
+        f'<div class="topic-name">{label}</div>'
+        f'</div>'
+    )
+pills += '</div>'
+st.markdown(pills, unsafe_allow_html=True)
+
+st.markdown('<div class="chart-wrap">', unsafe_allow_html=True)
+st.markdown('<div class="chart-title">Topic Breakdown</div><div class="chart-sub">All-time message count per topic category</div>', unsafe_allow_html=True)
+fig_topic = go.Figure(go.Bar(
+    x=TOPIC_LABELS,
+    y=[topic_counts[l] for l in TOPIC_LABELS],
+    marker_color=[TOPIC_COLOR[l] for l in TOPIC_LABELS],
+    marker_line_width=0,
+    text=[topic_counts[l] for l in TOPIC_LABELS],
+    textposition="outside",
+    textfont=dict(size=11),
+    hovertemplate="<b>%{x}</b><br>Count: %{y}<extra></extra>",
+))
+fig_topic.update_layout(**plotly_layout(250))
+st.plotly_chart(fig_topic, width='stretch', config={"displayModeBar": False})
+topic_hdr, topic_dl = st.columns([1, 1])
+with topic_hdr:
+    show_topic_data = st.checkbox("View data", key="show_topic")
+with topic_dl:
+    topic_df = pd.DataFrame({"Topic": TOPIC_LABELS, "Count": [topic_counts[l] for l in TOPIC_LABELS]})
+    csv_download(topic_df, "Download CSV", "topic_distribution.csv")
+if show_topic_data:
+    st.dataframe(topic_df, width='stretch', hide_index=True)
+st.markdown('</div>', unsafe_allow_html=True)
+
+
+# ── ENGAGEMENT SCORE ─────────────────────────────────────────
+st.divider()
+st.markdown(
+    '<div class="sec-hdr"><span class="sec-ttl">Engagement Score</span><span class="sec-pill">Live</span></div>',
+    unsafe_allow_html=True
+)
+
+_eng_json = json.dumps([{"sentiment": m.get("sentiment","Neutral"), "topic": m.get("topic","General"), "time": m.get("time","")} for m in all_data])
+eng = compute_engagement(_eng_json)
+
+ec1, ec2, ec3, ec4 = st.columns([2, 1, 1, 1])
+with ec1:
+    score_color = "#22c55e" if eng["score"] >= 70 else "#eab308" if eng["score"] >= 40 else "#ef4444"
+    bar_w = eng["score"]
+    st.markdown(
+        f'<div class="engage-card" style="border-color:{score_color}44;">'
+        f'<div class="engage-score" style="color:{score_color};">{eng["score"]}</div>'
+        f'<div class="engage-label">Engagement Score / 100 — {eng["grade"]}</div>'
+        f'<div class="engage-bar-bg"><div class="engage-bar-fill" style="width:{bar_w}%;background:{score_color};"></div></div>'
+        f'<div class="engage-breakdown">'
+        f'<div class="engage-item">Msg rate <span>{eng["rate"]}/min</span></div>'
+        f'<div class="engage-item">Positive <span>{eng["pos_ratio"]*100:.0f}%</span></div>'
+        f'<div class="engage-item">Questions <span>{eng["q_density"]*100:.0f}%</span></div>'
+        f'</div></div>',
+        unsafe_allow_html=True
+    )
+with ec2:
+    st.metric("Msgs/min", f"{eng['rate']:.1f}")
+with ec3:
+    st.metric("Positive ratio", f"{eng['pos_ratio']*100:.0f}%")
+with ec4:
+    st.metric("Question density", f"{eng['q_density']*100:.0f}%")
+
+# ── TOP CONTRIBUTORS ──────────────────────────────────────────
+st.divider()
+st.markdown(
+    '<div class="sec-hdr"><span class="sec-ttl">Top Contributors</span><span class="sec-pill">All Time</span></div>',
+    unsafe_allow_html=True
+)
+
+_contrib_json = json.dumps([{"author": m.get("author",""), "sentiment": m.get("sentiment","Neutral")} for m in all_data])
+contributors = compute_top_contributors(_contrib_json)
+
+if contributors:
+    max_count = contributors[0]["count"]
+    lc1, lc2 = st.columns([3, 2])
+    with lc1:
+        rank_icons   = {1: "🥇", 2: "🥈", 3: "🥉"}
+        rank_classes = {1: "gold", 2: "silver", 3: "bronze"}
+        for rank, c in enumerate(contributors, 1):
+            bar_pct  = int(c["count"] / max(max_count, 1) * 100)
+            rank_cls = rank_classes.get(rank, "")
+            rank_icon = rank_icons.get(rank, f"#{rank}")
+            author   = c["author"]
+            count    = c["count"]
+            pos_pct  = c["pos_pct"]
+            neu_pct  = c["neu_pct"]
+            neg_pct  = c["neg_pct"]
+            html = (
+                f'<div class="leaderboard-row">'
+                f'<div class="lb-rank {rank_cls}">{rank_icon}</div>'
+                f'<div class="lb-author">{author}</div>'
+                f'<div class="lb-bar"><div class="lb-bar-fill" style="width:{bar_pct}%;background:var(--accent);"></div></div>'
+                f'<div class="lb-sent">'
+                f'<span class="lb-dot" style="background:#22c55e;" title="Positive {pos_pct}%"></span>'
+                f'<span class="lb-dot" style="background:#eab308;" title="Neutral {neu_pct}%"></span>'
+                f'<span class="lb-dot" style="background:#ef4444;" title="Negative {neg_pct}%"></span>'
+                f'</div>'
+                f'<div class="lb-count">{count} msgs</div>'
+                f'</div>'
+            )
+            st.markdown(html, unsafe_allow_html=True)
+    with lc2:
+        top5 = contributors[:5]
+        fig_lb = go.Figure()
+        for sent, color in [("pos_pct","#22c55e"),("neu_pct","#eab308"),("neg_pct","#ef4444")]:
+            fig_lb.add_trace(go.Bar(
+                y=[c["author"][:18] for c in top5],
+                x=[c[sent] for c in top5],
+                name=sent.replace("_pct","").capitalize(),
+                orientation="h",
+                marker_color=color,
+                hovertemplate="%{y}: %{x}%<extra></extra>",
+            ))
+        layout_lb = plotly_layout(260)
+        layout_lb["barmode"] = "stack"
+        layout_lb["showlegend"] = True
+        layout_lb["legend"] = dict(orientation="h", y=1.1, font=dict(size=10))
+        layout_lb["xaxis"]["range"] = [0, 100]
+        layout_lb["xaxis"]["ticksuffix"] = "%"
+        fig_lb.update_layout(**layout_lb)
+        st.plotly_chart(fig_lb, width='stretch', config={"displayModeBar": False})
+
+    contrib_df = pd.DataFrame(contributors)
+    csv_download(contrib_df, "Download CSV", "top_contributors.csv")
+else:
+    st.info("Not enough data yet.")
+
+# ── WORD CLOUD ────────────────────────────────────────────────
+st.divider()
+st.markdown(
+    '<div class="sec-hdr"><span class="sec-ttl">Word Cloud</span><span class="sec-pill">All Time</span></div>',
+    unsafe_allow_html=True
+)
+
+wc_col1, wc_col2, wc_col3 = st.columns([1, 1, 3])
+with wc_col1:
+    wc_sentiment = st.selectbox("Filter sentiment", ["All", "Positive", "Neutral", "Negative"], key="wc_sent")
+with wc_col2:
+    wc_topic = st.selectbox("Filter topic", ["All"] + TOPIC_LABELS, key="wc_topic")
+
+_wc_json = json.dumps([{"text": m.get("text",""), "sentiment": m.get("sentiment","Neutral"), "topic": m.get("topic","General")} for m in all_data])
+word_freq = compute_word_freq(_wc_json, sentiment_filter=wc_sentiment, topic_filter=wc_topic)
+
+if word_freq:
+    try:
+        from wordcloud import WordCloud
+        import matplotlib.pyplot as plt
+        import io
+
+        freq_dict = dict(word_freq)
+        wc = WordCloud(
+            width=900, height=320,
+            background_color="white",
+            colormap="cool",
+            max_words=80,
+            prefer_horizontal=0.85,
+            collocations=False,
+        ).generate_from_frequencies(freq_dict)
+
+        st.markdown('<div class="chart-wrap">', unsafe_allow_html=True)
+        st.image(wc.to_array(), width="stretch")
+        st.markdown('</div>', unsafe_allow_html=True)
+
+        top20 = word_freq[:20]
+        fig_wf = go.Figure(go.Bar(
+            x=[w for w, _ in top20],
+            y=[c for _, c in top20],
+            marker_color="#7c3aed",
+            marker_line_width=0,
+            hovertemplate="<b>%{x}</b><br>%{y} times<extra></extra>",
+        ))
+        layout_wf = plotly_layout(180)
+        fig_wf.update_layout(**layout_wf)
+        st.plotly_chart(fig_wf, width='stretch', config={"displayModeBar": False})
+
+    except ImportError:
+        top20 = word_freq[:20]
+        fig_wf = go.Figure(go.Bar(
+            x=[w for w, _ in top20],
+            y=[c for _, c in top20],
+            marker_color="#7c3aed",
+            marker_line_width=0,
+        ))
+        fig_wf.update_layout(**plotly_layout(200))
+        st.plotly_chart(fig_wf, width='stretch', config={"displayModeBar": False})
+else:
+    st.info("Not enough text data yet.")
+
+# ── MULTI-STREAM COMPARISON ───────────────────────────────────
+active_streams = [s for s in st.session_state.streams if store_llen(s["redis_key"]) > 0]
+
+if len(active_streams) > 1:
+    st.divider()
+    n_streams = len(active_streams)
+    st.markdown(
+        f'<div class="sec-hdr"><span class="sec-ttl">Multi-Stream Comparison</span>'
+        f'<span class="sec-pill">{n_streams} streams</span></div>',
+        unsafe_allow_html=True
+    )
+
+    def stream_summary_chart(stream_df, color):
+        counts_s = stream_df["sentiment"].value_counts().to_dict()
+        p = counts_s.get("Positive", 0)
+        n = counts_s.get("Neutral",  0)
+        g = counts_s.get("Negative", 0)
+        t = max(p + n + g, 1)
+        fig = go.Figure(go.Bar(
+            x=["Positive", "Neutral", "Negative"],
+            y=[p, n, g],
+            marker_color=["#22c55e", "#eab308", "#ef4444"],
+            marker_line_width=0,
+            text=[p, n, g],
+            textposition="outside",
+            hovertemplate="<b>%{x}</b><br>%{y}<extra></extra>",
+        ))
+        fig.update_layout(**plotly_layout(200))
+        return fig, p, n, g, t
+
+    chunk_size = 3
+    for row_start in range(0, n_streams, chunk_size):
+        row_streams = active_streams[row_start:row_start + chunk_size]
+        cols = st.columns(len(row_streams))
+        for col, stream in zip(cols, row_streams):
+            sidx   = st.session_state.streams.index(stream)
+            color  = STREAM_COLORS[sidx]
+            slabel = STREAM_NAMES[sidx]
+            s_data = load_stream_data(stream["redis_key"])
+            if not s_data:
+                col.info(f"No data yet for Stream {slabel}")
+                continue
+            s_df = pd.DataFrame(s_data)
+            s_df["sentiment"] = s_df["sentiment"].apply(clean_sentiment)
+            s_df["topic"]     = s_df["topic"].apply(clean_topic) if "topic" in s_df.columns else "General"
+            fig, p, n, g, t = stream_summary_chart(s_df, color)
+            with col:
+                st.markdown(
+                    f'<span class="compare-label" style="background:{color}18;color:{color};border:1px solid {color}44;">'
+                    f'Stream {slabel} — {stream["redis_key"]}</span>',
+                    unsafe_allow_html=True
+                )
+                st.plotly_chart(fig, width='stretch', config={"displayModeBar": False})
+                st.markdown(
+                    f'<div style="font-size:0.78rem;color:var(--text-3);margin-bottom:8px;">'
+                    f'{t} msgs · <span style="color:#22c55e;">{p/t*100:.1f}% pos</span> · '
+                    f'<span style="color:#ef4444;">{g/t*100:.1f}% neg</span></div>',
+                    unsafe_allow_html=True
+                )
+
+    st.markdown('<div class="chart-wrap" style="margin-top:14px;">', unsafe_allow_html=True)
+    st.markdown('<div class="chart-title">Positive Ratio Over Time</div><div class="chart-sub">Rolling positive % per stream</div>', unsafe_allow_html=True)
+    fig_overlay = go.Figure()
+    for stream in active_streams:
+        sidx  = st.session_state.streams.index(stream)
+        color = STREAM_COLORS[sidx]
+        slabel = STREAM_NAMES[sidx]
+        s_data = load_stream_data(stream["redis_key"])
+        if not s_data:
+            continue
+        s_df = pd.DataFrame(s_data)
+        s_df["sentiment"] = s_df["sentiment"].apply(clean_sentiment)
+        s_df["is_pos"]    = (s_df["sentiment"] == "Positive").astype(int)
+        s_df["rolling"]   = s_df["is_pos"].rolling(10, min_periods=1).mean() * 100
+        fig_overlay.add_trace(go.Scatter(
+            x=list(range(len(s_df))),
+            y=s_df["rolling"],
+            mode="lines",
+            name=f"Stream {slabel}",
+            line=dict(color=color, width=2),
+            hovertemplate=f"Stream {slabel} msg %{{x}}: %{{y:.1f}}%<extra></extra>",
+        ))
+    layout_ov = plotly_layout(200)
+    layout_ov["showlegend"] = True
+    layout_ov["legend"] = dict(orientation="h", y=1.1, font=dict(size=11))
+    layout_ov["yaxis"]["range"] = [0, 100]
+    fig_overlay.update_layout(**layout_ov)
+    st.plotly_chart(fig_overlay, width='stretch', config={"displayModeBar": False})
+    st.markdown('</div>', unsafe_allow_html=True)
+
+elif len(st.session_state.streams) > 1:
+    st.divider()
+    st.info("Add video IDs to your extra stream slots and click ▶ Start to enable multi-stream comparison.")
+
+# ── PINNED MESSAGES ───────────────────────────────────────────
+if st.session_state.pinned_messages:
+    st.divider()
+    st.markdown(
+        '<div class="sec-hdr"><span class="sec-ttl">📌 Pinned Messages</span>'
+        f'<span class="sec-pill">{len(st.session_state.pinned_messages)} pinned</span></div>',
+        unsafe_allow_html=True
+    )
+    for idx, pmsg in enumerate(st.session_state.pinned_messages):
+        s       = pmsg.get("sentiment", "Neutral")
+        s_color = SENT_COLORS.get(s, "#6b7280")
+        t_color = TOPIC_COLOR.get(pmsg.get("topic", "General"), "#6b7280")
+        pcol1, pcol2 = st.columns([10, 1])
+        with pcol1:
+            st.markdown(
+                f'<div class="chat-card chat-pinned">'
+                f'<div class="chat-author">📌 {pmsg.get("author", "Unknown")}</div>'
+                f'<div class="chat-text">{pmsg.get("text", "")}</div>'
+                f'<div class="chat-badges">'
+                f'<span class="badge pin-badge">Pinned</span>'
+                f'<span class="badge" style="color:{s_color};">{s}</span>'
+                f'<span class="badge" style="color:{t_color};">{pmsg.get("topic","General")}</span>'
+                f'<span class="badge">{pmsg.get("time","")[:19]}</span>'
+                f'</div></div>',
+                unsafe_allow_html=True
+            )
+        with pcol2:
+            if st.button("✕", key=f"unpin_{idx}"):
+                st.session_state.pinned_messages.pop(idx)
+                st.rerun()
+
+
+# ── LIVE CHAT FEED ────────────────────────────────────────────
+st.divider()
+st.markdown('<div class="sec-hdr"><span class="sec-ttl">Live Chat Feed</span></div>', unsafe_allow_html=True)
+
+f1, f2, f3 = st.columns([1, 1, 2])
+with f1:
+    sentiment_filter = st.selectbox("Sentiment", ["All", "Positive", "Neutral", "Negative"])
+with f2:
+    topic_filter = st.selectbox("Topic", ["All"] + TOPIC_LABELS)
+with f3:
+    search_term = st.text_input("Search messages", placeholder="Filter by keyword...")
+
+filtered = df.copy()
+if sentiment_filter != "All":
+    filtered = filtered[filtered["sentiment"] == sentiment_filter]
+if topic_filter != "All":
+    filtered = filtered[filtered["topic"] == topic_filter]
+if search_term:
+    filtered = filtered[filtered["text"].str.contains(search_term, case=False, na=False)]
+
+feed_hdr, feed_dl = st.columns([3, 1])
+with feed_hdr:
+    st.markdown(
+        f'<div style="font-size:0.78rem;color:var(--text-3);margin-bottom:12px;">Showing {len(filtered)} of {len(df)} messages</div>',
+        unsafe_allow_html=True
+    )
+with feed_dl:
+    if not filtered.empty:
+        export_cols = [c for c in ["author", "text", "sentiment", "confidence", "topic", "time"] if c in filtered.columns]
+        csv_download(filtered[export_cols], "Download Feed CSV", "chat_feed.csv")
+
+SENT_ICON = {"Positive": "🟢", "Negative": "🔴", "Neutral": "🟡"}
+
+pinned_texts = {m.get("text", "") for m in st.session_state.pinned_messages}
+
+for i, (_, row) in enumerate(filtered.iloc[::-1].iterrows()):
+    s          = row.get("sentiment", "Neutral")
+    conf_pct   = int(row.get("confidence", 0) * 100)
+    topic      = clean_topic(row.get("topic", "General"))
+    t_color    = TOPIC_COLOR.get(topic, "#6b7280")
+    s_color    = SENT_COLORS.get(s, "#6b7280")
+    s_icon     = SENT_ICON.get(s, "⚪")
+    conf_color = "#22c55e" if conf_pct >= 70 else "#eab308" if conf_pct >= 40 else "#ef4444"
+    msg_text   = row.get("text", "")
+    is_pinned  = msg_text in pinned_texts
+
+    card_class = f"chat-card chat-{s.lower()}" + (" chat-pinned" if is_pinned else "")
+
+    msg_col, pin_col = st.columns([11, 1])
+    with msg_col:
+        st.markdown(
+            f'<div class="{card_class}">'
+            f'<div class="chat-author">{s_icon} {row.get("author", "Unknown")}'
+            + (' <span style="font-size:0.7rem;color:#eab308;">📌</span>' if is_pinned else '') +
+            f'</div>'
+            f'<div class="chat-text">{msg_text}</div>'
+            f'<div class="chat-badges">'
+            f'<span class="badge" style="color:{s_color};border-color:{s_color}33;">{s}</span>'
+            f'<span class="badge" style="color:{conf_color};">Confidence: {conf_pct}%</span>'
+            f'<span class="badge" style="color:{t_color};border-color:{t_color}33;">{topic}</span>'
+            f'</div></div>',
+            unsafe_allow_html=True
+        )
+    with pin_col:
+        if is_pinned:
+            if st.button("📌", key=f"unpin_feed_{i}", help="Unpin this message"):
+                st.session_state.pinned_messages = [
+                    m for m in st.session_state.pinned_messages if m.get("text") != msg_text
+                ]
+                st.rerun()
+        else:
+            if st.button("📍", key=f"pin_{i}", help="Pin this message"):
+                msg_dict = row.to_dict()
+                if msg_dict not in st.session_state.pinned_messages:
+                    st.session_state.pinned_messages.append(msg_dict)
+                st.rerun()
+
+# ── AUTO REFRESH ──────────────────────────────────────────────
+if auto_refresh:
+    time.sleep(refresh_rate)
+    st.rerun()

backend/config.py

@@ -1,6 +1,6 @@
 import os
 
-VIDEO_ID   = os.getenv("VIDEO_ID", "J3qcYJAhCMY")
+VIDEO_ID   = os.getenv("VIDEO_ID", "0AtIKJ9dL80")
 REDIS_HOST = os.getenv("REDIS_HOST", "localhost")
 REDIS_PORT = int(os.getenv("REDIS_PORT", 6379))
 REDIS_DB   = int(os.getenv("REDIS_DB", 0))

backend/main.py

@@ -47,7 +47,7 @@ r = redis.Redis(
     socket_connect_timeout=5,
 )
 
-VALID_TOPICS    = {"Appreciation", "Question", "Promo", "Spam", "General"}
+VALID_TOPICS    = {"Appreciation", "Question", "Promo", "Spam", "General", "MCQ Answer"}
 VALID_SENTIMENT = {"Positive", "Neutral", "Negative"}
 
 

backend/scraper.py

@@ -4,13 +4,13 @@ backend/scraper.py
 Fetches live YouTube chat comments, runs sentiment + topic classification,
 and pushes results to Redis.
 
-Run this as a standalone process:
-    python -m backend.scraper
+Accepts optional CLI arguments so multiple instances can run in parallel:
+    python -m backend.scraper --video_id VIDEO_ID --redis_key chat_messages_a
 
-or directly:
-    python backend/scraper.py
+Defaults fall back to config.py values.
 """
 
+import argparse
 import json
 import logging
 import time
@@ -20,7 +20,7 @@ import pytchat
 import redis
 
 from backend.config import (
-    VIDEO_ID,
+    VIDEO_ID as DEFAULT_VIDEO_ID,
     REDIS_HOST,
     REDIS_PORT,
     REDIS_DB,
@@ -28,7 +28,6 @@ from backend.config import (
 from ml.sentiment_model import predict_sentiment
 from ml.topic_model import predict_topic, VALID_TOPICS
 
-# ── Logging ────────────────────────────────────────────────────────────────────
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
@@ -36,28 +35,10 @@ logging.basicConfig(
 )
 logger = logging.getLogger("scraper")
 
-# ── Redis connection ───────────────────────────────────────────────────────────
-r = redis.Redis(
-    host=REDIS_HOST,
-    port=REDIS_PORT,
-    db=REDIS_DB,
-    decode_responses=True,
-    socket_connect_timeout=5,
-)
-
-try:
-    r.ping()
-    logger.info("Redis connected ✓")
-except redis.ConnectionError as e:
-    logger.error("Cannot connect to Redis: %s", e)
-    raise SystemExit(1)
-
-MAX_REDIS_MESSAGES = 1000  # cap the Redis list size
+MAX_REDIS_MESSAGES = 10000
 
 
-# ── Helpers ────────────────────────────────────────────────────────────────────
 def _safe_sentiment(text: str) -> tuple[str, float]:
-    """Run sentiment prediction with fallback on any error."""
     try:
         return predict_sentiment(text)
     except Exception as exc:
@@ -66,11 +47,9 @@ def _safe_sentiment(text: str) -> tuple[str, float]:
 
 
 def _safe_topic(text: str) -> tuple[str, float]:
-    """Run topic prediction with fallback on any error."""
     try:
         topic, conf = predict_topic(text)
         if topic not in VALID_TOPICS:
-            logger.warning("Invalid topic %r — using 'General'", topic)
             return "General", 0.50
         return topic, conf
     except Exception as exc:
@@ -78,54 +57,58 @@ def _safe_topic(text: str) -> tuple[str, float]:
         return "General", 0.50
 
 
-def _push_to_redis(data: dict) -> None:
-    """Push message to Redis list and trim to MAX_REDIS_MESSAGES."""
-    pipe = r.pipeline()
-    pipe.rpush("chat_messages", json.dumps(data))
-    pipe.ltrim("chat_messages", -MAX_REDIS_MESSAGES, -1)
-    pipe.execute()
-
+def run(video_id: str, redis_key: str) -> None:
+    r = redis.Redis(
+        host=REDIS_HOST,
+        port=REDIS_PORT,
+        db=REDIS_DB,
+        decode_responses=True,
+        socket_connect_timeout=5,
+    )
+    try:
+        r.ping()
+        logger.info("Redis connected ✓")
+    except redis.ConnectionError as e:
+        logger.error("Cannot connect to Redis: %s", e)
+        raise SystemExit(1)
 
-# ── Main loop ──────────────────────────────────────────────────────────────────
-def run() -> None:
-    logger.info("Starting live chat scraper for video: %s", VIDEO_ID)
+    logger.info("Starting scraper — video=%s  redis_key=%s", video_id, redis_key)
 
-    chat = pytchat.create(video_id=VIDEO_ID)
+    chat = pytchat.create(video_id=video_id)
     if not chat.is_alive():
-        logger.error("Could not connect to live chat. Is the stream live?")
+        logger.error("Could not connect to live chat for %s. Is the stream live?", video_id)
         return
 
-    logger.info("Live chat connected ✓  — press Ctrl+C to stop")
+    logger.info("Live chat connected ✓ — press Ctrl+C to stop")
 
     while chat.is_alive():
         try:
             for c in chat.get().sync_items():
                 text   = c.message.strip()
                 author = c.author.name
-
                 if not text:
                     continue
 
-                # ── Classify ──────────────────────────────────────────────
                 sentiment, s_conf = _safe_sentiment(text)
                 topic,     t_conf = _safe_topic(text)
 
-                # ── Build payload ─────────────────────────────────────────
                 message_data = {
-                    "author":      author,
-                    "text":        text,
-                    "sentiment":   sentiment,
-                    "confidence":  round(s_conf, 3),
-                    "topic":       topic,
-                    "topic_conf":  round(t_conf, 3),
-                    "time":        datetime.now().isoformat(),
+                    "author":     author,
+                    "text":       text,
+                    "sentiment":  sentiment,
+                    "confidence": round(s_conf, 3),
+                    "topic":      topic,
+                    "topic_conf": round(t_conf, 3),
+                    "time":       datetime.now().isoformat(),
                 }
 
-                # ── Store ─────────────────────────────────────────────────
-                _push_to_redis(message_data)
+                pipe = r.pipeline()
+                pipe.rpush(redis_key, json.dumps(message_data))
+                pipe.ltrim(redis_key, -MAX_REDIS_MESSAGES, -1)
+                pipe.execute()
 
                 logger.info(
-                    "[%s] %s | sentiment=%s(%.2f) topic=%s(%.2f) | %r",
+                    "[%s] %s | %s(%.2f) %s(%.2f) | %r",
                     message_data["time"][11:19],
                     author[:20],
                     sentiment, s_conf,
@@ -137,12 +120,16 @@ def run() -> None:
             logger.info("Stopped by user.")
             break
         except Exception as exc:
-            logger.error("Unexpected error in chat loop: %s", exc, exc_info=True)
+            logger.error("Unexpected error: %s", exc, exc_info=True)
 
         time.sleep(1)
 
-    logger.info("Chat stream ended.")
+    logger.info("Chat stream ended — key=%s", redis_key)
 
 
 if __name__ == "__main__":
-    run()
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--video_id",  default=DEFAULT_VIDEO_ID, help="YouTube video ID")
+    parser.add_argument("--redis_key", default="chat_messages",  help="Redis list key to write to")
+    args = parser.parse_args()
+    run(video_id=args.video_id, redis_key=args.redis_key)

frontend/streamlit_app.py

@@ -4,10 +4,14 @@ import redis
 import json
 import pandas as pd
 import plotly.graph_objects as go
+import plotly.express as px
 import time
 import re
 import sys
 import os
+import subprocess
+from datetime import datetime, timedelta
+from collections import defaultdict
 
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'backend'))
 from config import REDIS_HOST, REDIS_PORT, REDIS_DB
@@ -21,10 +25,11 @@ st.set_page_config(
 
 r = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB, decode_responses=True)
 
-TOPIC_LABELS = ["Appreciation", "Question", "Promo", "Spam", "General"]
+TOPIC_LABELS = ["Appreciation", "Question", "Promo", "Spam", "General", "MCQ Answer"]
 TOPIC_COLOR  = {
     "Appreciation": "#f59e0b", "Question": "#3b82f6",
-    "Promo": "#ec4899", "Spam": "#ef4444", "General": "#6b7280"
+    "Promo": "#ec4899", "Spam": "#ef4444", "General": "#6b7280",
+    "MCQ Answer": "#10b981"
 }
 SENT_COLORS = {"Positive": "#22c55e", "Neutral": "#eab308", "Negative": "#ef4444"}
 
@@ -39,7 +44,6 @@ THEME_JS = """<script>
     const m = bg.match(/rgb\((\d+),\s*(\d+),\s*(\d+)\)/);
     if (m) { isDark = (0.299*m[1] + 0.587*m[2] + 0.114*m[3]) < 128; }
     else {
-      // fallback: check body background
       const bodyBg = window.parent.getComputedStyle(window.parent.document.body).backgroundColor;
       const m2 = bodyBg.match(/rgb\((\d+),\s*(\d+),\s*(\d+)\)/);
       if (m2) { isDark = (0.299*m2[1] + 0.587*m2[2] + 0.114*m2[3]) < 128; }
@@ -65,6 +69,8 @@ CSS = """<style>
   --shadow:0 4px 24px rgba(0,0,0,0.4); --shadow-sm:0 2px 8px rgba(0,0,0,0.3);
   --pill-bg:rgba(124,58,237,0.15); --pill-border:rgba(124,58,237,0.3); --pill-text:#a78bfa;
   --plotly-paper:rgba(0,0,0,0); --plotly-plot:rgba(255,255,255,0.015); --plotly-grid:rgba(255,255,255,0.05); --plotly-text:#94a3b8;
+  --alert-bg:rgba(239,68,68,0.1); --alert-border:rgba(239,68,68,0.3);
+  --pin-bg:rgba(234,179,8,0.1); --pin-border:rgba(234,179,8,0.35);
 }
 [data-livepulse="light"] {
   --bg:#f4f6ff; --bg-card:#ffffff; --border:rgba(99,102,241,0.12);
@@ -75,6 +81,8 @@ CSS = """<style>
   --shadow:0 4px 24px rgba(99,102,241,0.12); --shadow-sm:0 2px 8px rgba(99,102,241,0.08);
   --pill-bg:rgba(109,40,217,0.08); --pill-border:rgba(109,40,217,0.2); --pill-text:#6d28d9;
   --plotly-paper:rgba(0,0,0,0); --plotly-plot:rgba(255,255,255,0.7); --plotly-grid:rgba(0,0,0,0.06); --plotly-text:#475569;
+  --alert-bg:rgba(239,68,68,0.07); --alert-border:rgba(239,68,68,0.25);
+  --pin-bg:rgba(234,179,8,0.08); --pin-border:rgba(234,179,8,0.3);
 }
 
 html,body,[data-testid="stAppViewContainer"],[data-testid="stMain"],.main .block-container {
@@ -95,19 +103,32 @@ html,body,[data-testid="stAppViewContainer"],[data-testid="stMain"],.main .block
 [data-testid="stMetricDelta"]{color:var(--accent-text)!important;}
 
 .stTextInput input { background:var(--input-bg)!important; border:1px solid var(--input-border)!important; border-radius:10px!important; color:var(--text-1)!important; }
+.stTextInput input::placeholder { color:var(--text-3)!important; opacity:1!important; }
+[data-testid="stSidebar"] .stTextInput input { background:#1a1a2e!important; border:1px solid rgba(124,58,237,0.4)!important; color:#f1f5f9!important; font-weight:500!important; }
+[data-testid="stSidebar"] .stTextInput input::placeholder { color:#64748b!important; }
+[data-testid="stSidebar"] .stTextInput input:focus { border-color:var(--accent)!important; box-shadow:0 0 0 2px rgba(124,58,237,0.2)!important; outline:none!important; }
+[data-testid="stSidebar"] label { color:var(--text-2)!important; }
 [data-baseweb="select"]>div { background:var(--input-bg)!important; border:1px solid var(--input-border)!important; border-radius:10px!important; color:var(--text-1)!important; }
 .stButton>button { background:linear-gradient(135deg,var(--accent),var(--accent2))!important; color:#fff!important; border:none!important; border-radius:10px!important; font-weight:600!important; font-family:'Space Grotesk',sans-serif!important; box-shadow:0 4px 16px rgba(124,58,237,0.3)!important; transition:all 0.2s!important; }
 .stButton>button:hover{transform:translateY(-2px)!important;}
 hr{border:none!important;border-top:1px solid var(--divider)!important;margin:1.2rem 0!important;}
 [data-testid="stSidebar"] label,[data-testid="stSidebar"] .stMarkdown p{color:var(--text-2)!important;font-size:0.83rem!important;}
 
-/* Download button override — keep it subtle */
-.dl-btn>button { background:var(--badge-bg)!important; color:var(--text-2)!important; border:1px solid var(--border)!important; border-radius:8px!important; font-size:0.75rem!important; padding:4px 12px!important; box-shadow:none!important; }
-.dl-btn>button:hover{background:var(--pill-bg)!important;color:var(--accent-text)!important;}
+[data-testid="stDownloadButton"]>button { background:var(--bg-card)!important; color:var(--text-2)!important; border:1px solid var(--border)!important; border-radius:8px!important; font-size:0.75rem!important; box-shadow:none!important; }
+[data-testid="stDownloadButton"]>button:hover { background:var(--pill-bg)!important; color:var(--accent-text)!important; border-color:var(--pill-border)!important; }
+
+[data-testid="stCheckbox"] label, [data-testid="stCheckbox"] span { color:var(--text-2)!important; font-size:0.82rem!important; }
+[data-testid="stCheckbox"] [data-testid="stWidgetLabel"] { color:var(--text-2)!important; }
 
 @keyframes pulse{0%{box-shadow:0 0 0 0 rgba(34,197,94,0.7);}70%{box-shadow:0 0 0 10px rgba(34,197,94,0);}100%{box-shadow:0 0 0 0 rgba(34,197,94,0);}}
 .live-dot{display:inline-block;width:9px;height:9px;background:var(--live);border-radius:50%;animation:pulse 1.8s infinite;margin-right:6px;vertical-align:middle;}
 
+@keyframes alertPulse{0%{opacity:1;}50%{opacity:0.7;}100%{opacity:1;}}
+.alert-banner{background:var(--alert-bg);border:1px solid var(--alert-border);border-radius:14px;padding:14px 18px;margin:12px 0;display:flex;align-items:center;gap:12px;animation:alertPulse 2s infinite;}
+.alert-icon{font-size:1.4rem;}
+.alert-text{font-size:0.88rem;font-weight:600;color:#ef4444;}
+.alert-sub{font-size:0.75rem;color:var(--text-3);margin-top:2px;}
+
 .stat-grid{display:flex;gap:12px;margin:10px 0 18px;flex-wrap:wrap;}
 .stat-card{flex:1;min-width:130px;background:var(--bg-card);border:1px solid var(--border);border-radius:20px;padding:22px 18px;text-align:center;transition:transform 0.2s,box-shadow 0.2s,background 0.3s;position:relative;overflow:hidden;box-shadow:var(--shadow-sm);}
 .stat-card:hover{transform:translateY(-4px);box-shadow:var(--shadow);}
@@ -116,6 +137,11 @@ hr{border:none!important;border-top:1px solid var(--divider)!important;margin:1.
 .stat-label{font-size:0.82rem;color:var(--text-2);font-weight:600;text-transform:uppercase;letter-spacing:0.06em;}
 .stat-sub{font-size:0.7rem;color:var(--text-3);margin-top:4px;}
 
+.velocity-card{background:var(--bg-card);border:1px solid var(--border);border-radius:20px;padding:18px 22px;box-shadow:var(--shadow-sm);display:flex;align-items:center;gap:16px;}
+.velocity-arrow{font-size:2rem;line-height:1;}
+.velocity-val{font-size:1.6rem;font-weight:800;letter-spacing:-0.03em;}
+.velocity-label{font-size:0.75rem;color:var(--text-3);font-weight:600;text-transform:uppercase;letter-spacing:0.06em;margin-top:2px;}
+
 .sec-hdr{display:flex;align-items:center;gap:10px;margin:6px 0 14px;}
 .sec-ttl{font-size:1rem;font-weight:700;color:var(--text-1);letter-spacing:-0.01em;}
 .sec-pill{background:var(--pill-bg);border:1px solid var(--pill-border);border-radius:20px;padding:2px 10px;font-size:0.68rem;color:var(--pill-text);font-weight:700;text-transform:uppercase;letter-spacing:0.08em;}
@@ -134,10 +160,38 @@ hr{border:none!important;border-top:1px solid var(--divider)!important;margin:1.
 .chat-card{background:var(--bg-card);border:1px solid var(--border);border-radius:16px;padding:14px 16px;margin-bottom:10px;border-left:3px solid transparent;animation:slideIn 0.2s ease;transition:background 0.2s,transform 0.15s,box-shadow 0.2s;box-shadow:var(--shadow-sm);}
 .chat-card:hover{transform:translateX(4px);box-shadow:var(--shadow);}
 .chat-positive{border-left-color:#22c55e;} .chat-negative{border-left-color:#ef4444;} .chat-neutral{border-left-color:#eab308;}
+.chat-pinned{border-left-color:#eab308!important;background:var(--pin-bg)!important;border-color:var(--pin-border)!important;}
 .chat-author{font-weight:700;font-size:0.83rem;color:var(--accent-text);margin-bottom:5px;}
 .chat-text{font-size:0.92rem;color:var(--text-2);line-height:1.55;margin-bottom:9px;}
 .chat-badges{display:flex;gap:6px;flex-wrap:wrap;}
 .badge{display:inline-flex;align-items:center;background:var(--badge-bg);border:1px solid var(--border);border-radius:20px;padding:3px 10px;font-size:0.7rem;font-weight:600;color:var(--text-2);}
+.pin-badge{background:rgba(234,179,8,0.15);border-color:rgba(234,179,8,0.4);color:#eab308;}
+
+.compare-label{font-size:0.72rem;font-weight:700;text-transform:uppercase;letter-spacing:0.08em;padding:3px 10px;border-radius:20px;display:inline-block;margin-bottom:8px;}
+
+.engage-card{background:var(--bg-card);border:1px solid var(--border);border-radius:20px;padding:20px 24px;box-shadow:var(--shadow-sm);position:relative;overflow:hidden;}
+.engage-score{font-size:3rem;font-weight:800;letter-spacing:-0.04em;line-height:1;}
+.engage-label{font-size:0.75rem;color:var(--text-3);font-weight:600;text-transform:uppercase;letter-spacing:0.08em;margin-top:4px;}
+.engage-bar-bg{background:var(--border);border-radius:99px;height:6px;margin-top:12px;overflow:hidden;}
+.engage-bar-fill{height:6px;border-radius:99px;transition:width 0.6s ease;}
+.engage-breakdown{display:flex;gap:16px;margin-top:10px;flex-wrap:wrap;}
+.engage-item{font-size:0.72rem;color:var(--text-3);}
+.engage-item span{font-weight:700;color:var(--text-2);}
+
+.leaderboard-row{display:flex;align-items:center;gap:12px;padding:10px 14px;background:var(--bg-card);border:1px solid var(--border);border-radius:14px;margin-bottom:8px;transition:transform 0.15s,box-shadow 0.15s;}
+.leaderboard-row:hover{transform:translateX(4px);box-shadow:var(--shadow);}
+.lb-rank{font-size:1rem;font-weight:800;color:var(--text-3);min-width:28px;}
+.lb-rank.gold{color:#f59e0b;} .lb-rank.silver{color:#94a3b8;} .lb-rank.bronze{color:#b45309;}
+.lb-author{font-size:0.85rem;font-weight:700;color:var(--text-1);flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}
+.lb-count{font-size:0.78rem;color:var(--text-3);min-width:40px;text-align:right;}
+.lb-bar{flex:2;height:5px;background:var(--border);border-radius:99px;overflow:hidden;}
+.lb-bar-fill{height:5px;border-radius:99px;}
+.lb-sent{display:flex;gap:4px;min-width:80px;justify-content:flex-end;}
+.lb-dot{width:8px;height:8px;border-radius:50%;display:inline-block;}
+
+.spam-alert{background:rgba(239,68,68,0.08);border:1px solid rgba(239,68,68,0.25);border-radius:14px;padding:14px 18px;margin:12px 0;display:flex;align-items:center;gap:12px;}
+.spam-alert-text{font-size:0.88rem;font-weight:600;color:#ef4444;}
+.spam-alert-sub{font-size:0.75rem;color:var(--text-3);margin-top:2px;}
 
 .empty-state{text-align:center;padding:80px 20px;background:var(--bg-card);border:1px solid var(--border);border-radius:24px;margin:40px 0;box-shadow:var(--shadow-sm);}
 .empty-icon{font-size:3.5rem;margin-bottom:16px;}
@@ -167,8 +221,16 @@ def update_config_video_id(video_id):
     with open(config_path, 'w') as f:
         f.write(content)
 
+def fetch_video_title(video_id):
+    try:
+        import urllib.request
+        url = f"https://www.youtube.com/oembed?url=https://www.youtube.com/watch?v={video_id}&format=json"
+        with urllib.request.urlopen(url, timeout=5) as resp:
+            return json.loads(resp.read())["title"]
+    except Exception:
+        return None
+
 def clean_topic(val):
-    """Normalize topic — replace None/NaN/empty with General."""
     if pd.isna(val) or str(val).strip() == "" or str(val).strip().lower() == "nan":
         return "General"
     return str(val).strip()
@@ -198,6 +260,221 @@ def csv_download(df_export, label, filename):
     st.download_button(label=f"⬇ {label}", data=csv,
                        file_name=filename, mime="text/csv", key=filename)
 
+@st.cache_data(ttl=5, show_spinner=False)
+def load_stream_data(redis_key: str, limit: int | None = None):
+    """Load and parse messages from a Redis key. Cached for 5s to avoid redundant reads."""
+    if limit:
+        raws = r.lrange(redis_key, -limit, -1)
+    else:
+        raws = r.lrange(redis_key, 0, -1)
+    data = []
+    for raw in raws:
+        try:
+            data.append(json.loads(raw))
+        except Exception:
+            pass
+    return data
+
+@st.cache_data(ttl=10, show_spinner=False)
+def compute_velocity(df_all_json: str, window: int = 20) -> dict:
+    """
+    Compute sentiment velocity. Accepts JSON string for cache key compatibility.
+    """
+    import json as _json
+    sentiments = [m.get("sentiment", "Neutral") for m in _json.loads(df_all_json)]
+    n = len(sentiments)
+    if n < window * 2:
+        return {"direction": "→", "delta": 0.0, "label": "Stable", "color": "#eab308"}
+    recent = sentiments[-window:]
+    prev   = sentiments[-window*2:-window]
+    r_pos  = sum(1 for s in recent if s == "Positive") / window
+    p_pos  = sum(1 for s in prev   if s == "Positive") / window
+    delta  = r_pos - p_pos
+    if delta > 0.08:
+        return {"direction": "↑", "delta": delta, "label": "Rising",  "color": "#22c55e"}
+    elif delta < -0.08:
+        return {"direction": "↓", "delta": delta, "label": "Falling", "color": "#ef4444"}
+    return {"direction": "→", "delta": delta, "label": "Stable", "color": "#eab308"}
+
+
+@st.cache_data(ttl=10, show_spinner=False)
+def build_heatmap_data(df_all_json: str, bucket_minutes: int = 1) -> pd.DataFrame:
+    """
+    Bucket messages into time intervals. Accepts JSON string for cache key compatibility.
+    """
+    import json as _json
+    records = _json.loads(df_all_json)
+    if not records:
+        return pd.DataFrame()
+    df_t = pd.DataFrame(records)
+    if "time" not in df_t.columns:
+        return pd.DataFrame()
+    df_t["time"] = pd.to_datetime(df_t["time"], errors="coerce")
+    df_t = df_t.dropna(subset=["time"])
+    if df_t.empty:
+        return pd.DataFrame()
+    df_t["bucket"] = df_t["time"].dt.floor(f"{bucket_minutes}min")
+    grouped = df_t.groupby(["bucket", "sentiment"]).size().unstack(fill_value=0)
+    for col in ["Positive", "Neutral", "Negative"]:
+        if col not in grouped.columns:
+            grouped[col] = 0
+    grouped = grouped.reset_index()
+    grouped.columns.name = None
+    return grouped[["bucket", "Positive", "Neutral", "Negative"]]
+
+def check_alert(df_all: pd.DataFrame, threshold: float = 0.4, window: int = 15) -> dict | None:
+    """Return alert info if negative ratio in last `window` messages exceeds threshold."""
+    if len(df_all) < window:
+        return None
+    recent = df_all.iloc[-window:]
+    neg_ratio = (recent["sentiment"] == "Negative").mean()
+    if neg_ratio >= threshold:
+        return {
+            "neg_ratio": neg_ratio,
+            "count": int((recent["sentiment"] == "Negative").sum()),
+            "window": window,
+        }
+    return None
+
+
+@st.cache_data(ttl=10, show_spinner=False)
+def compute_engagement(all_data_json: str, window: int = 50) -> dict:
+    """
+    Engagement score (0–100) = weighted combo of:
+      - message rate (msgs per minute, last window)
+      - positive ratio (last window)
+      - question density (last window)
+    """
+    import json as _j
+    msgs = _j.loads(all_data_json)
+    if not msgs:
+        return {"score": 0, "rate": 0.0, "pos_ratio": 0.0, "q_density": 0.0, "grade": "—"}
+
+    recent = msgs[-window:]
+    n = len(recent)
+
+    # Message rate: msgs per minute using timestamps
+    rate = 0.0
+    try:
+        t0 = datetime.fromisoformat(recent[0]["time"])
+        t1 = datetime.fromisoformat(recent[-1]["time"])
+        elapsed = max((t1 - t0).total_seconds() / 60, 0.1)
+        rate = round(n / elapsed, 1)
+    except Exception:
+        rate = float(n)
+
+    pos_ratio = sum(1 for m in recent if m.get("sentiment") == "Positive") / max(n, 1)
+    q_density = sum(1 for m in recent if m.get("topic") == "Question") / max(n, 1)
+
+    # Normalise rate: cap at 60 msgs/min = 100%
+    rate_norm = min(rate / 60, 1.0)
+    score = round((rate_norm * 0.4 + pos_ratio * 0.4 + q_density * 0.2) * 100)
+
+    if score >= 70:   grade = "🔥 High"
+    elif score >= 40: grade = "⚡ Medium"
+    else:             grade = "💤 Low"
+
+    return {"score": score, "rate": rate, "pos_ratio": pos_ratio, "q_density": q_density, "grade": grade}
+
+
+@st.cache_data(ttl=10, show_spinner=False)
+def compute_top_contributors(all_data_json: str, top_n: int = 10) -> list[dict]:
+    """Return top N authors by message count with their sentiment breakdown."""
+    import json as _j
+    from collections import Counter
+    msgs = _j.loads(all_data_json)
+    if not msgs:
+        return []
+
+    author_data: dict[str, dict] = {}
+    for m in msgs:
+        a = m.get("author", "Unknown")
+        if a not in author_data:
+            author_data[a] = {"count": 0, "Positive": 0, "Neutral": 0, "Negative": 0}
+        author_data[a]["count"] += 1
+        s = m.get("sentiment", "Neutral")
+        if s in author_data[a]:
+            author_data[a][s] += 1
+
+    sorted_authors = sorted(author_data.items(), key=lambda x: x[1]["count"], reverse=True)[:top_n]
+    result = []
+    for author, d in sorted_authors:
+        total = max(d["count"], 1)
+        result.append({
+            "author":    author,
+            "count":     d["count"],
+            "pos_pct":   round(d["Positive"] / total * 100),
+            "neu_pct":   round(d["Neutral"]  / total * 100),
+            "neg_pct":   round(d["Negative"] / total * 100),
+        })
+    return result
+
+
+@st.cache_data(ttl=10, show_spinner=False)
+def compute_word_freq(all_data_json: str, sentiment_filter: str = "All",
+                      topic_filter: str = "All", top_n: int = 60) -> list[tuple[str, int]]:
+    """Return top N (word, count) pairs after filtering stopwords."""
+    import json as _j
+    from collections import Counter
+
+    STOPWORDS = {
+        "the","a","an","is","it","in","on","at","to","of","and","or","but","for",
+        "with","this","that","are","was","be","as","by","from","have","has","had",
+        "not","no","so","if","do","did","will","can","just","i","you","he","she",
+        "we","they","my","your","his","her","our","their","me","him","us","them",
+        "what","how","why","when","where","who","which","there","here","been",
+        "would","could","should","may","might","shall","than","then","now","also",
+        "more","very","too","up","out","about","into","over","after","before",
+        "yaar","bhi","hai","hain","ho","kar","ke","ki","ka","ko","se","ne","ye",
+        "vo","woh","aur","nahi","nhi","toh","toh","koi","kuch","ab","ek","hi",
+    }
+
+    msgs = _j.loads(all_data_json)
+    words: list[str] = []
+    for m in msgs:
+        if sentiment_filter != "All" and m.get("sentiment") != sentiment_filter:
+            continue
+        if topic_filter != "All" and m.get("topic") != topic_filter:
+            continue
+        text = re.sub(r"[^\w\s]", " ", m.get("text", "").lower())
+        for w in text.split():
+            if len(w) > 2 and w not in STOPWORDS and not w.isdigit():
+                words.append(w)
+
+    return Counter(words).most_common(top_n)
+
+
+def check_spam_alert(df_all: pd.DataFrame, threshold: float = 0.3, window: int = 20) -> dict | None:
+    """Return alert if spam ratio in last `window` messages exceeds threshold."""
+    if "topic" not in df_all.columns or len(df_all) < window:
+        return None
+    recent = df_all.iloc[-window:]
+    spam_ratio = (recent["topic"] == "Spam").mean()
+    if spam_ratio >= threshold:
+        return {
+            "spam_ratio": spam_ratio,
+            "count": int((recent["topic"] == "Spam").sum()),
+            "window": window,
+        }
+    return None
+
+
+# ── SESSION STATE INIT ────────────────────────────────────────
+MAX_STREAMS = 5
+STREAM_COLORS = ["#7c3aed", "#10b981", "#f59e0b", "#3b82f6", "#ec4899"]
+STREAM_NAMES  = ["A", "B", "C", "D", "E"]
+
+if "pinned_messages" not in st.session_state:
+    st.session_state.pinned_messages = []
+if "alert_dismissed" not in st.session_state:
+    st.session_state.alert_dismissed = False
+if "last_alert_count" not in st.session_state:
+    st.session_state.last_alert_count = 0
+# Multi-stream: list of dicts {video_id, redis_key, label, proc}
+if "streams" not in st.session_state:
+    st.session_state.streams = [
+        {"video_id": "", "redis_key": "chat_messages", "label": "Stream A", "proc": None}
+    ]
 
 # ── SIDEBAR ──────────────────────────────────────────────────
 with st.sidebar:
@@ -208,15 +485,142 @@ with st.sidebar:
         '</div>', unsafe_allow_html=True
     )
     st.divider()
+
+    # ── Display Settings ──
     st.markdown('<p style="font-size:0.68rem;font-weight:700;color:var(--accent);text-transform:uppercase;letter-spacing:0.1em;margin-bottom:8px;">Display Settings</p>', unsafe_allow_html=True)
     refresh_rate = st.slider("Refresh interval (s)", 5, 60, 15)
     msg_limit    = st.slider("Message window", 10, 200, 50)
     auto_refresh = st.toggle("Live auto-refresh", value=True)
     st.divider()
+
+    # ── Alert Settings ──
+    st.markdown('<p style="font-size:0.68rem;font-weight:700;color:var(--accent);text-transform:uppercase;letter-spacing:0.1em;margin-bottom:8px;">Alert Settings</p>', unsafe_allow_html=True)
+    alert_enabled    = st.toggle("Negative spike alerts", value=True)
+    alert_threshold  = st.slider("Neg alert threshold (%)", 20, 80, 40) / 100
+    alert_window     = st.slider("Alert window (msgs)", 5, 30, 15)
+    spam_alert_on    = st.toggle("Spam rate alerts", value=True)
+    spam_threshold   = st.slider("Spam alert threshold (%)", 10, 60, 30) / 100
+    st.divider()
+
+    # ── Multi-Stream Scraper Control ──
+    st.markdown('<p style="font-size:0.68rem;font-weight:700;color:var(--accent);text-transform:uppercase;letter-spacing:0.1em;margin-bottom:8px;">Stream Control</p>', unsafe_allow_html=True)
+
+    import importlib
+    import config as _cfg
+    importlib.reload(_cfg)
+
+    # Pre-fill Stream A video_id from config on first load
+    if st.session_state.streams[0]["video_id"] == "":
+        st.session_state.streams[0]["video_id"] = _cfg.VIDEO_ID
+
+    for idx, stream in enumerate(st.session_state.streams):
+        color = STREAM_COLORS[idx]
+        label = STREAM_NAMES[idx]
+        st.markdown(
+            f'<div style="font-size:0.72rem;font-weight:700;color:{color};text-transform:uppercase;'
+            f'letter-spacing:0.08em;margin:10px 0 4px;border-left:3px solid {color};padding-left:8px;">'
+            f'Stream {label}</div>',
+            unsafe_allow_html=True
+        )
+        # Use widget key as the source of truth — never override with value= after first set
+        vid_skey  = f"vid_{idx}"
+        rkey_skey = f"rkey_{idx}"
+        if vid_skey not in st.session_state:
+            st.session_state[vid_skey]  = stream["video_id"]
+        if rkey_skey not in st.session_state:
+            st.session_state[rkey_skey] = stream["redis_key"]
+
+        st.text_input("Video ID / URL", placeholder="e.g. eFSK2-QRB0A", key=vid_skey)
+        st.text_input("Redis key", placeholder=f"chat_messages_{label.lower()}", key=rkey_skey)
+
+        sc1, sc2 = st.columns(2)
+        with sc1:
+            if st.button("▶ Start", key=f"start_{idx}", width='stretch'):
+                vid  = extract_video_id(st.session_state[vid_skey])
+                rkey = st.session_state[rkey_skey].strip() or f"chat_messages_{label.lower()}"
+                if vid:
+                    # Stop existing proc for this slot
+                    old_proc = st.session_state.streams[idx].get("proc")
+                    if old_proc and old_proc.poll() is None:
+                        old_proc.terminate()
+                    proc = subprocess.Popen(
+                        [sys.executable, "-m", "backend.scraper",
+                         "--video_id", vid, "--redis_key", rkey],
+                        cwd=os.path.abspath(os.path.join(os.path.dirname(__file__), "..")),
+                        stdout=subprocess.DEVNULL,
+                        stderr=subprocess.DEVNULL,
+                    )
+                    st.session_state.streams[idx]["proc"]      = proc
+                    st.session_state.streams[idx]["video_id"]  = vid
+                    st.session_state.streams[idx]["redis_key"] = rkey
+                    # Store title for stream A only (page header)
+                    if idx == 0:
+                        update_config_video_id(vid)
+                        title = fetch_video_title(vid)
+                        r.set("video_title", title) if title else r.delete("video_title")
+                        st.session_state.alert_dismissed = False
+                    st.success(f"Stream {label} started → `{rkey}`")
+                else:
+                    st.error("Invalid video ID")
+        with sc2:
+            if st.button("⏹ Stop", key=f"stop_{idx}", width='stretch'):
+                proc = st.session_state.streams[idx].get("proc")
+                if proc and proc.poll() is None:
+                    proc.terminate()
+                    st.session_state.streams[idx]["proc"] = None
+                    st.success(f"Stream {label} stopped")
+                else:
+                    st.warning("Not running")
+
+        proc = st.session_state.streams[idx].get("proc")
+        running = proc is not None and proc.poll() is None
+        dot_color = "#22c55e" if running else "#ef4444"
+        status    = "running" if running else "stopped"
+        st.markdown(f'<div style="font-size:0.72rem;color:{dot_color};margin-bottom:4px;">● {status}</div>', unsafe_allow_html=True)
+
+    st.divider()
+
+    # ── Add / Remove stream slots ──
+    add_col, rem_col = st.columns(2)
+    with add_col:
+        if len(st.session_state.streams) < MAX_STREAMS:
+            if st.button("＋ Add stream", width='stretch'):
+                n = len(st.session_state.streams)
+                st.session_state.streams.append({
+                    "video_id":  "",
+                    "redis_key": f"chat_messages_{STREAM_NAMES[n].lower()}",
+                    "label":     f"Stream {STREAM_NAMES[n]}",
+                    "proc":      None,
+                })
+                st.rerun()
+    with rem_col:
+        if len(st.session_state.streams) > 1:
+            if st.button("－ Remove last", width='stretch'):
+                removed = st.session_state.streams.pop()
+                proc = removed.get("proc")
+                if proc and proc.poll() is None:
+                    proc.terminate()
+                st.rerun()
+
+    st.divider()
+
+    # ── Pinned Messages ──
+    st.markdown('<p style="font-size:0.68rem;font-weight:700;color:var(--accent);text-transform:uppercase;letter-spacing:0.1em;margin-bottom:8px;">Pinned Messages</p>', unsafe_allow_html=True)
+    pin_count = len(st.session_state.pinned_messages)
+    st.markdown(f'<div style="font-size:0.78rem;color:var(--text-3);">{pin_count} message{"s" if pin_count != 1 else ""} pinned</div>', unsafe_allow_html=True)
+    if pin_count > 0 and st.button("🗑 Clear pins", width='stretch'):
+        st.session_state.pinned_messages = []
+        st.rerun()
+    st.divider()
+
+    # ── Danger Zone ──
     st.markdown('<p style="font-size:0.68rem;font-weight:700;color:#ef4444;text-transform:uppercase;letter-spacing:0.1em;margin-bottom:8px;">Danger Zone</p>', unsafe_allow_html=True)
-    if st.button("🗑 Clear all data", use_container_width=True):
-        r.delete("chat_messages")
-        st.success("Redis cleared.")
+    if st.button("🗑 Clear all data", width='stretch'):
+        for s in st.session_state.streams:
+            r.delete(s["redis_key"])
+        st.session_state.pinned_messages = []
+        st.session_state.alert_dismissed = False
+        st.success("All stream data cleared.")
     st.divider()
     st.markdown(
         '<div style="font-size:0.72rem;color:var(--text-3);text-align:center;line-height:1.6;">'
@@ -225,13 +629,17 @@ with st.sidebar:
         '</div>', unsafe_allow_html=True
     )
 
+
 # ── PAGE HEADER ───────────────────────────────────────────────
+_video_title = r.get("video_title")
+_subtitle = f"▶ {_video_title}" if _video_title else "Real-time sentiment · topic classification · engagement insights"
+
 col_title, col_live = st.columns([7, 1])
 with col_title:
     st.markdown(
         '<div style="padding:8px 0 4px;">'
         '<div style="font-size:2rem;font-weight:800;color:var(--text-1);letter-spacing:-0.04em;">YouTube Live Chat Analytics</div>'
-        '<div style="font-size:0.85rem;color:var(--text-3);margin-top:4px;">Real-time sentiment · topic classification · engagement insights</div>'
+        f'<div style="font-size:1.25rem;color:var(--accent-text);font-weight:600;margin-top:6px;">{_subtitle}</div>'
         '</div>', unsafe_allow_html=True
     )
 with col_live:
@@ -245,17 +653,15 @@ with col_live:
 st.divider()
 
 # ── DATA LOAD ─────────────────────────────────────────────────
-all_raw  = r.lrange("chat_messages", 0, -1)
-all_data = [json.loads(m) for m in all_raw]
-raw      = r.lrange("chat_messages", -msg_limit, -1)
-data     = [json.loads(m) for m in raw]
+all_data = load_stream_data("chat_messages")
+data     = all_data[-msg_limit:] if len(all_data) > msg_limit else all_data
 
 if not all_data:
     st.markdown(
         '<div class="empty-state">'
         '<div class="empty-icon">📭</div>'
         '<div class="empty-title">No messages yet</div>'
-        '<div class="empty-sub">Set a video ID in the sidebar, then run <code>python scraper.py</code></div>'
+        '<div class="empty-sub">Set a video ID in the sidebar, then click ▶ Start</div>'
         '</div>', unsafe_allow_html=True
     )
     if auto_refresh:
@@ -266,12 +672,58 @@ if not all_data:
 df     = pd.DataFrame(data)
 all_df = pd.DataFrame(all_data)
 
-# Normalize — kill undefined/NaN values
-df["sentiment"]  = df["sentiment"].apply(clean_sentiment)
-df["topic"]      = df["topic"].apply(clean_topic) if "topic" in df.columns else "General"
+df["sentiment"]     = df["sentiment"].apply(clean_sentiment)
+df["topic"]         = df["topic"].apply(clean_topic) if "topic" in df.columns else "General"
 all_df["sentiment"] = all_df["sentiment"].apply(clean_sentiment)
 all_df["topic"]     = all_df["topic"].apply(clean_topic) if "topic" in all_df.columns else "General"
 
+# ── ALERT BANNERS ─────────────────────────────────────────────
+if alert_enabled:
+    alert = check_alert(all_df, threshold=alert_threshold, window=alert_window)
+    total_now = len(all_df)
+    if total_now != st.session_state.last_alert_count:
+        st.session_state.last_alert_count = total_now
+        if alert:
+            st.session_state.alert_dismissed = False
+
+    if alert and not st.session_state.alert_dismissed:
+        a1, a2 = st.columns([8, 1])
+        with a1:
+            st.markdown(
+                f'<div class="alert-banner">'
+                f'<span class="alert-icon">🚨</span>'
+                f'<div>'
+                f'<div class="alert-text">Negative sentiment spike — {alert["neg_ratio"]*100:.0f}% negative in last {alert["window"]} messages</div>'
+                f'<div class="alert-sub">{alert["count"]} of {alert["window"]} messages are negative. Consider moderating.</div>'
+                f'</div></div>',
+                unsafe_allow_html=True
+            )
+        with a2:
+            if st.button("✕ Dismiss", key="dismiss_alert"):
+                st.session_state.alert_dismissed = True
+                st.rerun()
+
+if spam_alert_on:
+    spam_alert = check_spam_alert(all_df, threshold=spam_threshold, window=alert_window)
+    if spam_alert and not st.session_state.get("spam_dismissed", False):
+        s1, s2 = st.columns([8, 1])
+        with s1:
+            st.markdown(
+                f'<div class="spam-alert">'
+                f'<span class="alert-icon">🛡️</span>'
+                f'<div>'
+                f'<div class="spam-alert-text">Spam surge detected — {spam_alert["spam_ratio"]*100:.0f}% spam in last {spam_alert["window"]} messages</div>'
+                f'<div class="spam-alert-sub">{spam_alert["count"]} spam messages detected. Chat may be under flood attack.</div>'
+                f'</div></div>',
+                unsafe_allow_html=True
+            )
+        with s2:
+            if st.button("✕", key="dismiss_spam"):
+                st.session_state.spam_dismissed = True
+                st.rerun()
+    elif not spam_alert:
+        st.session_state.spam_dismissed = False
+
 # ── CUMULATIVE STATS ──────────────────────────────────────────
 all_counts = all_df["sentiment"].value_counts().to_dict()
 c_pos   = all_counts.get("Positive", 0)
@@ -279,23 +731,53 @@ c_neu   = all_counts.get("Neutral",  0)
 c_neg   = all_counts.get("Negative", 0)
 c_total = max(c_pos + c_neu + c_neg, 1)
 
+# Sentiment velocity
+velocity = compute_velocity(json.dumps([{"sentiment": m.get("sentiment","Neutral")} for m in all_data]))
+
 st.markdown(
     '<div class="sec-hdr"><span class="sec-ttl">Cumulative Sentiment</span><span class="sec-pill">All Time</span></div>',
     unsafe_allow_html=True
 )
-st.markdown(
-    f'<div class="stat-grid">'
-    f'<div class="stat-card"><div class="stat-accent" style="background:linear-gradient(90deg,#22c55e,#16a34a);"></div>'
-    f'<div class="stat-number" style="color:#22c55e;">{c_pos}</div><div class="stat-label">Positive</div><div class="stat-sub">{c_pos/c_total*100:.1f}% of total</div></div>'
-    f'<div class="stat-card"><div class="stat-accent" style="background:linear-gradient(90deg,#eab308,#ca8a04);"></div>'
-    f'<div class="stat-number" style="color:#eab308;">{c_neu}</div><div class="stat-label">Neutral</div><div class="stat-sub">{c_neu/c_total*100:.1f}% of total</div></div>'
-    f'<div class="stat-card"><div class="stat-accent" style="background:linear-gradient(90deg,#ef4444,#dc2626);"></div>'
-    f'<div class="stat-number" style="color:#ef4444;">{c_neg}</div><div class="stat-label">Negative</div><div class="stat-sub">{c_neg/c_total*100:.1f}% of total</div></div>'
-    f'<div class="stat-card"><div class="stat-accent" style="background:linear-gradient(90deg,#7c3aed,#4f46e5);"></div>'
-    f'<div class="stat-number" style="color:var(--accent-text);">{c_total}</div><div class="stat-label">Total</div><div class="stat-sub">all time</div></div>'
-    f'</div>',
-    unsafe_allow_html=True
-)
+
+v1, v2, v3, v4, v5 = st.columns([1, 1, 1, 1, 1])
+with v1:
+    st.markdown(
+        f'<div class="stat-card"><div class="stat-accent" style="background:linear-gradient(90deg,#22c55e,#16a34a);"></div>'
+        f'<div class="stat-number" style="color:#22c55e;">{c_pos}</div><div class="stat-label">Positive</div><div class="stat-sub">{c_pos/c_total*100:.1f}% of total</div></div>',
+        unsafe_allow_html=True
+    )
+with v2:
+    st.markdown(
+        f'<div class="stat-card"><div class="stat-accent" style="background:linear-gradient(90deg,#eab308,#ca8a04);"></div>'
+        f'<div class="stat-number" style="color:#eab308;">{c_neu}</div><div class="stat-label">Neutral</div><div class="stat-sub">{c_neu/c_total*100:.1f}% of total</div></div>',
+        unsafe_allow_html=True
+    )
+with v3:
+    st.markdown(
+        f'<div class="stat-card"><div class="stat-accent" style="background:linear-gradient(90deg,#ef4444,#dc2626);"></div>'
+        f'<div class="stat-number" style="color:#ef4444;">{c_neg}</div><div class="stat-label">Negative</div><div class="stat-sub">{c_neg/c_total*100:.1f}% of total</div></div>',
+        unsafe_allow_html=True
+    )
+with v4:
+    st.markdown(
+        f'<div class="stat-card"><div class="stat-accent" style="background:linear-gradient(90deg,#7c3aed,#4f46e5);"></div>'
+        f'<div class="stat-number" style="color:var(--accent-text);">{c_total}</div><div class="stat-label">Total</div><div class="stat-sub">all time</div></div>',
+        unsafe_allow_html=True
+    )
+with v5:
+    # Sentiment velocity card
+    vc = velocity["color"]
+    st.markdown(
+        f'<div class="velocity-card" style="border-color:{vc}44;">'
+        f'<div class="velocity-arrow" style="color:{vc};">{velocity["direction"]}</div>'
+        f'<div>'
+        f'<div class="velocity-val" style="color:{vc};">{velocity["label"]}</div>'
+        f'<div class="velocity-label">Sentiment Velocity<br>'
+        f'<span style="color:{vc};">{velocity["delta"]:+.0%} pos shift</span></div>'
+        f'</div></div>',
+        unsafe_allow_html=True
+    )
+
 
 # ── WINDOW METRICS ────────────────────────────────────────────
 st.divider()
@@ -319,11 +801,9 @@ c4.metric("Negative",  neg,  f"{neg/total*100:.1f}%")
 st.divider()
 col_l, col_r = st.columns(2)
 
-# ── Bar chart ──
 with col_l:
     st.markdown('<div class="chart-wrap">', unsafe_allow_html=True)
     st.markdown('<div class="chart-title">Sentiment Distribution</div><div class="chart-sub">Message count by sentiment class</div>', unsafe_allow_html=True)
-
     fig_bar = go.Figure(go.Bar(
         x=["Positive", "Neutral", "Negative"],
         y=[pos, neu, neg],
@@ -335,24 +815,20 @@ with col_l:
         hovertemplate="<b>%{x}</b><br>Count: %{y}<extra></extra>",
     ))
     fig_bar.update_layout(**plotly_layout(260))
-    st.plotly_chart(fig_bar, use_container_width=True, config={"displayModeBar": False})
-
+    st.plotly_chart(fig_bar, width='stretch', config={"displayModeBar": False})
     bar_hdr, bar_dl = st.columns([1, 1])
     with bar_hdr:
         show_bar_data = st.checkbox("View data", key="show_bar")
     with bar_dl:
         bar_df = pd.DataFrame({"Sentiment": ["Positive", "Neutral", "Negative"], "Count": [pos, neu, neg]})
         csv_download(bar_df, "Download CSV", "sentiment_distribution.csv")
-
     if show_bar_data:
-        st.dataframe(bar_df, use_container_width=True, hide_index=True)
+        st.dataframe(bar_df, width='stretch', hide_index=True)
     st.markdown('</div>', unsafe_allow_html=True)
 
-# ── Donut chart ──
 with col_r:
     st.markdown('<div class="chart-wrap">', unsafe_allow_html=True)
     st.markdown('<div class="chart-title">Sentiment Breakdown</div><div class="chart-sub">Proportional share per class</div>', unsafe_allow_html=True)
-
     fig_pie = go.Figure(go.Pie(
         labels=["Positive", "Neutral", "Negative"],
         values=[pos, neu, neg],
@@ -366,8 +842,7 @@ with col_r:
            "showlegend": True,
            "legend": dict(orientation="h", y=-0.08, font=dict(size=11))}
     )
-    st.plotly_chart(fig_pie, use_container_width=True, config={"displayModeBar": False})
-
+    st.plotly_chart(fig_pie, width='stretch', config={"displayModeBar": False})
     pie_hdr, pie_dl = st.columns([1, 1])
     with pie_hdr:
         show_pie_data = st.checkbox("View data", key="show_pie")
@@ -378,9 +853,8 @@ with col_r:
             "Percentage": [f"{pos/total*100:.1f}%", f"{neu/total*100:.1f}%", f"{neg/total*100:.1f}%"]
         })
         csv_download(pie_df, "Download CSV", "sentiment_breakdown.csv")
-
     if show_pie_data:
-        st.dataframe(pie_df, use_container_width=True, hide_index=True)
+        st.dataframe(pie_df, width='stretch', hide_index=True)
     st.markdown('</div>', unsafe_allow_html=True)
 
 # ── Confidence trend ──────────────────────────────────────────
@@ -388,10 +862,8 @@ if "confidence" in df.columns:
     st.divider()
     st.markdown('<div class="chart-wrap">', unsafe_allow_html=True)
     st.markdown('<div class="chart-title">Confidence Trend</div><div class="chart-sub">Model confidence per message in current window</div>', unsafe_allow_html=True)
-
     conf_df = df[["confidence"]].reset_index(drop=True)
     conf_df.index.name = "message_index"
-
     fig_line = go.Figure(go.Scatter(
         x=conf_df.index,
         y=conf_df["confidence"],
@@ -403,8 +875,7 @@ if "confidence" in df.columns:
     ))
     fig_line.update_layout(**plotly_layout(180))
     fig_line.update_yaxes(range=[0, 1])
-    st.plotly_chart(fig_line, use_container_width=True, config={"displayModeBar": False})
-
+    st.plotly_chart(fig_line, width='stretch', config={"displayModeBar": False})
     conf_hdr, conf_dl = st.columns([1, 1])
     with conf_hdr:
         show_conf_data = st.checkbox("View data", key="show_conf")
@@ -412,11 +883,53 @@ if "confidence" in df.columns:
         conf_export = conf_df.reset_index()
         conf_export.columns = ["message_index", "confidence"]
         csv_download(conf_export, "Download CSV", "confidence_trend.csv")
-
     if show_conf_data:
-        st.dataframe(conf_export, use_container_width=True, hide_index=True)
+        st.dataframe(conf_export, width='stretch', hide_index=True)
     st.markdown('</div>', unsafe_allow_html=True)
 
+
+# ── SENTIMENT HEATMAP OVER TIME ───────────────────────────────
+st.divider()
+st.markdown(
+    '<div class="sec-hdr"><span class="sec-ttl">Sentiment Heatmap</span><span class="sec-pill">Over Time</span></div>',
+    unsafe_allow_html=True
+)
+heatmap_data = build_heatmap_data(json.dumps([{"time": m.get("time",""), "sentiment": m.get("sentiment","Neutral")} for m in all_data]), bucket_minutes=1)
+
+if not heatmap_data.empty:
+    st.markdown('<div class="chart-wrap">', unsafe_allow_html=True)
+    st.markdown('<div class="chart-title">Sentiment Over Time</div><div class="chart-sub">Message volume per sentiment per minute bucket</div>', unsafe_allow_html=True)
+
+    fig_heat = go.Figure()
+    for sent, color in [("Positive", "#22c55e"), ("Neutral", "#eab308"), ("Negative", "#ef4444")]:
+        fig_heat.add_trace(go.Bar(
+            x=heatmap_data["bucket"],
+            y=heatmap_data[sent],
+            name=sent,
+            marker_color=color,
+            opacity=0.85,
+            hovertemplate=f"<b>{sent}</b><br>%{{x}}<br>Count: %{{y}}<extra></extra>",
+        ))
+
+    layout = plotly_layout(220)
+    layout["barmode"] = "stack"
+    layout["showlegend"] = True
+    layout["legend"] = dict(orientation="h", y=1.08, font=dict(size=11))
+    layout["xaxis"]["tickformat"] = "%H:%M"
+    fig_heat.update_layout(**layout)
+    st.plotly_chart(fig_heat, width='stretch', config={"displayModeBar": False})
+
+    heat_hdr, heat_dl = st.columns([1, 1])
+    with heat_hdr:
+        show_heat_data = st.checkbox("View data", key="show_heat")
+    with heat_dl:
+        csv_download(heatmap_data.rename(columns={"bucket": "time_bucket"}), "Download CSV", "sentiment_heatmap.csv")
+    if show_heat_data:
+        st.dataframe(heatmap_data.rename(columns={"bucket": "time_bucket"}), width='stretch', hide_index=True)
+    st.markdown('</div>', unsafe_allow_html=True)
+else:
+    st.info("Not enough timestamped data for heatmap yet.")
+
 # ── TOPIC DISTRIBUTION ────────────────────────────────────────
 st.divider()
 st.markdown(
@@ -429,7 +942,6 @@ topic_counts = {
     for label in TOPIC_LABELS
 }
 
-# Topic pill cards
 pills = '<div class="topic-grid">'
 for label in TOPIC_LABELS:
     color = TOPIC_COLOR[label]
@@ -445,7 +957,6 @@ st.markdown(pills, unsafe_allow_html=True)
 
 st.markdown('<div class="chart-wrap">', unsafe_allow_html=True)
 st.markdown('<div class="chart-title">Topic Breakdown</div><div class="chart-sub">All-time message count per topic category</div>', unsafe_allow_html=True)
-
 fig_topic = go.Figure(go.Bar(
     x=TOPIC_LABELS,
     y=[topic_counts[l] for l in TOPIC_LABELS],
@@ -457,19 +968,308 @@ fig_topic = go.Figure(go.Bar(
     hovertemplate="<b>%{x}</b><br>Count: %{y}<extra></extra>",
 ))
 fig_topic.update_layout(**plotly_layout(250))
-st.plotly_chart(fig_topic, use_container_width=True, config={"displayModeBar": False})
-
+st.plotly_chart(fig_topic, width='stretch', config={"displayModeBar": False})
 topic_hdr, topic_dl = st.columns([1, 1])
 with topic_hdr:
     show_topic_data = st.checkbox("View data", key="show_topic")
 with topic_dl:
     topic_df = pd.DataFrame({"Topic": TOPIC_LABELS, "Count": [topic_counts[l] for l in TOPIC_LABELS]})
     csv_download(topic_df, "Download CSV", "topic_distribution.csv")
-
 if show_topic_data:
-    st.dataframe(topic_df, use_container_width=True, hide_index=True)
+    st.dataframe(topic_df, width='stretch', hide_index=True)
 st.markdown('</div>', unsafe_allow_html=True)
 
+
+# ── ENGAGEMENT SCORE ─────────────────────────────────────────
+st.divider()
+st.markdown(
+    '<div class="sec-hdr"><span class="sec-ttl">Engagement Score</span><span class="sec-pill">Live</span></div>',
+    unsafe_allow_html=True
+)
+
+_eng_json = json.dumps([{"sentiment": m.get("sentiment","Neutral"), "topic": m.get("topic","General"), "time": m.get("time","")} for m in all_data])
+eng = compute_engagement(_eng_json)
+
+ec1, ec2, ec3, ec4 = st.columns([2, 1, 1, 1])
+with ec1:
+    score_color = "#22c55e" if eng["score"] >= 70 else "#eab308" if eng["score"] >= 40 else "#ef4444"
+    bar_w = eng["score"]
+    st.markdown(
+        f'<div class="engage-card" style="border-color:{score_color}44;">'
+        f'<div class="engage-score" style="color:{score_color};">{eng["score"]}</div>'
+        f'<div class="engage-label">Engagement Score / 100 — {eng["grade"]}</div>'
+        f'<div class="engage-bar-bg"><div class="engage-bar-fill" style="width:{bar_w}%;background:{score_color};"></div></div>'
+        f'<div class="engage-breakdown">'
+        f'<div class="engage-item">Msg rate <span>{eng["rate"]}/min</span></div>'
+        f'<div class="engage-item">Positive <span>{eng["pos_ratio"]*100:.0f}%</span></div>'
+        f'<div class="engage-item">Questions <span>{eng["q_density"]*100:.0f}%</span></div>'
+        f'</div></div>',
+        unsafe_allow_html=True
+    )
+with ec2:
+    st.metric("Msgs/min", f"{eng['rate']:.1f}")
+with ec3:
+    st.metric("Positive ratio", f"{eng['pos_ratio']*100:.0f}%")
+with ec4:
+    st.metric("Question density", f"{eng['q_density']*100:.0f}%")
+
+# ── TOP CONTRIBUTORS ──────────────────────────────────────────
+st.divider()
+st.markdown(
+    '<div class="sec-hdr"><span class="sec-ttl">Top Contributors</span><span class="sec-pill">All Time</span></div>',
+    unsafe_allow_html=True
+)
+
+_contrib_json = json.dumps([{"author": m.get("author",""), "sentiment": m.get("sentiment","Neutral")} for m in all_data])
+contributors = compute_top_contributors(_contrib_json)
+
+if contributors:
+    max_count = contributors[0]["count"]
+    lc1, lc2 = st.columns([3, 2])
+    with lc1:
+        rank_icons = {1: "🥇", 2: "🥈", 3: "🥉"}
+        rank_classes = {1: "gold", 2: "silver", 3: "bronze"}
+        for rank, c in enumerate(contributors, 1):
+            bar_pct  = int(c["count"] / max(max_count, 1) * 100)
+            rank_cls = rank_classes.get(rank, "")
+            rank_icon = rank_icons.get(rank, f"#{rank}")
+            author   = c["author"]
+            count    = c["count"]
+            pos_pct  = c["pos_pct"]
+            neu_pct  = c["neu_pct"]
+            neg_pct  = c["neg_pct"]
+            html = (
+                f'<div class="leaderboard-row">'
+                f'<div class="lb-rank {rank_cls}">{rank_icon}</div>'
+                f'<div class="lb-author">{author}</div>'
+                f'<div class="lb-bar"><div class="lb-bar-fill" style="width:{bar_pct}%;background:var(--accent);"></div></div>'
+                f'<div class="lb-sent">'
+                f'<span class="lb-dot" style="background:#22c55e;" title="Positive {pos_pct}%"></span>'
+                f'<span class="lb-dot" style="background:#eab308;" title="Neutral {neu_pct}%"></span>'
+                f'<span class="lb-dot" style="background:#ef4444;" title="Negative {neg_pct}%"></span>'
+                f'</div>'
+                f'<div class="lb-count">{count} msgs</div>'
+                f'</div>'
+            )
+            st.markdown(html, unsafe_allow_html=True)
+    with lc2:
+        # Stacked bar of top 5 contributors
+        top5 = contributors[:5]
+        fig_lb = go.Figure()
+        for sent, color in [("pos_pct","#22c55e"),("neu_pct","#eab308"),("neg_pct","#ef4444")]:
+            fig_lb.add_trace(go.Bar(
+                y=[c["author"][:18] for c in top5],
+                x=[c[sent] for c in top5],
+                name=sent.replace("_pct","").capitalize(),
+                orientation="h",
+                marker_color=color,
+                hovertemplate="%{y}: %{x}%<extra></extra>",
+            ))
+        layout_lb = plotly_layout(260)
+        layout_lb["barmode"] = "stack"
+        layout_lb["showlegend"] = True
+        layout_lb["legend"] = dict(orientation="h", y=1.1, font=dict(size=10))
+        layout_lb["xaxis"]["range"] = [0, 100]
+        layout_lb["xaxis"]["ticksuffix"] = "%"
+        fig_lb.update_layout(**layout_lb)
+        st.plotly_chart(fig_lb, width='stretch', config={"displayModeBar": False})
+
+    contrib_df = pd.DataFrame(contributors)
+    csv_download(contrib_df, "Download CSV", "top_contributors.csv")
+else:
+    st.info("Not enough data yet.")
+
+# ── WORD CLOUD ────────────────────────────────────────────────
+st.divider()
+st.markdown(
+    '<div class="sec-hdr"><span class="sec-ttl">Word Cloud</span><span class="sec-pill">All Time</span></div>',
+    unsafe_allow_html=True
+)
+
+wc_col1, wc_col2, wc_col3 = st.columns([1, 1, 3])
+with wc_col1:
+    wc_sentiment = st.selectbox("Filter sentiment", ["All", "Positive", "Neutral", "Negative"], key="wc_sent")
+with wc_col2:
+    wc_topic = st.selectbox("Filter topic", ["All"] + TOPIC_LABELS, key="wc_topic")
+
+_wc_json = json.dumps([{"text": m.get("text",""), "sentiment": m.get("sentiment","Neutral"), "topic": m.get("topic","General")} for m in all_data])
+word_freq = compute_word_freq(_wc_json, sentiment_filter=wc_sentiment, topic_filter=wc_topic)
+
+if word_freq:
+    try:
+        from wordcloud import WordCloud
+        import matplotlib.pyplot as plt
+        import io
+
+        freq_dict = dict(word_freq)
+        wc = WordCloud(
+            width=900, height=320,
+            background_color="white",
+            colormap="cool",
+            max_words=80,
+            prefer_horizontal=0.85,
+            collocations=False,
+        ).generate_from_frequencies(freq_dict)
+
+        st.markdown('<div class="chart-wrap">', unsafe_allow_html=True)
+        st.image(wc.to_array(), width="stretch")
+        st.markdown('</div>', unsafe_allow_html=True)
+
+        # Also show top 20 as a bar chart
+        top20 = word_freq[:20]
+        fig_wf = go.Figure(go.Bar(
+            x=[w for w, _ in top20],
+            y=[c for _, c in top20],
+            marker_color="#7c3aed",
+            marker_line_width=0,
+            hovertemplate="<b>%{x}</b><br>%{y} times<extra></extra>",
+        ))
+        layout_wf = plotly_layout(180)
+        fig_wf.update_layout(**layout_wf)
+        st.plotly_chart(fig_wf, width='stretch', config={"displayModeBar": False})
+
+    except ImportError:
+        # Fallback: just show bar chart if wordcloud not available
+        top20 = word_freq[:20]
+        fig_wf = go.Figure(go.Bar(
+            x=[w for w, _ in top20],
+            y=[c for _, c in top20],
+            marker_color="#7c3aed",
+            marker_line_width=0,
+        ))
+        fig_wf.update_layout(**plotly_layout(200))
+        st.plotly_chart(fig_wf, width='stretch', config={"displayModeBar": False})
+else:
+    st.info("Not enough text data yet.")
+
+# ── MULTI-STREAM COMPARISON ───────────────────────────────────
+active_streams = [s for s in st.session_state.streams if r.llen(s["redis_key"]) > 0]
+
+if len(active_streams) > 1:
+    st.divider()
+    n_streams = len(active_streams)
+    st.markdown(
+        f'<div class="sec-hdr"><span class="sec-ttl">Multi-Stream Comparison</span>'
+        f'<span class="sec-pill">{n_streams} streams</span></div>',
+        unsafe_allow_html=True
+    )
+
+    def stream_summary_chart(stream_df, color):
+        counts_s = stream_df["sentiment"].value_counts().to_dict()
+        p = counts_s.get("Positive", 0)
+        n = counts_s.get("Neutral",  0)
+        g = counts_s.get("Negative", 0)
+        t = max(p + n + g, 1)
+        fig = go.Figure(go.Bar(
+            x=["Positive", "Neutral", "Negative"],
+            y=[p, n, g],
+            marker_color=["#22c55e", "#eab308", "#ef4444"],
+            marker_line_width=0,
+            text=[p, n, g],
+            textposition="outside",
+            hovertemplate="<b>%{x}</b><br>%{y}<extra></extra>",
+        ))
+        fig.update_layout(**plotly_layout(200))
+        return fig, p, n, g, t
+
+    # Render in rows of up to 3 columns
+    chunk_size = 3
+    for row_start in range(0, n_streams, chunk_size):
+        row_streams = active_streams[row_start:row_start + chunk_size]
+        cols = st.columns(len(row_streams))
+        for col, stream in zip(cols, row_streams):
+            sidx   = st.session_state.streams.index(stream)
+            color  = STREAM_COLORS[sidx]
+            slabel = STREAM_NAMES[sidx]
+            s_data = load_stream_data(stream["redis_key"])
+            if not s_data:
+                col.info(f"No data yet for Stream {slabel}")
+                continue
+            s_df = pd.DataFrame(s_data)
+            s_df["sentiment"] = s_df["sentiment"].apply(clean_sentiment)
+            s_df["topic"]     = s_df["topic"].apply(clean_topic) if "topic" in s_df.columns else "General"
+            fig, p, n, g, t = stream_summary_chart(s_df, color)
+            with col:
+                st.markdown(
+                    f'<span class="compare-label" style="background:{color}18;color:{color};border:1px solid {color}44;">'
+                    f'Stream {slabel} — {stream["redis_key"]}</span>',
+                    unsafe_allow_html=True
+                )
+                st.plotly_chart(fig, width='stretch', config={"displayModeBar": False})
+                st.markdown(
+                    f'<div style="font-size:0.78rem;color:var(--text-3);margin-bottom:8px;">'
+                    f'{t} msgs · <span style="color:#22c55e;">{p/t*100:.1f}% pos</span> · '
+                    f'<span style="color:#ef4444;">{g/t*100:.1f}% neg</span></div>',
+                    unsafe_allow_html=True
+                )
+
+    # Overlay line chart — positive ratio over time for all streams
+    st.markdown('<div class="chart-wrap" style="margin-top:14px;">', unsafe_allow_html=True)
+    st.markdown('<div class="chart-title">Positive Ratio Over Time</div><div class="chart-sub">Rolling positive % per stream</div>', unsafe_allow_html=True)
+    fig_overlay = go.Figure()
+    for stream in active_streams:
+        sidx  = st.session_state.streams.index(stream)
+        color = STREAM_COLORS[sidx]
+        slabel = STREAM_NAMES[sidx]
+        s_data = load_stream_data(stream["redis_key"])
+        if not s_data:
+            continue
+        s_df = pd.DataFrame(s_data)
+        s_df["sentiment"] = s_df["sentiment"].apply(clean_sentiment)
+        s_df["is_pos"]    = (s_df["sentiment"] == "Positive").astype(int)
+        s_df["rolling"]   = s_df["is_pos"].rolling(10, min_periods=1).mean() * 100
+        fig_overlay.add_trace(go.Scatter(
+            x=list(range(len(s_df))),
+            y=s_df["rolling"],
+            mode="lines",
+            name=f"Stream {slabel}",
+            line=dict(color=color, width=2),
+            hovertemplate=f"Stream {slabel} msg %{{x}}: %{{y:.1f}}%<extra></extra>",
+        ))
+    layout_ov = plotly_layout(200)
+    layout_ov["showlegend"] = True
+    layout_ov["legend"] = dict(orientation="h", y=1.1, font=dict(size=11))
+    layout_ov["yaxis"]["range"] = [0, 100]
+    fig_overlay.update_layout(**layout_ov)
+    st.plotly_chart(fig_overlay, width='stretch', config={"displayModeBar": False})
+    st.markdown('</div>', unsafe_allow_html=True)
+
+elif len(st.session_state.streams) > 1:
+    st.divider()
+    st.info("Add video IDs to your extra stream slots and click ▶ Start to enable multi-stream comparison.")
+
+# ── PINNED MESSAGES ───────────────────────────────────────────
+if st.session_state.pinned_messages:
+    st.divider()
+    st.markdown(
+        '<div class="sec-hdr"><span class="sec-ttl">📌 Pinned Messages</span>'
+        f'<span class="sec-pill">{len(st.session_state.pinned_messages)} pinned</span></div>',
+        unsafe_allow_html=True
+    )
+    for idx, pmsg in enumerate(st.session_state.pinned_messages):
+        s       = pmsg.get("sentiment", "Neutral")
+        s_color = SENT_COLORS.get(s, "#6b7280")
+        t_color = TOPIC_COLOR.get(pmsg.get("topic", "General"), "#6b7280")
+        pcol1, pcol2 = st.columns([10, 1])
+        with pcol1:
+            st.markdown(
+                f'<div class="chat-card chat-pinned">'
+                f'<div class="chat-author">📌 {pmsg.get("author", "Unknown")}</div>'
+                f'<div class="chat-text">{pmsg.get("text", "")}</div>'
+                f'<div class="chat-badges">'
+                f'<span class="badge pin-badge">Pinned</span>'
+                f'<span class="badge" style="color:{s_color};">{s}</span>'
+                f'<span class="badge" style="color:{t_color};">{pmsg.get("topic","General")}</span>'
+                f'<span class="badge">{pmsg.get("time","")[:19]}</span>'
+                f'</div></div>',
+                unsafe_allow_html=True
+            )
+        with pcol2:
+            if st.button("✕", key=f"unpin_{idx}"):
+                st.session_state.pinned_messages.pop(idx)
+                st.rerun()
+
+
 # ── LIVE CHAT FEED ────────────────────────────────────────────
 st.divider()
 st.markdown('<div class="sec-hdr"><span class="sec-ttl">Live Chat Feed</span></div>', unsafe_allow_html=True)
@@ -498,33 +1298,55 @@ with feed_hdr:
     )
 with feed_dl:
     if not filtered.empty:
-        csv_download(filtered[["author","text","sentiment","confidence","topic","time"]]
-                     if all(c in filtered.columns for c in ["author","text","sentiment","confidence","topic","time"])
-                     else filtered,
-                     "Download Feed CSV", "chat_feed.csv")
+        export_cols = [c for c in ["author", "text", "sentiment", "confidence", "topic", "time"] if c in filtered.columns]
+        csv_download(filtered[export_cols], "Download Feed CSV", "chat_feed.csv")
 
 SENT_ICON = {"Positive": "🟢", "Negative": "🔴", "Neutral": "🟡"}
 
-for _, row in filtered.iloc[::-1].iterrows():
-    s         = row.get("sentiment", "Neutral")
-    conf_pct  = int(row.get("confidence", 0) * 100)
-    topic     = clean_topic(row.get("topic", "General"))
-    t_color   = TOPIC_COLOR.get(topic, "#6b7280")
-    s_color   = SENT_COLORS.get(s, "#6b7280")
-    s_icon    = SENT_ICON.get(s, "⚪")
-    conf_color = "#22c55e" if conf_pct >= 70 else "#eab308" if conf_pct >= 40 else "#ef4444"
+# Build a set of pinned texts for quick lookup
+pinned_texts = {m.get("text", "") for m in st.session_state.pinned_messages}
 
-    st.markdown(
-        f'<div class="chat-card chat-{s.lower()}">'
-        f'<div class="chat-author">{s_icon} {row.get("author", "Unknown")}</div>'
-        f'<div class="chat-text">{row.get("text", "")}</div>'
-        f'<div class="chat-badges">'
-        f'<span class="badge" style="color:{s_color};border-color:{s_color}33;">{s}</span>'
-        f'<span class="badge" style="color:{conf_color};">Confidence: {conf_pct}%</span>'
-        f'<span class="badge" style="color:{t_color};border-color:{t_color}33;">{topic}</span>'
-        f'</div></div>',
-        unsafe_allow_html=True
-    )
+for i, (_, row) in enumerate(filtered.iloc[::-1].iterrows()):
+    s          = row.get("sentiment", "Neutral")
+    conf_pct   = int(row.get("confidence", 0) * 100)
+    topic      = clean_topic(row.get("topic", "General"))
+    t_color    = TOPIC_COLOR.get(topic, "#6b7280")
+    s_color    = SENT_COLORS.get(s, "#6b7280")
+    s_icon     = SENT_ICON.get(s, "⚪")
+    conf_color = "#22c55e" if conf_pct >= 70 else "#eab308" if conf_pct >= 40 else "#ef4444"
+    msg_text   = row.get("text", "")
+    is_pinned  = msg_text in pinned_texts
+
+    card_class = f"chat-card chat-{s.lower()}" + (" chat-pinned" if is_pinned else "")
+
+    msg_col, pin_col = st.columns([11, 1])
+    with msg_col:
+        st.markdown(
+            f'<div class="{card_class}">'
+            f'<div class="chat-author">{s_icon} {row.get("author", "Unknown")}'
+            + (' <span style="font-size:0.7rem;color:#eab308;">📌</span>' if is_pinned else '') +
+            f'</div>'
+            f'<div class="chat-text">{msg_text}</div>'
+            f'<div class="chat-badges">'
+            f'<span class="badge" style="color:{s_color};border-color:{s_color}33;">{s}</span>'
+            f'<span class="badge" style="color:{conf_color};">Confidence: {conf_pct}%</span>'
+            f'<span class="badge" style="color:{t_color};border-color:{t_color}33;">{topic}</span>'
+            f'</div></div>',
+            unsafe_allow_html=True
+        )
+    with pin_col:
+        if is_pinned:
+            if st.button("📌", key=f"unpin_feed_{i}", help="Unpin this message"):
+                st.session_state.pinned_messages = [
+                    m for m in st.session_state.pinned_messages if m.get("text") != msg_text
+                ]
+                st.rerun()
+        else:
+            if st.button("📍", key=f"pin_{i}", help="Pin this message"):
+                msg_dict = row.to_dict()
+                if msg_dict not in st.session_state.pinned_messages:
+                    st.session_state.pinned_messages.append(msg_dict)
+                st.rerun()
 
 # ── AUTO REFRESH ──────────────────────────────────────────────
 if auto_refresh:

ml/topic_model.py

@@ -24,7 +24,7 @@ from transformers import pipeline
 # ── Configuration ──────────────────────────────────────────────────────────────
 MODEL_NAME = "facebook/bart-large-mnli"
 
-VALID_TOPICS = {"Appreciation", "Question", "Promo", "Spam", "General"}
+VALID_TOPICS = {"Appreciation", "Question", "Promo", "Spam", "General", "MCQ Answer"}
 
 # More descriptive labels → better zero-shot accuracy
 _CANDIDATE_LABELS = [
@@ -80,6 +80,14 @@ _PROMO_KW = {
 def _fast_path(text: str) -> tuple[str, float] | None:
     t = text.strip().lower()
 
+    # MCQ Answer: single letter or repeated letter(s) like a, b, aa, bbb, cccc
+    if re.fullmatch(r"[a-e]", t) or re.fullmatch(r"([a-e])\1*", t):
+        return "MCQ Answer", 0.95
+
+    # MCQ Answer: comma/space separated options like "a b c", "a,b", "aa bb"
+    if re.fullmatch(r"([a-e])\1*(\s*[,/]\s*([a-e])\3*)*", t):
+        return "MCQ Answer", 0.95
+
     # Spam: repeated chars or gibberish
     for pat in _SPAM_PATTERNS:
         if re.search(pat, t):

new_trained_data/muril-sentimix/config.json

@@ -0,0 +1,40 @@
+{
+  "add_cross_attention": false,
+  "architectures": [
+    "BertForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": null,
+  "classifier_dropout": null,
+  "dtype": "float32",
+  "embedding_size": 768,
+  "eos_token_id": null,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "Negative",
+    "1": "Neutral",
+    "2": "Positive"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "is_decoder": false,
+  "label2id": {
+    "negative": 0,
+    "neutral": 1,
+    "positive": 2
+  },
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "problem_type": "single_label_classification",
+  "tie_word_embeddings": true,
+  "transformers_version": "5.0.0",
+  "type_vocab_size": 2,
+  "use_cache": false,
+  "vocab_size": 197285
+}

new_trained_data/muril-sentimix/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4e28f220060cab19f110d1a7b0efb860aa0ae9af8ffb2e275ade77b9b827711b
+size 950257644

new_trained_data/muril-sentimix/tokenizer_config.json

@@ -0,0 +1,15 @@
+{
+  "backend": "tokenizers",
+  "cls_token": "[CLS]",
+  "do_lower_case": false,
+  "is_local": false,
+  "lowercase": false,
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": false,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}

new_trained_data/muril-sentimix/training_args.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4920d075f41a5e8a9bee5224014a00ec24f5822aeb271ea135c18ff621aa54db
+size 5201

requirements.txt

@@ -1,18 +1,7 @@
-fastapi
-uvicorn
-pytchat
-redis
-transformers
-torch
-streamlit
-pandas
-plotly
-emoji
-
 # Core ML
 torch>=2.0.0
 transformers>=4.38.0
-sentencepiece>=0.1.99       # needed by MuRIL tokenizer
+sentencepiece>=0.1.99
 
 # Emoji + slang handling
 emoji>=2.10.0
@@ -21,13 +10,9 @@ deep-translator>=1.11.4
 # Live chat scraping
 pytchat>=0.5.5
 
-# API server
-fastapi>=0.110.0
-uvicorn[standard]>=0.29.0
-
-# Cache / storage
-redis>=5.0.0
-
-# Dataset (only needed for fine-tuning MuRIL — optional)
-# datasets>=2.18.0
-# scikit-learn>=1.4.0        # for eval metrics during fine-tuning
+# Dashboard
+streamlit>=1.35.0
+pandas>=2.0.0
+plotly>=5.18.0
+wordcloud>=1.9.3
+matplotlib>=3.8.0