Upload app.py

app.py

@@ -1,784 +1,610 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Sundew Diabetes Watch — ADVANCED EDITION
-Showcasing the full power of Sundew's bio-inspired adaptive algorithms.
-
-FEATURES:
-- PipelineRuntime with custom diabetes-specific SignificanceModel
-- Real-time energy tracking with visualization
-- PI control threshold adaptation with telemetry
-- Statistical validation with bootstrap confidence intervals
-- Comprehensive metrics dashboard (F1, precision, recall, energy efficiency)
-- Event-level monitoring with runtime listeners
-- Telemetry export for hardware validation
-- Multi-model ensemble with adaptive weighting
-- Adversarial robustness testing
-"""
-from __future__ import annotations
-
-import json
-import math
-import os
-import time
-from collections import deque
-from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, List, Optional, Tuple
-
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-# ------------------------------ Sundew imports ------------------------------
-try:
-    from sundew.config import SundewConfig
-    from sundew.config_presets import get_preset
-    from sundew.interfaces import (
-        ControlState,
-        GatingDecision,
-        ProcessingContext,
-        ProcessingResult,
-        SignificanceModel,
-    )
-    from sundew.runtime import PipelineRuntime, RuntimeMetrics
-
-    _HAS_SUNDEW = True
-except Exception as e:
-    st.error(f"Sundew not available: {e}. Install with: pip install sundew-algorithms")
-    _HAS_SUNDEW = False
-    st.stop()
-
-# ------------------------------ Optional backends ------------------------------
-try:
-    import xgboost as xgb
-    _HAS_XGB = True
-except:
-    _HAS_XGB = False
-
-try:
-    import torch
-    _HAS_TORCH = True
-except:
-    _HAS_TORCH = False
-
-try:
-    import onnxruntime as ort
-    _HAS_ONNX = True
-except:
-    _HAS_ONNX = False
-
-from sklearn.linear_model import LogisticRegression
-from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
-from sklearn.preprocessing import StandardScaler
-from sklearn.pipeline import Pipeline
-from sklearn.metrics import f1_score, precision_score, recall_score, roc_auc_score
-
-# ------------------------------ Custom Diabetes Significance Model ------------------------------
-
-class DiabetesSignificanceModel(SignificanceModel):
-    """
-    Advanced diabetes-specific significance model.
-
-    Computes multi-factor risk score considering:
-    - Glycemic variability and rate of change
-    - Hypo/hyper proximity with non-linear penalties
-    - Insulin-on-board (IOB) decay model
-    - Carbohydrate absorption dynamics
-    - Activity impact on glucose
-    - Time-of-day circadian patterns
-    - Recent history and trend analysis
-    """
-
-    def __init__(self, config: Dict[str, Any]):
-        self.hypo_threshold = config.get("hypo_threshold", 70.0)
-        self.hyper_threshold = config.get("hyper_threshold", 180.0)
-        self.target_glucose = config.get("target_glucose", 100.0)
-        self.roc_critical = config.get("roc_critical", 3.0)  # mg/dL/min
-        self.insulin_half_life = config.get("insulin_half_life", 60.0)  # minutes
-        self.carb_absorption_time = config.get("carb_absorption_time", 180.0)  # minutes
-        self.activity_glucose_impact = config.get("activity_glucose_impact", 0.5)
-
-        # Adaptive weights (learned from data)
-        self.weights = {
-            "glycemic_deviation": 0.35,
-            "velocity_risk": 0.25,
-            "iob_risk": 0.15,
-            "cob_risk": 0.10,
-            "activity_risk": 0.05,
-            "variability": 0.10,
-        }
-
-        # History for trend analysis
-        self.glucose_history: deque = deque(maxlen=12)  # Last hour (5-min samples)
-        self.significance_ema = 0.5
-        self.ema_alpha = 0.15
-
-    def compute_significance(self, context: ProcessingContext) -> Tuple[float, Dict[str, Any]]:
-        """Compute diabetes-specific significance score."""
-        # Features is a dict attribute of context
-        features = context.features if hasattr(context, 'features') else {}
-
-        # Extract features safely with proper dict access
-        glucose = float(features.get("glucose_mgdl", 120.0)) if isinstance(features, dict) else 120.0
-        roc = float(features.get("roc_mgdl_min", 0.0)) if isinstance(features, dict) else 0.0
-        insulin = float(features.get("insulin_units", 0.0)) if isinstance(features, dict) else 0.0
-        carbs = float(features.get("carbs_g", 0.0)) if isinstance(features, dict) else 0.0
-        hr = float(features.get("hr", 70.0)) if isinstance(features, dict) else 70.0
-        steps = float(features.get("steps", 0)) if isinstance(features, dict) else 0
-        time_min = float(features.get("time_min", 0.0)) if isinstance(features, dict) else 0.0
-
-        # Update history
-        self.glucose_history.append(glucose)
-
-        # 1. Glycemic deviation (non-linear penalty for extremes)
-        if glucose < self.hypo_threshold:
-            hypo_gap = self.hypo_threshold - glucose
-            glycemic_score = min(1.0, (hypo_gap / 40.0) ** 1.5)  # Aggressive penalty
-        elif glucose > self.hyper_threshold:
-            hyper_gap = glucose - self.hyper_threshold
-            glycemic_score = min(1.0, (hyper_gap / 100.0) ** 1.2)
-        else:
-            # In range - low significance
-            deviation = abs(glucose - self.target_glucose)
-            glycemic_score = min(0.3, deviation / 100.0)
-
-        # 2. Velocity risk (rate of change)
-        velocity_magnitude = abs(roc)
-        velocity_score = min(1.0, velocity_magnitude / self.roc_critical)
-
-        # Directional penalty (falling with hypo, rising with hyper)
-        if glucose < 80 and roc < -0.5:
-            velocity_score *= 1.5  # Amplify falling hypo risk
-        elif glucose > 160 and roc > 0.5:
-            velocity_score *= 1.3  # Amplify rising hyper risk
-        velocity_score = min(1.0, velocity_score)
-
-        # 3. Insulin-on-board risk (exponential decay model)
-        if insulin > 0:
-            # Simplified IOB: recent insulin decays exponentially
-            iob_fraction = 1.0  # Assume all insulin still active (simplified)
-            iob_risk = min(1.0, insulin / 6.0) * iob_fraction
-
-            # Higher risk if glucose dropping with IOB
-            if roc < -0.5:
-                iob_risk *= 1.4
-        else:
-            iob_risk = 0.0
-
-        # 4. Carbs-on-board risk (absorption curve)
-        if carbs > 0:
-            # Simplified COB: recent carbs cause glucose spike risk
-            cob_risk = min(1.0, carbs / 60.0)
-
-            # Higher risk if glucose rising with COB
-            if roc > 0.5:
-                cob_risk *= 1.3
-        else:
-            cob_risk = 0.0
-
-        # 5. Activity risk (exercise lowers glucose, HR proxy)
-        activity_level = steps / 100.0 + max(0, hr - 100) / 60.0
-        activity_risk = min(0.5, activity_level * self.activity_glucose_impact)
-
-        # Amplify if exercising with insulin
-        if activity_level > 0.3 and insulin > 1.0:
-            activity_risk *= 1.6
-        activity_risk = min(1.0, activity_risk)
-
-        # 6. Glycemic variability (standard deviation of recent history)
-        if len(self.glucose_history) >= 3:
-            variability = float(np.std(list(self.glucose_history)))
-            variability_score = min(1.0, variability / 40.0)
-        else:
-            variability_score = 0.0
-
-        # Weighted combination
-        significance = (
-            self.weights["glycemic_deviation"] * glycemic_score +
-            self.weights["velocity_risk"] * velocity_score +
-            self.weights["iob_risk"] * iob_risk +
-            self.weights["cob_risk"] * cob_risk +
-            self.weights["activity_risk"] * activity_risk +
-            self.weights["variability"] * variability_score
-        )
-
-        # EMA smoothing to reduce noise
-        self.significance_ema = (1 - self.ema_alpha) * self.significance_ema + self.ema_alpha * significance
-        significance_smoothed = self.significance_ema
-
-        # Clamp to [0, 1]
-        significance_smoothed = max(0.0, min(1.0, significance_smoothed))
-
-        explanation = {
-            "glucose": glucose,
-            "roc": roc,
-            "components": {
-                "glycemic_deviation": glycemic_score,
-                "velocity_risk": velocity_score,
-                "iob_risk": iob_risk,
-                "cob_risk": cob_risk,
-                "activity_risk": activity_risk,
-                "variability": variability_score,
-            },
-            "raw_significance": significance,
-            "smoothed_significance": significance_smoothed,
-        }
-
-        return float(significance_smoothed), explanation
-
-    def update(self, context: ProcessingContext, outcome: Optional[Dict[str, Any]]) -> None:
-        """Adaptive weight learning based on outcomes."""
-        if outcome is None:
-            return
-
-        # Simple gradient-based weight adjustment
-        true_risk = outcome.get("true_risk", None)
-        if true_risk is not None:
-            predicted_sig = outcome.get("predicted_significance", 0.5)
-            error = true_risk - predicted_sig
-
-            # Adjust weights slightly
-            lr = 0.001
-            for key in self.weights:
-                component_value = outcome.get("components", {}).get(key, 0.0)
-                self.weights[key] += lr * error * component_value
-
-            # Normalize weights
-            total = sum(self.weights.values())
-            if total > 0:
-                for key in self.weights:
-                    self.weights[key] /= total
-
-    def get_parameters(self) -> Dict[str, Any]:
-        return {
-            "weights": self.weights,
-            "hypo_threshold": self.hypo_threshold,
-            "hyper_threshold": self.hyper_threshold,
-            "target_glucose": self.target_glucose,
-        }
-
-    def set_parameters(self, params: Dict[str, Any]) -> None:
-        self.weights = params.get("weights", self.weights)
-        self.hypo_threshold = params.get("hypo_threshold", self.hypo_threshold)
-        self.hyper_threshold = params.get("hyper_threshold", self.hyper_threshold)
-        self.target_glucose = params.get("target_glucose", self.target_glucose)
-
-
-# ------------------------------ Telemetry & Monitoring ------------------------------
-
-@dataclass
-class TelemetryEvent:
-    """Single telemetry event for export."""
-    timestamp: float
-    event_id: int
-    glucose: float
-    roc: float
-    significance: float
-    threshold: float
-    activated: bool
-    energy_level: float
-    risk_proba: Optional[float]
-    processing_time_ms: float
-    components: Dict[str, float] = field(default_factory=dict)
-
-
-class RuntimeMonitor:
-    """Real-time monitoring with event listeners."""
-
-    def __init__(self):
-        self.events: List[TelemetryEvent] = []
-        self.alerts: List[Dict[str, Any]] = []
-
-    def add_event(self, event: TelemetryEvent):
-        self.events.append(event)
-
-        # Check for alerts
-        if event.risk_proba is not None and event.risk_proba >= 0.6:
-            self.alerts.append({
-                "timestamp": event.timestamp,
-                "event_id": event.event_id,
-                "glucose": event.glucose,
-                "risk_proba": event.risk_proba,
-                "significance": event.significance,
-                "activated": event.activated,
-            })
-
-    def get_telemetry_df(self) -> pd.DataFrame:
-        if not self.events:
-            return pd.DataFrame()
-
-        data = []
-        for e in self.events:
-            row = {
-                "timestamp": e.timestamp,
-                "event_id": e.event_id,
-                "glucose": e.glucose,
-                "roc": e.roc,
-                "significance": e.significance,
-                "threshold": e.threshold,
-                "activated": e.activated,
-                "energy_level": e.energy_level,
-                "risk_proba": e.risk_proba,
-                "processing_time_ms": e.processing_time_ms,
-            }
-            row.update({f"comp_{k}": v for k, v in e.components.items()})
-            data.append(row)
-
-        return pd.DataFrame(data)
-
-    def export_json(self) -> str:
-        """Export telemetry as JSON for hardware validation."""
-        data = {
-            "events": [
-                {
-                    "timestamp": e.timestamp,
-                    "event_id": e.event_id,
-                    "glucose": e.glucose,
-                    "significance": e.significance,
-                    "threshold": e.threshold,
-                    "activated": e.activated,
-                    "energy_level": e.energy_level,
-                    "risk_proba": e.risk_proba,
-                    "processing_time_ms": e.processing_time_ms,
-                }
-                for e in self.events
-            ],
-            "alerts": self.alerts,
-            "summary": {
-                "total_events": len(self.events),
-                "total_activations": sum(1 for e in self.events if e.activated),
-                "activation_rate": sum(1 for e in self.events if e.activated) / max(len(self.events), 1),
-                "total_alerts": len(self.alerts),
-            }
-        }
-        return json.dumps(data, indent=2)
-
-
-# ------------------------------ Model backends ------------------------------
-
-def build_ensemble_model(df: pd.DataFrame):
-    """Advanced ensemble with multiple classifiers."""
-    # Prepare data
-    tmp = df.copy()
-    tmp["future_glucose"] = tmp["glucose_mgdl"].shift(-6)
-    tmp["label"] = ((tmp["future_glucose"] < 70) | (tmp["future_glucose"] > 180)).astype(int)
-    tmp = tmp.dropna(subset=["label"]).copy()
-
-    X = tmp[["glucose_mgdl", "roc_mgdl_min", "insulin_units", "carbs_g", "hr"]].fillna(0.0).values
-    y = tmp["label"].values
-
-    if len(np.unique(y)) < 2:
-        y = np.array([0, 1] * (len(X) // 2 + 1))[:len(X)]
-
-    # Train ensemble
-    scaler = StandardScaler()
-    X_scaled = scaler.fit_transform(X)
-
-    models = [
-        ("logreg", LogisticRegression(max_iter=1000, C=0.1)),
-        ("rf", RandomForestClassifier(n_estimators=50, max_depth=6, random_state=42)),
-        ("gbm", GradientBoostingClassifier(n_estimators=50, max_depth=4, learning_rate=0.1, random_state=42)),
-    ]
-
-    trained_models = []
-    for name, model in models:
-        try:
-            model.fit(X_scaled, y)
-            trained_models.append((name, model))
-        except:
-            pass
-
-    def _predict(Xarr: np.ndarray) -> float:
-        X_s = scaler.transform(Xarr)
-        predictions = []
-        for name, model in trained_models:
-            try:
-                if hasattr(model, "predict_proba"):
-                    pred = model.predict_proba(X_s)[0, 1]
-                else:
-                    pred = model.predict(X_s)[0]
-                predictions.append(pred)
-            except:
-                pass
-
-        if predictions:
-            return float(np.mean(predictions))
-        return 0.5
-
-    return _predict
-
-
-# ------------------------------ Bootstrap Statistics ------------------------------
-
-def bootstrap_metric(y_true: np.ndarray, y_pred: np.ndarray, metric_fn: Callable, n_bootstrap: int = 1000) -> Tuple[float, float, float]:
-    """Compute bootstrap confidence interval for a metric."""
-    n = len(y_true)
-    bootstrap_scores = []
-
-    rng = np.random.default_rng(42)
-    for _ in range(n_bootstrap):
-        indices = rng.choice(n, size=n, replace=True)
-        try:
-            score = metric_fn(y_true[indices], y_pred[indices])
-            bootstrap_scores.append(score)
-        except:
-            pass
-
-    if not bootstrap_scores:
-        return 0.0, 0.0, 0.0
-
-    mean = float(np.mean(bootstrap_scores))
-    ci_low = float(np.percentile(bootstrap_scores, 2.5))
-    ci_high = float(np.percentile(bootstrap_scores, 97.5))
-
-    return mean, ci_low, ci_high
-
-
-# ------------------------------ Streamlit UI ------------------------------
-
-st.set_page_config(page_title="Sundew Diabetes Watch - ADVANCED", layout="wide")
-
-st.title("🌿 Sundew Diabetes Watch — ADVANCED EDITION")
-st.caption("Bio-inspired adaptive gating showcasing the full power of Sundew algorithms")
-
-# Sidebar configuration
-with st.sidebar:
-    st.header("⚙️ Sundew Configuration")
-
-    preset_name = st.selectbox(
-        "Preset",
-        ["tuned_v2", "custom_health_hd82", "auto_tuned", "aggressive", "conservative", "energy_saver"],
-        index=0,
-        help="Use custom_health_hd82 for healthcare-optimized settings"
-    )
-
-    target_activation = st.slider("Target Activation Rate", 0.05, 0.50, 0.15, 0.01)
-    energy_pressure = st.slider("Energy Pressure", 0.0, 0.3, 0.05, 0.01)
-    gate_temperature = st.slider("Gate Temperature", 0.0, 0.3, 0.08, 0.01)
-
-    st.header("🩺 Diabetes Parameters")
-    hypo_threshold = st.number_input("Hypo Threshold (mg/dL)", 50.0, 90.0, 70.0)
-    hyper_threshold = st.number_input("Hyper Threshold (mg/dL)", 140.0, 250.0, 180.0)
-
-    st.header("📊 Analysis Options")
-    show_bootstrap = st.checkbox("Show Bootstrap CI", value=True)
-    show_energy_viz = st.checkbox("Show Energy Tracking", value=True)
-    show_components = st.checkbox("Show Significance Components", value=True)
-    export_telemetry = st.checkbox("Export Telemetry JSON", value=False)
-
-# File upload
-uploaded = st.file_uploader(
-    "Upload CGM CSV (timestamp, glucose_mgdl, carbs_g, insulin_units, steps, hr)",
-    type=["csv"],
-)
-
-use_synth = st.checkbox("Use synthetic example if no file uploaded", value=True)
-
-# Load data
-if uploaded is not None:
-    df = pd.read_csv(uploaded)
-else:
-    if not use_synth:
-        st.stop()
-
-    # Generate sophisticated synthetic data
-    rng = np.random.default_rng(42)
-    n = 600
-    t0 = pd.Timestamp.utcnow().floor("min")
-    times = [t0 + pd.Timedelta(minutes=5 * i) for i in range(n)]
-
-    # Circadian pattern + meals + insulin + exercise
-    circadian = 120 + 15 * np.sin(np.linspace(0, 8 * np.pi, n) - np.pi/2)
-    noise = rng.normal(0, 8, n)
-
-    # Meal events (3 per day)
-    meals = np.zeros(n)
-    meal_times = [60, 150, 270, 360, 450, 540]
-    for mt in meal_times:
-        if mt < n:
-            meals[mt:min(mt+30, n)] += rng.normal(45, 10)
-
-    # Insulin boluses (with meals)
-    insulin = np.zeros(n)
-    for mt in meal_times:
-        if mt < n and mt > 2:
-            insulin[mt-2] = rng.normal(4, 0.8)
-
-    # Exercise periods
-    steps = rng.integers(0, 120, size=n)
-    exercise_periods = [[120, 150], [400, 430]]
-    for start, end in exercise_periods:
-        if start < n and end <= n:
-            steps[start:end] = rng.integers(120, 180, size=end-start)
-
-    hr = 70 + (steps > 100) * rng.integers(25, 50, size=n) + rng.normal(0, 5, n)
-
-    # Glucose dynamics
-    glucose = circadian + noise
-    for i in range(n):
-        # Meal absorption (delayed)
-        if i >= 6:
-            glucose[i] += 0.4 * meals[i-6:i].sum() / 6
-        # Insulin effect (delayed, persistent)
-        if i >= 4:
-            glucose[i] -= 1.2 * insulin[i-4:i].sum() / 4
-        # Exercise effect
-        if steps[i] > 100:
-            glucose[i] -= 15
-
-    # Add some hypo/hyper episodes
-    glucose[180:200] = rng.normal(62, 5, 20)  # Hypo episode
-    glucose[350:365] = rng.normal(210, 10, 15)  # Hyper episode
-
-    df = pd.DataFrame({
-        "timestamp": times,
-        "glucose_mgdl": np.round(np.clip(glucose, 40, 350), 1),
-        "carbs_g": np.round(meals, 1),
-        "insulin_units": np.round(insulin, 1),
-        "steps": steps.astype(int),
-        "hr": np.round(hr, 0).astype(int),
-    })
-
-# Parse timestamps
-df["timestamp"] = pd.to_datetime(df["timestamp"], utc=True, errors="coerce")
-if df["timestamp"].dt.tz is None:
-    df["timestamp"] = df["timestamp"].dt.tz_localize("UTC")
-df = df.sort_values("timestamp").reset_index(drop=True)
-
-# Feature engineering
-df["dt_min"] = df["timestamp"].diff().dt.total_seconds() / 60.0
-df["glucose_prev"] = df["glucose_mgdl"].shift(1)
-df["roc_mgdl_min"] = (df["glucose_mgdl"] - df["glucose_prev"]) / df["dt_min"]
-df["roc_mgdl_min"] = df["roc_mgdl_min"].replace([np.inf, -np.inf], 0.0).fillna(0.0)
-df["time_min"] = (df["timestamp"] - df["timestamp"].iloc[0]).dt.total_seconds() / 60.0
-
-# Build heavy model
-with st.spinner("Training ensemble model..."):
-    predict_proba = build_ensemble_model(df)
-
-st.success("✅ Ensemble model trained (LogReg + RandomForest + GBM)")
-
-# Initialize Sundew runtime
-with st.spinner("Initializing Sundew PipelineRuntime..."):
-    config = get_preset(preset_name)
-    config.target_activation_rate = target_activation
-    config.energy_pressure = energy_pressure
-    config.gate_temperature = gate_temperature
-
-    # Custom significance model
-    diabetes_config = {
-        "hypo_threshold": hypo_threshold,
-        "hyper_threshold": hyper_threshold,
-        "target_glucose": 100.0,
-    }
-    significance_model = DiabetesSignificanceModel(diabetes_config)
-
-    # Build pipeline runtime
-    from sundew.runtime import PipelineRuntime, SimpleGatingStrategy, SimpleControlPolicy, SimpleEnergyModel
-
-    runtime = PipelineRuntime(
-        config=config,
-        significance_model=significance_model,
-        gating_strategy=SimpleGatingStrategy(config.hysteresis_gap),
-        control_policy=SimpleControlPolicy(config),
-        energy_model=SimpleEnergyModel(
-            processing_cost=config.base_processing_cost,
-            idle_cost=config.dormant_tick_cost,
-        ),
-    )
-
-st.success(f"✅ PipelineRuntime initialized with {preset_name} preset")
-
-# Runtime monitoring
-monitor = RuntimeMonitor()
-
-# Processing loop
-st.header("🔬 Processing Events")
-progress_bar = st.progress(0)
-status_text = st.empty()
-
-results = []
-ground_truth = []
-
-for idx, row in df.iterrows():
-    progress_bar.progress((idx + 1) / len(df))
-
-    # Create processing context
-    context = ProcessingContext(
-        timestamp=row["timestamp"].timestamp(),
-        sequence_id=idx,
-        features={
-            "glucose_mgdl": row["glucose_mgdl"],
-            "roc_mgdl_min": row["roc_mgdl_min"],
-            "insulin_units": row["insulin_units"],
-            "carbs_g": row["carbs_g"],
-            "hr": row["hr"],
-            "steps": row["steps"],
-            "time_min": row["time_min"],
-        },
-        history=[],
-        metadata={},
-    )
-
-    # Process with runtime
-    t_start = time.perf_counter()
-    result = runtime.process(context)
-    t_elapsed = (time.perf_counter() - t_start) * 1000  # ms
-
-    # Heavy model prediction if activated
-    risk_proba = None
-    if result.activated:
-        X = np.array([[
-            row["glucose_mgdl"],
-            row["roc_mgdl_min"],
-            row["insulin_units"],
-            row["carbs_g"],
-            row["hr"],
-        ]])
-        try:
-            risk_proba = predict_proba(X)
-        except:
-            risk_proba = None
-
-    # Ground truth (for evaluation)
-    future_idx = min(idx + 6, len(df) - 1)
-    future_glucose = df.iloc[future_idx]["glucose_mgdl"]
-    true_risk = 1 if (future_glucose < hypo_threshold or future_glucose > hyper_threshold) else 0
-    ground_truth.append(true_risk)
-
-    # Record telemetry
-    telemetry = TelemetryEvent(
-        timestamp=context.timestamp,
-        event_id=idx,
-        glucose=row["glucose_mgdl"],
-        roc=row["roc_mgdl_min"],
-        significance=result.significance,
-        threshold=result.threshold_used,
-        activated=result.activated,
-        energy_level=result.energy_consumed,  # Use energy_consumed as proxy
-        risk_proba=risk_proba,
-        processing_time_ms=t_elapsed,
-        components=result.explanation.get("feature_contributions", {}),
-    )
-    monitor.add_event(telemetry)
-
-    results.append({
-        "timestamp": row["timestamp"],
-        "glucose": row["glucose_mgdl"],
-        "roc": row["roc_mgdl_min"],
-        "significance": result.significance,
-        "threshold": result.threshold_used,
-        "activated": result.activated,
-        "energy_level": result.energy_consumed,
-        "risk_proba": risk_proba,
-        "true_risk": true_risk,
-    })
-
-progress_bar.empty()
-status_text.empty()
-
-# Convert to DataFrame
-results_df = pd.DataFrame(results)
-telemetry_df = monitor.get_telemetry_df()
-
-# Compute metrics
-total_events = len(results_df)
-total_activations = int(results_df["activated"].sum())
-activation_rate = total_activations / total_events
-energy_savings = 1 - activation_rate
-
-# Statistical evaluation (on activated events)
-activated_results = results_df[results_df["activated"]].copy()
-if len(activated_results) > 10:
-    y_true = activated_results["true_risk"].values
-    y_pred = (activated_results["risk_proba"].fillna(0.5) >= 0.5).astype(int).values
-
-    f1 = f1_score(y_true, y_pred, zero_division=0)
-    precision = precision_score(y_true, y_pred, zero_division=0)
-    recall = recall_score(y_true, y_pred, zero_division=0)
-
-    if show_bootstrap:
-        f1_mean, f1_low, f1_high = bootstrap_metric(y_true, y_pred, lambda yt, yp: f1_score(yt, yp, zero_division=0))
-        prec_mean, prec_low, prec_high = bootstrap_metric(y_true, y_pred, lambda yt, yp: precision_score(yt, yp, zero_division=0))
-        rec_mean, rec_low, rec_high = bootstrap_metric(y_true, y_pred, lambda yt, yp: recall_score(yt, yp, zero_division=0))
-else:
-    f1 = precision = recall = 0.0
-    f1_mean = prec_mean = rec_mean = 0.0
-    f1_low = f1_high = prec_low = prec_high = rec_low = rec_high = 0.0
-
-# Dashboard
-st.header("📊 Performance Dashboard")
-
-col1, col2, col3, col4 = st.columns(4)
-col1.metric("Total Events", f"{total_events}")
-col2.metric("Activations", f"{total_activations} ({activation_rate:.1%})")
-col3.metric("Energy Savings", f"{energy_savings:.1%}")
-col4.metric("Alerts", f"{len(monitor.alerts)}")
-
-col1, col2, col3 = st.columns(3)
-if show_bootstrap and len(activated_results) > 10:
-    col1.metric("F1 Score", f"{f1_mean:.3f}", help=f"95% CI: [{f1_low:.3f}, {f1_high:.3f}]")
-    col2.metric("Precision", f"{prec_mean:.3f}", help=f"95% CI: [{prec_low:.3f}, {prec_high:.3f}]")
-    col3.metric("Recall", f"{rec_mean:.3f}", help=f"95% CI: [{rec_low:.3f}, {rec_high:.3f}]")
-else:
-    col1.metric("F1 Score", f"{f1:.3f}")
-    col2.metric("Precision", f"{precision:.3f}")
-    col3.metric("Recall", f"{recall:.3f}")
-
-# Visualizations
-st.header("📈 Real-Time Visualizations")
-
-# Glucose + Threshold
-fig_col1, fig_col2 = st.columns(2)
-
-with fig_col1:
-    st.subheader("Glucose Levels")
-    chart_data = results_df.set_index("timestamp")[["glucose"]]
-    st.line_chart(chart_data, height=250)
-
-with fig_col2:
-    st.subheader("Significance vs Threshold (Adaptive PI Control)")
-    chart_data = results_df.set_index("timestamp")[["significance", "threshold"]]
-    st.line_chart(chart_data, height=250)
-
-# Energy tracking
-if show_energy_viz:
-    st.subheader("Energy Level (Bio-Inspired Regeneration)")
-    chart_data = results_df.set_index("timestamp")[["energy_level"]]
-    st.line_chart(chart_data, height=200)
-
-# Significance components
-if show_components and len(telemetry_df) > 0:
-    comp_cols = [c for c in telemetry_df.columns if c.startswith("comp_")]
-    if comp_cols:
-        st.subheader("Significance Components (Diabetes-Specific Risk Factors)")
-        chart_data = telemetry_df.set_index("timestamp")[comp_cols]
-        st.line_chart(chart_data, height=200)
-
-# Alerts
-st.header("⚠️ Risk Alerts")
-if monitor.alerts:
-    alerts_df = pd.DataFrame(monitor.alerts)
-    st.dataframe(alerts_df, use_container_width=True)
-else:
-    st.info("No high-risk alerts triggered in this window.")
-
-# Detailed telemetry
-with st.expander("🔍 Detailed Telemetry (Last 100 Events)"):
-    st.dataframe(results_df.tail(100), use_container_width=True)
-
-# Export telemetry
-if export_telemetry:
-    st.header("📥 Export Telemetry")
-    json_data = monitor.export_json()
-    st.download_button(
-        label="Download Telemetry JSON",
-        data=json_data,
-        file_name="sundew_diabetes_telemetry.json",
-        mime="application/json",
-    )
-    st.success("Telemetry ready for hardware validation workflows")
-
-# Footer
-st.divider()
-st.caption(f"🌿 Powered by Sundew Algorithms v0.7+ | PipelineRuntime with custom DiabetesSignificanceModel | Research prototype")
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Sundew Diabetes Watch — ADVANCED EDITION
+Showcasing the full power of Sundew's bio-inspired adaptive algorithms.
+
+FEATURES:
+- AdvancedDiabetesSignificanceModel from sundew.domains.healthcare
+- PipelineRuntime with multi-factor risk analysis (glycemic deviation, velocity, IOB, COB, activity, variability)
+- Real-time energy tracking with visualization
+- PI control threshold adaptation with telemetry
+- Statistical validation with bootstrap confidence intervals
+- Comprehensive metrics dashboard (F1, precision, recall, energy efficiency)
+- Event-level monitoring with runtime listeners
+- Telemetry export for hardware validation
+- Multi-model ensemble with adaptive weighting
+- Adversarial robustness testing
+- Adaptive weight learning from outcomes
+
+This app now uses the official sundew.domains.healthcare module, demonstrating
+integration between the Sundew algorithms package and real-world healthcare applications.
+"""
+from __future__ import annotations
+
+import json
+import math
+import os
+import time
+from collections import deque
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+import streamlit as st
+
+# ------------------------------ Sundew imports ------------------------------
+try:
+    from sundew.config import SundewConfig
+    from sundew.config_presets import get_preset
+    from sundew.interfaces import (
+        ControlState,
+        GatingDecision,
+        ProcessingContext,
+        ProcessingResult,
+        SignificanceModel,
+    )
+    from sundew.runtime import PipelineRuntime, RuntimeMetrics
+    from sundew.domains.healthcare import (
+        AdvancedDiabetesSignificanceModel,
+        build_advanced_diabetes_runtime,
+    )
+
+    _HAS_SUNDEW = True
+except Exception as e:
+    st.error(f"Sundew not available: {e}. Install with: pip install sundew-algorithms")
+    _HAS_SUNDEW = False
+    st.stop()
+
+# ------------------------------ Optional backends ------------------------------
+try:
+    import xgboost as xgb
+    _HAS_XGB = True
+except:
+    _HAS_XGB = False
+
+try:
+    import torch
+    _HAS_TORCH = True
+except:
+    _HAS_TORCH = False
+
+try:
+    import onnxruntime as ort
+    _HAS_ONNX = True
+except:
+    _HAS_ONNX = False
+
+from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
+from sklearn.preprocessing import StandardScaler
+from sklearn.pipeline import Pipeline
+from sklearn.metrics import f1_score, precision_score, recall_score, roc_auc_score
+
+# ------------------------------ Diabetes Significance Model ------------------------------
+# Now imported from sundew.domains.healthcare.AdvancedDiabetesSignificanceModel
+# This provides:
+# - Multi-factor risk analysis (glycemic deviation, velocity, IOB, COB, activity, variability)
+# - Adaptive weight learning from outcomes
+# - EMA smoothing for noise reduction
+# - Glucose history tracking
+
+
+# ------------------------------ Telemetry & Monitoring ------------------------------
+
+@dataclass
+class TelemetryEvent:
+    """Single telemetry event for export."""
+    timestamp: float
+    event_id: int
+    glucose: float
+    roc: float
+    significance: float
+    threshold: float
+    activated: bool
+    energy_level: float
+    risk_proba: Optional[float]
+    processing_time_ms: float
+    components: Dict[str, float] = field(default_factory=dict)
+
+
+class RuntimeMonitor:
+    """Real-time monitoring with event listeners."""
+
+    def __init__(self):
+        self.events: List[TelemetryEvent] = []
+        self.alerts: List[Dict[str, Any]] = []
+
+    def add_event(self, event: TelemetryEvent):
+        self.events.append(event)
+
+        # Check for alerts
+        if event.risk_proba is not None and event.risk_proba >= 0.6:
+            self.alerts.append({
+                "timestamp": event.timestamp,
+                "event_id": event.event_id,
+                "glucose": event.glucose,
+                "risk_proba": event.risk_proba,
+                "significance": event.significance,
+                "activated": event.activated,
+            })
+
+    def get_telemetry_df(self) -> pd.DataFrame:
+        if not self.events:
+            return pd.DataFrame()
+
+        data = []
+        for e in self.events:
+            row = {
+                "timestamp": e.timestamp,
+                "event_id": e.event_id,
+                "glucose": e.glucose,
+                "roc": e.roc,
+                "significance": e.significance,
+                "threshold": e.threshold,
+                "activated": e.activated,
+                "energy_level": e.energy_level,
+                "risk_proba": e.risk_proba,
+                "processing_time_ms": e.processing_time_ms,
+            }
+            row.update({f"comp_{k}": v for k, v in e.components.items()})
+            data.append(row)
+
+        return pd.DataFrame(data)
+
+    def export_json(self) -> str:
+        """Export telemetry as JSON for hardware validation."""
+        data = {
+            "events": [
+                {
+                    "timestamp": e.timestamp,
+                    "event_id": e.event_id,
+                    "glucose": e.glucose,
+                    "significance": e.significance,
+                    "threshold": e.threshold,
+                    "activated": e.activated,
+                    "energy_level": e.energy_level,
+                    "risk_proba": e.risk_proba,
+                    "processing_time_ms": e.processing_time_ms,
+                }
+                for e in self.events
+            ],
+            "alerts": self.alerts,
+            "summary": {
+                "total_events": len(self.events),
+                "total_activations": sum(1 for e in self.events if e.activated),
+                "activation_rate": sum(1 for e in self.events if e.activated) / max(len(self.events), 1),
+                "total_alerts": len(self.alerts),
+            }
+        }
+        return json.dumps(data, indent=2)
+
+
+# ------------------------------ Model backends ------------------------------
+
+def build_ensemble_model(df: pd.DataFrame):
+    """Advanced ensemble with multiple classifiers."""
+    # Prepare data
+    tmp = df.copy()
+    tmp["future_glucose"] = tmp["glucose_mgdl"].shift(-6)
+    tmp["label"] = ((tmp["future_glucose"] < 70) | (tmp["future_glucose"] > 180)).astype(int)
+    tmp = tmp.dropna(subset=["label"]).copy()
+
+    X = tmp[["glucose_mgdl", "roc_mgdl_min", "insulin_units", "carbs_g", "hr"]].fillna(0.0).values
+    y = tmp["label"].values
+
+    if len(np.unique(y)) < 2:
+        y = np.array([0, 1] * (len(X) // 2 + 1))[:len(X)]
+
+    # Train ensemble
+    scaler = StandardScaler()
+    X_scaled = scaler.fit_transform(X)
+
+    models = [
+        ("logreg", LogisticRegression(max_iter=1000, C=0.1)),
+        ("rf", RandomForestClassifier(n_estimators=50, max_depth=6, random_state=42)),
+        ("gbm", GradientBoostingClassifier(n_estimators=50, max_depth=4, learning_rate=0.1, random_state=42)),
+    ]
+
+    trained_models = []
+    for name, model in models:
+        try:
+            model.fit(X_scaled, y)
+            trained_models.append((name, model))
+        except:
+            pass
+
+    def _predict(Xarr: np.ndarray) -> float:
+        X_s = scaler.transform(Xarr)
+        predictions = []
+        for name, model in trained_models:
+            try:
+                if hasattr(model, "predict_proba"):
+                    pred = model.predict_proba(X_s)[0, 1]
+                else:
+                    pred = model.predict(X_s)[0]
+                predictions.append(pred)
+            except:
+                pass
+
+        if predictions:
+            return float(np.mean(predictions))
+        return 0.5
+
+    return _predict
+
+
+# ------------------------------ Bootstrap Statistics ------------------------------
+
+def bootstrap_metric(y_true: np.ndarray, y_pred: np.ndarray, metric_fn: Callable, n_bootstrap: int = 1000) -> Tuple[float, float, float]:
+    """Compute bootstrap confidence interval for a metric."""
+    n = len(y_true)
+    bootstrap_scores = []
+
+    rng = np.random.default_rng(42)
+    for _ in range(n_bootstrap):
+        indices = rng.choice(n, size=n, replace=True)
+        try:
+            score = metric_fn(y_true[indices], y_pred[indices])
+            bootstrap_scores.append(score)
+        except:
+            pass
+
+    if not bootstrap_scores:
+        return 0.0, 0.0, 0.0
+
+    mean = float(np.mean(bootstrap_scores))
+    ci_low = float(np.percentile(bootstrap_scores, 2.5))
+    ci_high = float(np.percentile(bootstrap_scores, 97.5))
+
+    return mean, ci_low, ci_high
+
+
+# ------------------------------ Streamlit UI ------------------------------
+
+st.set_page_config(page_title="Sundew Diabetes Watch - ADVANCED", layout="wide")
+
+st.title("🌿 Sundew Diabetes Watch — ADVANCED EDITION")
+st.caption("Bio-inspired adaptive gating showcasing the full power of Sundew algorithms")
+
+# Sidebar configuration
+with st.sidebar:
+    st.header("⚙️ Sundew Configuration")
+
+    preset_name = st.selectbox(
+        "Preset",
+        ["tuned_v2", "custom_health_hd82", "auto_tuned", "aggressive", "conservative", "energy_saver"],
+        index=0,
+        help="Use custom_health_hd82 for healthcare-optimized settings"
+    )
+
+    target_activation = st.slider("Target Activation Rate", 0.05, 0.50, 0.15, 0.01)
+    energy_pressure = st.slider("Energy Pressure", 0.0, 0.3, 0.05, 0.01)
+    gate_temperature = st.slider("Gate Temperature", 0.0, 0.3, 0.08, 0.01)
+
+    st.header("🩺 Diabetes Parameters")
+    hypo_threshold = st.number_input("Hypo Threshold (mg/dL)", 50.0, 90.0, 70.0)
+    hyper_threshold = st.number_input("Hyper Threshold (mg/dL)", 140.0, 250.0, 180.0)
+
+    st.header("📊 Analysis Options")
+    show_bootstrap = st.checkbox("Show Bootstrap CI", value=True)
+    show_energy_viz = st.checkbox("Show Energy Tracking", value=True)
+    show_components = st.checkbox("Show Significance Components", value=True)
+    export_telemetry = st.checkbox("Export Telemetry JSON", value=False)
+
+# File upload
+uploaded = st.file_uploader(
+    "Upload CGM CSV (timestamp, glucose_mgdl, carbs_g, insulin_units, steps, hr)",
+    type=["csv"],
+)
+
+use_synth = st.checkbox("Use synthetic example if no file uploaded", value=True)
+
+# Load data
+if uploaded is not None:
+    df = pd.read_csv(uploaded)
+else:
+    if not use_synth:
+        st.stop()
+
+    # Generate sophisticated synthetic data
+    rng = np.random.default_rng(42)
+    n = 600
+    t0 = pd.Timestamp.utcnow().floor("min")
+    times = [t0 + pd.Timedelta(minutes=5 * i) for i in range(n)]
+
+    # Circadian pattern + meals + insulin + exercise
+    circadian = 120 + 15 * np.sin(np.linspace(0, 8 * np.pi, n) - np.pi/2)
+    noise = rng.normal(0, 8, n)
+
+    # Meal events (3 per day)
+    meals = np.zeros(n)
+    meal_times = [60, 150, 270, 360, 450, 540]
+    for mt in meal_times:
+        if mt < n:
+            meals[mt:min(mt+30, n)] += rng.normal(45, 10)
+
+    # Insulin boluses (with meals)
+    insulin = np.zeros(n)
+    for mt in meal_times:
+        if mt < n and mt > 2:
+            insulin[mt-2] = rng.normal(4, 0.8)
+
+    # Exercise periods
+    steps = rng.integers(0, 120, size=n)
+    exercise_periods = [[120, 150], [400, 430]]
+    for start, end in exercise_periods:
+        if start < n and end <= n:
+            steps[start:end] = rng.integers(120, 180, size=end-start)
+
+    hr = 70 + (steps > 100) * rng.integers(25, 50, size=n) + rng.normal(0, 5, n)
+
+    # Glucose dynamics
+    glucose = circadian + noise
+    for i in range(n):
+        # Meal absorption (delayed)
+        if i >= 6:
+            glucose[i] += 0.4 * meals[i-6:i].sum() / 6
+        # Insulin effect (delayed, persistent)
+        if i >= 4:
+            glucose[i] -= 1.2 * insulin[i-4:i].sum() / 4
+        # Exercise effect
+        if steps[i] > 100:
+            glucose[i] -= 15
+
+    # Add some hypo/hyper episodes
+    glucose[180:200] = rng.normal(62, 5, 20)  # Hypo episode
+    glucose[350:365] = rng.normal(210, 10, 15)  # Hyper episode
+
+    df = pd.DataFrame({
+        "timestamp": times,
+        "glucose_mgdl": np.round(np.clip(glucose, 40, 350), 1),
+        "carbs_g": np.round(meals, 1),
+        "insulin_units": np.round(insulin, 1),
+        "steps": steps.astype(int),
+        "hr": np.round(hr, 0).astype(int),
+    })
+
+# Parse timestamps
+df["timestamp"] = pd.to_datetime(df["timestamp"], utc=True, errors="coerce")
+if df["timestamp"].dt.tz is None:
+    df["timestamp"] = df["timestamp"].dt.tz_localize("UTC")
+df = df.sort_values("timestamp").reset_index(drop=True)
+
+# Feature engineering
+df["dt_min"] = df["timestamp"].diff().dt.total_seconds() / 60.0
+df["glucose_prev"] = df["glucose_mgdl"].shift(1)
+df["roc_mgdl_min"] = (df["glucose_mgdl"] - df["glucose_prev"]) / df["dt_min"]
+df["roc_mgdl_min"] = df["roc_mgdl_min"].replace([np.inf, -np.inf], 0.0).fillna(0.0)
+df["time_min"] = (df["timestamp"] - df["timestamp"].iloc[0]).dt.total_seconds() / 60.0
+
+# Build heavy model
+with st.spinner("Training ensemble model..."):
+    predict_proba = build_ensemble_model(df)
+
+st.success("✅ Ensemble model trained (LogReg + RandomForest + GBM)")
+
+# Initialize Sundew runtime
+with st.spinner("Initializing Sundew PipelineRuntime..."):
+    config = get_preset(preset_name)
+    config.target_activation_rate = target_activation
+    config.energy_pressure = energy_pressure
+    config.gate_temperature = gate_temperature
+
+    # Custom significance model (now imported from sundew.domains.healthcare)
+    significance_model = AdvancedDiabetesSignificanceModel(
+        hypo_threshold=hypo_threshold,
+        hyper_threshold=hyper_threshold,
+        target_glucose=100.0,
+    )
+
+    # Build pipeline runtime
+    from sundew.runtime import PipelineRuntime, SimpleGatingStrategy, SimpleControlPolicy, SimpleEnergyModel
+
+    runtime = PipelineRuntime(
+        config=config,
+        significance_model=significance_model,
+        gating_strategy=SimpleGatingStrategy(config.hysteresis_gap),
+        control_policy=SimpleControlPolicy(config),
+        energy_model=SimpleEnergyModel(
+            processing_cost=config.base_processing_cost,
+            idle_cost=config.dormant_tick_cost,
+        ),
+    )
+
+st.success(f"✅ PipelineRuntime initialized with {preset_name} preset")
+
+# Runtime monitoring
+monitor = RuntimeMonitor()
+
+# Processing loop
+st.header("🔬 Processing Events")
+progress_bar = st.progress(0)
+status_text = st.empty()
+
+results = []
+ground_truth = []
+
+for idx, row in df.iterrows():
+    progress_bar.progress((idx + 1) / len(df))
+
+    # Create processing context
+    context = ProcessingContext(
+        timestamp=row["timestamp"].timestamp(),
+        sequence_id=idx,
+        features={
+            "glucose_mgdl": row["glucose_mgdl"],
+            "roc_mgdl_min": row["roc_mgdl_min"],
+            "insulin_units": row["insulin_units"],
+            "carbs_g": row["carbs_g"],
+            "hr": row["hr"],
+            "steps": row["steps"],
+            "time_min": row["time_min"],
+        },
+        history=[],
+        metadata={},
+    )
+
+    # Process with runtime
+    t_start = time.perf_counter()
+    result = runtime.process(context)
+    t_elapsed = (time.perf_counter() - t_start) * 1000  # ms
+
+    # Heavy model prediction if activated
+    risk_proba = None
+    if result.activated:
+        X = np.array([[
+            row["glucose_mgdl"],
+            row["roc_mgdl_min"],
+            row["insulin_units"],
+            row["carbs_g"],
+            row["hr"],
+        ]])
+        try:
+            risk_proba = predict_proba(X)
+        except:
+            risk_proba = None
+
+    # Ground truth (for evaluation)
+    future_idx = min(idx + 6, len(df) - 1)
+    future_glucose = df.iloc[future_idx]["glucose_mgdl"]
+    true_risk = 1 if (future_glucose < hypo_threshold or future_glucose > hyper_threshold) else 0
+    ground_truth.append(true_risk)
+
+    # Record telemetry
+    telemetry = TelemetryEvent(
+        timestamp=context.timestamp,
+        event_id=idx,
+        glucose=row["glucose_mgdl"],
+        roc=row["roc_mgdl_min"],
+        significance=result.significance,
+        threshold=result.threshold_used,
+        activated=result.activated,
+        energy_level=result.energy_consumed,  # Use energy_consumed as proxy
+        risk_proba=risk_proba,
+        processing_time_ms=t_elapsed,
+        components=result.explanation.get("feature_contributions", {}),
+    )
+    monitor.add_event(telemetry)
+
+    results.append({
+        "timestamp": row["timestamp"],
+        "glucose": row["glucose_mgdl"],
+        "roc": row["roc_mgdl_min"],
+        "significance": result.significance,
+        "threshold": result.threshold_used,
+        "activated": result.activated,
+        "energy_level": result.energy_consumed,
+        "risk_proba": risk_proba,
+        "true_risk": true_risk,
+    })
+
+progress_bar.empty()
+status_text.empty()
+
+# Convert to DataFrame
+results_df = pd.DataFrame(results)
+telemetry_df = monitor.get_telemetry_df()
+
+# Compute metrics
+total_events = len(results_df)
+total_activations = int(results_df["activated"].sum())
+activation_rate = total_activations / total_events
+energy_savings = 1 - activation_rate
+
+# Statistical evaluation (on activated events)
+activated_results = results_df[results_df["activated"]].copy()
+if len(activated_results) > 10:
+    y_true = activated_results["true_risk"].values
+    y_pred = (activated_results["risk_proba"].fillna(0.5) >= 0.5).astype(int).values
+
+    f1 = f1_score(y_true, y_pred, zero_division=0)
+    precision = precision_score(y_true, y_pred, zero_division=0)
+    recall = recall_score(y_true, y_pred, zero_division=0)
+
+    if show_bootstrap:
+        f1_mean, f1_low, f1_high = bootstrap_metric(y_true, y_pred, lambda yt, yp: f1_score(yt, yp, zero_division=0))
+        prec_mean, prec_low, prec_high = bootstrap_metric(y_true, y_pred, lambda yt, yp: precision_score(yt, yp, zero_division=0))
+        rec_mean, rec_low, rec_high = bootstrap_metric(y_true, y_pred, lambda yt, yp: recall_score(yt, yp, zero_division=0))
+else:
+    f1 = precision = recall = 0.0
+    f1_mean = prec_mean = rec_mean = 0.0
+    f1_low = f1_high = prec_low = prec_high = rec_low = rec_high = 0.0
+
+# Dashboard
+st.header("📊 Performance Dashboard")
+
+col1, col2, col3, col4 = st.columns(4)
+col1.metric("Total Events", f"{total_events}")
+col2.metric("Activations", f"{total_activations} ({activation_rate:.1%})")
+col3.metric("Energy Savings", f"{energy_savings:.1%}")
+col4.metric("Alerts", f"{len(monitor.alerts)}")
+
+col1, col2, col3 = st.columns(3)
+if show_bootstrap and len(activated_results) > 10:
+    col1.metric("F1 Score", f"{f1_mean:.3f}", help=f"95% CI: [{f1_low:.3f}, {f1_high:.3f}]")
+    col2.metric("Precision", f"{prec_mean:.3f}", help=f"95% CI: [{prec_low:.3f}, {prec_high:.3f}]")
+    col3.metric("Recall", f"{rec_mean:.3f}", help=f"95% CI: [{rec_low:.3f}, {rec_high:.3f}]")
+else:
+    col1.metric("F1 Score", f"{f1:.3f}")
+    col2.metric("Precision", f"{precision:.3f}")
+    col3.metric("Recall", f"{recall:.3f}")
+
+# Visualizations
+st.header("📈 Real-Time Visualizations")
+
+# Glucose + Threshold
+fig_col1, fig_col2 = st.columns(2)
+
+with fig_col1:
+    st.subheader("Glucose Levels")
+    chart_data = results_df.set_index("timestamp")[["glucose"]]
+    st.line_chart(chart_data, height=250)
+
+with fig_col2:
+    st.subheader("Significance vs Threshold (Adaptive PI Control)")
+    chart_data = results_df.set_index("timestamp")[["significance", "threshold"]]
+    st.line_chart(chart_data, height=250)
+
+# Energy tracking
+if show_energy_viz:
+    st.subheader("Energy Level (Bio-Inspired Regeneration)")
+    chart_data = results_df.set_index("timestamp")[["energy_level"]]
+    st.line_chart(chart_data, height=200)
+
+# Significance components
+if show_components and len(telemetry_df) > 0:
+    comp_cols = [c for c in telemetry_df.columns if c.startswith("comp_")]
+    if comp_cols:
+        st.subheader("Significance Components (Diabetes-Specific Risk Factors)")
+        chart_data = telemetry_df.set_index("timestamp")[comp_cols]
+        st.line_chart(chart_data, height=200)
+
+# Alerts
+st.header("⚠️ Risk Alerts")
+if monitor.alerts:
+    alerts_df = pd.DataFrame(monitor.alerts)
+    st.dataframe(alerts_df, use_container_width=True)
+else:
+    st.info("No high-risk alerts triggered in this window.")
+
+# Detailed telemetry
+with st.expander("🔍 Detailed Telemetry (Last 100 Events)"):
+    st.dataframe(results_df.tail(100), use_container_width=True)
+
+# Export telemetry
+if export_telemetry:
+    st.header("📥 Export Telemetry")
+    json_data = monitor.export_json()
+    st.download_button(
+        label="Download Telemetry JSON",
+        data=json_data,
+        file_name="sundew_diabetes_telemetry.json",
+        mime="application/json",
+    )
+    st.success("Telemetry ready for hardware validation workflows")
+
+# Footer
+st.divider()
+st.caption(f"🌿 Powered by Sundew Algorithms v0.7+ | PipelineRuntime with custom DiabetesSignificanceModel | Research prototype")