Upload 2 files

app.py

@@ -0,0 +1,457 @@
+# app.py
+# Streamlit App – Diabetes Guidance Chat + Regelauflösung aus Google-Sheet Tab "guidances"
+#
+# Voraussetzungen:
+# - Google Sheet mit Tab "guidances" (Header wie besprochen)
+# - Service Account Credentials entweder über:
+#     A) Streamlit Secrets: st.secrets["gcp_service_account"] (dict)
+#     B) JSON-Datei-Pfad in ENV: GOOGLE_APPLICATION_CREDENTIALS=/path/sa.json
+# - Sheet-ID als ENV oder Secrets:
+#     st.secrets["AGENT_SHEET_ID"] oder ENV: AGENT_SHEET_ID
+#
+# Start:
+#   streamlit run app.py
+
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+import pandas as pd
+import streamlit as st
+
+# ----------------------------
+# Optional: guidance_resolver import (falls Datei vorhanden)
+# ----------------------------
+try:
+    from guidance_resolver import prepare_guidances_df, resolve_guidance  # type: ignore
+except Exception:
+    prepare_guidances_df = None
+    resolve_guidance = None
+
+
+# ----------------------------
+# Fallback: Resolver direkt in app.py (robust gegen leere Trends/Typen)
+# ----------------------------
+ALLOWED_TRENDS = {"any", "stable", "rising", "falling", "double_falling"}
+
+
+def _to_float(x: Any, default: float) -> float:
+    if x is None or (isinstance(x, float) and pd.isna(x)) or (isinstance(x, str) and x.strip() == ""):
+        return float(default)
+    if isinstance(x, (int, float)):
+        return float(x)
+    if isinstance(x, str):
+        s = x.strip().replace(",", ".")
+        for token in ["mg/dl", "mgdl", " ", "\u00A0"]:
+            s = s.replace(token, "")
+        try:
+            return float(s)
+        except ValueError:
+            return float(default)
+    return float(default)
+
+
+def _to_int(x: Any, default: int) -> int:
+    try:
+        return int(round(_to_float(x, default=float(default))))
+    except Exception:
+        return int(default)
+
+
+def _norm_str(x: Any, default: str = "") -> str:
+    if x is None or (isinstance(x, float) and pd.isna(x)):
+        return default
+    s = str(x).strip()
+    return s if s else default
+
+
+def _norm_trend(x: Any) -> str:
+    s = _norm_str(x, default="any").lower()
+    mapping = {
+        "": "any",
+        "any": "any",
+        "egal": "any",
+        "stable": "stable",
+        "stabil": "stable",
+        "rising": "rising",
+        "steigend": "rising",
+        "up": "rising",
+        "falling": "falling",
+        "fallend": "falling",
+        "down": "falling",
+        "double_falling": "double_falling",
+        "doppelpfeil": "double_falling",
+        "↓↓": "double_falling",
+        "stark fallend": "double_falling",
+    }
+    s = mapping.get(s, s)
+    return s if s in ALLOWED_TRENDS else "any"
+
+
+def _normalize_columns(df: pd.DataFrame) -> pd.DataFrame:
+    col_map = {
+        "guidance_id": ["guidance_id", "id", "rule_id", "regel_id"],
+        "category": ["category", "kategorie"],
+        "priority": ["priority", "prio", "priorität", "prioritaet"],
+        "glucose_min_mgdl": ["glucose_min_mgdl", "min", "min_mgdl", "bg_min", "untergrenze", "low"],
+        "glucose_max_mgdl": ["glucose_max_mgdl", "max", "max_mgdl", "bg_max", "obergrenze", "high"],
+        "trend": ["trend", "pfeil", "arrow", "tendenz"],
+        "condition_note": ["condition_note", "condition", "bedingung", "note", "beschreibung"],
+        "action": ["action", "empfehlung", "handlung", "aktion"],
+        "carbs_g": ["carbs_g", "kh_g", "carbs", "kohlenhydrate_g", "kh"],
+        "food_examples": ["food_examples", "beispiele", "foods"],
+        "follow_up": ["follow_up", "next", "nachfolge", "kontrolle"],
+        "source": ["source", "quelle"],
+    }
+    reverse: Dict[str, str] = {}
+    lower_cols = {c.lower(): c for c in df.columns}
+    for canonical, variants in col_map.items():
+        for v in variants:
+            if v.lower() in lower_cols:
+                reverse[lower_cols[v.lower()]] = canonical
+                break
+    df = df.rename(columns=reverse)
+    for c in col_map.keys():
+        if c not in df.columns:
+            df[c] = None
+    return df
+
+
+@dataclass
+class GuidanceMatch:
+    rule: Optional[Dict[str, Any]]
+    matched: bool
+    reason: str
+    considered: int
+
+
+def _prepare_guidances_df_fallback(df: pd.DataFrame) -> pd.DataFrame:
+    df = _normalize_columns(df).copy()
+
+    df["guidance_id"] = df["guidance_id"].apply(lambda x: _norm_str(x, default=""))
+    df["category"] = df["category"].apply(lambda x: _norm_str(x, default=""))
+    df["priority"] = df["priority"].apply(lambda x: _to_int(x, default=9999))
+
+    df["glucose_min_mgdl"] = df["glucose_min_mgdl"].apply(lambda x: _to_float(x, default=0))
+    df["glucose_max_mgdl"] = df["glucose_max_mgdl"].apply(lambda x: _to_float(x, default=999))
+
+    df["trend"] = df["trend"].apply(_norm_trend)
+
+    for c in ["condition_note", "action", "carbs_g", "food_examples", "follow_up", "source"]:
+        df[c] = df[c].apply(lambda x: _norm_str(x, default=""))
+
+    df = df[~((df["action"] == "") & (df["guidance_id"] == ""))].copy()
+    df["__range_width"] = (df["glucose_max_mgdl"] - df["glucose_min_mgdl"]).abs()
+    df = df.sort_values(["priority", "__range_width"], ascending=[True, True]).reset_index(drop=True)
+    df = df.drop(columns=["__range_width"])
+    return df
+
+
+def _resolve_guidance_fallback(
+    guidances_df: pd.DataFrame,
+    glucose_mgdl: Optional[float],
+    trend: Optional[str] = None,
+    *,
+    require_action: bool = True,
+) -> GuidanceMatch:
+    if guidances_df is None or len(guidances_df) == 0:
+        return GuidanceMatch(
+            rule=None,
+            matched=False,
+            reason="Guidances sind leer (Tab 'guidances' nicht geladen oder keine Zeilen).",
+            considered=0,
+        )
+
+    t = _norm_trend(trend)
+
+    if glucose_mgdl is None:
+        for _, r in guidances_df.iterrows():
+            r_trend = _norm_trend(r.get("trend"))
+            if r_trend in ("any", t):
+                return GuidanceMatch(rule=r.to_dict(), matched=True, reason="Kein Wert → generische Regel gewählt.", considered=1)
+        return GuidanceMatch(rule=None, matched=False, reason="Kein Wert und keine generische Regel gefunden.", considered=len(guidances_df))
+
+    g = float(glucose_mgdl)
+    considered = 0
+
+    for _, r in guidances_df.iterrows():
+        considered += 1
+        r_min = float(r.get("glucose_min_mgdl", 0))
+        r_max = float(r.get("glucose_max_mgdl", 999))
+        r_trend = _norm_trend(r.get("trend"))
+
+        if not (r_min <= g <= r_max):
+            continue
+        if r_trend != "any" and r_trend != t:
+            continue
+        if require_action and _norm_str(r.get("action")) == "":
+            continue
+
+        return GuidanceMatch(
+            rule=r.to_dict(),
+            matched=True,
+            reason=f"Match: {r.get('guidance_id','(ohne id)')} (glucose={g}, trend={t})",
+            considered=considered,
+        )
+
+    fallback = {
+        "guidance_id": "DEFAULT_NO_MATCH",
+        "category": "fallback",
+        "priority": 9999,
+        "glucose_min_mgdl": 0,
+        "glucose_max_mgdl": 999,
+        "trend": "any",
+        "condition_note": "Keine passende Regel gefunden.",
+        "action": "⚠️ Keine passende Handlungsempfehlung gefunden. Bitte Trend/Wert prüfen oder Kontaktperson anrufen.",
+        "carbs_g": "",
+        "food_examples": "",
+        "follow_up": "",
+        "source": "system",
+    }
+    return GuidanceMatch(rule=fallback, matched=False, reason=f"Kein Match (glucose={g}, trend={t}). Fallback.", considered=considered)
+
+
+# Choose resolver implementation
+def _prepare_guidances(df: pd.DataFrame) -> pd.DataFrame:
+    if prepare_guidances_df is not None:
+        return prepare_guidances_df(df)  # type: ignore
+    return _prepare_guidances_df_fallback(df)
+
+
+def _resolve_guidance(df: pd.DataFrame, glucose: Optional[float], trend: Optional[str]) -> GuidanceMatch:
+    if resolve_guidance is not None:
+        # returns GuidanceMatch-like? (in our earlier file it returns GuidanceMatch)
+        return resolve_guidance(df, glucose_mgdl=glucose, trend=trend)  # type: ignore
+    return _resolve_guidance_fallback(df, glucose_mgdl=glucose, trend=trend)
+
+
+# ----------------------------
+# Google Sheets loader (gspread)
+# ----------------------------
+def _get_sheet_id() -> str:
+    # Priority: secrets > env
+    if "AGENT_SHEET_ID" in st.secrets:
+        return st.secrets["AGENT_SHEET_ID"]
+    sid = os.getenv("AGENT_SHEET_ID", "").strip()
+    if not sid:
+        st.error("AGENT_SHEET_ID fehlt. Bitte in st.secrets oder ENV setzen.")
+        st.stop()
+    return sid
+
+
+@st.cache_data(show_spinner=False)
+def load_guidances_from_sheet(sheet_id: str, tab: str = "guidances") -> pd.DataFrame:
+    try:
+        import gspread
+        from google.oauth2.service_account import Credentials
+    except Exception as e:
+        st.error("Fehlende Abhängigkeiten: gspread / google-auth. Bitte installieren.")
+        st.stop()
+
+    scopes = [
+        "https://www.googleapis.com/auth/spreadsheets.readonly",
+        "https://www.googleapis.com/auth/drive.readonly",
+    ]
+
+    # Credentials: prefer Streamlit secrets
+    creds = None
+    if "gcp_service_account" in st.secrets:
+        creds = Credentials.from_service_account_info(st.secrets["gcp_service_account"], scopes=scopes)
+    else:
+        # fallback: GOOGLE_APPLICATION_CREDENTIALS env path
+        sa_path = os.getenv("GOOGLE_APPLICATION_CREDENTIALS", "").strip()
+        if not sa_path:
+            st.error(
+                "Keine Service Account Credentials gefunden. "
+                "Nutze st.secrets['gcp_service_account'] oder ENV GOOGLE_APPLICATION_CREDENTIALS."
+            )
+            st.stop()
+        creds = Credentials.from_service_account_file(sa_path, scopes=scopes)
+
+    gc = gspread.authorize(creds)
+    sh = gc.open_by_key(sheet_id)
+    ws = sh.worksheet(tab)
+
+    values = ws.get_all_values()
+    if not values or len(values) < 2:
+        return pd.DataFrame()
+
+    header = values[0]
+    rows = values[1:]
+    df = pd.DataFrame(rows, columns=header)
+    return df
+
+
+# ----------------------------
+# NLP light: Frage -> (glucose, trend)
+# ----------------------------
+def extract_glucose_and_trend(user_text: str) -> tuple[Optional[float], str]:
+    """
+    Extract a glucose value (mg/dl) and trend from free text.
+    Trend defaults to 'any' if not found.
+    """
+    text = (user_text or "").strip()
+    if not text:
+        return None, "any"
+
+    # value extraction: first number between 20 and 500
+    m = re.search(r"(\d{2,3})\s*(mg\/dl|mgdl)?", text.lower())
+    glucose = None
+    if m:
+        v = int(m.group(1))
+        if 20 <= v <= 500:
+            glucose = float(v)
+
+    # trend extraction
+    t = "any"
+    # arrows / keywords
+    if "↓↓" in text or "doppelpfeil" in text.lower() or "stark fall" in text.lower():
+        t = "double_falling"
+    elif any(k in text.lower() for k in ["fallend", "sink", "runter", "down", "↓"]):
+        t = "falling"
+    elif any(k in text.lower() for k in ["steigend", "stieg", "hoch", "up", "↑"]):
+        t = "rising"
+    elif any(k in text.lower() for k in ["stabil", "gleich", "stable"]):
+        t = "stable"
+
+    return glucose, t
+
+
+# ----------------------------
+# Streamlit UI
+# ----------------------------
+st.set_page_config(page_title="Diabetes Guidance Agent", page_icon="🩺", layout="wide")
+
+st.title("🩺 Diabetes Guidance Agent")
+st.caption("Regelbasierte Handlungsempfehlungen aus dem Agent-Sheet (Tab: guidances).")
+
+sheet_id = _get_sheet_id()
+
+with st.sidebar:
+    st.subheader("Datenquelle")
+    st.write("Sheet-ID:", sheet_id)
+    tab_name = st.text_input("Guidances-Tab", value="guidances")
+    reload_btn = st.button("🔄 Neu laden")
+
+if reload_btn:
+    load_guidances_from_sheet.clear()
+
+raw_df = load_guidances_from_sheet(sheet_id, tab=tab_name)
+guidances = _prepare_guidances(raw_df)
+
+# top status
+c1, c2, c3 = st.columns([1, 1, 2])
+with c1:
+    st.metric("Guidance-Regeln geladen", int(len(guidances)))
+with c2:
+    st.metric("Tab", tab_name)
+with c3:
+    if len(guidances) == 0:
+        st.warning("Keine Regeln geladen. Bitte Tab-Name/Sheet prüfen.")
+    else:
+        st.success("Regeln sind verfügbar.")
+
+tabs = st.tabs(["💬 Guidance-Chat", "🧪 Manuelle Eingabe", "🔍 Debug / Regeln"])
+
+# --- Chat tab ---
+with tabs[0]:
+    st.subheader("💬 Frage eingeben")
+
+    user_q = st.text_area(
+        "Beispiele: „Was tun bei 105 mg/dl?“ / „Wert 110, fallend“ / „92 mg/dl ↓↓“",
+        height=90,
+        placeholder="Deine Frage…",
+    )
+
+    colA, colB = st.columns([1, 1])
+    with colA:
+        ask_btn = st.button("Antwort anzeigen", type="primary", use_container_width=True)
+    with colB:
+        debug_mode = st.checkbox("Debug anzeigen", value=False)
+
+    if ask_btn:
+        glucose, trend = extract_glucose_and_trend(user_q)
+
+        match = _resolve_guidance(guidances, glucose, trend)
+        rule = match.rule
+
+        if rule is None:
+            st.error("⚠️ Keine Regel verfügbar (guidances leer oder nicht geladen).")
+        else:
+            # ALWAYS show something (even fallback)
+            st.info(rule.get("action", ""))
+            if rule.get("carbs_g"):
+                st.caption(f"🍎 KH: {rule.get('carbs_g')}")
+            if rule.get("food_examples"):
+                st.caption(f"Beispiele: {rule.get('food_examples')}")
+            if rule.get("follow_up"):
+                st.caption(f"Weiter: {rule.get('follow_up')}")
+
+            if debug_mode:
+                st.divider()
+                st.write("**Extraktion**")
+                st.write({"glucose_mgdl": glucose, "trend": trend})
+                st.write("**Resolver**")
+                st.write({"matched": match.matched, "reason": match.reason, "considered_rows": match.considered})
+                st.write("**Rule**")
+                st.json(rule)
+
+# --- Manual input tab ---
+with tabs[1]:
+    st.subheader("🧪 Manuelle Eingabe (ohne NLP)")
+    if len(guidances) == 0:
+        st.warning("Keine Regeln geladen.")
+    else:
+        glucose = st.slider("Blutzucker (mg/dl)", min_value=40, max_value=250, value=110, step=1)
+        trend = st.selectbox("Trend", ["any", "stable", "rising", "falling", "double_falling"], index=0)
+
+        match = _resolve_guidance(guidances, glucose, trend)
+        rule = match.rule
+
+        st.info(rule.get("action", ""))
+        cols = st.columns(3)
+        cols[0].metric("Matched", "Ja" if match.matched else "Nein")
+        cols[1].metric("Considered", match.considered)
+        cols[2].metric("Rule", rule.get("guidance_id", ""))
+
+        st.caption(match.reason)
+        if rule.get("carbs_g"):
+            st.caption(f"🍎 KH: {rule.get('carbs_g')}")
+        if rule.get("food_examples"):
+            st.caption(f"Beispiele: {rule.get('food_examples')}")
+        if rule.get("follow_up"):
+            st.caption(f"Weiter: {rule.get('follow_up')}")
+
+# --- Debug tab ---
+with tabs[2]:
+    st.subheader("🔍 Debug / Regeln")
+    if len(guidances) == 0:
+        st.warning("Keine Regeln geladen. Prüfe Sheet-ID/Tab/Credentials.")
+    else:
+        st.write("Regeln (nach Priority sortiert):")
+        st.dataframe(guidances, use_container_width=True)
+
+        st.divider()
+        st.write("Schnellprüfung:")
+        issues = []
+
+        if guidances["guidance_id"].duplicated().any():
+            issues.append("Duplizierte guidance_id gefunden.")
+
+        bad_trends = sorted(set(guidances["trend"].unique()) - ALLOWED_TRENDS)
+        if bad_trends:
+            issues.append(f"Ungültige trend-Werte: {bad_trends}")
+
+        if (guidances["action"].fillna("").str.strip() == "").any():
+            issues.append("Mindestens eine Regel hat leere action.")
+
+        if issues:
+            for i in issues:
+                st.error(i)
+        else:
+            st.success("✅ Grundprüfung ok (IDs, Trends, actions).")
+
+st.sidebar.caption("Tipp: Wenn „keine Rückmeldung“, aktiviere Debug und prüfe, ob Regeln geladen sind und ob Trend/Wert extrahiert werden.")

guidance_resolver.py

@@ -0,0 +1,249 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, Tuple, List
+
+import pandas as pd
+
+
+ALLOWED_TRENDS = {"any", "stable", "rising", "falling", "double_falling"}
+
+
+# --- Helpers -----------------------------------------------------------------
+
+def _to_float(x: Any, default: float) -> float:
+    """
+    Coerce sheet values into float.
+    Accepts numbers, numeric strings, and strings with commas.
+    """
+    if x is None or (isinstance(x, float) and pd.isna(x)) or (isinstance(x, str) and x.strip() == ""):
+        return float(default)
+    if isinstance(x, (int, float)):
+        return float(x)
+    if isinstance(x, str):
+        s = x.strip().replace(",", ".")
+        # strip common non-numeric tokens
+        for token in ["mg/dl", "mgdl", " ", "\u00A0"]:
+            s = s.replace(token, "")
+        try:
+            return float(s)
+        except ValueError:
+            return float(default)
+    return float(default)
+
+
+def _to_int(x: Any, default: int) -> int:
+    try:
+        return int(round(_to_float(x, default=float(default))))
+    except Exception:
+        return int(default)
+
+
+def _norm_str(x: Any, default: str = "") -> str:
+    if x is None or (isinstance(x, float) and pd.isna(x)):
+        return default
+    s = str(x).strip()
+    return s if s else default
+
+
+def _norm_trend(x: Any) -> str:
+    """
+    Normalize trend input from sheet or upstream code.
+    Accepts: any, stable, rising, falling, double_falling
+    Also maps common variants.
+    """
+    s = _norm_str(x, default="any").lower()
+
+    mapping = {
+        "": "any",
+        "na": "any",
+        "n/a": "any",
+        "any": "any",
+        "egal": "any",
+        "stabil": "stable",
+        "stable": "stable",
+        "up": "rising",
+        "rising": "rising",
+        "steigend": "rising",
+        "down": "falling",
+        "falling": "falling",
+        "fallend": "falling",
+        "↓↓": "double_falling",
+        "doppelpfeil": "double_falling",
+        "double_falling": "double_falling",
+        "stark fallend": "double_falling",
+    }
+    s = mapping.get(s, s)
+    return s if s in ALLOWED_TRENDS else "any"
+
+
+def _normalize_columns(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Map common column names to the canonical schema.
+    This makes the app resilient if the sheet headers vary slightly.
+    """
+    col_map = {
+        # canonical: variants
+        "guidance_id": ["guidance_id", "id", "rule_id", "regel_id"],
+        "category": ["category", "kategorie"],
+        "priority": ["priority", "prio", "priorität", "prioritaet"],
+        "glucose_min_mgdl": ["glucose_min_mgdl", "min", "min_mgdl", "bg_min", "untergrenze", "low"],
+        "glucose_max_mgdl": ["glucose_max_mgdl", "max", "max_mgdl", "bg_max", "obergrenze", "high"],
+        "trend": ["trend", "pfeil", "arrow", "tendenz"],
+        "condition_note": ["condition_note", "condition", "bedingung", "note", "beschreibung"],
+        "action": ["action", "empfehlung", "handlung", "aktion"],
+        "carbs_g": ["carbs_g", "kh_g", "carbs", "kohlenhydrate_g", "kh"],
+        "food_examples": ["food_examples", "beispiele", "foods"],
+        "follow_up": ["follow_up", "next", "nachfolge", "kontrolle"],
+        "source": ["source", "quelle"],
+    }
+
+    # Create reverse lookup
+    reverse: Dict[str, str] = {}
+    lower_cols = {c.lower(): c for c in df.columns}
+
+    for canonical, variants in col_map.items():
+        for v in variants:
+            if v.lower() in lower_cols:
+                reverse[lower_cols[v.lower()]] = canonical
+                break
+
+    df = df.rename(columns=reverse)
+
+    # Ensure all canonical columns exist
+    for c in col_map.keys():
+        if c not in df.columns:
+            df[c] = None
+
+    return df
+
+
+@dataclass
+class GuidanceMatch:
+    rule: Optional[Dict[str, Any]]
+    matched: bool
+    reason: str
+    considered: int
+
+
+# --- Public API ---------------------------------------------------------------
+
+def prepare_guidances_df(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Normalize, type-coerce, and sort guidances.
+    Call this right after loading the sheet tab.
+    """
+    df = _normalize_columns(df).copy()
+
+    # Type coercion with safe defaults
+    df["guidance_id"] = df["guidance_id"].apply(lambda x: _norm_str(x, default=""))
+    df["category"] = df["category"].apply(lambda x: _norm_str(x, default=""))
+    df["priority"] = df["priority"].apply(lambda x: _to_int(x, default=9999))
+
+    # glucose bounds: default wide if missing
+    df["glucose_min_mgdl"] = df["glucose_min_mgdl"].apply(lambda x: _to_float(x, default=0))
+    df["glucose_max_mgdl"] = df["glucose_max_mgdl"].apply(lambda x: _to_float(x, default=999))
+
+    df["trend"] = df["trend"].apply(_norm_trend)
+
+    # Text fields
+    for c in ["condition_note", "action", "carbs_g", "food_examples", "follow_up", "source"]:
+        df[c] = df[c].apply(lambda x: _norm_str(x, default=""))
+
+    # Drop rows that are unusable (no action and no id)
+    df = df[~((df["action"] == "") & (df["guidance_id"] == ""))].copy()
+
+    # Sort by priority (ascending), then by specificity (narrower range first)
+    df["__range_width"] = (df["glucose_max_mgdl"] - df["glucose_min_mgdl"]).abs()
+    df = df.sort_values(["priority", "__range_width"], ascending=[True, True]).reset_index(drop=True)
+    df = df.drop(columns=["__range_width"])
+
+    return df
+
+
+def resolve_guidance(
+    guidances_df: pd.DataFrame,
+    glucose_mgdl: Optional[float],
+    trend: Optional[str] = None,
+    *,
+    require_action: bool = True,
+    debug: bool = False,
+) -> GuidanceMatch:
+    """
+    Returns the first matching rule by priority.
+    - glucose_mgdl can be None -> fallback to best 'any' rule or default.
+    - trend can be None/unknown -> normalized to 'any'
+    """
+    if guidances_df is None or len(guidances_df) == 0:
+        return GuidanceMatch(
+            rule=None,
+            matched=False,
+            reason="Guidances sind leer (Tab 'guidances' nicht geladen oder keine Zeilen).",
+            considered=0,
+        )
+
+    t = _norm_trend(trend)
+
+    # glucose missing: match the first rule that allows full range OR any
+    if glucose_mgdl is None:
+        # choose highest-priority generic
+        for _, r in guidances_df.iterrows():
+            if _norm_trend(r.get("trend")) in ("any", t):
+                rule = r.to_dict()
+                return GuidanceMatch(
+                    rule=rule,
+                    matched=True,
+                    reason="Kein Blutzuckerwert übergeben → generische Regel gewählt.",
+                    considered=1,
+                )
+        return GuidanceMatch(rule=None, matched=False, reason="Kein Wert und keine generische Regel gefunden.", considered=len(guidances_df))
+
+    g = float(glucose_mgdl)
+
+    considered = 0
+    for _, r in guidances_df.iterrows():
+        considered += 1
+
+        r_min = float(r.get("glucose_min_mgdl", 0))
+        r_max = float(r.get("glucose_max_mgdl", 999))
+        r_trend = _norm_trend(r.get("trend"))
+
+        if not (r_min <= g <= r_max):
+            continue
+
+        if r_trend != "any" and r_trend != t:
+            continue
+
+        # If require_action: skip empty actions
+        if require_action and _norm_str(r.get("action")) == "":
+            continue
+
+        rule = r.to_dict()
+        return GuidanceMatch(
+            rule=rule,
+            matched=True,
+            reason=f"Match gefunden: {rule.get('guidance_id','(ohne id)')} (trend={t}, glucose={g}).",
+            considered=considered,
+        )
+
+    # Fallback: show something instead of silence
+    fallback = {
+        "guidance_id": "DEFAULT_NO_MATCH",
+        "category": "fallback",
+        "priority": 9999,
+        "glucose_min_mgdl": 0,
+        "glucose_max_mgdl": 999,
+        "trend": "any",
+        "condition_note": "Keine passende Regel gefunden.",
+        "action": "⚠️ Keine passende Handlungsempfehlung gefunden. Bitte Trend/Wert prüfen oder Kontaktperson anrufen.",
+        "carbs_g": "",
+        "food_examples": "",
+        "follow_up": "",
+        "source": "system",
+    }
+    return GuidanceMatch(
+        rule=fallback,
+        matched=False,
+        reason=f"Kein Match (trend={t}, glucose={g}). Fallback ausgegeben.",
+        considered=considered,
+    )