test jenkins

Dutch lab results conventionally report HbA1c in mmol/mol rather than
DCCT/NGSP %. Adds gmi_mmol_per_mol() using the standard IFCC conversion
(Hoelzel et al. 2004) and shows it next to the existing % value on the
Samenvatting page and in the PDF summary.

Closes gitea #25.

Jenkinsfile

@@ -0,0 +1,11 @@
+pipeline {
+    agent any
+
+    stages {
+        stage('Do nothing') {
+            steps {
+                sh '/bin/true'
+            }
+        }
+    }
+}

nightscout_client.py

@@ -176,29 +176,39 @@ def _entries_since(since: datetime, until: datetime | None = None) -> pd.DataFra
     return df[["timestamp", "mmol"]].sort_values("timestamp").reset_index(drop=True)
 
 
+_TREATMENT_COLUMNS = ["timestamp", "eventType", "insulin", "carbs", "type", "absolute", "duration"]
+
+
 def _treatments_since(since: datetime, until: datetime | None = None) -> pd.DataFrame:
-    """Haal treatments op sinds `since` (en optioneel tot `until`), lokaal gefilterd."""
+    """Haal treatments op sinds `since` (en optioneel tot `until`), lokaal gefilterd.
+
+    `type` en `absolute`/`duration` komen erbij naast de oorspronkelijke
+    kolommen: AndroidAPS registreert een SMB-microbolus niet als eigen
+    `eventType`, maar als `eventType == "Correction Bolus"` met
+    `type == "SMB"` (zie reporting.bolus_stats() / gitea #20) — en
+    `absolute` (E/uur) + `duration` (minuten) op Temp Basal-treatments maken
+    het mogelijk afgeleverde basaalinsuline te berekenen zonder het
+    pompprofiel te hoeven ophalen (zie reporting.basal_stats()).
+    """
     data = _paginated_get("/api/v1/treatments.json", since, until, TREATMENTS_CURSOR_FIELD)
 
     if not data:
-        return pd.DataFrame(columns=["timestamp", "eventType", "insulin", "carbs"])
+        return pd.DataFrame(columns=_TREATMENT_COLUMNS)
 
     df = pd.DataFrame(data)
     df["timestamp"] = pd.to_datetime(df["created_at"], utc=True).dt.tz_localize(None)
-    for col in ("insulin", "carbs"):
+    for col in ("insulin", "carbs", "absolute", "duration"):
         if col not in df.columns:
             df[col] = pd.NA
         df[col] = pd.to_numeric(df[col], errors="coerce")
-    if "eventType" not in df.columns:
-        df["eventType"] = ""
+    for col in ("eventType", "type"):
+        if col not in df.columns:
+            df[col] = ""
+        df[col] = df[col].fillna("")
     df = df[df["timestamp"] >= since.replace(tzinfo=None)]
     if until is not None:
         df = df[df["timestamp"] <= until.replace(tzinfo=None)]
-    return (
-        df[["timestamp", "eventType", "insulin", "carbs"]]
-        .sort_values("timestamp")
-        .reset_index(drop=True)
-    )
+    return df[_TREATMENT_COLUMNS].sort_values("timestamp").reset_index(drop=True)
 
 
 def fetch_entries(hours: int = 24) -> pd.DataFrame:

pages/2_Samenvatting.py

@@ -4,6 +4,7 @@ import streamlit as st
 from auth import require_auth
 from nightscout_client import NightscoutConfigError
 from reporting import (
+    gmi_mmol_per_mol,
     gmi_percent,
     percent_cv,
     sensor_active_percent,
@@ -43,6 +44,7 @@ active_pct = sensor_active_percent(glucose, start, end)
 
 mean_mmol = glucose["mmol"].mean()
 gmi = gmi_percent(mean_mmol)
+gmi_mmol_mol = gmi_mmol_per_mol(gmi)
 cv = percent_cv(glucose)
 tir = tir_breakdown_5band(glucose)
 
@@ -50,7 +52,11 @@ st.subheader("Kerncijfers")
 col1, col2, col3, col4 = st.columns(4)
 col1.metric("Sensordekking", f"{active_pct:.0f}%", help="Streefwaarde: ≥70%")
 col2.metric("Gemiddelde glucose", f"{mean_mmol:.1f} mmol/L")
-col3.metric("Geschat HbA1c (GMI)", f"{gmi:.1f}%", help="Bergenstal et al. 2018 — geen labwaarde")
+col3.metric(
+    "Geschat HbA1c (GMI)",
+    f"{gmi:.1f}% ({gmi_mmol_mol:.0f} mmol/mol)",
+    help="Bergenstal et al. 2018 — geen labwaarde",
+)
 col4.metric("Variabiliteit (%CV)", f"{cv:.0f}%", help="Streefwaarde: ≤36%")
 
 st.subheader("Tijd in bereik (5 klinische banden)")

pages/7_Trends.py

@@ -6,14 +6,16 @@ from auth import require_auth
 from data_processing import classify_treatments
 from nightscout_client import NightscoutConfigError
 from reporting import (
+    basal_stats,
     bolus_stats,
     day_of_week_pattern,
-    gmi_percent,
+    gmi_trend,
     overnight_daytime_split,
     site_interval_stats,
 )
 from ui_common import (
     get_colors,
+    hex_to_rgba,
     load_range_data,
     render_completeness_warning,
     select_period_days,
@@ -45,26 +47,70 @@ render_completeness_warning(glucose, start, end)
 colors = get_colors()
 events = classify_treatments(treatments)
 
-# --- FR7: geschat HbA1c (GMI) per maand ------------------------------------
-st.subheader("Geschat HbA1c (GMI) per maand")
-monthly = glucose.copy()
-monthly["month"] = monthly["timestamp"].dt.to_period("M").astype(str)
-monthly_gmi = monthly.groupby("month")["mmol"].mean().apply(gmi_percent)
+# --- FR7: geschat HbA1c (GMI) trend ----------------------------------------
+st.subheader("Geschat HbA1c (GMI) trend")
+trend = gmi_trend(glucose)
 
-if len(monthly_gmi) >= 1:
-    fig = go.Figure(
-        go.Bar(x=monthly_gmi.index, y=monthly_gmi.to_numpy(), marker_color=colors["glucose"])
+if len(trend) >= 2:
+    fig = go.Figure()
+    fig.add_trace(
+        go.Scatter(
+            x=trend["date"], y=trend["trend_upper"], mode="lines", line={"width": 0}, showlegend=False,
+            hoverinfo="skip",
+        )
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=trend["date"],
+            y=trend["trend_lower"],
+            mode="lines",
+            line={"width": 0},
+            fill="tonexty",
+            fillcolor=hex_to_rgba(colors["muted"], 0.2),
+            name="95% betrouwbaarheidsband",
+            hoverinfo="skip",
+        )
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=trend["date"],
+            y=trend["trend"],
+            mode="lines",
+            line={"color": colors["muted"], "width": 2, "dash": "dash"},
+            name="Trend (lineair)",
+        )
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=trend["date"],
+            y=trend["rolling_avg"],
+            mode="lines",
+            line={"color": colors["glucose"], "width": 2},
+            name="Voortschrijdend gemiddelde (7d)",
+        )
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=trend["date"],
+            y=trend["gmi"],
+            mode="markers",
+            marker={"color": colors["glucose"], "size": 5, "opacity": 0.5},
+            name="Dag-GMI",
+        )
     )
     fig.update_layout(
         paper_bgcolor="rgba(0,0,0,0)",
         plot_bgcolor="rgba(0,0,0,0)",
         font_color=colors["text"],
-        height=280,
+        height=320,
         margin={"l": 10, "r": 10, "t": 10, "b": 10},
         yaxis={"title": "GMI (%)", "gridcolor": colors["grid"]},
-        xaxis={"title": "Maand", "gridcolor": colors["grid"]},
+        xaxis={"title": "Datum", "gridcolor": colors["grid"]},
+        legend={"orientation": "h", "yanchor": "bottom", "y": 1.02, "xanchor": "left", "x": 0},
     )
     st.plotly_chart(fig, width="stretch")
+else:
+    st.info("Niet genoeg dagen met data voor een trendlijn (minstens 2 nodig).")
 st.caption("GMI is een schatting (Bergenstal et al. 2018), geen labwaarde.")
 
 # --- FR8: nacht vs. overdag --------------------------------------------------
@@ -93,18 +139,25 @@ if not weekday_plot.empty:
     )
     st.plotly_chart(fig, width="stretch")
 
-# --- FR8: bolus-insuline --------------------------------------------------
-st.subheader("Bolus-insuline")
+# --- FR8: insuline (basaal + bolus-uitsplitsing) ---------------------------
+st.subheader("Insuline")
 st.caption(
-    "Alleen bolusinsuline (maaltijd/correctie/combo/SMB) — basaalinsuline vereist "
-    "profielgegevens en is hier niet in verwerkt (zie docs/design-reporting.md)."
+    "Basaal berekend uit Temp Basal-treatments (snelheid x duur), zonder pompprofiel "
+    "nodig — een ondergrens bij periodes zonder actieve temp basal. Boluses "
+    "opgesplitst naar voeding, handmatige correctie en automatische SMB-microbolus "
+    "(gitea #20)."
 )
 bolus = bolus_stats(treatments)
-col1, col2 = st.columns(2)
-col1.metric("Totaal bolus", f"{bolus['total_units']:.1f} E")
-col2.metric("Aantal boluses", bolus["count"])
-if bolus["by_type"]:
-    st.table({"type": list(bolus["by_type"].keys()), "eenheden": list(bolus["by_type"].values())})
+basal = basal_stats(treatments, days)
+total_units = bolus["total_units"] + basal["total_units"]
+col1, col2, col3 = st.columns(3)
+col1.metric("Totaal insuline", f"{total_units:.1f} E")
+col2.metric("Gem. per dag", f"{total_units / days:.1f} E")
+col3.metric("Aantal boluses", bolus["count"])
+
+breakdown = {"Basaal": basal["total_units"], **bolus["by_type"]}
+if any(breakdown.values()):
+    st.table({"Categorie": list(breakdown.keys()), "Eenheden": list(breakdown.values())})
 
 # --- FR8: pompsite-leeftijd vs. glucose/insuline ---------------------------
 st.subheader("Pompsite-leeftijd vs. glucose en insuline")

pdf_export.py

@@ -21,8 +21,14 @@ from fpdf import FPDF
 from fpdf.enums import XPos, YPos
 
 from reporting import (
+    HIGH,
+    LOW,
+    VERY_HIGH,
+    VERY_LOW,
     agp_percentile_bands,
     completeness_warning,
+    detect_events,
+    gmi_mmol_per_mol,
     gmi_percent,
     percent_cv,
     sensor_active_percent,
@@ -31,12 +37,46 @@ from reporting import (
 
 SECTION_SUMMARY = "Samenvatting"
 SECTION_AGP = "AGP profiel"
+SECTION_DAGOVERZICHT = "Dagoverzicht"
 SECTION_EVENTS = "Hypo-/hyperevents"
 
-AVAILABLE_SECTIONS = [SECTION_SUMMARY, SECTION_AGP, SECTION_EVENTS]
+AVAILABLE_SECTIONS = [SECTION_SUMMARY, SECTION_AGP, SECTION_DAGOVERZICHT, SECTION_EVENTS]
 
 _LINE_KWARGS = {"new_x": XPos.LMARGIN, "new_y": YPos.NEXT}
 
+# Zelfde kleuren als het PALETTE["light"] in ui_common.py — bewust hier
+# gedupliceerd (5 hex-waarden) in plaats van ui_common.py te importeren, want
+# dat zou een streamlit-dependency in deze module trekken die verder bewust
+# vrij van UI-framework-imports is (los te unit-testen, zie moduledocstring).
+_MUTED = "#898781"
+_TIR_BAND_ORDER = ["very_low", "low", "in_range", "high", "very_high"]
+_TIR_BAND_LABELS = {
+    "very_low": "Zeer laag",
+    "low": "Laag",
+    "in_range": "In bereik",
+    "high": "Hoog",
+    "very_high": "Zeer hoog",
+}
+_TIR_COLORS = {
+    "very_low": "#8b1a1a",
+    "low": "#d03b3b",
+    "in_range": "#0ca30c",
+    "high": "#fab219",
+    "very_high": "#c76f0a",
+}
+_THRESHOLD_LINES = [VERY_LOW, LOW, HIGH, VERY_HIGH]
+DAGOVERZICHT_MAX_DAYS = 14
+
+
+def _add_threshold_lines(ax) -> None:
+    """Teken de 4 klinische drempellijnen (3.0/3.9/10.0/13.9 mmol/L) op een matplotlib-as.
+
+    PDF-tegenhanger van ui_common.add_threshold_lines() voor de Plotly-versie
+    op de dashboardpagina's (gitea #15) — zelfde 4 waarden, zelfde grijstint.
+    """
+    for value in _THRESHOLD_LINES:
+        ax.axhline(value, color=_MUTED, linewidth=0.7, linestyle=":")
+
 
 def _agp_figure_png(glucose: pd.DataFrame) -> bytes:
     bands = agp_percentile_bands(glucose)
@@ -45,6 +85,7 @@ def _agp_figure_png(glucose: pd.DataFrame) -> bytes:
     ax.fill_between(hours, bands["p5"], bands["p95"], alpha=0.15, color="#2a78d6", label="5e-95e pct")
     ax.fill_between(hours, bands["p25"], bands["p75"], alpha=0.3, color="#2a78d6", label="25e-75e pct")
     ax.plot(hours, bands["p50"], color="#2a78d6", linewidth=2, label="Mediaan")
+    _add_threshold_lines(ax)
     ax.set_xlabel("Uur van de dag")
     ax.set_ylabel("mmol/L")
     ax.set_xlim(0, 24)
@@ -58,6 +99,69 @@ def _agp_figure_png(glucose: pd.DataFrame) -> bytes:
     return buf.getvalue()
 
 
+def _tir_bar_figure_png(tir: dict) -> bytes:
+    """Gestapelde staafgrafiek van de 5 TIR-banden — PDF-tegenhanger van
+    ui_common.build_tir_stacked_bar_figure() (gitea #14)."""
+    fig, ax = plt.subplots(figsize=(7, 1.1))
+    left = 0.0
+    for band in _TIR_BAND_ORDER:
+        value = tir[band]
+        ax.barh(0, value, left=left, color=_TIR_COLORS[band], label=_TIR_BAND_LABELS[band])
+        left += value
+    ax.set_xlim(0, 100)
+    ax.set_yticks([])
+    ax.set_xlabel("%")
+    ax.legend(loc="upper center", bbox_to_anchor=(0.5, -0.75), ncol=5, fontsize=7, frameon=False)
+
+    buf = io.BytesIO()
+    # bbox_inches="tight" i.p.v. fig.tight_layout(): de legend zit buiten de
+    # axes (bbox_to_anchor met negatieve y), waar tight_layout() niet voor
+    # kan compenseren — savefig's eigen bbox-berekening kan dat wel.
+    fig.savefig(buf, format="png", dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    buf.seek(0)
+    return buf.getvalue()
+
+
+def _daily_figure_png(day_df: pd.DataFrame, day_label: str) -> bytes:
+    """Eén dag als kleine lijngrafiek — PDF-tegenhanger van de Dagoverzicht-pagina (gitea #16)."""
+    hours = day_df["timestamp"].dt.hour + day_df["timestamp"].dt.minute / 60
+    fig, ax = plt.subplots(figsize=(7, 1.4))
+    ax.plot(hours, day_df["mmol"], color="#2a78d6", linewidth=1.2)
+    _add_threshold_lines(ax)
+    ax.set_xlim(0, 24)
+    ax.set_xticks(range(0, 25, 4))
+    ax.set_ylabel("mmol/L", fontsize=8)
+    ax.set_title(day_label, fontsize=9, loc="left")
+    ax.tick_params(labelsize=7)
+    fig.tight_layout()
+
+    buf = io.BytesIO()
+    fig.savefig(buf, format="png", dpi=150)
+    plt.close(fig)
+    buf.seek(0)
+    return buf.getvalue()
+
+
+def _event_hour_histogram_png(events: pd.DataFrame, color: str) -> bytes:
+    """Aantal events per uur-van-de-dag — PDF-tegenhanger van render_event_level()'s
+    histogram op de Hypo/Hyper Events-pagina's (gitea #17, #18)."""
+    hour_counts = events["start"].dt.hour.value_counts().reindex(range(24), fill_value=0).sort_index()
+    fig, ax = plt.subplots(figsize=(7, 2))
+    ax.bar(hour_counts.index, hour_counts.to_numpy(), color=color)
+    ax.set_xlabel("Uur van de dag")
+    ax.set_ylabel("Aantal events")
+    ax.set_xlim(-0.5, 23.5)
+    ax.set_xticks(range(0, 24, 2))
+    fig.tight_layout()
+
+    buf = io.BytesIO()
+    fig.savefig(buf, format="png", dpi=150)
+    plt.close(fig)
+    buf.seek(0)
+    return buf.getvalue()
+
+
 def _add_summary_section(pdf: FPDF, glucose: pd.DataFrame, start, end) -> None:
     mean_mmol = glucose["mmol"].mean()
     tir = tir_breakdown_5band(glucose)
@@ -75,7 +179,8 @@ def _add_summary_section(pdf: FPDF, glucose: pd.DataFrame, start, end) -> None:
     pdf.set_font("Helvetica", "", 11)
     pdf.cell(0, 6, f"Sensordekking: {active_pct:.0f}%", **_LINE_KWARGS)
     pdf.cell(0, 6, f"Gemiddelde glucose: {mean_mmol:.1f} mmol/L", **_LINE_KWARGS)
-    pdf.cell(0, 6, f"Geschat HbA1c (GMI): {gmi_percent(mean_mmol):.1f}%", **_LINE_KWARGS)
+    gmi = gmi_percent(mean_mmol)
+    pdf.cell(0, 6, f"Geschat HbA1c (GMI): {gmi:.1f}% ({gmi_mmol_per_mol(gmi):.0f} mmol/mol)", **_LINE_KWARGS)
     pdf.cell(0, 6, f"Variabiliteit (%CV): {percent_cv(glucose):.0f}%", **_LINE_KWARGS)
     pdf.ln(2)
     pdf.cell(0, 6, f"Zeer laag (<3.0 mmol/L): {tir['very_low']:.0f}%", **_LINE_KWARGS)
@@ -83,6 +188,9 @@ def _add_summary_section(pdf: FPDF, glucose: pd.DataFrame, start, end) -> None:
     pdf.cell(0, 6, f"In bereik (3.9-10.0 mmol/L): {tir['in_range']:.0f}%", **_LINE_KWARGS)
     pdf.cell(0, 6, f"Hoog (10.0-13.9 mmol/L): {tir['high']:.0f}%", **_LINE_KWARGS)
     pdf.cell(0, 6, f"Zeer hoog (>13.9 mmol/L): {tir['very_high']:.0f}%", **_LINE_KWARGS)
+    pdf.ln(2)
+    png_bytes = _tir_bar_figure_png(tir)
+    pdf.image(io.BytesIO(png_bytes), w=160)
     pdf.ln(4)
 
 
@@ -94,7 +202,29 @@ def _add_agp_section(pdf: FPDF, glucose: pd.DataFrame) -> None:
     pdf.ln(4)
 
 
-def _add_events_section(pdf: FPDF, events_summary: dict[str, dict]) -> None:
+def _add_dagoverzicht_section(pdf: FPDF, glucose: pd.DataFrame) -> None:
+    """Eén dagelijkse mini-grafiek per kalenderdag (gitea #16), max. de meest
+    recente DAGOVERZICHT_MAX_DAYS dagen — voor langere periodes zou de PDF
+    anders onwerkbaar lang worden."""
+    pdf.set_font("Helvetica", "B", 13)
+    pdf.cell(0, 8, "Dagoverzicht", **_LINE_KWARGS)
+
+    df = glucose.copy()
+    df["date"] = df["timestamp"].dt.date
+    dates = sorted(df["date"].unique())
+    if len(dates) > DAGOVERZICHT_MAX_DAYS:
+        dates = dates[-DAGOVERZICHT_MAX_DAYS:]
+        pdf.set_font("Helvetica", "I", 9)
+        pdf.cell(0, 5, f"Beperkt tot de meest recente {DAGOVERZICHT_MAX_DAYS} dagen.", **_LINE_KWARGS)
+
+    for day in dates:
+        day_df = df[df["date"] == day]
+        png_bytes = _daily_figure_png(day_df, day.strftime("%A %d-%m-%Y"))
+        pdf.image(io.BytesIO(png_bytes), w=180)
+    pdf.ln(4)
+
+
+def _add_events_section(pdf: FPDF, glucose: pd.DataFrame, events_summary: dict[str, dict]) -> None:
     pdf.set_font("Helvetica", "B", 13)
     pdf.cell(0, 8, "Hypo-/hyperevents", **_LINE_KWARGS)
     pdf.set_font("Helvetica", "", 11)
@@ -106,6 +236,18 @@ def _add_events_section(pdf: FPDF, events_summary: dict[str, dict]) -> None:
             f"{summary['events_per_week']:.1f}/week",
             **_LINE_KWARGS,
         )
+    pdf.ln(2)
+
+    # Alleen Level 1 krijgt een grafiek in het PDF-rapport (gitea #17, #18) —
+    # geen tabel met losse events, de samenvattende cijfers staan al hierboven.
+    if not glucose.empty:
+        hypo_events = detect_events(glucose, LOW, "below")
+        if not hypo_events.empty:
+            pdf.image(io.BytesIO(_event_hour_histogram_png(hypo_events, _TIR_COLORS["low"])), w=180)
+        hyper_events = detect_events(glucose, HIGH, "above")
+        if not hyper_events.empty:
+            pdf.image(io.BytesIO(_event_hour_histogram_png(hyper_events, _TIR_COLORS["high"])), w=180)
+
     pdf.ln(4)
 
 
@@ -135,8 +277,10 @@ def build_report_pdf(
             _add_summary_section(pdf, glucose, start, end)
         if SECTION_AGP in sections:
             _add_agp_section(pdf, glucose)
+        if SECTION_DAGOVERZICHT in sections:
+            _add_dagoverzicht_section(pdf, glucose)
 
     if SECTION_EVENTS in sections and events_summary:
-        _add_events_section(pdf, events_summary)
+        _add_events_section(pdf, glucose, events_summary)
 
     return bytes(pdf.output())

reporting.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 
 from itertools import pairwise
 
+import numpy as np
 import pandas as pd
 
 from nightscout_client import INSULIN_EVENT_TYPES
@@ -35,6 +36,79 @@ def gmi_percent(mean_mmol: float) -> float:
     return round(3.31 + 0.4311 * mean_mmol, 1)
 
 
+def gmi_mmol_per_mol(gmi_pct: float) -> int:
+    """Zet een GMI-percentage (DCCT/NGSP) om naar IFCC mmol/mol.
+
+    mmol/mol = 10.929 x (% - 2.15) — de standaard IFCC-omrekening
+    (Hoelzel et al. 2004, Clin Chem 50(1):166-174), gangbare eenheid in
+    Nederlandse labuitslagen naast het %-getal (gitea #25). Bijv. 6.5% =
+    48 mmol/mol, de bekende diagnostische drempel.
+    """
+    return round(10.929 * (gmi_pct - 2.15))
+
+
+GMI_TREND_COLUMNS = ["date", "gmi", "rolling_avg", "trend", "trend_lower", "trend_upper"]
+
+
+def daily_gmi(glucose: pd.DataFrame) -> pd.DataFrame:
+    """Geschat HbA1c (GMI) per kalenderdag — scatterpunten voor de trendgrafiek (gitea #19)."""
+    if glucose.empty:
+        return pd.DataFrame(columns=["date", "gmi"])
+
+    df = glucose.copy()
+    df["date"] = df["timestamp"].dt.date
+    daily_mean = df.groupby("date")["mmol"].mean()
+    result = daily_mean.apply(gmi_percent).reset_index()
+    result.columns = ["date", "gmi"]
+    return result.sort_values("date").reset_index(drop=True)
+
+
+def gmi_trend(glucose: pd.DataFrame, rolling_window_days: int = 7) -> pd.DataFrame:
+    """Dagelijkse GMI-punten plus voortschrijdend gemiddelde en een lineaire
+    trendlijn met 95%-betrouwbaarheidsband (gitea #19).
+
+    Gebruikt een normaalbenadering (z=1.96) voor de betrouwbaarheidsband i.p.v.
+    een exacte t-verdeling — dat zou een scipy-dependency toevoegen aan een
+    verder bewust lichte container (dezelfde afweging als het niet gebruiken
+    van kaleido in pdf_export.py). Bij de hier gebruikelijke steekproefgroottes
+    (14-90 dagpunten) is het verschil met de exacte t-kritieke waarde
+    verwaarloosbaar voor een visuele trendindicatie.
+
+    Elke keer opnieuw berekend uit de al-opgehaalde periode-data (geen aparte
+    database) — de bestaande 1-uurs Streamlit-cache op load_range_data()
+    voorkomt al herhaalde Nightscout-calls voor dezelfde periode. Bij een
+    veel langere trend (jaren i.p.v. de huidige max. 90 dagen) zou een aparte
+    opslag wél de moeite waard worden.
+    """
+    daily = daily_gmi(glucose)
+    if len(daily) < 2:
+        return daily.reindex(columns=GMI_TREND_COLUMNS)
+
+    daily = daily.copy()
+    daily["rolling_avg"] = daily["gmi"].rolling(window=rolling_window_days, min_periods=1).mean()
+
+    x = np.arange(len(daily), dtype=float)
+    y = daily["gmi"].to_numpy()
+    slope, intercept = np.polyfit(x, y, 1)
+    fitted = intercept + slope * x
+
+    residuals = y - fitted
+    degrees_of_freedom = max(len(x) - 2, 1)
+    residual_std = np.sqrt(np.sum(residuals**2) / degrees_of_freedom)
+    x_mean = x.mean()
+    sum_sq_x = np.sum((x - x_mean) ** 2)
+    standard_error = (
+        np.zeros_like(x)
+        if sum_sq_x == 0
+        else residual_std * np.sqrt(1 / len(x) + (x - x_mean) ** 2 / sum_sq_x)
+    )
+    z_95 = 1.96
+    daily["trend"] = fitted
+    daily["trend_lower"] = fitted - z_95 * standard_error
+    daily["trend_upper"] = fitted + z_95 * standard_error
+    return daily[GMI_TREND_COLUMNS]
+
+
 def percent_cv(glucose: pd.DataFrame) -> float:
     """Glucosevariabiliteit als %CV (standaarddeviatie / gemiddelde * 100)."""
     if glucose.empty:
@@ -330,22 +404,35 @@ def day_of_week_pattern(glucose: pd.DataFrame) -> pd.DataFrame:
     return pd.DataFrame(rows, columns=columns)
 
 
+SMB_TYPE = "SMB"
+BASAL_EVENT_TYPE = "Temp Basal"
+
+
 def bolus_stats(treatments: pd.DataFrame) -> dict:
     """Samenvatting van bolus-insuline, opgesplitst naar type.
 
-    Let op: dit betreft alleen bolusinsuline (maaltijd/correctie/combo/SMB).
-    Basaalinsuline wordt hier niet in meegenomen — dat vereist profielgegevens
-    (zie docs/design-reporting.md, scoping-kanttekening) en levert dus geen
-    volledige totale-dagdosis op.
+    AndroidAPS in SMB-looping registreert een automatische micro-bolus niet
+    als eigen `eventType`, maar als `eventType == "Correction Bolus"` met
+    `type == "SMB"` — zonder dit onderscheid werden alle SMB's stilzwijgend
+    als "Correction Bolus" (handmatige correctie) meegeteld, wat gitea #20
+    meldde als "bolus stats empty/onduidelijk". Geverifieerd rechtstreeks
+    tegen de productiedata: bij deze gebruiker is vrijwel elke "Correction
+    Bolus" in werkelijkheid een automatische SMB.
+
+    Let op: dit betreft alleen bolusinsuline (voeding/correctie/combo/SMB).
+    Basaalinsuline zit hier niet in — zie basal_stats().
     """
     if treatments.empty:
         return {"total_units": 0.0, "count": 0, "by_type": {}}
 
-    bolus = treatments[treatments["eventType"].isin(INSULIN_EVENT_TYPES) & treatments["insulin"].notna()]
+    bolus = treatments[treatments["eventType"].isin(INSULIN_EVENT_TYPES) & treatments["insulin"].notna()].copy()
     if bolus.empty:
         return {"total_units": 0.0, "count": 0, "by_type": {}}
 
-    by_type = bolus.groupby("eventType")["insulin"].sum().round(1).to_dict()
+    is_smb = (bolus["eventType"] == "Correction Bolus") & (bolus.get("type", "") == SMB_TYPE)
+    bolus["category"] = bolus["eventType"].where(~is_smb, SMB_TYPE)
+
+    by_type = bolus.groupby("category")["insulin"].sum().round(1).to_dict()
     return {
         "total_units": round(bolus["insulin"].sum(), 1),
         "count": len(bolus),
@@ -353,6 +440,35 @@ def bolus_stats(treatments: pd.DataFrame) -> dict:
     }
 
 
+def basal_stats(treatments: pd.DataFrame, period_days: float) -> dict:
+    """Totale basaalinsuline uit Temp Basal-treatments (rate x duur), zonder pompprofiel.
+
+    AndroidAPS zet in gesloten-lus-modus vrijwel continu Temp Basal-treatments
+    met een `absolute` snelheid (E/uur) en `duration` (minuten); de som van
+    afgeleverde eenheden daaruit benadert de daadwerkelijke basaaldosis
+    nauwkeurig genoeg zonder het pompprofiel te hoeven ophalen (gitea #20).
+    Periodes zonder actieve temp basal (dan geldt het profiel-basaaltempo)
+    worden hierin gemist — dit is dus een ondergrens, geen exacte totale-
+    dagdosis.
+    """
+    if treatments.empty or period_days <= 0:
+        return {"total_units": 0.0, "avg_units_per_day": 0.0}
+
+    temp_basal = treatments[
+        (treatments["eventType"] == BASAL_EVENT_TYPE)
+        & treatments["absolute"].notna()
+        & treatments["duration"].notna()
+    ]
+    if temp_basal.empty:
+        return {"total_units": 0.0, "avg_units_per_day": 0.0}
+
+    total_units = (temp_basal["absolute"] * temp_basal["duration"] / 60).sum()
+    return {
+        "total_units": round(total_units, 1),
+        "avg_units_per_day": round(total_units / period_days, 1),
+    }
+
+
 SITE_INTERVAL_COLUMNS = [
     "start",
     "end",

tests/test_nightscout_client.py

@@ -90,6 +90,38 @@ def test_fetch_treatments_fills_missing_columns(monkeypatch):
     assert result.iloc[0]["eventType"] == "Site Change"
     assert pd_isna(result.iloc[0]["insulin"])
     assert pd_isna(result.iloc[0]["carbs"])
+    assert result.iloc[0]["type"] == ""
+    assert pd_isna(result.iloc[0]["absolute"])
+    assert pd_isna(result.iloc[0]["duration"])
+
+
+def test_fetch_treatments_passes_through_type_and_temp_basal_fields(monkeypatch):
+    """SMB-classificatie (reporting.bolus_stats) en basaalberekening
+    (reporting.basal_stats) hebben deze velden nodig — zie gitea #20."""
+    monkeypatch.setenv("NIGHTSCOUT_URL", "https://example.com")
+    now = datetime.now(timezone.utc)
+    payload = [
+        {
+            "created_at": now.isoformat(),
+            "eventType": "Correction Bolus",
+            "insulin": 0.5,
+            "type": "SMB",
+        },
+        {
+            "created_at": now.isoformat(),
+            "eventType": "Temp Basal",
+            "absolute": 1.2,
+            "duration": 30,
+        },
+    ]
+    monkeypatch.setattr(ns.requests, "get", lambda *a, **k: FakeResponse(payload))
+
+    result = ns.fetch_treatments(hours=24)
+    smb_row = result[result["eventType"] == "Correction Bolus"].iloc[0]
+    basal_row = result[result["eventType"] == "Temp Basal"].iloc[0]
+    assert smb_row["type"] == "SMB"
+    assert basal_row["absolute"] == pytest.approx(1.2)
+    assert basal_row["duration"] == pytest.approx(30)
 
 
 def pd_isna(value):

tests/test_pdf_export.py

@@ -2,7 +2,14 @@ from datetime import date
 
 import pandas as pd
 
-from pdf_export import SECTION_AGP, SECTION_EVENTS, SECTION_SUMMARY, build_report_pdf
+from pdf_export import (
+    DAGOVERZICHT_MAX_DAYS,
+    SECTION_AGP,
+    SECTION_DAGOVERZICHT,
+    SECTION_EVENTS,
+    SECTION_SUMMARY,
+    build_report_pdf,
+)
 
 
 def _sample_glucose():
@@ -10,6 +17,15 @@ def _sample_glucose():
     return pd.DataFrame({"timestamp": timestamps, "mmol": [6.0 + (i % 5) for i in range(48)]})
 
 
+def _glucose_with_hypo_and_hyper_events():
+    """3 dagen data met een echte hypo- (<3.9, >=15 min) en hyperepisode (>10.0)."""
+    timestamps = pd.date_range("2026-01-01", periods=3 * 24 * 12, freq="5min")
+    values = [7.0] * len(timestamps)
+    values[10:15] = [3.0] * 5  # 25 min hypo
+    values[100:106] = [12.0] * 6  # 30 min hyper
+    return pd.DataFrame({"timestamp": timestamps, "mmol": values})
+
+
 def test_build_report_pdf_produces_valid_pdf_bytes():
     glucose = _sample_glucose()
     events_summary = {
@@ -39,3 +55,38 @@ def test_build_report_pdf_handles_no_sections_selected():
     glucose = _sample_glucose()
     pdf_bytes = build_report_pdf([], glucose, {}, date(2026, 1, 1), date(2026, 1, 2))
     assert pdf_bytes.startswith(b"%PDF")
+
+
+def test_build_report_pdf_includes_dagoverzicht_section():
+    glucose = _sample_glucose()
+    pdf_bytes = build_report_pdf(
+        [SECTION_DAGOVERZICHT], glucose, {}, date(2026, 1, 1), date(2026, 1, 2)
+    )
+    assert pdf_bytes.startswith(b"%PDF")
+    assert len(pdf_bytes) > 500
+
+
+def test_build_report_pdf_caps_dagoverzicht_at_max_days():
+    timestamps = pd.date_range("2026-01-01", periods=(DAGOVERZICHT_MAX_DAYS + 10) * 24, freq="1h")
+    glucose = pd.DataFrame({"timestamp": timestamps, "mmol": [7.0] * len(timestamps)})
+    pdf_bytes = build_report_pdf(
+        [SECTION_DAGOVERZICHT],
+        glucose,
+        {},
+        timestamps[0].date(),
+        timestamps[-1].date(),
+    )
+    assert pdf_bytes.startswith(b"%PDF")
+
+
+def test_build_report_pdf_draws_hypo_and_hyper_charts_when_events_present():
+    glucose = _glucose_with_hypo_and_hyper_events()
+    events_summary = {
+        "Hypo Level 1": {"count": 1, "avg_duration_minutes": 25.0, "events_per_week": 2.3},
+        "Hyper Level 1": {"count": 1, "avg_duration_minutes": 30.0, "events_per_week": 2.3},
+    }
+    pdf_bytes = build_report_pdf(
+        [SECTION_EVENTS], glucose, events_summary, date(2026, 1, 1), date(2026, 1, 4)
+    )
+    assert pdf_bytes.startswith(b"%PDF")
+    assert len(pdf_bytes) > 500

tests/test_reporting.py

@@ -4,12 +4,17 @@ import pandas as pd
 import pytest
 
 from reporting import (
+    GMI_TREND_COLUMNS,
     agp_percentile_bands,
+    basal_stats,
     bolus_stats,
     completeness_warning,
+    daily_gmi,
     day_of_week_pattern,
     detect_events,
+    gmi_mmol_per_mol,
     gmi_percent,
+    gmi_trend,
     minutes_per_day,
     overnight_daytime_split,
     percent_cv,
@@ -31,6 +36,63 @@ def test_gmi_percent_matches_bergenstal_formula():
     assert gmi_percent(7.0) == pytest.approx(6.3, abs=0.05)
 
 
+def test_gmi_mmol_per_mol_matches_known_ifcc_reference_values():
+    # 6.5% is de bekende diagnostische drempel = 48 mmol/mol (IFCC).
+    assert gmi_mmol_per_mol(6.5) == 48
+    assert gmi_mmol_per_mol(7.0) == 53
+
+
+def test_daily_gmi_aggregates_per_calendar_day():
+    glucose = _series(
+        [
+            ("2026-01-01 08:00", 6.0),
+            ("2026-01-01 20:00", 8.0),
+            ("2026-01-02 08:00", 7.0),
+        ]
+    )
+    result = daily_gmi(glucose)
+    assert list(result["date"].astype(str)) == ["2026-01-01", "2026-01-02"]
+    assert result["gmi"].iloc[0] == pytest.approx(gmi_percent(7.0))  # gemiddelde van 6.0 en 8.0
+    assert result["gmi"].iloc[1] == pytest.approx(gmi_percent(7.0))
+
+
+def test_daily_gmi_handles_empty_input():
+    empty = pd.DataFrame(columns=["timestamp", "mmol"])
+    result = daily_gmi(empty)
+    assert result.empty
+    assert list(result.columns) == ["date", "gmi"]
+
+
+def test_gmi_trend_handles_empty_input():
+    empty = pd.DataFrame(columns=["timestamp", "mmol"])
+    result = gmi_trend(empty)
+    assert result.empty
+    assert list(result.columns) == GMI_TREND_COLUMNS
+
+
+def test_gmi_trend_returns_no_line_for_a_single_day():
+    glucose = _series([("2026-01-01 08:00", 6.0)])
+    result = gmi_trend(glucose)
+    assert list(result.columns) == GMI_TREND_COLUMNS
+    assert len(result) == 1
+    assert pd.isna(result["trend"].iloc[0])
+
+
+def test_gmi_trend_fits_increasing_linear_trend_with_band_around_it():
+    pairs = [(f"2026-01-{i + 1:02d} 08:00", 6.0 + i * 0.2) for i in range(10)]
+    glucose = _series(pairs)
+    result = gmi_trend(glucose, rolling_window_days=3)
+
+    assert len(result) == 10
+    assert result["trend"].iloc[-1] > result["trend"].iloc[0]
+    assert (result["trend_lower"] <= result["trend"]).all()
+    assert (result["trend"] <= result["trend_upper"]).all()
+    # Vrijwel lineaire input (gmi_percent rondt af op 1 decimaal, dus een
+    # kleine restfout blijft over) -> smalle betrouwbaarheidsband.
+    assert (result["trend_upper"] - result["trend_lower"]).max() == pytest.approx(0, abs=0.15)
+    assert result["rolling_avg"].iloc[-1] > result["rolling_avg"].iloc[0]
+
+
 def test_percent_cv_handles_empty_input():
     empty = pd.DataFrame(columns=["timestamp", "mmol"])
     assert percent_cv(empty) == 0.0
@@ -339,6 +401,7 @@ def test_bolus_stats_splits_by_event_type():
             "eventType": ["Meal Bolus", "Correction Bolus", "Site Change"],
             "insulin": [4.0, 1.5, None],
             "carbs": [45.0, None, None],
+            "type": ["NORMAL", "NORMAL", ""],
         }
     )
     result = bolus_stats(treatments)
@@ -347,12 +410,76 @@ def test_bolus_stats_splits_by_event_type():
     assert result["by_type"] == {"Meal Bolus": 4.0, "Correction Bolus": 1.5}
 
 
+def test_bolus_stats_reclassifies_smb_correction_boluses_separately():
+    """AndroidAPS registreert een automatische SMB-microbolus als
+    eventType == "Correction Bolus" met type == "SMB" — dit moet apart van
+    een handmatige correctiebolus (type != "SMB") geteld worden (gitea #20)."""
+    treatments = pd.DataFrame(
+        {
+            "timestamp": pd.to_datetime(["2026-01-01 08:00", "2026-01-01 12:00"]),
+            "eventType": ["Correction Bolus", "Correction Bolus"],
+            "insulin": [0.3, 0.9],
+            "carbs": [None, None],
+            "type": ["SMB", "NORMAL"],
+        }
+    )
+    result = bolus_stats(treatments)
+    assert result["by_type"] == {"SMB": 0.3, "Correction Bolus": 0.9}
+
+
+def test_bolus_stats_treats_missing_type_column_as_non_smb():
+    treatments = pd.DataFrame(
+        {
+            "timestamp": pd.to_datetime(["2026-01-01 08:00"]),
+            "eventType": ["Correction Bolus"],
+            "insulin": [0.9],
+            "carbs": [None],
+        }
+    )
+    result = bolus_stats(treatments)
+    assert result["by_type"] == {"Correction Bolus": 0.9}
+
+
 def test_bolus_stats_handles_empty_input():
-    empty = pd.DataFrame(columns=["timestamp", "eventType", "insulin", "carbs"])
+    empty = pd.DataFrame(columns=["timestamp", "eventType", "insulin", "carbs", "type"])
     result = bolus_stats(empty)
     assert result == {"total_units": 0.0, "count": 0, "by_type": {}}
 
 
+def test_basal_stats_sums_temp_basal_rate_times_duration():
+    treatments = pd.DataFrame(
+        {
+            "timestamp": pd.to_datetime(["2026-01-01 08:00", "2026-01-01 08:30"]),
+            "eventType": ["Temp Basal", "Temp Basal"],
+            "absolute": [1.2, 0.6],
+            "duration": [30, 60],
+        }
+    )
+    # 1.2 E/u * 0.5u + 0.6 E/u * 1u = 0.6 + 0.6 = 1.2 E over 1 dag
+    result = basal_stats(treatments, period_days=1)
+    assert result["total_units"] == pytest.approx(1.2)
+    assert result["avg_units_per_day"] == pytest.approx(1.2)
+
+
+def test_basal_stats_ignores_non_temp_basal_rows_and_missing_fields():
+    treatments = pd.DataFrame(
+        {
+            "timestamp": pd.to_datetime(["2026-01-01 08:00", "2026-01-01 08:30"]),
+            "eventType": ["Meal Bolus", "Temp Basal"],
+            "absolute": [None, None],
+            "duration": [None, 30],
+        }
+    )
+    result = basal_stats(treatments, period_days=1)
+    assert result == {"total_units": 0.0, "avg_units_per_day": 0.0}
+
+
+def test_basal_stats_handles_empty_input():
+    empty = pd.DataFrame(columns=["timestamp", "eventType", "absolute", "duration"])
+    result = basal_stats(empty, period_days=1)
+    assert result == {"total_units": 0.0, "avg_units_per_day": 0.0}
+
+
 def test_site_interval_stats_splits_by_site_change():
     glucose = _series(
         [