Create app.py

app.py

@@ -0,0 +1,567 @@
+import os
+import json
+import random
+from datetime import datetime, timedelta
+from typing import Dict, Any, List, Tuple
+
+import gradio as gr
+import pandas as pd
+
+# ============================
+# Branding
+# ============================
+PROCELEVATE_BLUE = "#0F2C59"
+
+CUSTOM_CSS = f"""
+/* Primary buttons */
+.gr-button.gr-button-primary,
+button.primary {{
+  background: {PROCELEVATE_BLUE} !important;
+  border-color: {PROCELEVATE_BLUE} !important;
+  color: white !important;
+  font-weight: 650 !important;
+}}
+.gr-button.gr-button-primary:hover,
+button.primary:hover {{
+  filter: brightness(0.92);
+}}
+
+/* Tabs selected */
+button[data-testid="tab-button"][aria-selected="true"] {{
+  border-bottom: 3px solid {PROCELEVATE_BLUE} !important;
+  color: {PROCELEVATE_BLUE} !important;
+  font-weight: 750 !important;
+}}
+
+/* Subtle modern rounding */
+.block, .gr-box, .gr-panel {{
+  border-radius: 14px !important;
+}}
+"""
+
+# ============================
+# Settings / Paths
+# ============================
+DATA_DIR = "data"
+OPS_FILE = os.path.join(DATA_DIR, "ops_events.json")
+
+ADMIN_PIN = os.environ.get("ADMIN_PIN", "2580")  # demo PIN
+
+# ============================
+# Demo: generate operational events
+# ============================
+DEPARTMENTS = ["Front Office", "Housekeeping", "F&B", "Maintenance", "Security"]
+EVENT_TYPES = [
+    "Check-in delay",
+    "Self check-in success",
+    "Concierge question",
+    "Room service order",
+    "Housekeeping request",
+    "Towel request",
+    "Maintenance issue",
+    "Noise complaint",
+    "Wi-Fi complaint",
+    "Late checkout request",
+    "Breakfast query",
+    "Dinner menu query",
+]
+SENTIMENTS = ["Positive", "Neutral", "Negative"]
+
+def ensure_data_dir():
+    os.makedirs(DATA_DIR, exist_ok=True)
+
+def load_events() -> List[Dict[str, Any]]:
+    ensure_data_dir()
+    if not os.path.exists(OPS_FILE):
+        return []
+    try:
+        with open(OPS_FILE, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return data if isinstance(data, list) else []
+    except Exception:
+        return []
+
+def save_events(events: List[Dict[str, Any]]):
+    ensure_data_dir()
+    with open(OPS_FILE, "w", encoding="utf-8") as f:
+        json.dump(events, f, ensure_ascii=False, indent=2)
+
+def dt_now_str():
+    return datetime.now().strftime("%Y-%m-%d %H:%M")
+
+def date_str(d: datetime):
+    return d.strftime("%Y-%m-%d")
+
+def simulate_events(days: int = 7, seed: int = 42) -> List[Dict[str, Any]]:
+    random.seed(seed)
+    base = datetime.now().date()
+
+    events = []
+    for i in range(days):
+        d = base - timedelta(days=(days - 1 - i))
+        # Vary volumes by day (simulate peaks)
+        base_volume = random.randint(80, 140)
+        peak_multiplier = 1.15 if d.weekday() in [4, 5] else 1.0  # Fri/Sat peaks
+        volume = int(base_volume * peak_multiplier)
+
+        for _ in range(volume):
+            evt_type = random.choices(
+                EVENT_TYPES,
+                weights=[7, 10, 18, 7, 14, 12, 7, 5, 5, 5, 6, 8],
+                k=1
+            )[0]
+
+            dept = "Front Office"
+            if evt_type in ["Housekeeping request", "Towel request"]:
+                dept = "Housekeeping"
+            elif evt_type in ["Dinner menu query", "Breakfast query", "Room service order"]:
+                dept = "F&B"
+            elif evt_type in ["Maintenance issue", "Wi-Fi complaint"]:
+                dept = "Maintenance"
+            elif evt_type in ["Noise complaint"]:
+                dept = "Security"
+
+            sentiment = random.choices(SENTIMENTS, weights=[35, 45, 20], k=1)[0]
+            if evt_type in ["Noise complaint", "Wi-Fi complaint", "Maintenance issue", "Check-in delay"]:
+                sentiment = random.choices(SENTIMENTS, weights=[10, 35, 55], k=1)[0]
+            if evt_type in ["Self check-in success"]:
+                sentiment = random.choices(SENTIMENTS, weights=[70, 25, 5], k=1)[0]
+
+            # Simulated timestamps (spread within day)
+            hour = random.randint(6, 23)
+            minute = random.randint(0, 59)
+            ts = datetime(d.year, d.month, d.day, hour, minute)
+
+            # Extra attributes for some events
+            wait_mins = None
+            if evt_type == "Check-in delay":
+                wait_mins = random.randint(8, 25)
+
+            req_priority = None
+            if evt_type in ["Maintenance issue", "Noise complaint"]:
+                req_priority = random.choices(["Normal", "Urgent"], weights=[70, 30], k=1)[0]
+
+            events.append({
+                "timestamp": ts.strftime("%Y-%m-%d %H:%M"),
+                "date": ts.strftime("%Y-%m-%d"),
+                "department": dept,
+                "event_type": evt_type,
+                "sentiment": sentiment,
+                "wait_mins": wait_mins,
+                "priority": req_priority,
+                "channel": random.choice(["Front Desk", "Phone", "WhatsApp", "Web/App", "Concierge Agent"]),
+            })
+
+    return events
+
+# ============================
+# Analytics + Pulse generation
+# ============================
+def events_to_df(events: List[Dict[str, Any]]) -> pd.DataFrame:
+    if not events:
+        return pd.DataFrame(columns=["timestamp", "date", "department", "event_type", "sentiment", "wait_mins", "priority", "channel"])
+    df = pd.DataFrame(events)
+    return df
+
+def compute_kpis(df: pd.DataFrame, target_date: str) -> Dict[str, Any]:
+    if df.empty:
+        return {
+            "target_date": target_date,
+            "total_events": 0,
+            "neg_sentiment_rate": 0.0,
+            "self_checkin_success": 0,
+            "checkin_delays": 0,
+            "avg_delay_mins": None,
+            "hk_requests": 0,
+            "wifi_complaints": 0,
+            "maintenance_issues": 0,
+            "dinner_queries": 0,
+        }
+
+    ddf = df[df["date"] == target_date].copy()
+    if ddf.empty:
+        return {
+            "target_date": target_date,
+            "total_events": 0,
+            "neg_sentiment_rate": 0.0,
+            "self_checkin_success": 0,
+            "checkin_delays": 0,
+            "avg_delay_mins": None,
+            "hk_requests": 0,
+            "wifi_complaints": 0,
+            "maintenance_issues": 0,
+            "dinner_queries": 0,
+        }
+
+    total = len(ddf)
+    neg_rate = (ddf["sentiment"].eq("Negative").sum() / total) if total else 0.0
+
+    delays = ddf[ddf["event_type"] == "Check-in delay"]
+    avg_delay = None
+    if not delays.empty and delays["wait_mins"].notna().any():
+        avg_delay = float(delays["wait_mins"].dropna().mean())
+
+    return {
+        "target_date": target_date,
+        "total_events": int(total),
+        "neg_sentiment_rate": float(neg_rate),
+        "self_checkin_success": int((ddf["event_type"] == "Self check-in success").sum()),
+        "checkin_delays": int((ddf["event_type"] == "Check-in delay").sum()),
+        "avg_delay_mins": avg_delay,
+        "hk_requests": int(ddf["event_type"].isin(["Housekeeping request", "Towel request"]).sum()),
+        "wifi_complaints": int((ddf["event_type"] == "Wi-Fi complaint").sum()),
+        "maintenance_issues": int((ddf["event_type"] == "Maintenance issue").sum()),
+        "dinner_queries": int((ddf["event_type"] == "Dinner menu query").sum()),
+    }
+
+def compare_to_prev_day(df: pd.DataFrame, target_date: str) -> Dict[str, Any]:
+    t = datetime.strptime(target_date, "%Y-%m-%d").date()
+    prev = t - timedelta(days=1)
+    prev_date = prev.strftime("%Y-%m-%d")
+
+    k_today = compute_kpis(df, target_date)
+    k_prev = compute_kpis(df, prev_date)
+
+    def delta(a, b):
+        if a is None or b is None:
+            return None
+        return a - b
+
+    return {
+        "prev_date": prev_date,
+        "today": k_today,
+        "prev": k_prev,
+        "delta_total_events": delta(k_today["total_events"], k_prev["total_events"]),
+        "delta_neg_rate_pp": delta(k_today["neg_sentiment_rate"]*100, k_prev["neg_sentiment_rate"]*100),
+        "delta_checkin_delays": delta(k_today["checkin_delays"], k_prev["checkin_delays"]),
+        "delta_hk_requests": delta(k_today["hk_requests"], k_prev["hk_requests"]),
+        "delta_maintenance": delta(k_today["maintenance_issues"], k_prev["maintenance_issues"]),
+        "delta_wifi": delta(k_today["wifi_complaints"], k_prev["wifi_complaints"]),
+        "delta_dinner_queries": delta(k_today["dinner_queries"], k_prev["dinner_queries"]),
+    }
+
+def build_alerts_and_actions(k: Dict[str, Any], comp: Dict[str, Any]) -> Tuple[pd.DataFrame, List[str], List[str]]:
+    alerts = []
+    actions = []
+    positives = []
+
+    # Thresholds (demo defaults)
+    neg_rate = k["neg_sentiment_rate"]
+    delays = k["checkin_delays"]
+    avg_delay = k["avg_delay_mins"]
+    hk = k["hk_requests"]
+    wifi = k["wifi_complaints"]
+    maint = k["maintenance_issues"]
+    dinner = k["dinner_queries"]
+
+    # Alerts
+    if neg_rate >= 0.30:
+        alerts.append(("RED", "Guest dissatisfaction spike", f"Negative sentiment rate is {neg_rate*100:.0f}% today."))
+        actions.append("GM to review top complaints today; run 10-min standup with FO/HK/F&B leads.")
+    elif neg_rate >= 0.22:
+        alerts.append(("AMBER", "Guest dissatisfaction rising", f"Negative sentiment rate is {neg_rate*100:.0f}% today."))
+        actions.append("Supervisor to spot-check service recovery for negative interactions.")
+
+    if delays >= 8:
+        details = f"{delays} check-in delay events today."
+        if avg_delay is not None:
+            details += f" Avg delay ~{avg_delay:.0f} mins."
+        alerts.append(("RED", "Front desk check-in delays", details))
+        actions.append("Add 1 staff during peak arrival window; use express/self-check flow for pre-arrivals.")
+    elif delays >= 4:
+        alerts.append(("AMBER", "Check-in delays observed", f"{delays} check-in delay events today."))
+        actions.append("Review arrival peaks; pre-assign rooms for early arrivals.")
+
+    if hk >= 25:
+        alerts.append(("AMBER", "High housekeeping load", f"{hk} housekeeping-related requests today."))
+        actions.append("Temporarily re-balance HK routes; pre-stage linens/towels for speed.")
+    if wifi >= 6:
+        alerts.append(("AMBER", "Wi-Fi issues", f"{wifi} Wi-Fi complaints today."))
+        actions.append("Check AP health in hotspot floors; proactive message with Wi-Fi steps to guests.")
+    if maint >= 6:
+        alerts.append(("AMBER", "Maintenance load high", f"{maint} maintenance issues today."))
+        actions.append("Prioritize urgent issues; schedule preventive checks during low occupancy hours.")
+
+    # Trend alerts vs previous day
+    if comp and comp.get("delta_checkin_delays") is not None and comp["delta_checkin_delays"] >= 4:
+        alerts.append(("AMBER", "Delays increased vs yesterday", f"Check-in delays up by {comp['delta_checkin_delays']} vs {comp['prev_date']}."))
+    if comp and comp.get("delta_hk_requests") is not None and comp["delta_hk_requests"] >= 8:
+        alerts.append(("AMBER", "HK requests increased vs yesterday", f"HK-related requests up by {comp['delta_hk_requests']} vs {comp['prev_date']}."))
+
+    # Positives
+    if k["self_checkin_success"] >= 15:
+        positives.append(f"Self check-in adoption is strong ({k['self_checkin_success']} successful self check-ins).")
+    if delays <= 2 and k["total_events"] > 0:
+        positives.append("Front desk flow looks stable today (low check-in delays).")
+    if maint == 0 and k["total_events"] > 0:
+        positives.append("No maintenance issues recorded today.")
+    if neg_rate <= 0.15 and k["total_events"] > 0:
+        positives.append("Guest sentiment is healthy today (low negative rate).")
+
+    # If no alerts, add a default positive note
+    if not alerts and k["total_events"] > 0:
+        positives.append("No major operational risks detected. Continue monitoring peak windows.")
+
+    alerts_df = pd.DataFrame(alerts, columns=["Severity", "Category", "Detail"]) if alerts else pd.DataFrame(columns=["Severity", "Category", "Detail"])
+    return alerts_df, actions, positives
+
+def generate_pulse_text(k: Dict[str, Any], comp: Dict[str, Any], alerts_df: pd.DataFrame, actions: List[str], positives: List[str]) -> str:
+    td = k["target_date"]
+    prev = comp.get("prev_date") if comp else None
+
+    # Small deltas summary
+    delta_bits = []
+    if comp:
+        if comp.get("delta_total_events") is not None:
+            delta_bits.append(f"Total activity {'+' if comp['delta_total_events']>=0 else ''}{comp['delta_total_events']} vs {prev}")
+        if comp.get("delta_neg_rate_pp") is not None:
+            delta_bits.append(f"Neg. sentiment {'+' if comp['delta_neg_rate_pp']>=0 else ''}{comp['delta_neg_rate_pp']:.0f} pp vs {prev}")
+        if comp.get("delta_checkin_delays") is not None:
+            delta_bits.append(f"Check-in delays {'+' if comp['delta_checkin_delays']>=0 else ''}{comp['delta_checkin_delays']} vs {prev}")
+
+    delta_line = " | ".join(delta_bits) if delta_bits else "Trend comparison not available."
+
+    # Compose narrative
+    top_alerts = ""
+    if not alerts_df.empty:
+        # show up to 3 alerts in text
+        top = alerts_df.head(3).to_dict(orient="records")
+        lines = []
+        for a in top:
+            icon = "🔴" if a["Severity"] == "RED" else "🟠"
+            lines.append(f"{icon} **{a['Category']}** — {a['Detail']}")
+        top_alerts = "\n".join(lines)
+    else:
+        top_alerts = "🟢 No major operational risks detected."
+
+    # Actions list (up to 4)
+    action_lines = "\n".join([f"✅ {a}" for a in actions[:4]]) if actions else "✅ Maintain current staffing and monitor peaks."
+
+    # Positives (up to 3)
+    pos_lines = "\n".join([f"🟢 {p}" for p in positives[:3]]) if positives else "🟢 Stable day expected."
+
+    avg_delay_str = f"{k['avg_delay_mins']:.0f} mins" if k["avg_delay_mins"] is not None else "N/A"
+
+    pulse = f"""
+## 📊 Hotel Operations Pulse — {td}
+
+**Snapshot**
+- Total operational signals captured: **{k['total_events']}**
+- Negative sentiment rate: **{k['neg_sentiment_rate']*100:.0f}%**
+- Check-in delays: **{k['checkin_delays']}** (avg delay: **{avg_delay_str}**)
+- Housekeeping-related requests: **{k['hk_requests']}**
+- Maintenance issues: **{k['maintenance_issues']}**
+- Wi-Fi complaints: **{k['wifi_complaints']}**
+- Dinner/menu queries: **{k['dinner_queries']}**
+- Self check-in successes: **{k['self_checkin_success']}**
+
+**Trend vs {prev if prev else 'previous day'}**
+- {delta_line}
+
+### 🚦 Key Alerts
+{top_alerts}
+
+### ✅ Recommended Actions (Manager / Supervisor)
+{action_lines}
+
+### 🌟 Positive Signals
+{pos_lines}
+
+**Note:** This is a demo pulse generated from sample operational signals. In production, this can connect to PMS / POS / housekeeping logs / guest feedback channels.
+"""
+    return pulse.strip()
+
+def kpis_table(k: Dict[str, Any], comp: Dict[str, Any]) -> pd.DataFrame:
+    def fmt_delta(x):
+        if x is None:
+            return ""
+        return f"{'+' if x>=0 else ''}{x}"
+
+    rows = [
+        ("Total signals", k["total_events"], fmt_delta(comp.get("delta_total_events") if comp else None)),
+        ("Negative sentiment (%)", round(k["neg_sentiment_rate"]*100), f"{fmt_delta(round(comp.get('delta_neg_rate_pp')))} pp" if comp and comp.get("delta_neg_rate_pp") is not None else ""),
+        ("Check-in delays (#)", k["checkin_delays"], fmt_delta(comp.get("delta_checkin_delays") if comp else None)),
+        ("Avg delay (mins)", (round(k["avg_delay_mins"]) if k["avg_delay_mins"] is not None else "N/A"), ""),
+        ("HK requests (#)", k["hk_requests"], fmt_delta(comp.get("delta_hk_requests") if comp else None)),
+        ("Maintenance issues (#)", k["maintenance_issues"], fmt_delta(comp.get("delta_maintenance") if comp else None)),
+        ("Wi-Fi complaints (#)", k["wifi_complaints"], fmt_delta(comp.get("delta_wifi") if comp else None)),
+        ("Dinner/menu queries (#)", k["dinner_queries"], fmt_delta(comp.get("delta_dinner_queries") if comp else None)),
+        ("Self check-in successes (#)", k["self_checkin_success"], ""),
+    ]
+    return pd.DataFrame(rows, columns=["Metric", "Today", "Δ vs Yesterday"])
+
+# ============================
+# Ops Assistant (simple NL routing)
+# ============================
+def ops_assistant_answer(question: str, k: Dict[str, Any], comp: Dict[str, Any], alerts_df: pd.DataFrame, actions: List[str]) -> str:
+    q = (question or "").strip().lower()
+    if not q:
+        return "Ask something like: “What needs attention today?” or “Any issues in housekeeping?”"
+
+    if "attention" in q or "focus" in q or "urgent" in q or "risk" in q:
+        if alerts_df.empty:
+            return "🟢 No major risks detected. Focus on peak arrival windows and keep service recovery readiness."
+        top = alerts_df.head(3).to_dict(orient="records")
+        lines = []
+        for a in top:
+            icon = "🔴" if a["Severity"] == "RED" else "🟠"
+            lines.append(f"{icon} {a['Category']}: {a['Detail']}")
+        return "Here are the top items needing attention:\n- " + "\n- ".join(lines)
+
+    if "housekeeping" in q or "towel" in q:
+        return f"Housekeeping load today: {k['hk_requests']} HK-related requests. " + (
+            "Recommendation: re-balance routes and pre-stage linens/towels during peak."
+            if k["hk_requests"] >= 20 else
+            "Load looks manageable; keep monitoring peak hours."
+        )
+
+    if "front" in q or "check-in" in q or "lobby" in q:
+        avg_delay = f"{k['avg_delay_mins']:.0f} mins" if k["avg_delay_mins"] is not None else "N/A"
+        return f"Front desk today: {k['checkin_delays']} check-in delay signals (avg: {avg_delay}). " + (
+            "Recommendation: add 1 staff during peak + push self-check pre-arrival."
+            if k["checkin_delays"] >= 4 else
+            "Flow looks stable; keep express check-in visible."
+        )
+
+    if "wifi" in q:
+        return f"Wi-Fi complaints today: {k['wifi_complaints']}. " + (
+            "Recommendation: check AP health + proactive guest message with Wi-Fi steps."
+            if k["wifi_complaints"] >= 4 else
+            "Low complaint volume; continue monitoring."
+        )
+
+    if "recommend" in q or "action" in q or "do next" in q:
+        if not actions:
+            return "Recommended actions: maintain staffing plan, monitor peaks, and review any negative feedback quickly."
+        return "Recommended actions:\n- " + "\n- ".join(actions[:5])
+
+    if "compare" in q or "yesterday" in q or "trend" in q:
+        if not comp:
+            return "Trend comparison not available."
+        msg = (
+            f"Compared to {comp['prev_date']}:\n"
+            f"- Total signals: {comp['delta_total_events']:+d}\n"
+            f"- Check-in delays: {comp['delta_checkin_delays']:+d}\n"
+            f"- HK requests: {comp['delta_hk_requests']:+d}\n"
+            f"- Maintenance issues: {comp['delta_maintenance']:+d}\n"
+            f"- Wi-Fi complaints: {comp['delta_wifi']:+d}\n"
+        )
+        if comp.get("delta_neg_rate_pp") is not None:
+            msg += f"- Negative sentiment: {comp['delta_neg_rate_pp']:+.0f} pp\n"
+        return msg
+
+    return "I can help with: risks, priorities, department issues (front desk/housekeeping/F&B/maintenance), trends vs yesterday, and recommended actions. Try: “What needs attention today?”"
+
+# ============================
+# UI Actions
+# ============================
+def refresh_pulse(selected_date: str) -> Tuple[str, pd.DataFrame, pd.DataFrame, str, Dict[str, Any]]:
+    events = load_events()
+    df = events_to_df(events)
+
+    if not selected_date:
+        # default to latest date in dataset
+        if df.empty:
+            selected_date = date_str(datetime.now())
+        else:
+            selected_date = sorted(df["date"].unique())[-1]
+
+    k = compute_kpis(df, selected_date)
+    comp = compare_to_prev_day(df, selected_date) if not df.empty else {}
+    alerts_df, actions, positives = build_alerts_and_actions(k, comp)
+
+    pulse_md = generate_pulse_text(k, comp, alerts_df, actions, positives)
+    kpi_df = kpis_table(k, comp)
+
+    quick_summary = (
+        f"Today: {k['total_events']} signals | Neg: {k['neg_sentiment_rate']*100:.0f}% | "
+        f"Delays: {k['checkin_delays']} | HK: {k['hk_requests']} | Maint: {k['maintenance_issues']}"
+    )
+    return pulse_md, kpi_df, alerts_df, quick_summary, {"k": k, "comp": comp, "alerts": alerts_df.to_dict(orient="records"), "actions": actions}
+
+def answer_ops(question: str, state: Dict[str, Any]) -> str:
+    if not state or "k" not in state:
+        return "Please generate the pulse first."
+    k = state["k"]
+    comp = state.get("comp", {})
+    alerts_df = pd.DataFrame(state.get("alerts", []))
+    actions = state.get("actions", [])
+    return ops_assistant_answer(question, k, comp, alerts_df, actions)
+
+def admin_unlock(pin: str):
+    if (pin or "").strip() == ADMIN_PIN:
+        return gr.update(visible=False), gr.update(visible=True), "✅ Admin access granted."
+    return gr.update(visible=True), gr.update(visible=False), "❌ Incorrect PIN."
+
+def admin_generate(days: int, seed: int):
+    events = simulate_events(days=int(days), seed=int(seed))
+    save_events(events)
+    return f"✅ Generated {len(events)} demo operational events across last {days} day(s). Updated at {dt_now_str()}."
+
+def admin_clear(pin: str):
+    if (pin or "").strip() != ADMIN_PIN:
+        return "❌ Incorrect PIN. Cannot clear data."
+    save_events([])
+    return f"✅ Cleared demo data at {dt_now_str()}."
+
+# ============================
+# Build UI
+# ============================
+with gr.Blocks(title="AI Hotel Operations Pulse (Prototype)", css=CUSTOM_CSS) as demo:
+    gr.Markdown(
+        """
+# 📌 AI Hotel Operations Pulse (Prototype)
+A manager/owner-focused assistant that summarizes hotel health, flags risks, and recommends actions — **without reading long reports**.
+
+**Outputs:** Daily Pulse • KPI Snapshot • Alerts • Recommended Actions • Ops Assistant Q&A  
+**Note:** Demo uses sample operational signals. In production, this can connect to PMS/POS/housekeeping logs/guest feedback systems.
+"""
+    )
+
+    state = gr.State({})
+
+    with gr.Tab("Manager / Owner Pulse"):
+        with gr.Row():
+            selected_date = gr.Textbox(label="Pulse Date (YYYY-MM-DD)", placeholder="Leave blank to use latest available date")
+            btn = gr.Button("Generate Pulse", variant="primary")
+
+        quick = gr.Markdown("")
+
+        pulse_md = gr.Markdown("")
+        with gr.Row():
+            kpi_table_out = gr.Dataframe(label="KPI Snapshot", interactive=False, wrap=True)
+            alerts_out = gr.Dataframe(label="Alerts (Red/Amber)", interactive=False, wrap=True)
+
+        gr.Markdown("### 🧠 Ask the Ops Assistant")
+        q = gr.Textbox(label="Ask a manager-style question", placeholder="e.g., What needs my attention today? Any housekeeping issues? Compare vs yesterday.")
+        ask_btn = gr.Button("Ask", variant="primary")
+        a = gr.Textbox(label="Answer", lines=6, interactive=False)
+
+        btn.click(refresh_pulse, inputs=[selected_date], outputs=[pulse_md, kpi_table_out, alerts_out, quick, state])
+        ask_btn.click(answer_ops, inputs=[q, state], outputs=[a])
+
+    with gr.Tab("Admin (Demo Data)"):
+        gr.Markdown("### Admin access (PIN protected)")
+        pin_box = gr.Textbox(label="Enter Admin PIN", type="password", placeholder="PIN")
+        unlock_btn = gr.Button("Unlock Admin Tools", variant="primary")
+        unlock_status = gr.Markdown("")
+
+        admin_tools = gr.Column(visible=False)
+        with admin_tools:
+            gr.Markdown("Generate realistic demo operational signals.")
+            with gr.Row():
+                days = gr.Slider(3, 21, value=7, step=1, label="Days of demo data")
+                seed = gr.Slider(1, 999, value=42, step=1, label="Random seed (for repeatability)")
+            gen_btn = gr.Button("Generate / Refresh Demo Data", variant="primary")
+            gen_out = gr.Markdown("")
+
+            gr.Markdown("---")
+            clear_btn = gr.Button("Clear Demo Data (PIN required)")
+            clear_out = gr.Markdown("")
+
+            gen_btn.click(admin_generate, inputs=[days, seed], outputs=[gen_out])
+            clear_btn.click(admin_clear, inputs=[pin_box], outputs=[clear_out])
+
+        unlock_btn.click(admin_unlock, inputs=[pin_box], outputs=[pin_box, admin_tools, unlock_status])
+
+demo.launch()