feat(notifications): v0.5.0 -- Master Toggles UX redesign + Central Connection GUI + grouped categories + region scoping

Per-family notification policy (PagerDuty/Grafana-style): each family gets a
severity threshold + region scope + a severity->channel routing matrix, so an
operator opts in per family rather than hand-writing rules.

SECTION 1 -- BACKEND
- config.py: new NotificationToggle dataclass (enabled, min_severity, regions,
  severity_channels{severity->[channel types]}, quiet_hours_override, + per-channel
  delivery config: broadcast_channel/node_ids/smtp_*/recipients/webhook_*).
  notifications.toggles is now a dict[family]->NotificationToggle with 8 family
  defaults (mesh_health, weather, fire, rf_propagation, roads, avalanche, seismic,
  tracking), all enabled=false (opt-in), min_severity=priority,
  severity_channels={priority:[mesh_broadcast], immediate:[mesh_broadcast, mesh_dm]},
  quiet_hours_override=true. (Old TogglesConfig.enabled was only read by
  build_pipeline via getattr -> degrades to ToggleFilter no-op, so the pipeline
  filter is unchanged; toggles now drive the Dispatcher instead.)
- region_scope:list added to NotificationRuleConfig; _matching_rules filters by
  event.region/regions ([] = all).
- Dispatcher: _dispatch_toggles runs IN PARALLEL to rule matching -- looks up
  get_toggle(event.category), checks enabled + region scope + severity threshold,
  then for each channel in severity_channels[event.severity] builds a synthetic
  rule (override_quiet set only for immediate when quiet_hours_override) and
  delivers. 'digest' channel is skipped in live dispatch (handled by accumulator).
- categories.py: get_toggle() prefix fallback maps the live phases-2.7-2.14
  categories (weather_warning, wildfire_incident, earthquake_event,
  traffic_congestion, geomagnetic/rf_*, stream_*, ...) to their family, fixing the
  v0.4 "category -> other" gap.
- config_loader.py: SECRET_FIELDS += notifications.toggles.*.smtp_password.
- _dataclass_to_dict now recurses dict-of-dataclasses, and the loader coerces the
  toggles dict -> NotificationToggle on both the full-load and section-PUT paths
  (so GUI save round-trips correctly).
- tests/test_notification_toggles.py (11): enabled/disabled, region filter
  (empty+populated+regions-list), severity threshold, per-severity channel routing,
  digest-skipped-live, quiet-hours-override immediate-only, category->family,
  rules+toggles both fire. Full suite: 294 passed (283 + 11).

SECTION 2 -- FRONTEND
- Notifications.tsx: MasterToggles component above the rules section -- 8 family
  cards (icon + enable toggle; collapsed summary 'OFF' or 'N regions, M channels at
  <sev>+'; expanded: severity threshold, severity x channel checkbox matrix,
  region list, quiet-hours-override toggle, per-channel config:
  broadcast_channel/DM node IDs/recipients/SMTP host+port/webhook URL).
- Environment.tsx: CentralConnectionPanel above the family tabs (url, durable,
  enabled) wired to environmental.central.
- npm run build clean (tsc strict); rebuilt static committed (index-CfYlhn4e.js).

SECTION 3 -- VERIFICATION
- py_compile + tsc strict clean; pytest 294 passed.
- Rebuilt prod: /notifications serves Master Toggles, /environment serves Central
  Connection (strings confirmed in the served bundle); 8 adapters, pipeline
  started, no tracebacks, healthy.
- GUI round-trip: enable weather toggle (min_severity=priority,
  regions=[Magic Valley], severity_channels.priority=[mesh_broadcast]) -> PUT
  {saved:true} -> notifications.yaml reflects it; env_feeds traffic.api_key stayed
  ${TOMTOM_API_KEY} (C.3.1 secret preservation holds). Restored to clean opt-in
  baseline.
- Synthetic NWS weather_warning/priority/Magic Valley -> routes through the weather
  toggle to mesh_broadcast; out-of-region and below-threshold events correctly
  dropped.

DEFERRED (noted for a follow-up, not blocking Matt's morning config): Section 2B
rules-editor polish -- grouped-by-family category checkboxes, region_scope
multi-select in the rule editor (backend field + filtering ARE in), tooltips, and
the fire-count Active/No-activity badge -- were not built tonight to keep the build
shippable and verified; the Advanced Rules section is otherwise unchanged and
still functional.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

tests/test_notification_toggles.py

@@ -0,0 +1,125 @@
+"""v0.5 Section 1: NotificationToggle dispatch routing tests."""
+
+import asyncio
+
+from meshai.config import Config
+from meshai.notifications.pipeline.dispatcher import Dispatcher
+from meshai.notifications.events import make_event
+
+
+class RecChannel:
+    def __init__(self, rec):
+        self.rec = rec
+
+    async def deliver(self, payload, rule):
+        self.rec.append({
+            "delivery_type": rule.delivery_type,
+            "name": rule.name,
+            "broadcast_channel": rule.broadcast_channel,
+            "node_ids": list(rule.node_ids),
+            "override_quiet": rule.override_quiet,
+        })
+        return True
+
+
+def _dispatch(cfg, event):
+    rec = []
+    d = Dispatcher(cfg, lambda rule, conn: RecChannel(rec), connector=None)
+    asyncio.run(d.dispatch(event))
+    return rec
+
+
+def _cfg(enable="weather", **kw):
+    cfg = Config()
+    cfg.notifications.rules = []
+    t = cfg.notifications.toggles[enable]
+    t.enabled = True
+    t.min_severity = kw.get("min_severity", "priority")
+    t.regions = kw.get("regions", [])
+    t.severity_channels = kw.get("severity_channels", {"priority": ["mesh_broadcast"]})
+    return cfg
+
+
+def _ev(severity="priority", category="weather_warning", region=None, regions=None):
+    return make_event(source="nws", category=category, severity=severity,
+                      region=region, regions=regions or [], title="t")
+
+
+def test_disabled_toggle_no_dispatch():
+    cfg = Config(); cfg.notifications.rules = []  # weather disabled by default
+    assert _dispatch(cfg, _ev()) == []
+
+
+def test_enabled_toggle_dispatches():
+    rec = _dispatch(_cfg(), _ev(severity="priority"))
+    assert len(rec) == 1 and rec[0]["delivery_type"] == "mesh_broadcast"
+    assert rec[0]["name"] == "toggle:weather"
+
+
+def test_region_empty_allows_all():
+    rec = _dispatch(_cfg(regions=[]), _ev(region="Boise"))
+    assert len(rec) == 1
+
+
+def test_region_populated_blocks_mismatch():
+    cfg = _cfg(regions=["Magic Valley"])
+    assert _dispatch(cfg, _ev(region="Boise")) == []
+    assert len(_dispatch(cfg, _ev(region="Magic Valley"))) == 1
+
+
+def test_region_matches_via_regions_list():
+    cfg = _cfg(regions=["Magic Valley"])
+    assert len(_dispatch(cfg, _ev(region=None, regions=["Magic Valley", "X"]))) == 1
+
+
+def test_severity_threshold():
+    cfg = _cfg(min_severity="priority",
+               severity_channels={"routine": ["mesh_broadcast"], "priority": ["mesh_broadcast"],
+                                  "immediate": ["mesh_broadcast"]})
+    assert _dispatch(cfg, _ev(severity="routine")) == []     # below threshold
+    assert len(_dispatch(cfg, _ev(severity="priority"))) == 1
+    assert len(_dispatch(cfg, _ev(severity="immediate"))) == 1
+
+
+def test_per_severity_channel_routing():
+    cfg = _cfg(min_severity="routine",
+               severity_channels={"priority": ["mesh_broadcast"],
+                                  "immediate": ["mesh_broadcast", "mesh_dm"]})
+    assert len(_dispatch(cfg, _ev(severity="priority"))) == 1
+    imm = _dispatch(cfg, _ev(severity="immediate"))
+    assert {r["delivery_type"] for r in imm} == {"mesh_broadcast", "mesh_dm"}
+
+
+def test_digest_channel_skipped_in_live_dispatch():
+    cfg = _cfg(severity_channels={"priority": ["digest", "mesh_broadcast"]})
+    rec = _dispatch(cfg, _ev(severity="priority"))
+    assert [r["delivery_type"] for r in rec] == ["mesh_broadcast"]  # digest not live-dispatched
+
+
+def test_quiet_hours_override_immediate_only():
+    cfg = _cfg(min_severity="routine",
+               severity_channels={"priority": ["mesh_broadcast"], "immediate": ["mesh_broadcast"]})
+    cfg.notifications.toggles["weather"].quiet_hours_override = True
+    assert _dispatch(cfg, _ev(severity="priority"))[0]["override_quiet"] is False
+    assert _dispatch(cfg, _ev(severity="immediate"))[0]["override_quiet"] is True
+
+
+def test_category_maps_to_correct_family():
+    # seismic family toggle handles earthquake_event via get_toggle fallback
+    cfg = Config(); cfg.notifications.rules = []
+    cfg.notifications.toggles["seismic"].enabled = True
+    cfg.notifications.toggles["seismic"].severity_channels = {"priority": ["mesh_broadcast"]}
+    rec = _dispatch(cfg, _ev(severity="priority", category="earthquake_event"))
+    assert len(rec) == 1 and rec[0]["name"] == "toggle:seismic"
+
+
+def test_rules_and_toggles_both_fire():
+    from meshai.config import NotificationRuleConfig
+    cfg = _cfg()
+    cfg.notifications.rules = [NotificationRuleConfig(
+        name="legacy", enabled=True, trigger_type="condition",
+        categories=["weather_warning"], min_severity="routine",
+        delivery_type="mesh_broadcast")]
+    rec = _dispatch(cfg, _ev(severity="priority"))
+    names = {r["name"] for r in rec}
+    assert "legacy" in names and "toggle:weather" in names  # parallel paths both fire