Update existing Space with new files

app.py

@@ -32,7 +32,15 @@ try:
 except Exception:
     HAS_AUTOREFRESH = False
 
+# Make this folder importable no matter where the app is launched from
+# (fixes "ModuleNotFoundError: No module named 'src'" on some setups).
+import os
+import sys
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
 from src.i18n import LANGS, SPEECH_LANG, t, build_area_vocab, resolve_area
+from src import ops
+import time as _time
 
 ROOT = Path(__file__).resolve().parent
 PROC = ROOT / "data" / "processed"
@@ -61,7 +69,7 @@ def require_login():
     st.markdown(
         "<div style='background:linear-gradient(135deg,#7C3AED,#EC4899);"
         "border-radius:18px;padding:26px 30px;color:#fff;margin-bottom:20px;'>"
-        "<div style='font-size:2rem;font-weight:800;'>दृष्टि — DRISHTI</div>"
+        "<div style='font-size:2rem;font-weight:600;'>दृष्टि — DRISHTI</div>"
         "<div style='opacity:0.92;margin-top:4px;'>Digital Real-time Intelligence for "
         "Smart Hotspot &amp; Traffic Insights · हर सड़क पर नज़र, हर सफ़र आसान</div></div>",
         unsafe_allow_html=True)
@@ -91,7 +99,7 @@ def load():
     hot = pd.read_parquet(PROC / "hotspots.parquet")
     fc = pd.read_parquet(PROC / "forecast.parquet")
     off = pd.read_parquet(PROC / "offenders.parquet")
-    meta = json.loads((PROC / "meta.json").read_text())
+    meta = json.loads((PROC / "meta.json").read_text(encoding="utf-8"))
     fc = fc.merge(hot[["h3", "location", "junction_name", "cii"]], on="h3", how="left")
     return hot, fc, off, meta
 
@@ -144,6 +152,7 @@ def inject_css():
         border:none; border-radius:10px; font-weight:600; }
       .stTextInput input, [data-baseweb="select"] > div {
         border:1px solid rgba(139,92,246,0.35) !important; border-radius:10px; }
+      .stTextInput input { padding:0.55rem 0.75rem; font-size:0.95rem; }
     </style>""", unsafe_allow_html=True)
 
 
@@ -350,19 +359,45 @@ def active_theme():
         return "dark"
 
 
+def theme_css(mode):
+    """Light / system overrides layered on top of the dark default.
+    No !important on text colours, so inline-coloured bits (logo, KPI accents,
+    status cards) keep their colours; only the *defaults* get recoloured."""
+    light = """
+      .stApp { background-color:#F6F3FF; }
+      .stApp p, .stApp li, .stApp label,
+      .stApp h1, .stApp h2, .stApp h3, .stApp h4 { color:#241748; }
+      [data-testid="stCaptionContainer"], [data-testid="stCaptionContainer"] p { color:#5f548b; }
+      section[data-testid="stSidebar"] > div:first-child { background:#ECE6FB; }
+      section[data-testid="stSidebar"], section[data-testid="stSidebar"] p,
+      section[data-testid="stSidebar"] label, section[data-testid="stSidebar"] div { color:#2b1d55; }
+      [data-testid="stSegmentedControl"] button p { color:#2b1d55; }
+      .drishti-sub { color:#2563EB !important; }
+    """
+    if mode == "light":
+        return f"<style>{light}</style>"
+    if mode == "system":
+        return f"<style>@media (prefers-color-scheme: light) {{{light}}}</style>"
+    return ""
+
+
 # ==================== APP ====================
 inject_css()
 require_login()        # comment this line out to disable the login gate
 hot, fc, off, meta = load()
-THEME = active_theme()
+THEME = active_theme()        # follows the ⋮ menu (top-right) -> Settings -> Theme
 ACCENT = "#FACC15" if THEME == "dark" else "#2563EB"   # gold text -> yellow (dark) / blue (light)
+MAP_STYLE = "dark" if THEME == "dark" else "light"
+NAV_COLOR = "#9B8FC2" if THEME == "dark" else "#4C3A82"
 area_vocab = build_area_vocab(hot)
 hot["fill"] = hot["cii"].apply(cii_color)
 mm = meta["model_metrics"]
 
-NAV_KEYS = ["tab_map", "tab_ops", "tab_trends", "tab_rank", "tab_off", "tab_fc"]
+NAV_KEYS = ["tab_map", "tab_ops", "tab_trends", "tab_rank", "tab_off", "tab_fc",
+            "tab_patrol", "tab_whatif", "tab_event"]
 NAV_ICONS = ["geo-alt-fill", "broadcast", "graph-up", "list-check",
-             "exclamation-triangle-fill", "magic"]
+             "exclamation-triangle-fill", "magic",
+             "signpost-split-fill", "sliders", "calendar-event-fill"]
 
 with st.sidebar:
     st.markdown(
@@ -396,8 +431,8 @@ with st.sidebar:
         choice = option_menu(
             None, labels, icons=NAV_ICONS, default_index=0,
             styles={"container": {"background-color": "transparent", "padding": "2px 0"},
-                    "icon": {"color": "#9B8FC2", "font-size": "15px"},
-                    "nav-link": {"color": "#9B8FC2", "font-size": "14px",
+                    "icon": {"color": NAV_COLOR, "font-size": "15px"},
+                    "nav-link": {"color": NAV_COLOR, "font-size": "14px",
                                  "border-radius": "10px", "margin": "3px 0",
                                  "--hover-color": "rgba(139,92,246,0.15)"},
                     "nav-link-selected": {"background-color": VIOLET, "color": "#fff",
@@ -407,26 +442,6 @@ with st.sidebar:
         choice = st.radio("Navigate", labels, label_visibility="collapsed")
     section = NAV_KEYS[labels.index(choice)]
 
-    st.divider()
-    st.markdown("<div style='font-size:0.72rem;font-weight:700;letter-spacing:0.06em;"
-                "opacity:0.5;margin-bottom:6px;'>🎨 THEME</div>", unsafe_allow_html=True)
-    _cur = st.query_params.get("theme", "system")
-    _keep = "auth=1&" if st.session_state.get("authed") else ""
-    _seg = [("system", "◐", "System"), ("light", "☀", "Light"), ("dark", "🌙", "Dark")]
-    _html = ("<div style='display:flex;gap:4px;background:rgba(139,92,246,0.10);"
-             "border:1px solid rgba(139,92,246,0.25);border-radius:11px;padding:4px;'>")
-    for _val, _ic, _lab in _seg:
-        _active = (_cur == _val)
-        _href = "?" + _keep + ("" if _val == "system" else f"theme={_val}")
-        _href = _href.rstrip("&") or "?"
-        _style = ("background:#8B5CF6;color:#fff;box-shadow:0 2px 8px rgba(139,92,246,0.4);"
-                  if _active else "color:#9B8FC2;")
-        _html += (f"<a href='{_href}' target='_self' style='flex:1;text-align:center;"
-                  f"padding:7px 2px;border-radius:8px;text-decoration:none;line-height:1.25;"
-                  f"font-size:0.7rem;font-weight:600;{_style}'>"
-                  f"<div style='font-size:1.05rem;'>{_ic}</div>{_lab}</a>")
-    _html += "</div>"
-    st.markdown(_html, unsafe_allow_html=True)
     st.divider()
     if "history" not in st.session_state:
         st.session_state.history = []
@@ -446,6 +461,10 @@ with st.sidebar:
         f"<span style='opacity:0.65;'>Forecast MAE {mm['valid_mae']} · "
         f"↓{mm.get('improvement_pct','')}% vs baseline</span></div>",
         unsafe_allow_html=True)
+    st.divider()
+    st.markdown("<div style='font-size:0.72rem;font-weight:700;letter-spacing:0.06em;"
+                "opacity:0.5;margin:4px 0 2px 2px;'>🎨 THEME</div>", unsafe_allow_html=True)
+    st.caption("Switch theme via the ⋮ menu (top-right) → Settings → Theme.")
 
 # ----- header + KPIs (always) -----
 st.markdown(
@@ -453,48 +472,32 @@ st.markdown(
     "font-weight:800;letter-spacing:-0.01em;'>दृष्टि — DRISHTI</h1>",
     unsafe_allow_html=True)
 st.markdown(
-    f"<div style='color:{ACCENT};font-weight:600;font-size:1.02rem;'>"
+    f"<div class='drishti-sub' style='color:{ACCENT};font-weight:600;font-size:1.02rem;'>"
     "Digital Real-time Intelligence for Smart Hotspot &amp; Traffic Insights</div>",
     unsafe_allow_html=True)
-st.caption("हर सड़क पर नज़र, हर सफ़र आसान  ·  "
-           f"Bengaluru · {meta['date_range'][0]} → {meta['date_range'][1]} · "
-           f"{meta['n_records']:,} violations · {meta['n_cells']:,} zones")
+st.caption("हर सड़क पर नज़र, हर सफ़र आसान  ·  Bengaluru Traffic Police")
 
-sp = meta.get("kpi_sparks", {})
-kc = st.columns(4)
-with kc[0]:
-    kpi_card("🚗", t("kpi_violations", lang), f"{meta['n_records']:,}",
-             accent="#8B5CF6", series=sp.get("violations"))
-with kc[1]:
-    kpi_card("📍", t("kpi_zones", lang), f"{meta['n_cells']:,}",
-             accent="#22D3EE", series=sp.get("zones"))
-with kc[2]:
-    kpi_card("🔥", t("kpi_high", lang), f"{int((hot.cii >= 70).sum()):,}",
-             accent=ACCENT, series=sp.get("peak"))
-with kc[3]:
-    bl = mm.get("baseline_lag7_mae", 1.0)
-    kpi_card("🎯", t("kpi_mae", lang), mm["valid_mae"], accent="#34D399",
-             series=[bl, mm["valid_mae"]], viz="bars",
-             sub=(f"<span style='color:#34D399;font-weight:600;'>↓ "
-                  f"{mm['improvement_pct']}% vs baseline</span>"
-                  if mm.get("improvement_pct") else None))
-st.write("")
-
-# ----- voice / command bar (always) -----
-st.subheader("🎙️ " + t("voice_nav", lang))
-cv1, cv2 = st.columns([3, 1])
-with cv1:
-    typed = st.text_input(t("ask", lang), placeholder=t("placeholder", lang))
+# ----- command / voice bar (top of content, prominent) -----
+_mic_ready = "🎤 ready" if HAS_MIC else "⚠️ mic component missing"
+st.markdown(
+    "<div style='display:flex;align-items:center;gap:10px;margin:16px 0 8px 0;'>"
+    "<div style='width:32px;height:32px;border-radius:10px;flex:none;"
+    "background:linear-gradient(135deg,#7C3AED,#EC4899);display:flex;align-items:center;"
+    "justify-content:center;font-size:16px;box-shadow:0 3px 12px rgba(124,77,255,.4);'>🎙️</div>"
+    f"<div style='font-weight:700;font-size:1.04rem;'>{t('voice_nav', lang)}</div>"
+    "<div style='flex:1;'></div>"
+    f"<div style='font-size:0.72rem;opacity:.6;white-space:nowrap;'>{_mic_ready}"
+    "  ·  🔊 EN · ಕನ್ನಡ · हिन्दी</div></div>", unsafe_allow_html=True)
+cb1, cb2 = st.columns([6, 1])
+with cb1:
+    typed = st.text_input(t("ask", lang), placeholder="🔍  " + t("placeholder", lang),
+                          label_visibility="collapsed")
 spoken = None
-with cv2:
-    st.write("")
+with cb2:
     if HAS_MIC:
         spoken = speech_to_text(language=SPEECH_LANG.get(lang, "en-IN"),
-                                start_prompt=t("speak", lang), stop_prompt=t("stop", lang),
+                                start_prompt="🎤", stop_prompt="⏹",
                                 just_once=True, use_container_width=True, key="stt")
-mic_status = ("🎤 mic ready (use Chrome, allow the mic, stay online)" if HAS_MIC
-              else "⚠️ mic component missing — run `pip install -r requirements.txt`")
-st.caption(mic_status + "  ·  🔊 read-aloud works in English / Kannada / Hindi")
 
 query = spoken or typed
 if query:
@@ -525,24 +528,69 @@ if query:
             play_tts(summary, say_lang)
         if st.button(f"🔊 Read aloud ({lang_name})", key="read_btn"):
             play_tts(summary, say_lang)
+st.write("")
 
+sp = meta.get("kpi_sparks", {})
+kc = st.columns(4)
+with kc[0]:
+    kpi_card("🚗", t("kpi_violations", lang), f"{meta['n_records']:,}",
+             accent="#8B5CF6", series=sp.get("violations"))
+with kc[1]:
+    kpi_card("📍", t("kpi_zones", lang), f"{meta['n_cells']:,}",
+             accent="#22D3EE", series=sp.get("zones"))
+with kc[2]:
+    kpi_card("🔥", t("kpi_high", lang), f"{int((hot.cii >= 70).sum()):,}",
+             accent=ACCENT, series=sp.get("peak"))
+with kc[3]:
+    bl = mm.get("baseline_lag7_mae", 1.0)
+    kpi_card("🎯", t("kpi_mae", lang), mm["valid_mae"], accent="#34D399",
+             series=[bl, mm["valid_mae"]], viz="bars",
+             sub=(f"<span style='color:#34D399;font-weight:600;'>↓ "
+                  f"{mm['improvement_pct']}% vs baseline</span>"
+                  if mm.get("improvement_pct") else None))
+st.write("")
 st.divider()
 
 # ==================== sections ====================
 if section == "tab_map":
-    min_cii = st.slider(t("min_cii", lang), 0, 100, 40, 5)
+    mc1, mc2 = st.columns([1.1, 2.6])
+    with mc1:
+        min_cii = st.slider(t("min_cii", lang), 0, 100, 50, 5)
     view = hot[hot.cii >= min_cii]
-    st.caption(f"{len(view):,} / {len(hot):,}")
+    with mc2:
+        st.markdown(
+            "<div style='display:flex;align-items:center;gap:12px;padding-top:1.7rem;"
+            "flex-wrap:wrap;'>"
+            f"<span style='font-size:0.9rem;'>Showing <b>{len(view):,}</b> of "
+            f"{len(hot):,} zones</span>"
+            "<span style='flex:1;'></span>"
+            "<span style='font-size:0.78rem;opacity:.7;'>Low</span>"
+            "<div style='width:150px;height:11px;border-radius:6px;"
+            "border:1px solid rgba(125,90,200,0.45);background:linear-gradient(90deg,"
+            "rgb(22,163,74) 0%,rgb(245,158,11) 50%,rgb(220,38,38) 100%);'></div>"
+            "<span style='font-size:0.78rem;opacity:.7;'>High</span>"
+            "<span style='font-size:0.76rem;opacity:.55;'>CII 0–100</span></div>",
+            unsafe_allow_html=True)
     layer = pdk.Layer("H3HexagonLayer", view, pickable=True, filled=True, extruded=True,
                       get_hexagon="h3", get_fill_color="fill",
-                      get_elevation="cii", elevation_scale=18, opacity=0.55)
+                      get_elevation="cii", elevation_scale=8, opacity=0.55)
     st.pydeck_chart(pdk.Deck(
         layers=[layer],
         initial_view_state=pdk.ViewState(latitude=12.97, longitude=77.59, zoom=11, pitch=45),
-        map_style="dark",
-        tooltip={"html": "<b>CII {cii}</b> (rank #{cii_rank})<br/>{location}<br/>"
-                         "<b>{n_violations}</b> violations · <b>{active_days}</b> days<br/>"
-                         "Top: {top_violation}"},
+        map_style=MAP_STYLE,
+        tooltip={
+            "html": "<div style='font-weight:700;font-size:13px;'>CII {cii}"
+                    "<span style='opacity:.7;font-weight:500;'> · rank #{cii_rank}</span></div>"
+                    "<div style='font-size:11px;opacity:.85;margin-top:1px;'>{location}</div>"
+                    "<div style='font-size:11px;margin-top:3px;'><b>{n_violations}</b> "
+                    "violations · <b>{active_days}</b> days</div>"
+                    "<div style='font-size:11px;'>Top: {top_violation}</div>",
+            "style": {"backgroundColor": "rgba(20,12,46,0.94)", "color": "#F4F1FF",
+                      "borderRadius": "10px", "padding": "10px 12px", "maxWidth": "250px",
+                      "whiteSpace": "normal", "lineHeight": "1.35",
+                      "fontFamily": "Plus Jakarta Sans, sans-serif",
+                      "border": "1px solid rgba(139,92,246,0.45)",
+                      "boxShadow": "0 8px 26px rgba(0,0,0,0.4)"}},
     ), use_container_width=True, height=560)
 
 elif section == "tab_ops":
@@ -586,24 +634,86 @@ elif section == "tab_ops":
         "top_violation": "Top violation"}),
         use_container_width=True, hide_index=True, height=340)
 
-    st.markdown("#### 🚓 Impose a regulatory action")
-    if "dispatch_log" not in st.session_state:
-        st.session_state.dispatch_log = []
-    e1, e2 = st.columns(2)
-    zone = e1.selectbox("Zone", alerts["location"].tolist() if len(alerts) else ["—"])
-    act = e2.selectbox("Action", ["Deploy patrol", "Issue no-parking enforcement",
-                                  "Tow & fine", "Install signage / barricade",
-                                  "Escalate to control room", "Mark resolved"])
-    if st.button("📨 Dispatch action"):
-        st.session_state.dispatch_log.insert(0, {
-            "Time": datetime.now().strftime("%H:%M:%S"),
-            "Officer": st.session_state.get("user", "—"),
-            "Zone": zone.split(",")[0], "Action": act})
-        st.success(f"Dispatched: {act} → {zone.split(',')[0]}")
-    if st.session_state.dispatch_log:
-        st.markdown("**Dispatch log — this session**")
-        st.dataframe(pd.DataFrame(st.session_state.dispatch_log),
-                     use_container_width=True, hide_index=True, height=200)
+    # ---- cross-officer dispatch & coordination board (shared across sessions) ----
+    st.markdown("#### 🚓 Dispatch & coordination board")
+    st.caption("Shared live across every signed-in officer. Tow/crane units are a simulated "
+               "fleet; in production these are live GPS units with push-to-mobile alerts.")
+    fleet = ops.make_fleet(hot)
+
+    watch = st.checkbox("🔔 Live board (auto-refresh every 5s)", value=True)
+    if watch and HAS_AUTOREFRESH:
+        st_autorefresh(interval=5000, key="board_refresh")
+
+    e1, e2, e3 = st.columns([2.2, 2.2, 1.1])
+    zopts = alerts["location"].tolist() if len(alerts) else hot["location"].head(20).tolist()
+    zone = e1.selectbox("Zone", zopts, key="disp_zone")
+    act = e2.selectbox("Action", ["Deploy patrol", "Tow & fine", "Install signage / barricade",
+                                  "On-spot challan drive", "Escalate to control room"],
+                       key="disp_act")
+    auto_tow = e3.checkbox("Assign nearest unit", value=True)
+    if st.button("📨 Dispatch", type="primary"):
+        zrow = hot[hot["location"] == zone]
+        unit, dist = (None, None)
+        if auto_tow and len(zrow):
+            unit, dist = ops.nearest_unit(float(zrow["lat"].iat[0]), float(zrow["lon"].iat[0]), fleet)
+        ops.add_dispatch({
+            "ts": _time.time(),
+            "time": datetime.now().strftime("%H:%M:%S"),
+            "officer": st.session_state.get("user", "—"),
+            "zone": zone.split(",")[0],
+            "cii": float(zrow["cii"].iat[0]) if len(zrow) else None,
+            "action": act,
+            "unit": unit["unit"] if unit else "—",
+            "eta_km": dist if dist is not None else None,
+            "status": "Dispatched"})
+        msg = f"Dispatched: {act} → {zone.split(',')[0]}"
+        if unit:
+            msg += f"  ·  nearest unit {unit['unit']} (~{dist} km)"
+        st.success(msg)
+
+    board = ops.read_dispatches()
+    # toast when a NEW dispatch from another officer appears since we last looked
+    max_id = max([b.get("id", 0) for b in board], default=0)
+    if max_id > st.session_state.get("board_seen", 0):
+        newest = board[0]
+        if newest.get("officer") != st.session_state.get("user"):
+            st.toast(f"🔔 {newest.get('officer')} → {newest.get('action')} @ "
+                     f"{newest.get('zone')}", icon="🚓")
+        st.session_state.board_seen = max_id
+
+    open_n = sum(1 for b in board if b.get("status") != "Resolved")
+    clears = [b["clear_min"] for b in board if b.get("clear_min") is not None]
+    s1, s2, s3 = st.columns(3)
+    s1.metric("Open dispatches", open_n)
+    s2.metric("Resolved", len(clears))
+    s3.metric("Avg time-to-clear", f"{(sum(clears)/len(clears)):.0f} min" if clears else "—")
+
+    if board:
+        bdf = pd.DataFrame(board)
+        for c in ["time", "officer", "zone", "action", "unit", "status"]:
+            if c not in bdf.columns:
+                bdf[c] = "—"
+        st.dataframe(bdf[["time", "officer", "zone", "action", "unit", "status"]].rename(columns={
+            "time": "Time", "officer": "Officer", "zone": "Zone", "action": "Action",
+            "unit": "Unit", "status": "Status"}),
+            use_container_width=True, hide_index=True, height=240)
+        open_ids = [b["id"] for b in board if b.get("status") != "Resolved"]
+        rc1, rc2, rc3 = st.columns([2.5, 1, 1])
+        if open_ids:
+            rid = rc1.selectbox("Resolve a dispatch (logs time-to-clear)", open_ids,
+                                format_func=lambda i: f"#{i} · " +
+                                next((b.get("zone", "") for b in board if b.get("id") == i), ""),
+                                key="resolve_pick")
+            if rc2.button("✅ Resolve", key="resolve_btn"):
+                ops.resolve_dispatch(rid)
+                st.rerun()
+        if rc3.button("🗑 Reset board", key="clear_board"):
+            ops.clear_dispatches()
+            st.session_state.board_seen = 0
+            st.rerun()
+    else:
+        st.info("No dispatches yet — dispatch an action above and it appears instantly "
+                "for every officer on the board.")
 
 elif section == "tab_trends":
     tr = load_trends()
@@ -704,22 +814,58 @@ elif section == "tab_off":
         "Spatial spread · how many distinct zones each offender hits"),
         use_container_width=True)
 
+    # ---- escalation ladder (chronic-offender enforcement tiers) ----
+    st.markdown("##### ⚖️ Repeat-offender escalation ladder")
+    st.caption("Chronic plates are auto-tiered for escalating action — in production these "
+               "fire as e-challan notices / RTO referrals, directly targeting the 34%.")
+    tiers_all = off["n_violations"].apply(ops.escalation_tier)
+    off_e = off.copy()
+    off_e["tier"] = [x[0] for x in tiers_all]
+    off_e["tier_icon"] = [x[1] for x in tiers_all]
+    off_e["rec_action"] = [x[2] for x in tiers_all]
+    tc = off_e.groupby("tier_icon").size()
+    tcols = st.columns(4)
+    for col, (ic, nm) in zip(tcols, [("🔴", "Chronic"), ("🟠", "Habitual"),
+                                     ("🟡", "Repeat"), ("🔵", "Watchlist")]):
+        col.metric(f"{ic} {nm}", int(tc.get(ic, 0)))
+
     q = st.text_input(t("search_vehicle", lang), key="off_search")
-    view = off
+    view = off_e
     if q:
-        view = off[off["vehicle_number"].str.contains(q, case=False, na=False)
-                   | off["top_location"].str.contains(q, case=False, na=False)]
+        view = off_e[off_e["vehicle_number"].str.contains(q, case=False, na=False)
+                     | off_e["top_location"].str.contains(q, case=False, na=False)]
     n_off = st.slider(t("top_n_off", lang), 5, 100, 25, 5, key="off_n")
+    view = view.copy()
+    view["Tier"] = view["tier_icon"] + " " + view["tier"]
     st.dataframe(view.head(n_off)[["rank", "vehicle_number", "n_violations", "n_zones",
-                                   "vehicle_type", "top_location", "first_seen",
-                                   "last_seen"]].rename(columns={
-        "rank": "Rank", "vehicle_number": "Vehicle (anon.)", "n_violations": "Violations",
-        "n_zones": "Zones hit", "vehicle_type": "Type", "top_location": "Most-seen location",
-        "first_seen": "First seen", "last_seen": "Last seen"}),
-        use_container_width=True, hide_index=True, height=460)
-    st.download_button(t("dl_offenders", lang), view.head(n_off).to_csv(index=False),
+                                   "vehicle_type", "Tier", "rec_action", "last_seen"]].rename(
+        columns={"rank": "Rank", "vehicle_number": "Vehicle (anon.)",
+                 "n_violations": "Violations", "n_zones": "Zones hit", "vehicle_type": "Type",
+                 "rec_action": "Recommended action", "last_seen": "Last seen"}),
+        use_container_width=True, hide_index=True, height=420)
+    st.download_button(t("dl_offenders", lang),
+                       view.head(n_off).drop(columns=["tier_icon"]).to_csv(index=False),
                        "repeat_offenders.csv", mime="text/csv", key="off_dl")
 
+    with st.expander("📄 Generate a formal notice (e-challan draft)"):
+        pick = st.selectbox("Vehicle", view.head(n_off)["vehicle_number"].tolist(),
+                            key="notice_v")
+        r = off_e[off_e["vehicle_number"] == pick].iloc[0]
+        notice = (f"BENGALURU TRAFFIC POLICE — REPEAT-OFFENDER NOTICE\n"
+                  f"-----------------------------------------------\n"
+                  f"Vehicle (anonymised): {pick}\n"
+                  f"Vehicle type        : {r['vehicle_type']}\n"
+                  f"Recorded violations : {r['n_violations']} across {r['n_zones']} zone(s)\n"
+                  f"Period              : {r['first_seen']} to {r['last_seen']}\n"
+                  f"Most-seen location  : {r['top_location']}\n"
+                  f"Escalation tier     : {r['tier_icon']} {r['tier']}\n"
+                  f"Recommended action  : {r['rec_action']}\n\n"
+                  f"As per repeat-violation provisions, the above vehicle is liable for "
+                  f"escalated penalty. This is a system-generated draft for review.\n")
+        st.code(notice)
+        st.download_button("⬇️ Download notice (TXT)", notice, f"notice_{pick}.txt",
+                           mime="text/plain", key="notice_dl")
+
 elif section == "tab_fc":
     day = fc["forecast_for"].iat[0]
     st.caption(f"{day}")
@@ -730,7 +876,7 @@ elif section == "tab_fc":
     st.pydeck_chart(pdk.Deck(
         layers=[fc_layer],
         initial_view_state=pdk.ViewState(latitude=12.97, longitude=77.59, zoom=11, pitch=0),
-        map_style="dark",
+        map_style=MAP_STYLE,
         tooltip={"html": "Risk #{risk_rank} · {pred_intensity}<br/>{location}"},
     ), use_container_width=True, height=520)
     st.dataframe(topf[["risk_rank", "location", "junction_name",
@@ -739,6 +885,169 @@ elif section == "tab_fc":
         "pred_intensity": "Predicted intensity", "cii": "Current CII"}),
         use_container_width=True, hide_index=True)
 
+elif section == "tab_patrol":
+    st.subheader("🗓️ Patrol-beat & shift planner")
+    day = fc["forecast_for"].iat[0]
+    st.caption(f"Tomorrow's predicted hotspots ({day}) grouped by station jurisdiction — "
+               "a deployable morning briefing. Zones from the LightGBM forecast; suggested "
+               "shift windows from each zone's peak-hour profile.")
+
+    plan = ops.patrol_plan(fc, hot, top_zones=60)
+    if not len(plan):
+        st.info("No forecast zones available to plan.")
+    else:
+        summ = (plan.groupby("police_station")
+                .agg(zones=("h3", "count"), intensity=("pred_intensity", "sum"),
+                     units=("units", "sum"))
+                .sort_values("intensity", ascending=False).reset_index())
+        c = st.columns(3)
+        c[0].metric("Hotspot zones tomorrow", len(plan))
+        c[1].metric("Stations to brief", plan["police_station"].nunique())
+        c[2].metric("Patrol units to deploy", int(plan["units"].sum()))
+
+        st.markdown("##### 🚦 Priority stations tomorrow")
+        st.plotly_chart(bar_chart(
+            pd.DataFrame({"label": summ["police_station"].head(10),
+                          "value": summ["intensity"].head(10).round(0)}),
+            "Top 10 stations by total predicted intensity", ramp=True),
+            use_container_width=True)
+
+        stations = ["All divisions"] + summ["police_station"].tolist()
+        pick = st.selectbox("Division / station beat", stations, key="patrol_div")
+        view = plan if pick == "All divisions" else plan[plan["police_station"] == pick]
+
+        mlayer = pdk.Layer("ScatterplotLayer", view, pickable=True, get_position="[lon, lat]",
+                           get_radius="pred_intensity * 6 + 80",
+                           get_fill_color="[124, 58, 237, 170]")
+        st.pydeck_chart(pdk.Deck(
+            layers=[mlayer],
+            initial_view_state=pdk.ViewState(latitude=12.97, longitude=77.59, zoom=11, pitch=0),
+            map_style=MAP_STYLE,
+            tooltip={"html": "<b>{location}</b><br/>pred {pred_intensity} · "
+                             "{units} unit(s)<br/>{shift}"}),
+            use_container_width=True, height=420)
+
+        brief = view.copy()
+        brief["order"] = range(1, len(brief) + 1)
+        show = brief[["order", "police_station", "location", "junction_name",
+                      "pred_intensity", "shift", "units"]].rename(columns={
+            "order": "#", "police_station": "Station", "location": "Zone",
+            "junction_name": "Junction", "pred_intensity": "Predicted intensity",
+            "shift": "Suggested shift", "units": "Units"})
+        st.dataframe(show, use_container_width=True, hide_index=True, height=380)
+        st.download_button("⬇️  Download tomorrow's patrol briefing (CSV)",
+                           show.to_csv(index=False), "patrol_briefing.csv",
+                           mime="text/csv", key="patrol_dl")
+
+elif section == "tab_whatif":
+    st.subheader("🧪 What-if intervention simulator")
+    st.caption("Project the CII drop from an intervention using the *same* published CII "
+               "weights (volume 45% · persistence 30% · peak 25%). Lever effects are "
+               "transparent, configurable assumptions — not a black box.")
+
+    wcol = st.columns([2.4, 2])
+    zopts = hot.sort_values("cii", ascending=False)["location"].head(150).tolist()
+    zsel = wcol[0].selectbox("Target zone", zopts, key="wi_zone")
+    levers = wcol[1].multiselect("Intervention(s)", list(ops.INTERVENTIONS.keys()),
+                                 default=["Bollards / barricade"], key="wi_lev")
+
+    zrow = hot[hot["location"] == zsel].iloc[0]
+    cur_cii = float(zrow["cii"])
+    reductions = ops.combine_interventions(levers)
+    new_cii, eff_pct = ops.whatif_new_cii(cur_cii, reductions, meta.get("cii_weights", {}))
+    cur_rank = int(zrow["cii_rank"])
+    proj_rank = ops.new_rank(new_cii, hot["cii"].tolist())
+
+    k = st.columns(3)
+    with k[0]:
+        kpi_card("🎯", "Projected CII", f"{new_cii:.0f}", accent="#22D3EE",
+                 sub=f"<span style='color:#34D399;'>↓ from {cur_cii:.0f} (−{eff_pct:.0f}%)</span>")
+    with k[1]:
+        kpi_card("📊", "Projected city rank", f"#{proj_rank}", accent=VIOLET,
+                 sub=f"<span style='color:#34D399;'>from #{cur_rank} "
+                 f"(↓ {max(0, proj_rank - cur_rank)} places)</span>")
+    with k[2]:
+        kpi_card("🧩", "Levers applied", f"{len(levers)}", accent="#FACC15",
+                 sub="combined with diminishing returns")
+
+    st.write("")
+    st.plotly_chart(bar_chart(
+        pd.DataFrame({"label": ["Current CII", "Projected CII"], "value": [cur_cii, new_cii]}),
+        f"{zsel.split(',')[0]} — projected impact of intervention", ramp=False),
+        use_container_width=True)
+
+    comp = pd.DataFrame({
+        "Component": ["Severity-weighted volume", "Persistence", "Peak concentration"],
+        "Weight": ["45%", "30%", "25%"],
+        "Modelled reduction": [f"−{reductions['volume'] * 100:.0f}%",
+                               f"−{reductions['persistence'] * 100:.0f}%",
+                               f"−{reductions['peak'] * 100:.0f}%"]})
+    st.markdown("##### How the projection is built")
+    st.dataframe(comp, use_container_width=True, hide_index=True)
+    st.caption("Each lever reduces components by configurable fractions; multiple levers "
+               "combine multiplicatively. The headline change is the weight-blended "
+               "reduction applied to this zone's CII — fully auditable.")
+
+elif section == "tab_event":
+    st.subheader("🎪 Event mode — venue surge projection")
+    st.caption("Project congestion around a known venue on event days (match / concert / "
+               "sale). Surge = each nearby zone's CII × an event multiplier, from its "
+               "historical pattern — useful for pre-positioning before the rush.")
+
+    VENUES = {
+        "M. Chinnaswamy Stadium (cricket)": (12.9788, 77.5996),
+        "Sree Kanteerava Stadium": (12.9617, 77.5972),
+        "Orion Mall, Rajajinagar": (13.0108, 77.5550),
+        "Phoenix Marketcity, Whitefield": (12.9959, 77.6965),
+        "Mantri Square, Malleshwaram": (13.0068, 77.5705),
+        "Kempegowda Bus Station (Majestic)": (12.9774, 77.5717),
+        "MG Road / Brigade Road": (12.9756, 77.6068),
+    }
+    EVENTS = {"Cricket match / concert (high)": 1.6, "Mall sale / festival (medium)": 1.4,
+              "Weekday office rush (low)": 1.25}
+
+    ec = st.columns([2.3, 2, 1])
+    venue = ec[0].selectbox("Venue", list(VENUES.keys()), key="ev_venue")
+    etype = ec[1].selectbox("Event type", list(EVENTS.keys()), key="ev_type")
+    kr = ec[2].slider("Radius (rings)", 1, 3, 2, key="ev_k")
+
+    vlat, vlon = VENUES[venue]
+    mult = EVENTS[etype]
+    tmp = hot[["h3", "lat", "lon"]].copy()
+    tmp["_d"] = (tmp["lat"] - vlat) ** 2 + (tmp["lon"] - vlon) ** 2
+    center_h3 = tmp.nsmallest(1, "_d")["h3"].iat[0]
+    surge = ops.event_surge(hot, center_h3, kr, mult)
+
+    if not len(surge):
+        st.info("No mapped hotspot zones near this venue in the dataset.")
+    else:
+        m = st.columns(3)
+        m[0].metric("Zones in surge radius", len(surge))
+        m[1].metric("Peak projected CII", f"{surge['surge_cii'].max():.0f}")
+        m[2].metric("Avg added load", f"+{surge['delta'].mean():.0f} CII")
+
+        surge2 = surge.copy()
+        surge2["radius"] = surge2["surge_cii"] * 5 + 60
+        slayer = pdk.Layer("ScatterplotLayer", surge2, pickable=True, get_position="[lon, lat]",
+                           get_radius="radius", get_fill_color="[239, 68, 68, 160]")
+        vlayer = pdk.Layer("ScatterplotLayer", pd.DataFrame([{"lat": vlat, "lon": vlon}]),
+                           get_position="[lon, lat]", get_radius=180,
+                           get_fill_color="[124, 58, 237, 230]")
+        st.pydeck_chart(pdk.Deck(
+            layers=[slayer, vlayer],
+            initial_view_state=pdk.ViewState(latitude=vlat, longitude=vlon, zoom=13, pitch=0),
+            map_style=MAP_STYLE,
+            tooltip={"html": "<b>{location}</b><br/>CII {cii} → surge {surge_cii} (+{delta})"}),
+            use_container_width=True, height=440)
+
+        show = surge[["location", "junction_name", "cii", "surge_cii", "delta",
+                      "n_violations"]].rename(columns={
+            "location": "Zone", "junction_name": "Junction", "cii": "Normal CII",
+            "surge_cii": "Event CII", "delta": "Δ surge", "n_violations": "Hist. violations"})
+        st.dataframe(show, use_container_width=True, hide_index=True, height=320)
+        st.caption(f"Projection: normal CII × {mult} (event multiplier), capped at 100. "
+                   "The violet dot is the venue; red dots are expected surge zones.")
+
 st.divider()
 st.caption(f"CII = severity-weighted volume (45%) + persistence (30%) + peak "
            f"concentration (25%), amplified near junctions. Forecast: LightGBM, "

data/processed/forecast.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a3dc6af6e39b79339ec846f8910b3aa1474501ba5bb1c81fb15cd16b7e441707
+oid sha256:1208066f9e9397f36c0c7cd42496592b8318c098c86cffd9f97f89a2a7b8f896
 size 38055

src/i18n.py

@@ -47,6 +47,12 @@ STRINGS = {
                 "hi": "🚨  बार-बार उल्लंघनकर्ता"},
     "tab_fc": {"en": "🔮  Tomorrow's forecast", "kn": "🔮  ನಾಳಿನ ಮುನ್ಸೂಚನೆ",
                "hi": "🔮  कल का पूर्वानुमान"},
+    "tab_patrol": {"en": "🗓️  Patrol planner", "kn": "🗓️  ಗಸ್ತು ಯೋಜನೆ",
+                   "hi": "🗓️  गश्त योजना"},
+    "tab_whatif": {"en": "🧪  What-if simulator", "kn": "🧪  ವಾಟ್-ಇಫ್ ಸಿಮ್ಯುಲೇಟರ್",
+                   "hi": "🧪  व्हाट-इफ सिम्युलेटर"},
+    "tab_event": {"en": "🎪  Event mode", "kn": "🎪  ಈವೆಂಟ್ ಮೋಡ್",
+                  "hi": "🎪  इवेंट मोड"},
     "min_cii": {"en": "Minimum CII to display", "kn": "ಪ್ರದರ್ಶಿಸಲು ಕನಿಷ್ಠ CII",
                 "hi": "दिखाने हेतु न्यूनतम CII"},
     "top_n_zones": {"en": "Show top N zones", "kn": "ಮೇಲಿನ N ವಲಯಗಳನ್ನು ತೋರಿಸಿ",

src/ops.py

@@ -0,0 +1,206 @@
+"""Operational layer for DRISHTI.
+
+Backs the six command-and-control features:
+  1. cross-officer dispatch board   -> file-backed shared store (across sessions)
+  2. tow / crane fleet + nearest-unit + time-to-clear SLA
+  3. what-if intervention projection (transparent, tied to the CII weights)
+  4. patrol-beat & shift planning from the forecast (grouped by police_station)
+  5. repeat-offender escalation tiers
+  6. event-mode surge projection around a chosen zone (H3 k-ring)
+
+Everything is computed from the provided dataset. The tow fleet and dispatch
+records are an operational SIMULATION layer (not external data).
+"""
+import json
+import math
+import os
+import tempfile
+import time
+
+# ----------------------------------------------------------------------
+# 1 + 4.  shared dispatch board (cross-session, cross-officer)
+# /tmp is writable on HF Spaces and shared across all sessions of the container.
+# ----------------------------------------------------------------------
+DISPATCH_PATH = os.path.join(tempfile.gettempdir(), "drishti_dispatch.json")
+
+
+def _read_json(path, default):
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return default
+
+
+def _write_json(path, data):
+    tmp = path + ".tmp"
+    with open(tmp, "w", encoding="utf-8") as f:
+        json.dump(data, f)
+    os.replace(tmp, path)          # atomic on the same filesystem
+
+
+def read_dispatches():
+    data = _read_json(DISPATCH_PATH, [])
+    return data if isinstance(data, list) else []
+
+
+def add_dispatch(rec):
+    data = read_dispatches()
+    rec["id"] = (max([r.get("id", 0) for r in data]) + 1) if data else 1
+    data.insert(0, rec)
+    _write_json(DISPATCH_PATH, data[:200])
+    return rec["id"]
+
+
+def resolve_dispatch(did):
+    data = read_dispatches()
+    now = time.time()
+    for r in data:
+        if r.get("id") == did and r.get("status") != "Resolved":
+            r["status"] = "Resolved"
+            r["resolved_ts"] = now
+            r["clear_min"] = round((now - r.get("ts", now)) / 60.0, 1)
+    _write_json(DISPATCH_PATH, data)
+
+
+def clear_dispatches():
+    _write_json(DISPATCH_PATH, [])
+
+
+# ----------------------------------------------------------------------
+# 2.  tow / crane fleet (simulated) + nearest-unit assignment + distance
+# ----------------------------------------------------------------------
+def make_fleet(hotspots):
+    """Anchor a small simulated fleet at spread-out points across the data bbox."""
+    lat0, lat1 = float(hotspots["lat"].min()), float(hotspots["lat"].max())
+    lon0, lon1 = float(hotspots["lon"].min()), float(hotspots["lon"].max())
+    names = ["Tow-North", "Tow-South", "Tow-East", "Tow-West", "Crane-Central", "Tow-SE"]
+    frac = [(0.78, 0.50), (0.22, 0.50), (0.50, 0.82), (0.50, 0.18), (0.50, 0.50), (0.32, 0.72)]
+    fleet = []
+    for nm, (fy, fx) in zip(names, frac):
+        fleet.append({"unit": nm,
+                      "lat": lat0 + fy * (lat1 - lat0),
+                      "lon": lon0 + fx * (lon1 - lon0)})
+    return fleet
+
+
+def haversine(la1, lo1, la2, lo2):
+    R = 6371.0
+    p1, p2 = math.radians(la1), math.radians(la2)
+    dp = math.radians(la2 - la1)
+    dl = math.radians(lo2 - lo1)
+    a = math.sin(dp / 2) ** 2 + math.cos(p1) * math.cos(p2) * math.sin(dl / 2) ** 2
+    return 2 * R * math.asin(math.sqrt(a))
+
+
+def nearest_unit(lat, lon, fleet):
+    best, bd = None, 1e9
+    for u in fleet:
+        d = haversine(lat, lon, u["lat"], u["lon"])
+        if d < bd:
+            best, bd = u, d
+    return best, round(bd, 2)
+
+
+# ----------------------------------------------------------------------
+# 3.  what-if intervention projection
+# CII is a weighted sum of (volume, persistence, peak) components, so the
+# headline CII drop is just the weighted blend of each lever's effect.
+# ----------------------------------------------------------------------
+INTERVENTIONS = {
+    "No-parking signage":      {"volume": 0.25, "persistence": 0.05, "peak": 0.10},
+    "Bollards / barricade":    {"volume": 0.45, "persistence": 0.25, "peak": 0.15},
+    "Towing drive":            {"volume": 0.15, "persistence": 0.05, "peak": 0.35},
+    "Dedicated parking bay":   {"volume": 0.40, "persistence": 0.30, "peak": 0.20},
+    "Static enforcement post": {"volume": 0.30, "persistence": 0.35, "peak": 0.30},
+}
+
+
+def combine_interventions(selected):
+    """Combine chosen levers multiplicatively per component (diminishing returns)."""
+    comp = {"volume": 0.0, "persistence": 0.0, "peak": 0.0}
+    for name in selected:
+        eff = INTERVENTIONS.get(name, {})
+        for k in comp:
+            comp[k] = 1 - (1 - comp[k]) * (1 - eff.get(k, 0.0))
+    return comp
+
+
+def whatif_new_cii(cii, reductions, weights):
+    """reductions: component -> fraction (0-1). weights: meta cii_weights dict."""
+    wv = weights.get("weighted_volume", weights.get("volume", 0.45))
+    wp = weights.get("persistence", 0.30)
+    wk = weights.get("peak_share", weights.get("peak", weights.get("peak_concentration", 0.25)))
+    s = (wv + wp + wk) or 1.0
+    wv, wp, wk = wv / s, wp / s, wk / s
+    eff = (wv * reductions.get("volume", 0)
+           + wp * reductions.get("persistence", 0)
+           + wk * reductions.get("peak", 0))
+    eff = max(0.0, min(0.95, eff))
+    return round(float(cii) * (1 - eff), 1), round(eff * 100, 1)
+
+
+def new_rank(new_cii, all_cii_desc):
+    """Rank a projected CII against the existing distribution (1 = worst)."""
+    above = sum(1 for c in all_cii_desc if c > new_cii)
+    return above + 1
+
+
+# ----------------------------------------------------------------------
+# 5.  repeat-offender escalation tiers (calibrated to the data's 11-55 range)
+# ----------------------------------------------------------------------
+def escalation_tier(n):
+    """Return (tier_label, icon, recommended_action)."""
+    if n >= 40:
+        return ("Chronic — license/RC review", "🔴", "RTO referral + court summons")
+    if n >= 25:
+        return ("Habitual — court summons", "🟠", "Summons + cumulative penalty")
+    if n >= 16:
+        return ("Repeat — escalated fine", "🟡", "Escalated fine + formal notice")
+    return ("Watchlist — formal notice", "🔵", "Formal notice via e-challan")
+
+
+# ----------------------------------------------------------------------
+# 6.  patrol-beat & shift planning (beats = police_station jurisdictions)
+# ----------------------------------------------------------------------
+def patrol_plan(forecast_df, hotspots_df, top_zones=40):
+    cols = ["h3", "police_station", "peak_share", "location", "cii", "junction_name"]
+    h = hotspots_df[cols].copy()
+    plan = forecast_df.merge(h, on="h3", how="left", suffixes=("", "_h"))
+    plan = plan.dropna(subset=["police_station"])
+    plan = plan.sort_values("pred_intensity", ascending=False).head(top_zones).copy()
+
+    def shift(ps):
+        try:
+            ps = float(ps)
+        except Exception:
+            return "All-day rotating"
+        if math.isnan(ps):
+            return "All-day rotating"
+        return "Peak hours (08-11, 17-21)" if ps >= 0.45 else "All-day rotating"
+
+    plan["shift"] = plan["peak_share"].apply(shift)
+    pmax = plan["pred_intensity"].max() or 1.0
+    plan["units"] = (plan["pred_intensity"] / pmax * 2 + 1).round().astype(int)
+    # prefer the merged location/junction if present
+    if "location_h" in plan.columns:
+        plan["location"] = plan["location"].fillna(plan["location_h"])
+    return plan
+
+
+# ----------------------------------------------------------------------
+# 7.  event-mode surge (H3 k-ring around a chosen zone)
+# ----------------------------------------------------------------------
+def event_surge(hotspots_df, center_h3, k, multiplier):
+    try:
+        import h3
+        try:
+            ring = set(h3.grid_disk(center_h3, k))      # h3 v4
+        except Exception:
+            ring = set(h3.k_ring(center_h3, k))         # h3 v3
+    except Exception:
+        ring = {center_h3}
+    sub = hotspots_df[hotspots_df["h3"].isin(ring)].copy()
+    sub["surge_cii"] = (sub["cii"] * float(multiplier)).clip(upper=100).round(1)
+    sub["delta"] = (sub["surge_cii"] - sub["cii"]).round(1)
+    return sub.sort_values("surge_cii", ascending=False)