fix: persistent alert state, push retry, structured follow-up

1. Persistent alert/dedupe state:
   - _notified_evening_slots and _slot_alerts saved to data/alert_state.json
   - Loaded on startup via _load_alert_state()
   - Survives server restarts — no duplicate notifications

2. Push notification retry:
   - Failed push notifications retry up to 3 attempts
   - Exponential backoff (0s, 1s, 2s)
   - Only retries on failed/error status, stops on sent/partial

3. Structured follow-up detection:
   - Bilingual keyword lists for form and notify follow-ups
   - Extracted to _detect_followup() method
   - Supports both German and English assistant responses
   - Follow-up confirmation logged explicitly

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: annawiewer

src/wiesn_agent/api.py

@@ -49,6 +49,7 @@
 WEB_DIST = next((p for p in _WEB_DIST_CANDIDATES if p.exists()), _WEB_DIST_CANDIDATES[0])
 CHAT_LOG_FILE = DATA_DIR / "chat_history.json"
 ACTIVITY_LOG_FILE = DATA_DIR / "activity_log.json"
+ALERT_STATE_FILE = DATA_DIR / "alert_state.json"
 
 # Track background scanner state
 _scanner_task: asyncio.Task | None = None
@@ -335,8 +336,42 @@ async def _scan_portals(portals: list, config: WiesnConfig) -> list[dict]:
 # Track already-notified evening slots to avoid repeated push notifications.
 # Key: "portal_name|datum_text|time_text"
 _notified_evening_slots: set[str] = set()
-# Track slots where push delivery succeeded (separate from detection)
-_push_delivered_slots: set[str] = set()
+
+
+def _save_alert_state() -> None:
+    """Persist dedupe set and recent alerts to disk."""
+    try:
+        DATA_DIR.mkdir(parents=True, exist_ok=True)
+        state = {
+            "notified_slots": list(_notified_evening_slots),
+            "alerts": list(_slot_alerts),
+            "alert_id": _slot_alert_id,
+        }
+        ALERT_STATE_FILE.write_text(
+            json.dumps(state, ensure_ascii=False, indent=2), encoding="utf-8"
+        )
+    except Exception as e:
+        logger.warning("Failed to save alert state: %s", e)
+
+
+def _load_alert_state() -> None:
+    """Restore dedupe set and recent alerts from disk on startup."""
+    global _slot_alert_id
+    if not ALERT_STATE_FILE.exists():
+        return
+    try:
+        data = json.loads(ALERT_STATE_FILE.read_text(encoding="utf-8"))
+        if isinstance(data.get("notified_slots"), list):
+            _notified_evening_slots.update(data["notified_slots"])
+            logger.info("Restored %d notified slot keys from disk", len(_notified_evening_slots))
+        if isinstance(data.get("alerts"), list):
+            for a in data["alerts"][-50:]:
+                _slot_alerts.append(a)
+            logger.info("Restored %d slot alerts from disk", len(_slot_alerts))
+        if isinstance(data.get("alert_id"), int):
+            _slot_alert_id = max(_slot_alert_id, data["alert_id"])
+    except Exception as e:
+        logger.warning("Failed to load alert state: %s", e)
 
 
 async def _notify_new_evening_slots(results: list[dict], config: WiesnConfig) -> None:
@@ -380,7 +415,7 @@ async def _notify_new_evening_slots(results: list[dict], config: WiesnConfig) ->
                         datum_text_val = ds.get("datum_text", ds.get("datum_value", ""))
                         _push_slot_alert(portal_name, datum_text_val, times, booking_url)
 
-                        # Push notification only if outside quiet hours
+                        # Push notification only if outside quiet hours (with retry)
                         push_status = "skipped_quiet_hours"
                         if push_allowed:
                             title = f"Evening slots: {portal_name}"
@@ -390,18 +425,28 @@ async def _notify_new_evening_slots(results: list[dict], config: WiesnConfig) ->
                                 f"🌙 {times}\n"
                                 f"\n→ Book now: {booking_url}"
                             )
-                            result_json = await send_notification(
-                                title=title,
-                                message=message,
-                                config=config.notifications,
-                                notify_type="success",
-                                event_type="evening_slot",
-                            )
-                            try:
-                                result_data = _json.loads(result_json)
-                                push_status = result_data.get("status", "unknown")
-                            except (ValueError, TypeError):
-                                push_status = "error"
+                            # Retry up to 2 times on failure
+                            for attempt in range(3):
+                                result_json = await send_notification(
+                                    title=title,
+                                    message=message,
+                                    config=config.notifications,
+                                    notify_type="success",
+                                    event_type="evening_slot",
+                                )
+                                try:
+                                    result_data = _json.loads(result_json)
+                                    push_status = result_data.get("status", "unknown")
+                                except (ValueError, TypeError):
+                                    push_status = "error"
+                                if push_status in ("sent", "partial"):
+                                    break
+                                if attempt < 2:
+                                    logger.warning(
+                                        "Push notification failed (attempt %d/3) for %s, retrying...",
+                                        attempt + 1, portal_name,
+                                    )
+                                    await asyncio.sleep(2 ** attempt)
 
                         # Log truthfully
                         _log_activity(
@@ -414,6 +459,9 @@ async def _notify_new_evening_slots(results: list[dict], config: WiesnConfig) ->
                                   portal=portal_name, datum=datum_text_val,
                                   push_status=push_status)
 
+    # Persist alert state after processing
+    _save_alert_state()
+
 
 async def _background_scanner() -> None:
     """Periodically scan all enabled portals in the background."""
@@ -461,6 +509,7 @@ async def lifespan(app: FastAPI):
     # Restore persisted state
     _load_chat_log()
     _load_activity_log()
+    _load_alert_state()
 
     _scanner_task = asyncio.create_task(_background_scanner())
     logger.info("[Scanner] Background scanner started")

src/wiesn_agent/chat_agent.py

@@ -275,6 +275,16 @@ class TriageExecutor(Executor):
         "ja bitte", "ja gerne", "mach das", "ja mach das",
     ))
 
+    # Structured follow-up detection keywords by language
+    _FOLLOWUP_FORM_KW = [
+        "formular", "ausfüllen", "fill out", "fill in", "reservation form",
+        "reservierungsformular", "book for you", "shall i fill",
+    ]
+    _FOLLOWUP_NOTIFY_KW = [
+        "benachrichtig", "notify", "alert you", "test-benachrichtigung",
+        "notification channels", "let you know", "inform you",
+    ]
+
     def __init__(self) -> None:
         super().__init__(id="triage")
         self._last_intent = "chat"
@@ -300,23 +310,29 @@ async def handle(
             lower = user_text.lower().strip()
             if lower in self._CONFIRM_WORDS:
                 intent = self._pending_followup
+                logger.info("[Triage] Follow-up confirmed: %s → %s", lower, intent)
 
-        # Detect what the last assistant message offered as follow-up
-        self._pending_followup = None
-        for m in reversed(messages):
-            if m.role == "assistant" and m.text:
-                lower_reply = m.text.lower()
-                if "formular" in lower_reply or "ausfüllen" in lower_reply:
-                    self._pending_followup = "form"
-                elif "benachrichtig" in lower_reply or "notify" in lower_reply:
-                    self._pending_followup = "notify"
-                break
+        # Detect structured follow-up from last assistant message
+        self._pending_followup = self._detect_followup(messages)
 
         self._last_intent = intent
         target = self.INTENT_TO_EXECUTOR[intent]
         logger.info("[Triage] '%s' → %s", user_text[:60], intent)
         await ctx.send_message(list(messages), target_id=target)  # type: ignore[arg-type]
 
+    def _detect_followup(self, messages: list[Message]) -> str | None:
+        """Detect what the last assistant message offered as a follow-up action."""
+        for m in reversed(messages):
+            if m.role == "assistant" and m.text:
+                lower = m.text.lower()
+                # Check form follow-up first (more specific)
+                if any(kw in lower for kw in self._FOLLOWUP_FORM_KW):
+                    return "form"
+                if any(kw in lower for kw in self._FOLLOWUP_NOTIFY_KW):
+                    return "notify"
+                break
+        return None
+
     def _classify(self, text: str) -> str:
         lower = text.lower().strip()