Release 1.2.0 with calmer snack planning and PDF exports

CloudronManifest.json

@@ -4,8 +4,8 @@
   "author": "Florian Heinz",
   "description": "Private Flask app for meals, shopping and gentle food planning",
   "tagline": "einfach essen planen",
-  "version": "1.0.0",
+  "version": "1.2.0",
-  "upstreamVersion": "1.0.0",
+  "upstreamVersion": "1.2.0",
   "healthCheckPath": "/",
   "httpPort": 8000,
   "manifestVersion": 2,

RELEASE_NOTES_1.1.1.md

@@ -0,0 +1,53 @@
+# Nouri 1.1.1
+
+Nouri 1.1.1 bündelt die jüngsten Verbesserungen rund um Mahlzeiten-Vorschläge, Plan-Einträge, Push-Erinnerungen und den letzten Feinschliff bei Bezeichnungen und Versionierung. Der Release macht die App im Alltag direkter nutzbar und runder im Verhalten.
+
+## Highlights
+
+- generierte Mahlzeiten lassen sich pro Nutzer dauerhaft ausblenden
+- vorhandene Mahlzeiten mit nur 1 bis 2 fehlenden Zutaten werden jetzt ebenfalls vorgeschlagen
+- einzelne Plan-Einträge können nachträglich für `Für mich` oder `Gemeinsam` angepasst werden
+- Frühstück-, Mittag- und Abend-Erinnerungen arbeiten zuverlässiger über echte Zeitfenster
+- Begriffe wie `Mahlzeitideen` werden wieder korrekt großgeschrieben
+- App- und Cloudron-Version stehen jetzt auf `1.1.1`
+
+## Neu in 1.1.1
+
+### Mahlzeiten und Vorschläge
+
+- Im Bereich `Was zuhause gut zusammenpasst` werden die Aktionsbuttons wieder korrekt dargestellt.
+- Generierte Mahlzeiten können mit `Dauerhaft ausblenden` pro Nutzer aus den Vorschlägen entfernt werden.
+- Nouri zeigt jetzt nicht nur vollständige Kombinationen aus Zuhause an.
+- Auch vorhandene Mahlzeitenideen mit nur 1 oder 2 fehlenden Lebensmitteln werden vorgeschlagen.
+- Fehlende Dinge werden direkt kenntlich gemacht, zum Beispiel mit `Es fehlt noch: ...`.
+
+### Plan und Tagesansicht
+
+- Ein einzelner Planeintrag kann jetzt im Tagesplan direkt angepasst werden.
+- So lässt sich zum Beispiel ein geplanter Snack nachträglich nur für eine Person setzen, ohne die Grundeinstellungen der Mahlzeit oder des Lebensmittels zu ändern.
+- Die Anzeige `Für mich`, `Für alle` und persönliche Zuordnungen ist in diesem Zusammenhang klarer geworden.
+
+### Push und Erinnerungen
+
+- Die zeitgesteuerten Erinnerungen für fehlendes Frühstück, Mittagessen und Abendessen laufen nicht mehr nur in einem sehr kleinen Zeitfenster.
+- Stattdessen nutzt Nouri jetzt breitere Zeitfenster:
+  - Frühstück ab `08:00`
+  - Mittagessen ab `12:00`
+  - Abendessen ab `18:00`
+- Dadurch greifen die normalen Erinnerungen deutlich zuverlässiger, auch wenn der Reminder-Worker nicht exakt in derselben Minute läuft.
+
+### Oberfläche
+
+- Die automatisch kleingeschriebene Anzeige im Tagesplan wurde korrigiert.
+- Begriffe wie `Mahlzeitideen` erscheinen wieder so, wie sie in der App gedacht sind.
+
+### Versionierung
+
+- `CloudronManifest.json` wurde auf `1.1.1` angehoben.
+- Der interne Versions-Fallback in `nouri/__init__.py` wurde ebenfalls auf `1.1.1` gesetzt.
+- Die Schema-Version in `nouri/db.py` folgt jetzt ebenfalls `1.1.1`.
+
+## Cloudron
+
+- Das Update kann sauber als neue Version ausgerollt werden.
+- Footer, Release-Link und Versionsanzeige greifen damit wieder auf einen konsistenten Stand zu.

RELEASE_NOTES_1.2.0.md

@@ -0,0 +1,60 @@
+# Nouri 1.2.0
+
+Nouri 1.2.0 bündelt die Weiterentwicklung seit 1.1.1 zu einem ruhigeren und alltagstauglicheren Planungs-Release. Der Fokus lag auf weniger Überforderung im Plan, besseren kleinen Erinnerungen und einem sauberen PDF-Export für den Wochenplan.
+
+## Neu in 1.2.0
+
+### Snacks ruhiger im Tages- und Wochenplan
+
+- Hauptmahlzeiten bleiben immer sichtbar.
+- Snack-Bereiche werden nur bei Bedarf eingeblendet.
+- Leere Snack-Slots lassen sich wieder ausblenden.
+- In der Wochenansicht wurden die Snack-Aktionen sprachlich gestrafft:
+  - `Snacks ergänzen`
+  - `Vormittag`
+  - `Nachmittag`
+  - `Abend`
+
+### Bessere visuelle Betonung im Plan
+
+- Ausgewählte und eingetragene Mahlzeiten werden im Tagesplan klarer hervorgehoben.
+- Die Wochenansicht betont gefüllte Slots jetzt ähnlich wie die Tagesansicht.
+- Snack-Slots fügen sich in der Wochenansicht stimmiger ein und wirken ruhiger.
+
+### Kleine tägliche Snack-Erinnerung
+
+- Neue Option in den Einstellungen:
+  - `Am Nachmittag an etwas Kleines erinnern`
+- Wenn noch kein Snack geplant ist, kann Nouri einmal täglich eine kleine Push-Erinnerung schicken.
+- Die Push-Nachricht nimmt zuerst passende Mahlzeitenideen und sonst einfache Kombinationen aus dem, was zuhause da ist.
+
+### Wochenplan als PDF exportieren
+
+- Die Wochenansicht kann jetzt als PDF exportiert werden.
+- Der Export ist schlicht und druckfreundlich gehalten.
+- Es gibt zwei Varianten:
+  - `Meinen Essensplan`
+  - `Unseren Essensplan`
+- Im gemeinsamen PDF werden persönliche Einträge mit echten Namen gekennzeichnet, zum Beispiel `Für Flo`.
+- Snack-Zeilen erscheinen nur dann, wenn sie in der Woche tatsächlich genutzt werden.
+
+### Export-Menü vereinfacht
+
+- Statt zwei einzelner Export-Buttons gibt es jetzt einen einzigen Button:
+  - `PDF exportieren`
+- Darunter öffnet sich eine kleine Auswahl für die beiden PDF-Varianten.
+
+## Technische Änderungen
+
+- `fpdf2` wurde als Abhängigkeit ergänzt.
+- Cloudron-Version und Upstream-Version stehen jetzt auf `1.2.0`.
+- Die interne Schema-Version und der App-Version-Fallback wurden auf `1.2.0` angehoben.
+
+## Betroffene Bereiche
+
+- Tagesplan
+- Wochenansicht
+- Push-Erinnerungen
+- Einstellungen
+- PDF-Export
+- Cloudron-Paketierung

nouri/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import os
 import secrets
 from datetime import date, timedelta
@@ -34,6 +35,7 @@ from .main import main_bp
 
 WEEKDAY_NAMES = ["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"]
 WEEKDAY_SHORT_NAMES = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]
+DEFAULT_RELEASE_URL = "https://git.hnz.io/hnzio/nouri-App/releases"
 
 
 def load_secret_key(data_dir: Path) -> str:
@@ -54,11 +56,38 @@ def load_secret_key(data_dir: Path) -> str:
     return secret_value
 
 
+def load_app_version(root_dir: Path) -> str:
+    env_version = os.environ.get("NOURI_APP_VERSION", "").strip()
+    if env_version:
+        return env_version
+
+    manifest_path = root_dir / "CloudronManifest.json"
+    if manifest_path.exists():
+        try:
+            manifest_data = json.loads(manifest_path.read_text(encoding="utf-8"))
+        except json.JSONDecodeError:
+            manifest_data = {}
+        manifest_version = str(
+            manifest_data.get("upstreamVersion")
+            or manifest_data.get("version")
+            or ""
+        ).strip()
+        if manifest_version:
+            return manifest_version
+    return "1.2.0"
+
+
+def load_release_url() -> str:
+    return os.environ.get("NOURI_RELEASE_URL", DEFAULT_RELEASE_URL).strip() or DEFAULT_RELEASE_URL
+
+
 def create_app() -> Flask:
     root_dir = Path(__file__).resolve().parent.parent
     data_dir = Path(os.environ.get("NOURI_DATA_DIR", root_dir / "data")).resolve()
     upload_dir = data_dir / "uploads"
     db_path = data_dir / "nouri.sqlite3"
+    app_version = load_app_version(root_dir)
+    release_url = load_release_url()
 
     data_dir.mkdir(parents=True, exist_ok=True)
     ensure_upload_structure(upload_dir)
@@ -74,7 +103,8 @@ def create_app() -> Flask:
         SESSION_COOKIE_HTTPONLY=True,
         SESSION_COOKIE_SAMESITE="Lax",
         SESSION_COOKIE_SECURE=os.environ.get("NOURI_SECURE_COOKIES", "0") == "1",
-        APP_VERSION="1.0.0",
+        APP_VERSION=app_version,
+        RELEASE_URL=release_url,
         TIMEZONE=os.environ.get("NOURI_TIMEZONE", "Europe/Berlin"),
         VAPID_PUBLIC_KEY=os.environ.get("NOURI_VAPID_PUBLIC_KEY", ""),
         VAPID_PRIVATE_KEY=os.environ.get("NOURI_VAPID_PRIVATE_KEY", ""),
@@ -114,6 +144,7 @@ def create_app() -> Flask:
             "notification_channel_options": NOTIFICATION_CHANNEL_OPTIONS,
             "today": date.today(),
             "app_version": app.config["APP_VERSION"],
+            "app_release_url": app.config["RELEASE_URL"],
             "push_public_key": app.config["VAPID_PUBLIC_KEY"],
             "push_available": bool(app.config["VAPID_PUBLIC_KEY"] and app.config["VAPID_PRIVATE_KEY"]),
             "weekday_name": lambda value: WEEKDAY_NAMES[value.weekday()],

nouri/db.py

@@ -10,7 +10,7 @@ from werkzeug.security import generate_password_hash
 
 from .constants import DAYPARTS, DEFAULT_CATEGORIES, DEFAULT_CATEGORY_BUILDERS
 
-CURRENT_SCHEMA_VERSION = "1.0.0"
+CURRENT_SCHEMA_VERSION = "1.2.0"
 
 
 def get_db() -> sqlite3.Connection:
@@ -162,6 +162,7 @@ def bootstrap_legacy_schema(database: sqlite3.Connection) -> None:
             push_missing_breakfast INTEGER NOT NULL DEFAULT 0,
             push_missing_lunch INTEGER NOT NULL DEFAULT 0,
             push_missing_dinner INTEGER NOT NULL DEFAULT 0,
+            push_small_snack INTEGER NOT NULL DEFAULT 0,
             suggest_home_for_today INTEGER NOT NULL DEFAULT 1,
             remind_small_snack INTEGER NOT NULL DEFAULT 0,
             remind_nuts INTEGER NOT NULL DEFAULT 0,
@@ -205,6 +206,19 @@ def bootstrap_legacy_schema(database: sqlite3.Connection) -> None:
         """
     )
 
+    database.execute(
+        """
+        CREATE TABLE IF NOT EXISTS hidden_generated_suggestions (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id INTEGER NOT NULL,
+            suggestion_key TEXT NOT NULL,
+            created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            UNIQUE (user_id, suggestion_key),
+            FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+        )
+        """
+    )
+
     database.execute(
         """
         CREATE TABLE IF NOT EXISTS shopping_needs (
@@ -243,6 +257,7 @@ def bootstrap_legacy_schema(database: sqlite3.Connection) -> None:
         add_column_if_missing(database, "user_settings", "push_missing_breakfast INTEGER NOT NULL DEFAULT 0")
         add_column_if_missing(database, "user_settings", "push_missing_lunch INTEGER NOT NULL DEFAULT 0")
         add_column_if_missing(database, "user_settings", "push_missing_dinner INTEGER NOT NULL DEFAULT 0")
+        add_column_if_missing(database, "user_settings", "push_small_snack INTEGER NOT NULL DEFAULT 0")
 
 
 def ensure_default_household(database: sqlite3.Connection) -> int:
@@ -368,6 +383,7 @@ def ensure_schema_upgrades(database: sqlite3.Connection) -> None:
     add_column_if_missing(database, "user_settings", "push_missing_breakfast INTEGER NOT NULL DEFAULT 0")
     add_column_if_missing(database, "user_settings", "push_missing_lunch INTEGER NOT NULL DEFAULT 0")
     add_column_if_missing(database, "user_settings", "push_missing_dinner INTEGER NOT NULL DEFAULT 0")
+    add_column_if_missing(database, "user_settings", "push_small_snack INTEGER NOT NULL DEFAULT 0")
 
     if default_owner_id is not None:
         database.execute(
@@ -418,6 +434,7 @@ def ensure_schema_upgrades(database: sqlite3.Connection) -> None:
     database.execute("UPDATE user_settings SET push_missing_breakfast = 0 WHERE push_missing_breakfast IS NULL")
     database.execute("UPDATE user_settings SET push_missing_lunch = 0 WHERE push_missing_lunch IS NULL")
     database.execute("UPDATE user_settings SET push_missing_dinner = 0 WHERE push_missing_dinner IS NULL")
+    database.execute("UPDATE user_settings SET push_small_snack = 0 WHERE push_small_snack IS NULL")
 
     database.execute(
         """
@@ -456,6 +473,12 @@ def ensure_schema_upgrades(database: sqlite3.Connection) -> None:
         ON shopping_needs (household_id, activation_date, is_activated)
         """
     )
+    database.execute(
+        """
+        CREATE INDEX IF NOT EXISTS idx_hidden_generated_suggestions_user
+        ON hidden_generated_suggestions (user_id)
+        """
+    )
     set_meta(database, "schema_version", CURRENT_SCHEMA_VERSION)
 
 

nouri/main.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from collections import defaultdict
 from datetime import date, datetime, timedelta
+from io import BytesIO
 from itertools import product
 from pathlib import Path
 import sqlite3
@@ -72,6 +73,13 @@ VISIBILITY_FORM_OPTIONS = [
 ]
 TARGET_USER_OPTIONS_DEFAULT = "__all__"
 WEEKDAY_LABELS = ["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"]
+PRIMARY_DAYPART_SLUGS = {"breakfast", "lunch", "dinner"}
+SNACK_DAYPART_SLUGS = {"morning-snack", "afternoon-snack", "late-snack"}
+PDF_DAYPART_LABELS = {
+    "morning-snack": "Snack am Vormittag",
+    "afternoon-snack": "Snack am Nachmittag",
+    "late-snack": "Später Snack",
+}
 
 
 @main_bp.before_app_request
@@ -95,6 +103,10 @@ def get_dayparts() -> list:
     return get_db().execute("SELECT * FROM dayparts ORDER BY sort_order").fetchall()
 
 
+def format_weekday(day_value: date) -> str:
+    return WEEKDAY_LABELS[day_value.weekday()]
+
+
 def get_household_users(active_only: bool = True):
     query = """
         SELECT id, username, display_name, role
@@ -193,6 +205,7 @@ def default_user_settings() -> dict:
         "push_missing_breakfast": False,
         "push_missing_lunch": False,
         "push_missing_dinner": False,
+        "push_small_snack": False,
         "suggest_home_for_today": True,
         "remind_small_snack": False,
         "remind_nuts": False,
@@ -235,6 +248,7 @@ def get_user_settings() -> dict:
         "push_missing_breakfast",
         "push_missing_lunch",
         "push_missing_dinner",
+        "push_small_snack",
         "suggest_home_for_today",
         "remind_small_snack",
         "remind_nuts",
@@ -357,7 +371,12 @@ def describe_record(entry: dict) -> dict:
     entry["visibility_label"] = VISIBILITY_LABELS.get(entry.get("visibility"), "Gemeinsam")
     entry["visibility_description"] = VISIBILITY_DESCRIPTIONS.get(entry.get("visibility"), "")
     entry["owner_label"] = "Von mir" if entry["is_mine"] else f"Von {owner_name}"
-    entry["for_label"] = f"Für {target_name}" if target_name else "Für alle"
+    if target_name:
+        entry["for_label"] = f"Für {target_name}"
+    elif entry["is_personal"]:
+        entry["for_label"] = "Für mich" if entry["is_mine"] else f"Für {owner_name}"
+    else:
+        entry["for_label"] = "Für alle"
     entry["can_edit"] = entry["is_shared"] or entry["is_mine"] or g.user["role"] == "admin"
     return entry
 
@@ -1267,6 +1286,23 @@ def normalized_component_signature(component_ids: list[int]) -> tuple[int, ...]:
     return tuple(sorted({int(component_id) for component_id in component_ids}))
 
 
+def generated_suggestion_key(component_ids: list[int]) -> str:
+    signature = normalized_component_signature(component_ids)
+    return "generated:" + "-".join(str(component_id) for component_id in signature)
+
+
+def fetch_hidden_generated_suggestion_keys() -> set[str]:
+    rows = get_db().execute(
+        """
+        SELECT suggestion_key
+        FROM hidden_generated_suggestions
+        WHERE user_id = ?
+        """,
+        (g.user["id"],),
+    ).fetchall()
+    return {row["suggestion_key"] for row in rows}
+
+
 def build_generated_meal_name(combo: list[dict], daypart_slug: str) -> str:
     names = [item["name"] for item in combo]
     if daypart_slug in {"breakfast", "morning-snack", "afternoon-snack", "late-snack"} and len(names) >= 2:
@@ -1341,6 +1377,13 @@ def build_dynamic_meal_suggestions(home_foods: list[dict], daypart_slug: str, li
                     "reason": pattern["reason"],
                     "component_ids": [item["id"] for item in combo_items],
                     "existing_item_id": None,
+                    "visibility": "shared",
+                    "daypart_id": None,
+                    "missing_component_ids": [],
+                    "missing_components": [],
+                    "needs_shopping": False,
+                    "is_generated": True,
+                    "suggestion_key": generated_suggestion_key([item["id"] for item in combo_items]),
                 }
             )
             if len(suggestions) >= limit * 3:
@@ -1353,6 +1396,7 @@ def build_dynamic_meal_suggestions(home_foods: list[dict], daypart_slug: str, li
 def build_home_recipe_suggestions(daypart_id: int | None = None, limit: int = 4) -> list[dict]:
     settings = get_user_settings()
     daypart_slug = (get_daypart_by_id(daypart_id)["slug"] if daypart_id and get_daypart_by_id(daypart_id) else "")
+    hidden_keys = fetch_hidden_generated_suggestion_keys()
     home_foods = [
         item
         for item in fetch_items(kind="food", availability="home")
@@ -1360,30 +1404,76 @@ def build_home_recipe_suggestions(daypart_id: int | None = None, limit: int = 4)
     ]
     home_food_ids = {item["id"] for item in home_foods}
     home_food_map = {int(item["id"]): item for item in home_foods}
+    visible_foods = [
+        item
+        for item in fetch_items(kind="food", include_archived=False)
+        if item_matches_daypart(item, daypart_id)
+    ]
+    visible_food_map = {int(item["id"]): item for item in visible_foods}
 
     suggestions: list[dict] = []
     seen_signatures: set[tuple[int, ...]] = set()
     meals = [item for item in fetch_items(kind="meal") if item_matches_daypart(item, daypart_id)]
     for meal in meals:
-        if meal["component_ids"] and all(component_id in home_food_ids for component_id in meal["component_ids"]):
+        if not meal["component_ids"]:
-            signature = normalized_component_signature(meal["component_ids"])
+            continue
-            if signature in seen_signatures:
+        component_ids = [int(component_id) for component_id in meal["component_ids"]]
-                continue
+        if not all(component_id in visible_food_map for component_id in component_ids):
-            seen_signatures.add(signature)
+            continue
-            component_items = [home_food_map[component_id] for component_id in meal["component_ids"] if component_id in home_food_map]
+
+        signature = normalized_component_signature(component_ids)
+        if signature in seen_signatures:
+            continue
+
+        component_items = [visible_food_map[component_id] for component_id in component_ids]
+        available_items = [home_food_map[component_id] for component_id in component_ids if component_id in home_food_map]
+        missing_items = [visible_food_map[component_id] for component_id in component_ids if component_id not in home_food_ids]
+
+        if not available_items:
+            continue
+        if missing_items and len(missing_items) > 2:
+            continue
+
+        seen_signatures.add(signature)
+        if missing_items:
+            missing_names = [item["name"] for item in missing_items]
+            suggestions.append(
+                {
+                    "title": meal["name"],
+                    "reason": f"Es fehlt noch: {', '.join(missing_names)}",
+                    "component_ids": component_ids,
+                    "existing_item_id": meal["id"],
+                    "visibility": meal["visibility"],
+                    "daypart_id": daypart_id or meal.get("primary_daypart_id"),
+                    "missing_component_ids": [item["id"] for item in missing_items],
+                    "missing_components": missing_names,
+                    "needs_shopping": True,
+                    "is_generated": False,
+                    "suggestion_key": None,
+                    "score": score_suggestion_components(available_items, daypart_slug=daypart_slug, settings=settings) + 18 - (len(missing_items) * 4),
+                }
+            )
+        else:
             suggestions.append(
                 {
                     "title": meal["name"],
                     "reason": "Zuhause vorhanden",
-                    "component_ids": meal["component_ids"],
+                    "component_ids": component_ids,
                     "existing_item_id": meal["id"],
+                    "visibility": meal["visibility"],
+                    "daypart_id": daypart_id or meal.get("primary_daypart_id"),
+                    "missing_component_ids": [],
+                    "missing_components": [],
+                    "needs_shopping": False,
+                    "is_generated": False,
+                    "suggestion_key": None,
                     "score": score_suggestion_components(component_items, daypart_slug=daypart_slug, settings=settings) + 40,
                 }
             )
 
     for suggestion in build_dynamic_meal_suggestions(home_foods, daypart_slug, limit=limit * 2):
         signature = normalized_component_signature(suggestion["component_ids"])
-        if signature in seen_signatures:
+        if signature in seen_signatures or suggestion["suggestion_key"] in hidden_keys:
             continue
         seen_signatures.add(signature)
         component_items = [home_food_map[component_id] for component_id in suggestion["component_ids"] if component_id in home_food_map]
@@ -1460,6 +1550,13 @@ def build_daypart_suggestions(daypart_id: int) -> list[dict]:
             "reason": "Für später vormerken",
             "component_ids": [],
             "existing_item_id": item["id"] if item["kind"] == "meal" else None,
+            "visibility": item["visibility"],
+            "daypart_id": daypart_id,
+            "missing_component_ids": [],
+            "missing_components": [],
+            "needs_shopping": False,
+            "is_generated": False,
+            "suggestion_key": None,
         }
         for item in archived_items[:2]
     ]
@@ -1733,7 +1830,7 @@ def build_selected_quick_action(
             return {
                 "type": "existing",
                 "title": selected_item["name"],
-                "subtitle": "Bereit zum Eintragen",
+                "subtitle": "Ausgewählt. Du kannst es jetzt direkt eintragen.",
                 "item_id": int(selected_item["id"]),
                 "visibility": selected_item["visibility"],
                 "daypart_id": daypart_id,
@@ -1743,7 +1840,7 @@ def build_selected_quick_action(
         return {
             "type": "generated",
             "title": selected_meal_name,
-            "subtitle": "Vorgeschlagen aus dem, was zuhause da ist",
+            "subtitle": "Ausgewählt aus dem, was zuhause gut passt.",
             "component_ids": selected_component_ids,
             "visibility": "shared",
             "daypart_id": daypart_id,
@@ -1798,6 +1895,9 @@ def build_day_planner_sections(
                     candidates=candidates,
                 ),
                 "is_open": selected_daypart_id == daypart["id"],
+                "is_primary_daypart": daypart["slug"] in PRIMARY_DAYPART_SLUGS,
+                "is_snack_daypart": daypart["slug"] in SNACK_DAYPART_SLUGS,
+                "visible_by_default": daypart["slug"] in PRIMARY_DAYPART_SLUGS or bool(entries) or selected_daypart_id == daypart["id"],
                 "summary_items": [entry["item_name"] for entry in entries][:2],
                 "default_visibility": "shared",
             }
@@ -1829,7 +1929,20 @@ def build_template_day_sections(selected_map: dict[int, list[int]] | None = None
 
 def fetch_week_cards(week_start: date):
     days = [week_start + timedelta(days=index) for index in range(7)]
+    week_end = week_start + timedelta(days=6)
     grouped_entries = fetch_plan_entries_for_range(week_start, week_start + timedelta(days=6))
+    picker_map = {}
+    for daypart in get_dayparts():
+        candidates = fetch_plan_candidates(int(daypart["id"]))
+        meal_candidates = dedupe_items(
+            [item for item in candidates if item["kind"] == "meal" and item["availability_state"] == "home"]
+            + [item for item in candidates if item["kind"] == "meal"],
+            limit=4,
+        )
+        picker_map[int(daypart["id"])] = {
+            "meal_candidates": meal_candidates,
+            "recipe_suggestions": build_home_recipe_suggestions(int(daypart["id"]), limit=3),
+        }
     cards = []
     for current_day in days:
         filled_dayparts = []
@@ -1838,11 +1951,27 @@ def fetch_week_cards(week_start: date):
         slots = []
         for daypart in get_dayparts():
             slot_entries = grouped_entries.get((current_day.isoformat(), daypart["id"]), [])
-            slots.append({"daypart": dict(daypart), "entries": slot_entries})
+            is_snack_daypart = daypart["slug"] in SNACK_DAYPART_SLUGS
+            visible_by_default = (not is_snack_daypart) or bool(slot_entries)
+            slots.append(
+                {
+                    "daypart": dict(daypart),
+                    "entries": slot_entries,
+                    "copy_allowed": bool(slot_entries) and current_day < week_end,
+                    "picker": picker_map.get(int(daypart["id"]), {"meal_candidates": [], "recipe_suggestions": []}),
+                    "is_snack_daypart": is_snack_daypart,
+                    "visible_by_default": visible_by_default,
+                }
+            )
             if slot_entries:
                 filled_dayparts.append({"id": daypart["id"], "name": daypart["name"], "count": len(slot_entries)})
                 planned_count += len(slot_entries)
                 preview_items.extend(entry["item_name"] for entry in slot_entries[:2])
+        hidden_snack_slots = [
+            {"id": int(slot["daypart"]["id"]), "name": slot["daypart"]["name"]}
+            for slot in slots
+            if slot["is_snack_daypart"] and not slot["visible_by_default"]
+        ]
         cards.append(
             {
                 "date": current_day,
@@ -1850,11 +1979,161 @@ def fetch_week_cards(week_start: date):
                 "planned_count": planned_count,
                 "preview_items": preview_items[:4],
                 "slots": slots,
+                "hidden_snack_slots": hidden_snack_slots,
             }
         )
     return cards
 
 
+def format_week_pdf_entry(entry: dict) -> str:
+    return entry["item_name"]
+
+
+def normalize_pdf_export_mode(raw: str | None) -> str:
+    return "household" if raw == "household" else "mine"
+
+
+def fetch_plan_entries_for_range_export(start_date: date, end_date: date, *, mode: str):
+    params: list[object] = [start_date.isoformat(), end_date.isoformat()]
+    if mode == "household":
+        where_clause = "plan_entries.household_id = ?"
+        params.append(current_household_id())
+    else:
+        where_clause = visible_clause("plan_entries")
+        params.extend(visible_params())
+
+    rows = get_db().execute(
+        f"""
+        SELECT plan_entries.*,
+               items.name AS item_name,
+               items.kind AS item_kind,
+               items.photo_filename,
+               items.availability_state,
+               dayparts.name AS daypart_name,
+               dayparts.slug AS daypart_slug,
+               dayparts.sort_order,
+               owner.display_name AS owner_display_name,
+               owner.username AS owner_username,
+               target.display_name AS target_display_name,
+               target.username AS target_username
+        FROM plan_entries
+        JOIN items ON items.id = plan_entries.item_id
+        JOIN dayparts ON dayparts.id = plan_entries.daypart_id
+        LEFT JOIN users AS owner ON owner.id = plan_entries.owner_user_id
+        LEFT JOIN users AS target ON target.id = items.target_user_id
+        WHERE plan_date BETWEEN ? AND ? AND {where_clause}
+        ORDER BY plan_date, dayparts.sort_order, items.name
+        """,
+        params,
+    ).fetchall()
+    grouped = defaultdict(list)
+    for row in describe_records(rows):
+        grouped[(row["plan_date"], row["daypart_id"])].append(row)
+    return grouped
+
+
+def format_week_pdf_entry(entry: dict, *, mode: str) -> str:
+    label = entry["item_name"]
+    if mode == "household":
+        if entry.get("target_name"):
+            return f"{label} (Für {entry['target_name']})"
+        if entry.get("is_personal"):
+            return f"{label} (Für {entry['owner_name']})"
+        return f"{label} (Für alle)"
+
+    if entry.get("is_shared"):
+        return f"{label} (gemeinsam)"
+    return label
+
+
+def build_week_pdf_rows(week_start: date, *, mode: str) -> tuple[list, list[list[str]]]:
+    days = [week_start + timedelta(days=index) for index in range(7)]
+    grouped_entries = fetch_plan_entries_for_range_export(week_start, week_start + timedelta(days=6), mode=mode)
+    rows: list[list[str]] = []
+    dayparts = get_dayparts()
+    visible_dayparts = []
+    for daypart in dayparts:
+        row_cells: list[str] = []
+        has_content = False
+        row_label = PDF_DAYPART_LABELS.get(daypart["slug"], daypart["name"])
+        row = [daypart["name"]]
+        for current_day in days:
+            entries = grouped_entries.get((current_day.isoformat(), daypart["id"]), [])
+            cell_value = "\n".join(format_week_pdf_entry(entry, mode=mode) for entry in entries)
+            row_cells.append(cell_value)
+            has_content = has_content or bool(cell_value.strip())
+
+        if daypart["slug"] in PRIMARY_DAYPART_SLUGS or has_content:
+            visible_dayparts.append([row_label, *row_cells])
+
+    return days, visible_dayparts
+
+
+def build_week_plan_pdf(week_start: date, *, mode: str = "mine") -> bytes:
+    try:
+        from fpdf import FPDF
+        from fpdf.fonts import FontFace
+    except ImportError as exc:  # pragma: no cover - depends on optional package in local env
+        raise RuntimeError("Für den PDF-Export fehlt noch die Abhängigkeit aus der requirements.txt.") from exc
+
+    mode = normalize_pdf_export_mode(mode)
+    week_end = week_start + timedelta(days=6)
+    week_number = week_start.isocalendar().week
+    days, rows = build_week_pdf_rows(week_start, mode=mode)
+    plan_label = "Mein Essensplan" if mode == "mine" else "Unser Essensplan"
+
+    pdf = FPDF(orientation="L", unit="mm", format="A4")
+    pdf.set_auto_page_break(auto=True, margin=14)
+    pdf.set_margins(left=14, top=14, right=14)
+    pdf.add_page()
+
+    pdf.set_title(f"{plan_label} KW {week_number:02d}")
+    pdf.set_author("Nouri")
+    pdf.set_creator("Nouri")
+
+    pdf.set_font("Helvetica", "B", 18)
+    pdf.cell(0, 9, f"{plan_label} vom {week_start.strftime('%d.%m.%Y')} bis {week_end.strftime('%d.%m.%Y')}", new_x="LMARGIN", new_y="NEXT")
+    pdf.set_font("Helvetica", "", 11)
+    pdf.set_text_color(82, 82, 82)
+    pdf.cell(0, 6, f"KW {week_number:02d}", new_x="LMARGIN", new_y="NEXT")
+    pdf.ln(3)
+    pdf.set_text_color(20, 20, 20)
+
+    headings = [" "] + [f"{format_weekday(day)}\n{day.strftime('%d.%m.%Y')}" for day in days]
+    first_column_width = 34
+    remaining_width = pdf.w - pdf.l_margin - pdf.r_margin - first_column_width
+    day_column_width = remaining_width / 7
+    column_widths = (first_column_width, *([day_column_width] * 7))
+
+    header_style = FontFace(emphasis="B", fill_color=(240, 240, 240))
+    first_column_style = FontFace(emphasis="B", fill_color=(248, 248, 248))
+    body_style = FontFace(fill_color=(255, 255, 255))
+
+    with pdf.table(
+        borders_layout="SINGLE_TOP_LINE",
+        cell_fill_color=(255, 255, 255),
+        cell_fill_mode="ROWS",
+        col_widths=column_widths,
+        gutter_height=0,
+        gutter_width=0,
+        headings_style=header_style,
+        line_height=5.5,
+        text_align=("LEFT", "LEFT", "LEFT", "LEFT", "LEFT", "LEFT", "LEFT", "LEFT"),
+        width=pdf.w - pdf.l_margin - pdf.r_margin,
+    ) as table:
+        header_row = table.row()
+        for heading in headings:
+            header_row.cell(heading, padding=(2.8, 2.5, 2.8, 2.5), v_align="M")
+
+        for row in rows:
+            table_row = table.row()
+            table_row.cell(row[0], style=first_column_style, padding=(2.5, 2.8, 2.5, 2.8), v_align="M")
+            for value in row[1:]:
+                table_row.cell(value or " ", style=body_style, padding=(2.5, 2.8, 2.5, 2.8), v_align="TOP")
+
+    return bytes(pdf.output())
+
+
 def count_visible_items(availability_state: str) -> int:
     row = get_db().execute(
         f"SELECT COUNT(*) AS count FROM items WHERE availability_state = ? AND {visible_clause('items')}",
@@ -2397,6 +2676,23 @@ def insert_plan_entry(*, item_id: int, daypart_id: int, plan_date: date, visibil
     )
 
 
+def update_plan_entry(entry_id: int, *, visibility: str, note: str) -> None:
+    get_db().execute(
+        """
+        UPDATE plan_entries
+        SET visibility = ?,
+            owner_user_id = CASE
+                WHEN ? = 'personal' THEN ?
+                ELSE owner_user_id
+            END,
+            note = ?
+        WHERE id = ?
+        """,
+        (visibility, visibility, g.user["id"], note, entry_id),
+    )
+    get_db().commit()
+
+
 def planner_template_options():
     return fetch_day_templates()
 
@@ -2457,6 +2753,25 @@ def template_library():
     )
 
 
+@main_bp.post("/suggestions/hide")
+@login_required
+def suggestion_hide():
+    component_ids = [int(value) for value in request.form.getlist("component_ids") if value.isdigit()]
+    if not component_ids:
+        flash("Diese Kombination konnte gerade nicht ausgeblendet werden.", "error")
+        return redirect(request.referrer or url_for("main.dashboard"))
+    get_db().execute(
+        """
+        INSERT OR IGNORE INTO hidden_generated_suggestions (user_id, suggestion_key)
+        VALUES (?, ?)
+        """,
+        (g.user["id"], generated_suggestion_key(component_ids)),
+    )
+    get_db().commit()
+    flash("Diese generierte Mahlzeit wird dir künftig nicht mehr vorgeschlagen.", "info")
+    return redirect(request.referrer or url_for("main.dashboard"))
+
+
 @main_bp.route("/templates/day/new", methods=("GET", "POST"))
 @login_required
 def day_template_create():
@@ -2808,6 +3123,7 @@ def settings_view():
                     push_missing_breakfast = ?,
                     push_missing_lunch = ?,
                     push_missing_dinner = ?,
+                    push_small_snack = ?,
                     suggest_home_for_today = ?,
                     remind_small_snack = ?,
                     remind_nuts = ?,
@@ -2832,6 +3148,7 @@ def settings_view():
                     parse_checkbox("push_missing_breakfast", False),
                     parse_checkbox("push_missing_lunch", False),
                     parse_checkbox("push_missing_dinner", False),
+                    parse_checkbox("push_small_snack", False),
                     parse_checkbox("suggest_home_for_today", True),
                     parse_checkbox("remind_small_snack", False),
                     parse_checkbox("remind_nuts", False),
@@ -3483,6 +3800,28 @@ def planner():
     )
 
 
+@main_bp.get("/planner/export.pdf")
+@login_required
+def planner_export_pdf():
+    week_start = parse_week_start(request.args.get("week"))
+    mode = normalize_pdf_export_mode(request.args.get("mode"))
+    try:
+        pdf_bytes = build_week_plan_pdf(week_start, mode=mode)
+    except RuntimeError as exc:
+        flash(str(exc), "error")
+        return redirect(url_for("main.planner", week=week_start.isoformat()))
+
+    week_number = week_start.isocalendar().week
+    prefix = "mein-essensplan" if mode == "mine" else "unser-essensplan"
+    filename = f"{prefix}-kw-{week_number:02d}-{week_start.year}.pdf"
+    return send_file(
+        BytesIO(pdf_bytes),
+        mimetype="application/pdf",
+        as_attachment=True,
+        download_name=filename,
+    )
+
+
 @main_bp.route("/planner/day", methods=("GET", "POST"))
 @login_required
 def planner_day():
@@ -3580,6 +3919,38 @@ def planner_generated_meal():
     return redirect(f"{url_for('main.planner_day', date=selected_date.isoformat(), daypart_id=daypart_id)}#daypart-{daypart_id}")
 
 
+@main_bp.post("/planner/<int:entry_id>/update")
+@login_required
+def planner_update(entry_id: int):
+    selected_date = parse_plan_date(request.form.get("plan_date"))
+    entry = get_db().execute(
+        f"""
+        SELECT plan_entries.*,
+               owner.display_name AS owner_display_name,
+               owner.username AS owner_username
+        FROM plan_entries
+        LEFT JOIN users AS owner ON owner.id = plan_entries.owner_user_id
+        WHERE plan_entries.id = ? AND {visible_clause('plan_entries')}
+        """,
+        [entry_id, *visible_params()],
+    ).fetchone()
+    if entry is None:
+        flash("Der Planeintrag wurde nicht gefunden.", "error")
+        return redirect(url_for("main.planner_day", date=selected_date.isoformat()))
+
+    try:
+        ensure_can_edit(describe_record(dict(entry)), "Diesen Planeintrag kannst du gerade nicht bearbeiten.")
+    except PermissionError as exc:
+        flash(str(exc), "error")
+        return redirect(url_for("main.planner_day", date=selected_date.isoformat()))
+
+    visibility = normalize_visibility(request.form.get("visibility"), entry["visibility"])
+    note = request.form.get("note", "").strip()
+    update_plan_entry(entry_id, visibility=visibility, note=note)
+    flash("Der Planeintrag wurde angepasst.", "success")
+    return redirect(url_for("main.planner_day", date=selected_date.isoformat(), daypart_id=entry["daypart_id"]))
+
+
 @main_bp.post("/planner/<int:entry_id>/remove")
 @login_required
 def planner_remove(entry_id: int):
@@ -3662,3 +4033,85 @@ def planner_move(entry_id: int):
             "redirect_url": url_for("main.planner", week=parse_week_start(target_date.isoformat()).isoformat()),
         }
     )
+
+
+@main_bp.post("/planner/slot/copy-forward")
+@login_required
+def planner_slot_copy_forward():
+    source_date = parse_plan_date(request.form.get("source_date"))
+    target_date = source_date + timedelta(days=1)
+    daypart_raw = request.form.get("daypart_id", "").strip()
+    if not daypart_raw.isdigit():
+        flash("Die Tageszeit konnte nicht erkannt werden.", "error")
+        return redirect(url_for("main.planner", week=parse_week_start(source_date.isoformat()).isoformat()))
+
+    daypart_id = int(daypart_raw)
+    entries = get_db().execute(
+        f"""
+        SELECT plan_entries.*,
+               owner.display_name AS owner_display_name,
+               owner.username AS owner_username
+        FROM plan_entries
+        LEFT JOIN users AS owner ON owner.id = plan_entries.owner_user_id
+        WHERE plan_entries.plan_date = ? AND plan_entries.daypart_id = ? AND {visible_clause('plan_entries')}
+        ORDER BY plan_entries.id
+        """,
+        [source_date.isoformat(), daypart_id, *visible_params()],
+    ).fetchall()
+
+    copied_count = 0
+    shopping_added = 0
+    shopping_scheduled = 0
+
+    for raw_entry in entries:
+        entry = describe_record(dict(raw_entry))
+        try:
+            ensure_can_edit(entry, "Diesen Planeintrag kannst du gerade nicht kopieren.")
+        except PermissionError:
+            continue
+
+        duplicate = get_db().execute(
+            """
+            SELECT id
+            FROM plan_entries
+            WHERE household_id = ?
+              AND plan_date = ?
+              AND daypart_id = ?
+              AND item_id = ?
+              AND visibility = ?
+              AND COALESCE(note, '') = COALESCE(?, '')
+            LIMIT 1
+            """,
+            (
+                current_household_id(),
+                target_date.isoformat(),
+                daypart_id,
+                entry["item_id"],
+                entry["visibility"],
+                entry.get("note", ""),
+            ),
+        ).fetchone()
+        if duplicate:
+            continue
+
+        shopping_result = insert_plan_entry(
+            item_id=entry["item_id"],
+            daypart_id=daypart_id,
+            plan_date=target_date,
+            visibility=entry["visibility"],
+            note=entry.get("note", "") or "",
+        )
+        copied_count += 1
+        shopping_added += int(shopping_result["count"])
+        shopping_scheduled += int(shopping_result["scheduled_count"])
+
+    if copied_count == 0:
+        flash("Für diese Tageszeit gab es nichts Neues zum Kopieren.", "info")
+    else:
+        if shopping_added:
+            flash("Fehlende Lebensmittel wurden für den passenden Einkauf ergänzt.", "info")
+        elif shopping_scheduled:
+            flash("Fehlende Lebensmittel wurden für später vorgemerkt.", "info")
+        flash(f"{copied_count} Eintrag{' wurde' if copied_count == 1 else 'e wurden'} zum nächsten Tag kopiert.", "success")
+
+    return redirect(url_for("main.planner", week=parse_week_start(source_date.isoformat()).isoformat()))

nouri/reminders.py

@@ -13,11 +13,20 @@ from .push import send_push_message
 
 
 MEAL_PUSH_RULES = [
-    {"slug": "breakfast", "setting": "push_missing_breakfast", "hour": 8, "minute": 0, "label": "Frühstück"},
+    {"slug": "breakfast", "setting": "push_missing_breakfast", "hour": 8, "minute": 0, "end_hour": 12, "label": "Frühstück"},
-    {"slug": "lunch", "setting": "push_missing_lunch", "hour": 12, "minute": 0, "label": "Mittagessen"},
+    {"slug": "lunch", "setting": "push_missing_lunch", "hour": 12, "minute": 0, "end_hour": 18, "label": "Mittagessen"},
-    {"slug": "dinner", "setting": "push_missing_dinner", "hour": 18, "minute": 0, "label": "Abendessen"},
+    {"slug": "dinner", "setting": "push_missing_dinner", "hour": 18, "minute": 0, "end_hour": 24, "label": "Abendessen"},
 ]
 
+SNACK_PUSH_RULE = {
+    "slugs": ("morning-snack", "afternoon-snack", "late-snack"),
+    "setting": "push_small_snack",
+    "hour": 15,
+    "minute": 0,
+    "end_hour": 20,
+    "label": "Etwas Kleines",
+}
+
 
 def current_local_time() -> datetime:
     timezone_name = current_app.config.get("TIMEZONE", "Europe/Berlin")
@@ -73,6 +82,24 @@ def plan_exists_for_daypart(user, *, planned_date: date, daypart_id: int) -> boo
     return bool(int(row["count"] or 0))
 
 
+def plan_exists_for_any_daypart(user, *, planned_date: date, daypart_ids: list[int]) -> bool:
+    if not daypart_ids:
+        return False
+    placeholders = ", ".join("?" for _ in daypart_ids)
+    row = get_db().execute(
+        f"""
+        SELECT COUNT(*) AS count
+        FROM plan_entries
+        WHERE household_id = ?
+          AND plan_date = ?
+          AND daypart_id IN ({placeholders})
+          AND (visibility = 'shared' OR owner_user_id = ?)
+        """,
+        [int(user["household_id"]), planned_date.isoformat(), *daypart_ids, int(user["id"])],
+    ).fetchone()
+    return bool(int(row["count"] or 0))
+
+
 def reminder_event_exists(user_id: int, event_key: str) -> bool:
     row = get_db().execute(
         "SELECT 1 FROM reminder_events WHERE user_id = ? AND event_key = ? LIMIT 1",
@@ -92,10 +119,11 @@ def mark_reminder_event(user_id: int, event_key: str) -> None:
     get_db().commit()
 
 
-def due_for_rule(now: datetime, *, hour: int, minute: int) -> bool:
+def due_for_rule(now: datetime, *, hour: int, minute: int, end_hour: int) -> bool:
-    target = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
+    current_minutes = (now.hour * 60) + now.minute
-    delta = (now - target).total_seconds()
+    target_minutes = (hour * 60) + minute
-    return 0 <= delta < 180
+    end_minutes = end_hour * 60
+    return target_minutes <= current_minutes < end_minutes
 
 
 def build_push_target_url(*, planned_date: date, daypart_id: int, suggestion: dict | None) -> str:
@@ -118,6 +146,13 @@ def build_push_message(label: str, suggestion: dict | None) -> tuple[str, str]:
     return title, f"Für {label.lower()} ist noch nichts geplant."
 
 
+def build_small_snack_push_message(suggestion: dict | None) -> tuple[str, str]:
+    title = "Nouri · Etwas Kleines"
+    if suggestion and suggestion.get("title"):
+        return title, f"Für später wäre etwas Kleines möglich. Zuhause passt gerade: {suggestion['title']}."
+    return title, "Für später wäre etwas Kleines möglich. Vielleicht passt heute etwas Einfaches wie Nüsse oder ein Apfel."
+
+
 def best_suggestion_for_user(user, daypart_id: int) -> dict | None:
     previous_user = getattr(g, "user", None)
     g.user = user
@@ -128,6 +163,19 @@ def best_suggestion_for_user(user, daypart_id: int) -> dict | None:
     return suggestions[0] if suggestions else None
 
 
+def best_small_snack_suggestion_for_user(user, daypart_ids: list[int]) -> tuple[int | None, dict | None]:
+    previous_user = getattr(g, "user", None)
+    g.user = user
+    try:
+        for daypart_id in daypart_ids:
+            suggestions = build_home_recipe_suggestions(daypart_id, limit=1)
+            if suggestions:
+                return daypart_id, suggestions[0]
+    finally:
+        g.user = previous_user
+    return (daypart_ids[0] if daypart_ids else None), None
+
+
 def send_due_meal_pushes(now: datetime | None = None) -> int:
     now = now or current_local_time()
     planned_date = now.date()
@@ -155,7 +203,7 @@ def send_due_meal_pushes(now: datetime | None = None) -> int:
         for rule in MEAL_PUSH_RULES:
             if not settings.get(rule["setting"]):
                 continue
-            if not due_for_rule(now, hour=rule["hour"], minute=rule["minute"]):
+            if not due_for_rule(now, hour=rule["hour"], minute=rule["minute"], end_hour=rule["end_hour"]):
                 continue
 
             daypart = dayparts.get(rule["slug"])
@@ -189,6 +237,50 @@ def send_due_meal_pushes(now: datetime | None = None) -> int:
                 mark_reminder_event(int(user["id"]), event_key)
                 sent_count += 1
 
+        snack_rule = SNACK_PUSH_RULE
+        if settings.get(snack_rule["setting"]) and due_for_rule(
+            now,
+            hour=snack_rule["hour"],
+            minute=snack_rule["minute"],
+            end_hour=snack_rule["end_hour"],
+        ):
+            snack_daypart_ids = [
+                int(dayparts[slug]["id"])
+                for slug in snack_rule["slugs"]
+                if slug in dayparts
+            ]
+            if snack_daypart_ids and not plan_exists_for_any_daypart(
+                user,
+                planned_date=planned_date,
+                daypart_ids=snack_daypart_ids,
+            ):
+                event_key = f"meal-push:{planned_date.isoformat()}:small-snack"
+                if not reminder_event_exists(int(user["id"]), event_key):
+                    daypart_id, suggestion = best_small_snack_suggestion_for_user(user, snack_daypart_ids)
+                    title, body = build_small_snack_push_message(suggestion)
+                    url = build_push_target_url(
+                        planned_date=planned_date,
+                        daypart_id=daypart_id or snack_daypart_ids[0],
+                        suggestion=suggestion,
+                    )
+
+                    delivered = False
+                    for subscription in subscriptions:
+                        ok, _error = send_push_message(
+                            {
+                                "endpoint": subscription["endpoint"],
+                                "keys": {"p256dh": subscription["p256dh"], "auth": subscription["auth"]},
+                            },
+                            title=title,
+                            body=body,
+                            url=url,
+                        )
+                        delivered = delivered or ok
+
+                    if delivered:
+                        mark_reminder_event(int(user["id"]), event_key)
+                        sent_count += 1
+
     return sent_count
 
 

nouri/schema.sql

@@ -61,6 +61,7 @@ CREATE TABLE IF NOT EXISTS user_settings (
     push_missing_breakfast INTEGER NOT NULL DEFAULT 0,
     push_missing_lunch INTEGER NOT NULL DEFAULT 0,
     push_missing_dinner INTEGER NOT NULL DEFAULT 0,
+    push_small_snack INTEGER NOT NULL DEFAULT 0,
     suggest_home_for_today INTEGER NOT NULL DEFAULT 1,
     remind_small_snack INTEGER NOT NULL DEFAULT 0,
     remind_nuts INTEGER NOT NULL DEFAULT 0,
@@ -94,6 +95,15 @@ CREATE TABLE IF NOT EXISTS reminder_events (
     FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
 );
 
+CREATE TABLE IF NOT EXISTS hidden_generated_suggestions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    user_id INTEGER NOT NULL,
+    suggestion_key TEXT NOT NULL,
+    created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE (user_id, suggestion_key),
+    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+);
+
 CREATE TABLE IF NOT EXISTS dayparts (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     slug TEXT NOT NULL UNIQUE,

nouri/static/css/styles.css

@@ -89,7 +89,8 @@ textarea {
 }
 
 button,
-.button {
+.button,
+.ghost-button {
     display: inline-flex;
     align-items: center;
     justify-content: center;
@@ -852,6 +853,38 @@ legend {
     overflow: hidden;
 }
 
+.day-tile.has-selection {
+    border-color: color-mix(in srgb, var(--accent) 34%, var(--line) 66%);
+    box-shadow: 0 20px 36px rgba(94, 68, 49, 0.16);
+}
+
+.day-tile.has-entries {
+    position: relative;
+    border-color: color-mix(in srgb, var(--accent) 24%, var(--line) 76%);
+    background:
+        linear-gradient(180deg, color-mix(in srgb, var(--surface) 90%, #ffe8d8 10%), color-mix(in srgb, var(--surface) 96%, #fff 4%));
+    box-shadow: 0 18px 34px rgba(94, 68, 49, 0.14);
+}
+
+.day-tile.has-entries::before {
+    content: "";
+    position: absolute;
+    inset: 0 auto 0 0;
+    width: 4px;
+    background: linear-gradient(180deg, color-mix(in srgb, var(--accent-strong) 76%, white 24%), color-mix(in srgb, var(--accent) 72%, transparent 28%));
+    opacity: 0.9;
+}
+
+.day-tile.has-entries .day-tile-summary {
+    background:
+        linear-gradient(180deg, rgba(255, 236, 221, 0.28), rgba(255, 255, 255, 0));
+}
+
+.day-tile.has-entries .status-pill {
+    background: color-mix(in srgb, var(--mint-soft) 78%, var(--surface) 22%);
+    border: 1px solid color-mix(in srgb, var(--mint-soft) 54%, var(--line) 46%);
+}
+
 .day-tile > summary::-webkit-details-marker {
     display: none;
 }
@@ -891,11 +924,85 @@ legend {
     height: 1.15rem;
 }
 
+.day-tile.has-entries .day-tile-icon {
+    background: linear-gradient(145deg, rgba(255, 255, 255, 0.98), color-mix(in srgb, var(--accent-soft) 68%, #fff 32%));
+    box-shadow: 0 10px 22px rgba(94, 68, 49, 0.14);
+}
+
+.day-tile-summary-text {
+    margin: 0.2rem 0 0;
+    color: color-mix(in srgb, var(--text) 84%, white 16%);
+    font-size: 1.08rem;
+}
+
+.day-tile.has-entries .day-tile-summary-text {
+    color: color-mix(in srgb, var(--text) 90%, white 10%);
+    font-weight: 600;
+}
+
+[data-theme="dark"] .day-tile.has-entries {
+    border-color: color-mix(in srgb, var(--accent) 30%, var(--line) 70%);
+    background:
+        linear-gradient(180deg, color-mix(in srgb, var(--surface) 96%, #3f3430 4%), color-mix(in srgb, var(--surface) 100%, #000 0%));
+    box-shadow: 0 18px 38px rgba(0, 0, 0, 0.26);
+}
+
+[data-theme="dark"] .day-tile.has-entries .day-tile-summary {
+    background:
+        linear-gradient(90deg, rgba(243, 177, 125, 0.10), rgba(243, 177, 125, 0.03) 38%, rgba(255, 255, 255, 0) 68%);
+}
+
+[data-theme="dark"] .day-tile.has-entries .day-tile-icon {
+    background: linear-gradient(145deg, rgba(255, 255, 255, 0.12), rgba(243, 177, 125, 0.16));
+    box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.08);
+}
+
+[data-theme="dark"] .day-tile.has-entries .status-pill {
+    background: rgba(155, 198, 175, 0.20);
+    border-color: rgba(155, 198, 175, 0.16);
+}
+
+[data-theme="dark"] .day-tile.has-entries .day-tile-summary-text {
+    color: #f3ece7;
+}
+
 .day-tile-body {
     padding: 0 1.25rem 1.25rem;
     border-top: 1px solid var(--line);
 }
 
+.snack-reveal-panel {
+    padding: 1rem 1.1rem;
+}
+
+.snack-reveal-actions {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.65rem;
+}
+
+.snack-reveal-button {
+    padding: 0.58rem 0.9rem;
+}
+
+.week-card-snack-actions {
+    display: grid;
+    gap: 0.7rem;
+    margin: 0.2rem 0 0.95rem;
+    padding: 0.8rem 0.9rem;
+    border-radius: 18px;
+    border: 1px solid var(--line);
+    background: color-mix(in srgb, var(--surface) 94%, var(--surface-strong) 6%);
+}
+
+.week-card-snack-actions .eyebrow {
+    margin: 0;
+}
+
+.week-card-empty-copy {
+    margin-bottom: 0.95rem;
+}
+
 .quick-add-row {
     display: flex;
     flex-wrap: wrap;
@@ -937,6 +1044,31 @@ legend {
     background: color-mix(in srgb, var(--surface) 88%, #fff 12%);
 }
 
+.planner-entry-edit {
+    margin-top: 0.85rem;
+}
+
+.planner-entry-edit > summary {
+    width: fit-content;
+    cursor: pointer;
+    list-style: none;
+}
+
+.planner-entry-edit > summary::-webkit-details-marker {
+    display: none;
+}
+
+.planner-entry-inline-form {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    gap: 0.8rem;
+    margin-top: 0.8rem;
+}
+
+.planner-entry-inline-form .wide {
+    grid-column: 1 / -1;
+}
+
 .template-card,
 .template-list-card,
 .suggestion-card {
@@ -946,12 +1078,35 @@ legend {
     background: color-mix(in srgb, var(--surface-strong) 84%, #fff 16%);
 }
 
+.selected-quick-action {
+    background: linear-gradient(180deg, color-mix(in srgb, var(--accent-soft) 82%, #fff 18%), color-mix(in srgb, var(--surface-strong) 82%, #fff 18%));
+    border-color: color-mix(in srgb, var(--accent) 36%, var(--line) 64%);
+    box-shadow: 0 16px 30px rgba(94, 68, 49, 0.12);
+}
+
 .template-list-card,
 .week-template-row {
     display: grid;
     gap: 0.9rem;
 }
 
+.template-list-card-actions {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.65rem;
+    align-items: center;
+}
+
+.template-list-card-actions form {
+    margin: 0;
+}
+
+.template-list-card .ghost-button,
+.template-list-card .button {
+    width: auto;
+    align-self: flex-start;
+}
+
 .week-template-row {
     padding: 1rem;
     border-radius: 18px;
@@ -1105,24 +1260,99 @@ legend {
     align-items: flex-start;
 }
 
-.week-card-count {
-    font-size: 1.25rem;
-    font-family: var(--font-heading);
-    margin: 0.8rem 0 0.2rem;
-}
-
 .week-card-actions {
     margin-top: 1rem;
 }
 
+.export-menu {
+    position: relative;
+}
+
+.export-menu > summary {
+    list-style: none;
+}
+
+.export-menu > summary::-webkit-details-marker {
+    display: none;
+}
+
+.export-menu-trigger::after {
+    content: "▾";
+    font-size: 0.8rem;
+    opacity: 0.7;
+}
+
+.export-menu[open] .export-menu-trigger {
+    background: var(--accent-soft);
+}
+
+.export-menu-panel {
+    position: absolute;
+    top: calc(100% + 0.45rem);
+    right: 0;
+    z-index: 14;
+    min-width: 13.5rem;
+    display: grid;
+    gap: 0.15rem;
+    padding: 0.45rem;
+    border-radius: 18px;
+    border: 1px solid var(--line);
+    background: color-mix(in srgb, var(--surface) 96%, #fff 4%);
+    box-shadow: var(--shadow);
+}
+
+.export-menu-panel a {
+    display: block;
+    padding: 0.8rem 0.9rem;
+    border-radius: 14px;
+    color: var(--text);
+    text-decoration: none;
+}
+
+.export-menu-panel a:hover {
+    background: var(--accent-soft);
+}
+
+.week-card {
+    position: relative;
+    overflow: visible;
+}
+
+.week-card.has-open-picker {
+    z-index: 6;
+}
+
 .week-slot {
+    position: relative;
     padding: 0.85rem;
     border-radius: 18px;
-    background: color-mix(in srgb, var(--surface-strong) 80%, #fff 20%);
+    background: linear-gradient(180deg, color-mix(in srgb, var(--surface-strong) 84%, #fff 16%), color-mix(in srgb, var(--surface) 90%, #fff 10%));
     border: 1px solid var(--line);
     transition: border-color 160ms ease, background 160ms ease, transform 160ms ease;
 }
 
+.week-slot.has-entries {
+    border-color: color-mix(in srgb, var(--accent) 24%, var(--line) 76%);
+    background:
+        linear-gradient(180deg, color-mix(in srgb, var(--surface) 90%, #ffe8d8 10%), color-mix(in srgb, var(--surface) 96%, #fff 4%));
+    box-shadow: 0 18px 34px rgba(94, 68, 49, 0.12);
+}
+
+.week-slot.has-entries::before {
+    content: "";
+    position: absolute;
+    inset: 0 auto 0 0;
+    width: 4px;
+    border-radius: 18px 0 0 18px;
+    background: linear-gradient(180deg, color-mix(in srgb, var(--accent-strong) 76%, white 24%), color-mix(in srgb, var(--accent) 72%, transparent 28%));
+    opacity: 0.9;
+}
+
+.week-slot.week-slot-snack.has-entries {
+    background:
+        linear-gradient(180deg, color-mix(in srgb, var(--surface) 92%, #ffe3cf 8%), color-mix(in srgb, var(--surface) 98%, #fff 2%));
+}
+
 .week-slot.is-drag-over {
     background: var(--accent-soft);
     border-color: color-mix(in srgb, var(--accent) 60%, var(--line) 40%);
@@ -1137,11 +1367,91 @@ legend {
     margin-bottom: 0.5rem;
 }
 
+.week-slot-head-meta {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.45rem;
+}
+
+.week-slot-count {
+    min-width: 1.9rem;
+    text-align: center;
+    font-weight: 700;
+    color: var(--muted);
+}
+
+.week-slot.has-entries .week-slot-count {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    min-width: 2rem;
+    height: 2rem;
+    padding: 0 0.55rem;
+    border-radius: 999px;
+    border: 1px solid color-mix(in srgb, var(--mint-soft) 54%, var(--line) 46%);
+    background: color-mix(in srgb, var(--mint-soft) 78%, var(--surface) 22%);
+    color: color-mix(in srgb, var(--text) 86%, #173127 14%);
+}
+
+.week-slot-add {
+    width: 1.9rem;
+    height: 1.9rem;
+    display: inline-grid;
+    place-items: center;
+    padding: 0;
+    border-radius: 999px;
+    border: 1px solid var(--line);
+    background: var(--accent-soft);
+    color: var(--text);
+    font-weight: 700;
+    font-size: 1.15rem;
+    line-height: 1;
+    text-align: center;
+}
+
+.week-slot-add:hover {
+    background: color-mix(in srgb, var(--accent-soft) 72%, #fff 28%);
+}
+
+.week-slot-picker {
+    position: absolute;
+    top: calc(100% + 0.55rem);
+    left: 0;
+    right: 0;
+    z-index: 12;
+    display: grid;
+    gap: 0.9rem;
+    padding: 0.95rem;
+    border-radius: 18px;
+    border: 1px solid var(--line);
+    background: color-mix(in srgb, var(--surface) 96%, #fff 4%);
+    box-shadow: var(--shadow);
+}
+
+.week-slot-picker[hidden] {
+    display: none;
+}
+
+.week-slot-picker-head {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 0.75rem;
+}
+
+.week-slot-picker-close {
+    padding: 0.5rem 0.85rem;
+}
+
+.week-slot-picker-search {
+    margin-bottom: 0.1rem;
+}
+
 .plan-chip {
     padding: 0.7rem 0.8rem;
     border-radius: 16px;
-    background: linear-gradient(180deg, rgba(255, 255, 255, 0.92), rgba(255, 246, 239, 0.92));
+    background: linear-gradient(180deg, color-mix(in srgb, var(--surface) 72%, #fff 28%), color-mix(in srgb, var(--accent-soft) 55%, var(--surface) 45%));
-    border: 1px solid var(--line);
+    border: 1px solid color-mix(in srgb, var(--accent) 18%, var(--line) 82%);
     cursor: grab;
     box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.65);
 }
@@ -1160,11 +1470,115 @@ legend {
     transform: scale(0.98);
 }
 
+.week-slot-actions {
+    display: flex;
+    justify-content: flex-end;
+    margin-top: 0.65rem;
+}
+
+.week-slot-copy {
+    padding: 0.55rem 0.85rem;
+}
+
 .plan-chip small,
 .week-slot-empty {
     color: var(--muted);
 }
 
+.week-slot-empty {
+    display: grid;
+    justify-items: start;
+    gap: 0.65rem;
+    padding: 0.85rem;
+    border-radius: 16px;
+    border: 1px dashed color-mix(in srgb, var(--line) 74%, var(--accent) 26%);
+    background: color-mix(in srgb, var(--surface) 92%, #fff 8%);
+}
+
+.week-slot-empty p {
+    margin: 0;
+}
+
+[data-theme="dark"] .week-slot {
+    background: linear-gradient(180deg, rgba(66, 57, 54, 0.96), rgba(58, 50, 48, 0.98));
+    border-color: rgba(243, 177, 125, 0.14);
+    box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.04);
+}
+
+[data-theme="dark"] .week-card-snack-actions {
+    background: rgba(47, 40, 38, 0.72);
+    border-color: rgba(243, 177, 125, 0.10);
+}
+
+[data-theme="dark"] .export-menu-panel {
+    background: rgba(43, 37, 35, 0.98);
+    border-color: rgba(243, 177, 125, 0.14);
+    box-shadow: 0 22px 46px rgba(0, 0, 0, 0.34);
+}
+
+[data-theme="dark"] .export-menu-panel a:hover {
+    background: rgba(243, 177, 125, 0.10);
+}
+
+[data-theme="dark"] .week-slot.has-entries {
+    border-color: rgba(243, 177, 125, 0.18);
+    background:
+        linear-gradient(180deg, rgba(70, 60, 57, 0.98), rgba(58, 50, 48, 0.99));
+    box-shadow: 0 18px 34px rgba(0, 0, 0, 0.24);
+}
+
+[data-theme="dark"] .week-slot.week-slot-snack.has-entries {
+    background:
+        linear-gradient(180deg, rgba(75, 64, 60, 0.98), rgba(60, 52, 49, 0.99));
+}
+
+[data-theme="dark"] .week-slot.has-entries .week-slot-count {
+    border-color: rgba(155, 198, 175, 0.16);
+    background: rgba(155, 198, 175, 0.20);
+    color: #eef8f2;
+}
+
+[data-theme="dark"] .week-slot.is-drag-over {
+    background: linear-gradient(180deg, rgba(87, 71, 64, 0.98), rgba(72, 58, 53, 0.98));
+    border-color: rgba(243, 177, 125, 0.24);
+}
+
+[data-theme="dark"] .week-slot-add {
+    background: rgba(243, 177, 125, 0.16);
+    border-color: rgba(243, 177, 125, 0.18);
+    color: #f7efe9;
+}
+
+[data-theme="dark"] .week-slot-add:hover {
+    background: rgba(243, 177, 125, 0.22);
+}
+
+[data-theme="dark"] .week-slot-picker {
+    background: rgba(43, 37, 35, 0.98);
+    border-color: rgba(243, 177, 125, 0.14);
+    box-shadow: 0 22px 46px rgba(0, 0, 0, 0.34);
+}
+
+[data-theme="dark"] .plan-chip {
+    background: linear-gradient(180deg, rgba(86, 72, 66, 0.98), rgba(72, 60, 56, 0.98));
+    border-color: rgba(243, 177, 125, 0.18);
+    box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.05);
+}
+
+[data-theme="dark"] .week-slot-copy {
+    background: rgba(255, 255, 255, 0.03);
+    border-color: rgba(243, 177, 125, 0.12);
+}
+
+[data-theme="dark"] .week-slot-copy:hover {
+    background: rgba(243, 177, 125, 0.10);
+}
+
+[data-theme="dark"] .week-slot-empty {
+    background: rgba(58, 50, 48, 0.72);
+    border-color: rgba(243, 177, 125, 0.16);
+}
+
 .flash-stack {
     display: grid;
     gap: 0.7rem;
@@ -1505,6 +1919,10 @@ legend {
         min-width: 100%;
     }
 
+    .planner-entry-inline-form {
+        grid-template-columns: 1fr;
+    }
+
     .mobile-nav-stack {
         position: fixed;
         left: 0.75rem;

nouri/static/js/planner.js

@@ -4,6 +4,38 @@
         return meta ? meta.getAttribute("content") : "";
     };
 
+    const scrollKey = "nouri-week-scroll";
+
+    const rememberScroll = () => {
+        sessionStorage.setItem(scrollKey, String(window.scrollY));
+    };
+
+    const restoreScroll = () => {
+        const savedScroll = sessionStorage.getItem(scrollKey);
+        if (!savedScroll) return;
+        sessionStorage.removeItem(scrollKey);
+        window.requestAnimationFrame(() => {
+            window.scrollTo({ top: Number(savedScroll), left: 0, behavior: "auto" });
+        });
+    };
+
+    const postAndRefreshInPlace = async (form) => {
+        const payload = new URLSearchParams(new FormData(form));
+        const response = await fetch(form.action, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
+                "X-Requested-With": "XMLHttpRequest",
+            },
+            body: payload.toString(),
+        });
+        if (!response.ok) {
+            throw new Error("request failed");
+        }
+        rememberScroll();
+        window.location.reload();
+    };
+
     const initWeekDragAndDrop = () => {
         const board = document.querySelector(".week-board");
         if (!board) return;
@@ -75,7 +107,185 @@
         });
     };
 
+    const initWeekCopyForward = () => {
+        document.querySelectorAll(".js-copy-forward-form").forEach((form) => {
+            form.addEventListener("submit", async (event) => {
+                event.preventDefault();
+                try {
+                    await postAndRefreshInPlace(form);
+                } catch (_error) {
+                    window.location.reload();
+                }
+            });
+        });
+    };
+
+    const initWeekSlotPicker = () => {
+        const board = document.querySelector(".week-board");
+        if (!board) return;
+
+        const closeAllPickers = () => {
+            board.querySelectorAll(".week-card").forEach((card) => {
+                card.classList.remove("has-open-picker");
+            });
+            board.querySelectorAll(".week-slot").forEach((slot) => {
+                slot.classList.remove("is-picker-open");
+            });
+            board.querySelectorAll(".week-slot-picker").forEach((picker) => {
+                picker.hidden = true;
+            });
+        };
+
+        board.querySelectorAll("[data-week-slot-picker-open]").forEach((button) => {
+            button.addEventListener("click", (event) => {
+                event.preventDefault();
+                const slot = button.closest(".week-slot");
+                if (!slot) return;
+                const picker = slot.querySelector(".week-slot-picker");
+                if (!picker) return;
+                const card = slot.closest(".week-card");
+                const shouldOpen = picker.hidden;
+                closeAllPickers();
+                if (shouldOpen) {
+                    picker.hidden = false;
+                    slot.classList.add("is-picker-open");
+                    if (card) {
+                        card.classList.add("has-open-picker");
+                    }
+                    const filterInput = picker.querySelector("[data-filter-input]");
+                    if (filterInput instanceof HTMLInputElement) {
+                        filterInput.value = "";
+                        filterInput.dispatchEvent(new Event("input", { bubbles: true }));
+                        window.requestAnimationFrame(() => filterInput.focus());
+                    }
+                }
+            });
+        });
+
+        board.querySelectorAll("[data-week-slot-picker-close]").forEach((button) => {
+            button.addEventListener("click", () => {
+                const slot = button.closest(".week-slot");
+                if (!slot) return;
+                const picker = slot.querySelector(".week-slot-picker");
+                const card = slot.closest(".week-card");
+                if (!picker) return;
+                picker.hidden = true;
+                slot.classList.remove("is-picker-open");
+                if (card) {
+                    card.classList.remove("has-open-picker");
+                }
+            });
+        });
+
+        board.querySelectorAll(".js-week-slot-submit").forEach((form) => {
+            form.addEventListener("submit", async (event) => {
+                event.preventDefault();
+                try {
+                    await postAndRefreshInPlace(form);
+                } catch (_error) {
+                    window.location.reload();
+                }
+            });
+        });
+
+        document.addEventListener("click", (event) => {
+            const target = event.target;
+            if (!(target instanceof Element)) return;
+            if (target.closest(".week-slot")) return;
+            closeAllPickers();
+        });
+    };
+
+    const syncActionContainerVisibility = (container) => {
+        if (!(container instanceof HTMLElement)) return;
+        const hasVisibleButtons = Array.from(container.querySelectorAll("button")).some((button) => {
+            return !button.hidden;
+        });
+        container.hidden = !hasVisibleButtons;
+    };
+
+    const revealActionButton = (container, selector) => {
+        if (!(container instanceof HTMLElement) || !selector) return;
+        const button = container.querySelector(`button[data-target="${selector}"]`);
+        if (!(button instanceof HTMLButtonElement)) return;
+        button.hidden = false;
+        container.hidden = false;
+    };
+
+    const initDaySnackReveal = () => {
+        document.querySelectorAll("[data-day-snack-open]").forEach((button) => {
+            button.addEventListener("click", () => {
+                const selector = button.getAttribute("data-target");
+                if (!selector) return;
+                const tile = document.querySelector(selector);
+                if (!(tile instanceof HTMLDetailsElement)) return;
+                tile.hidden = false;
+                tile.open = true;
+                button.hidden = true;
+                tile.scrollIntoView({ block: "nearest", inline: "nearest" });
+                syncActionContainerVisibility(button.closest("[data-day-snack-actions]"));
+            });
+        });
+
+        document.querySelectorAll("[data-day-snack-hide]").forEach((button) => {
+            button.addEventListener("click", () => {
+                const selector = button.getAttribute("data-target");
+                if (!selector) return;
+                const tile = document.querySelector(selector);
+                if (!(tile instanceof HTMLDetailsElement)) return;
+                tile.open = false;
+                tile.hidden = true;
+                revealActionButton(document.querySelector("[data-day-snack-actions]"), selector);
+            });
+        });
+    };
+
+    const initWeekSnackReveal = () => {
+        document.querySelectorAll("[data-week-snack-slot-open]").forEach((button) => {
+            button.addEventListener("click", () => {
+                const selector = button.getAttribute("data-target");
+                if (!selector) return;
+                const slot = document.querySelector(selector);
+                if (!(slot instanceof HTMLElement)) return;
+                slot.hidden = false;
+                button.hidden = true;
+                syncActionContainerVisibility(button.closest("[data-week-snack-actions]"));
+                const openButton = slot.querySelector("[data-week-slot-picker-open]");
+                if (openButton instanceof HTMLButtonElement) {
+                    openButton.click();
+                } else {
+                    slot.scrollIntoView({ block: "nearest", inline: "nearest" });
+                }
+            });
+        });
+
+        document.querySelectorAll("[data-week-snack-slot-hide]").forEach((button) => {
+            button.addEventListener("click", () => {
+                const selector = button.getAttribute("data-target");
+                if (!selector) return;
+                const slot = document.querySelector(selector);
+                if (!(slot instanceof HTMLElement)) return;
+                const picker = slot.querySelector(".week-slot-picker");
+                if (picker instanceof HTMLElement) {
+                    picker.hidden = true;
+                }
+                slot.classList.remove("is-picker-open");
+                slot.hidden = true;
+                const card = slot.closest(".week-card");
+                if (card) {
+                    card.classList.remove("has-open-picker");
+                }
+                revealActionButton(slot.closest(".week-card")?.querySelector("[data-week-snack-actions]"), selector);
+            });
+        });
+    };
+
     document.addEventListener("DOMContentLoaded", () => {
+        restoreScroll();
         initWeekDragAndDrop();
+        initWeekCopyForward();
+        initWeekSlotPicker();
+        initDaySnackReveal();
+        initWeekSnackReveal();
     });
 })();

nouri/templates/base.html

@@ -91,7 +91,7 @@
 
         <footer class="site-footer">
             <div class="footer-copy">
-                <span>Version {{ app_version }}</span>
+                <a href="{{ app_release_url }}" target="_blank" rel="noreferrer">Version {{ app_version }}</a>
                 <span>Made with <span class="ui-icon icon-heart"></span> in Göttingen</span>
             </div>
             <div class="footer-copy">

nouri/templates/dashboard.html

@@ -134,8 +134,26 @@
                         <div>
                             <strong>{{ suggestion.title }}</strong>
                             <small>{{ suggestion.reason }}</small>
+                            {% if suggestion.needs_shopping and suggestion.missing_components %}
+                                <div class="chip-row">
+                                    <span class="chip status-idea">Es fehlt noch: {{ suggestion.missing_components|join(', ') }}</span>
+                                </div>
+                            {% endif %}
+                        </div>
+                        <div class="template-list-card-actions">
+                            {% if suggestion.existing_item_id %}
+                                <a class="ghost-button" href="{{ url_for('main.planner_day', date=today.isoformat(), item_id=suggestion.existing_item_id, daypart_id=suggestion.daypart_id or 1) }}">Im Tagesplan öffnen</a>
+                            {% else %}
+                                <a class="ghost-button" href="{{ url_for('main.item_create', kind='meal', name=suggestion.title, component_ids=suggestion.component_ids) }}">Als Mahlzeit anlegen</a>
+                                <form method="post" action="{{ url_for('main.suggestion_hide') }}">
+                                    {{ csrf_input() }}
+                                    {% for component_id in suggestion.component_ids %}
+                                        <input type="hidden" name="component_ids" value="{{ component_id }}">
+                                    {% endfor %}
+                                    <button class="ghost-button" type="submit">Dauerhaft ausblenden</button>
+                                </form>
+                            {% endif %}
                         </div>
-                        <a class="ghost-button" href="{{ url_for('main.item_create', kind='meal', name=suggestion.title, component_ids=suggestion.component_ids) }}">Als Mahlzeit anlegen</a>
                     </article>
                 {% endfor %}
             </div>

nouri/templates/home/list.html

@@ -51,8 +51,26 @@
                     <div>
                         <strong>{{ suggestion.title }}</strong>
                         <small>{{ suggestion.reason }}</small>
+                        {% if suggestion.needs_shopping and suggestion.missing_components %}
+                            <div class="chip-row">
+                                <span class="chip status-idea">Es fehlt noch: {{ suggestion.missing_components|join(', ') }}</span>
+                            </div>
+                        {% endif %}
+                    </div>
+                    <div class="template-list-card-actions">
+                        {% if suggestion.existing_item_id %}
+                            <a class="ghost-button" href="{{ url_for('main.planner_day', date=today.isoformat(), item_id=suggestion.existing_item_id, daypart_id=suggestion.daypart_id or 1) }}">Im Tagesplan öffnen</a>
+                        {% else %}
+                            <a class="ghost-button" href="{{ url_for('main.item_create', kind='meal', name=suggestion.title, component_ids=suggestion.component_ids) }}">Als Mahlzeit anlegen</a>
+                            <form method="post" action="{{ url_for('main.suggestion_hide') }}">
+                                {{ csrf_input() }}
+                                {% for component_id in suggestion.component_ids %}
+                                    <input type="hidden" name="component_ids" value="{{ component_id }}">
+                                {% endfor %}
+                                <button class="ghost-button" type="submit">Dauerhaft ausblenden</button>
+                            </form>
+                        {% endif %}
                     </div>
-                    <a class="ghost-button" href="{{ url_for('main.item_create', kind='meal', name=suggestion.title, component_ids=suggestion.component_ids) }}">Als Mahlzeit anlegen</a>
                 </article>
             {% endfor %}
         </div>

nouri/templates/planner/day.html

@@ -54,26 +54,53 @@
 </section>
 
 <section class="planner-day-stack">
+    {% set hidden_snack_sections = sections | selectattr('is_snack_daypart') | rejectattr('visible_by_default') | list %}
+    {% if hidden_snack_sections %}
+        <section class="panel compact-form-panel snack-reveal-panel" data-day-snack-actions>
+            <div class="panel-head">
+                <h2>Zwischenmahlzeit hinzufügen</h2>
+            </div>
+            <div class="chip-row snack-reveal-actions">
+                {% for section in hidden_snack_sections %}
+                    <button
+                        class="ghost-button snack-reveal-button"
+                        type="button"
+                        data-day-snack-open
+                        data-target="#daypart-{{ section.daypart.id }}"
+                    >
+                        {{ section.daypart.name }}
+                    </button>
+                {% endfor %}
+            </div>
+        </section>
+    {% endif %}
+
     {% for section in sections %}
-        <details class="day-tile" id="daypart-{{ section.daypart.id }}" {% if section.is_open %}open{% endif %}>
+        <details
+            class="day-tile{% if section.entries %} has-entries{% endif %}{% if section.selected_quick_action %} has-selection{% endif %}"
+            id="daypart-{{ section.daypart.id }}"
+            {% if section.is_snack_daypart and not section.visible_by_default %}hidden data-day-snack-tile{% endif %}
+            {% if section.is_open %}open{% endif %}
+        >
             <summary class="day-tile-summary">
                 <div class="day-tile-summary-main">
                     <div class="day-tile-icon"><span class="ui-icon icon-calendar"></span></div>
                     <div>
                         <h2>{{ section.daypart.name }}</h2>
                         {% if section.summary_items %}
-                            <p class="muted">{{ section.summary_items|join(', ') }}</p>
+                            <p class="day-tile-summary-text">{{ section.summary_items|join(', ') }}</p>
                         {% else %}
                             <p class="muted">Noch frei. Öffnen, wenn du etwas ergänzen möchtest.</p>
                         {% endif %}
                     </div>
                 </div>
-                <span class="status-pill">{{ section.entries|length }} geplant</span>
+                <span class="status-pill{% if section.entries %} status-home{% endif %}">{{ section.entries|length }} geplant</span>
             </summary>
 
             <div class="day-tile-body">
                 {% if section.selected_quick_action %}
-                    <div class="suggestion-card">
+                    <div class="suggestion-card selected-quick-action">
+                        <span class="status-pill status-home">Schon ausgewählt</span>
                         <strong>{{ section.selected_quick_action.title }}</strong>
                         <p class="muted">{{ section.selected_quick_action.subtitle }}</p>
                         {% if section.selected_quick_action.type == 'existing' %}
@@ -150,20 +177,34 @@
                         <h3>Passt gut dazu</h3>
                         <div class="quick-add-row compact-quick-row">
                             {% for suggestion in section.recipe_suggestions %}
-                                <form method="post" action="{{ url_for('main.planner_generated_meal') }}">
+                                {% if suggestion.existing_item_id %}
-                                    {{ csrf_input() }}
+                                    <form method="post" action="{{ url_for('main.planner_day', date=selected_date.isoformat()) }}">
-                                    <input type="hidden" name="plan_date" value="{{ selected_date.isoformat() }}">
+                                        {{ csrf_input() }}
-                                    <input type="hidden" name="daypart_id" value="{{ section.daypart.id }}">
+                                        <input type="hidden" name="plan_date" value="{{ selected_date.isoformat() }}">
-                                    <input type="hidden" name="meal_name" value="{{ suggestion.title }}">
+                                        <input type="hidden" name="daypart_id" value="{{ section.daypart.id }}">
-                                    <input type="hidden" name="visibility" value="shared">
+                                        <input type="hidden" name="item_id" value="{{ suggestion.existing_item_id }}">
-                                    {% for component_id in suggestion.component_ids %}
+                                        <input type="hidden" name="visibility" value="{{ suggestion.visibility or 'shared' }}">
-                                        <input type="hidden" name="component_ids" value="{{ component_id }}">
+                                        <button class="quick-add-button compact-button" type="submit">
-                                    {% endfor %}
+                                            <span>{{ suggestion.title }}</span>
-                                    <button class="quick-add-button compact-button" type="submit">
+                                            <small>{{ suggestion.reason }}</small>
-                                        <span>{{ suggestion.title }}</span>
+                                        </button>
-                                        <small>{{ suggestion.reason }}</small>
+                                    </form>
-                                    </button>
+                                {% else %}
-                                </form>
+                                    <form method="post" action="{{ url_for('main.planner_generated_meal') }}">
+                                        {{ csrf_input() }}
+                                        <input type="hidden" name="plan_date" value="{{ selected_date.isoformat() }}">
+                                        <input type="hidden" name="daypart_id" value="{{ section.daypart.id }}">
+                                        <input type="hidden" name="meal_name" value="{{ suggestion.title }}">
+                                        <input type="hidden" name="visibility" value="shared">
+                                        {% for component_id in suggestion.component_ids %}
+                                            <input type="hidden" name="component_ids" value="{{ component_id }}">
+                                        {% endfor %}
+                                        <button class="quick-add-button compact-button" type="submit">
+                                            <span>{{ suggestion.title }}</span>
+                                            <small>{{ suggestion.reason }}</small>
+                                        </button>
+                                    </form>
+                                {% endif %}
                             {% endfor %}
                         </div>
                     </div>
@@ -185,7 +226,7 @@
                                 <button class="picker-row" type="submit">
                                     <span>{{ item.name }}</span>
                                     <small>
-                                        {{ item_kind_labels[item.kind]|lower }}
+                                        {{ item_kind_labels[item.kind] }}
                                         {% if item.availability_state == 'home' %} · zuhause{% endif %}
                                     </small>
                                 </button>
@@ -220,11 +261,45 @@
                                 {% if entry.note %}
                                     <p>{{ entry.note }}</p>
                                 {% endif %}
+                                {% if entry.can_edit %}
+                                    <details class="planner-entry-edit">
+                                        <summary class="ghost-button">Anpassen</summary>
+                                        <form method="post" action="{{ url_for('main.planner_update', entry_id=entry.id) }}" class="planner-entry-inline-form">
+                                            {{ csrf_input() }}
+                                            <input type="hidden" name="plan_date" value="{{ selected_date.isoformat() }}">
+                                            <label>
+                                                Für wen?
+                                                <select name="visibility">
+                                                    {% for value, label in visibility_options %}
+                                                        <option value="{{ value }}" {% if entry.visibility == value %}selected{% endif %}>{{ label }}</option>
+                                                    {% endfor %}
+                                                </select>
+                                            </label>
+                                            <label class="wide">
+                                                Notiz
+                                                <input type="text" name="note" value="{{ entry.note or '' }}" placeholder="Optional">
+                                            </label>
+                                            <button type="submit">Speichern</button>
+                                        </form>
+                                    </details>
+                                {% endif %}
                             </article>
                         {% endfor %}
                     </div>
                 {% else %}
                     <p class="empty-state">Hier ist noch nichts eingetragen. Ein kleiner Anfang reicht völlig.</p>
+                    {% if section.is_snack_daypart %}
+                        <div class="row-actions snack-inline-actions">
+                            <button
+                                class="ghost-button"
+                                type="button"
+                                data-day-snack-hide
+                                data-target="#daypart-{{ section.daypart.id }}"
+                            >
+                                Wieder ausblenden
+                            </button>
+                        </div>
+                    {% endif %}
                 {% endif %}
             </div>
         </details>

nouri/templates/planner/week.html

@@ -10,6 +10,13 @@
     <div class="week-nav">
         <a class="ghost-button" href="{{ url_for('main.planner', week=prev_week.isoformat()) }}">Vorige Woche</a>
         <span>{{ week_start.strftime('%d.%m.%Y') }} bis {{ week_end.strftime('%d.%m.%Y') }}</span>
+        <details class="export-menu">
+            <summary class="ghost-button export-menu-trigger">PDF exportieren</summary>
+            <div class="export-menu-panel">
+                <a href="{{ url_for('main.planner_export_pdf', week=week_start.isoformat(), mode='mine') }}">Meinen Essensplan</a>
+                <a href="{{ url_for('main.planner_export_pdf', week=week_start.isoformat(), mode='household') }}">Unseren Essensplan</a>
+            </div>
+        </details>
         <a class="ghost-button" href="{{ url_for('main.planner', week=next_week.isoformat()) }}">Nächste Woche</a>
     </div>
 </section>
@@ -80,24 +87,125 @@
                 {% endif %}
             </div>
 
-            {% if card.filled_dayparts %}
+            {% if not card.filled_dayparts %}
-                <p class="week-card-count">{{ card.planned_count }} Einträge</p>
+                <p class="empty-state week-card-empty-copy">Noch offen. Du kannst den Tag ganz leicht nach und nach füllen.</p>
-                <div class="chip-row">
+            {% endif %}
-                    {% for slot in card.filled_dayparts %}
+
-                        <span class="chip">{{ slot.name }} · {{ slot.count }}</span>
+            {% if card.hidden_snack_slots %}
-                    {% endfor %}
+                <div class="week-card-snack-actions" data-week-snack-actions>
+                    <div>
+                        <p class="eyebrow">Snacks ergänzen</p>
+                    </div>
+                    <div class="chip-row snack-reveal-actions">
+                        {% for hidden_slot in card.hidden_snack_slots %}
+                            <button
+                                class="ghost-button snack-reveal-button"
+                                type="button"
+                                data-week-snack-slot-open
+                                data-target="#week-slot-{{ card.date.isoformat() }}-{{ hidden_slot.id }}"
+                            >
+                                {% if hidden_slot.name == 'Vormittagssnack' %}
+                                    Vormittag
+                                {% elif hidden_slot.name == 'Nachmittagssnack' %}
+                                    Nachmittag
+                                {% elif hidden_slot.name == 'Später Snack' %}
+                                    Abend
+                                {% else %}
+                                    {{ hidden_slot.name }}
+                                {% endif %}
+                            </button>
+                        {% endfor %}
+                    </div>
                 </div>
-                <p class="muted">{{ card.preview_items | join(', ') }}</p>
-            {% else %}
-                <p class="empty-state">Noch offen. Du kannst den Tag ganz leicht nach und nach füllen.</p>
             {% endif %}
 
             <div class="week-slot-stack">
                 {% for slot in card.slots %}
-                    <div class="week-slot drop-slot" data-target-date="{{ card.date.isoformat() }}" data-target-daypart-id="{{ slot.daypart.id }}">
+                    <div
+                        class="week-slot drop-slot{% if slot.entries %} has-entries{% endif %}{% if slot.is_snack_daypart %} week-slot-snack{% endif %}"
+                        id="week-slot-{{ card.date.isoformat() }}-{{ slot.daypart.id }}"
+                        data-target-date="{{ card.date.isoformat() }}"
+                        data-target-daypart-id="{{ slot.daypart.id }}"
+                        {% if slot.is_snack_daypart and not slot.visible_by_default %}hidden data-week-snack-slot{% endif %}
+                    >
                         <div class="week-slot-head">
                             <strong>{{ slot.daypart.name }}</strong>
-                            <span>{{ slot.entries|length }}</span>
+                            <div class="week-slot-head-meta">
+                                <span class="week-slot-count{% if slot.entries %} status-home{% endif %}">{{ slot.entries|length }}</span>
+                                <button class="week-slot-add" type="button" data-week-slot-picker-open aria-label="{{ slot.daypart.name }} an {{ weekday_name(card.date) }} direkt ergänzen">+</button>
+                            </div>
+                        </div>
+                        <div class="week-slot-picker" hidden>
+                            <div class="week-slot-picker-head">
+                                <strong>{{ slot.daypart.name }} ergänzen</strong>
+                                <button class="ghost-button week-slot-picker-close" type="button" data-week-slot-picker-close>Schließen</button>
+                            </div>
+                            <label class="planner-search week-slot-picker-search">
+                                <span>Suche</span>
+                                <input type="text" placeholder="Mahlzeiten oder Ideen suchen" data-filter-input data-filter-target="#week-slot-picker-list-{{ card.date.isoformat() }}-{{ slot.daypart.id }}">
+                            </label>
+                            <div id="week-slot-picker-list-{{ card.date.isoformat() }}-{{ slot.daypart.id }}">
+                            {% if slot.picker.meal_candidates %}
+                                <div class="planner-subsection">
+                                    <h3>Mahlzeitenideen</h3>
+                                    <div class="quick-add-row compact-quick-row">
+                                        {% for item in slot.picker.meal_candidates %}
+                                            <form method="post" action="{{ url_for('main.planner_day', date=card.date.isoformat()) }}" class="js-week-slot-submit" data-filter-label="{{ item.name|lower }}">
+                                                {{ csrf_input() }}
+                                                <input type="hidden" name="plan_date" value="{{ card.date.isoformat() }}">
+                                                <input type="hidden" name="daypart_id" value="{{ slot.daypart.id }}">
+                                                <input type="hidden" name="item_id" value="{{ item.id }}">
+                                                <input type="hidden" name="visibility" value="{{ item.visibility }}">
+                                                <button class="quick-add-button compact-button" type="submit">
+                                                    <span>{{ item.name }}</span>
+                                                    {% if item.availability_state == 'home' %}<small>Zuhause vorhanden</small>{% endif %}
+                                                </button>
+                                            </form>
+                                        {% endfor %}
+                                    </div>
+                                </div>
+                            {% endif %}
+                            {% if slot.picker.recipe_suggestions %}
+                                <div class="planner-subsection">
+                                    <h3>Passt gut dazu</h3>
+                                    <div class="quick-add-row compact-quick-row">
+                                        {% for suggestion in slot.picker.recipe_suggestions %}
+                                            {% if suggestion.existing_item_id %}
+                                                <form method="post" action="{{ url_for('main.planner_day', date=card.date.isoformat()) }}" class="js-week-slot-submit" data-filter-label="{{ suggestion.title|lower }} {{ suggestion.reason|lower }}">
+                                                    {{ csrf_input() }}
+                                                    <input type="hidden" name="plan_date" value="{{ card.date.isoformat() }}">
+                                                    <input type="hidden" name="daypart_id" value="{{ slot.daypart.id }}">
+                                                    <input type="hidden" name="item_id" value="{{ suggestion.existing_item_id }}">
+                                                    <input type="hidden" name="visibility" value="{{ suggestion.visibility or 'shared' }}">
+                                                    <button class="quick-add-button compact-button" type="submit">
+                                                        <span>{{ suggestion.title }}</span>
+                                                        <small>{{ suggestion.reason }}</small>
+                                                    </button>
+                                                </form>
+                                            {% else %}
+                                                <form method="post" action="{{ url_for('main.planner_generated_meal') }}" class="js-week-slot-submit" data-filter-label="{{ suggestion.title|lower }} {{ suggestion.reason|lower }}">
+                                                    {{ csrf_input() }}
+                                                    <input type="hidden" name="plan_date" value="{{ card.date.isoformat() }}">
+                                                    <input type="hidden" name="daypart_id" value="{{ slot.daypart.id }}">
+                                                    <input type="hidden" name="meal_name" value="{{ suggestion.title }}">
+                                                    <input type="hidden" name="visibility" value="{{ suggestion.visibility or 'shared' }}">
+                                                    {% for component_id in suggestion.component_ids %}
+                                                        <input type="hidden" name="component_ids" value="{{ component_id }}">
+                                                    {% endfor %}
+                                                    <button class="quick-add-button compact-button" type="submit">
+                                                        <span>{{ suggestion.title }}</span>
+                                                        <small>{{ suggestion.reason }}</small>
+                                                    </button>
+                                                </form>
+                                            {% endif %}
+                                        {% endfor %}
+                                    </div>
+                                </div>
+                            {% endif %}
+                            {% if not slot.picker.meal_candidates and not slot.picker.recipe_suggestions %}
+                                <p class="empty-state">Hier ist gerade noch nichts vorbereitet. Im Tagesplan kannst du jederzeit etwas Neues anlegen.</p>
+                            {% endif %}
+                            </div>
                         </div>
                         {% if slot.entries %}
                             <div class="week-entry-stack">
@@ -108,8 +216,30 @@
                                     </article>
                                 {% endfor %}
                             </div>
+                            <div class="week-slot-actions">
+                                {% if slot.copy_allowed %}
+                                    <form method="post" action="{{ url_for('main.planner_slot_copy_forward') }}" class="js-copy-forward-form">
+                                        {{ csrf_input() }}
+                                        <input type="hidden" name="source_date" value="{{ card.date.isoformat() }}">
+                                        <input type="hidden" name="daypart_id" value="{{ slot.daypart.id }}">
+                                        <button class="ghost-button week-slot-copy" type="submit">Zum nächsten Tag kopieren</button>
+                                    </form>
+                                {% endif %}
+                            </div>
                         {% else %}
-                            <p class="week-slot-empty">Hierher ziehen</p>
+                            <div class="week-slot-empty">
+                                <p>Hierher ziehen</p>
+                                {% if slot.is_snack_daypart %}
+                                    <button
+                                        class="ghost-button week-slot-hide"
+                                        type="button"
+                                        data-week-snack-slot-hide
+                                        data-target="#week-slot-{{ card.date.isoformat() }}-{{ slot.daypart.id }}"
+                                    >
+                                        Wieder ausblenden
+                                    </button>
+                                {% endif %}
+                            </div>
                         {% endif %}
                     </div>
                 {% endfor %}

nouri/templates/settings.html

@@ -133,6 +133,7 @@
 
             <fieldset>
                 <legend>Alltag</legend>
+                <label class="inline-check"><input type="checkbox" name="push_small_snack" value="1" {% if user_settings.push_small_snack %}checked{% endif %}><span>Am Nachmittag an etwas Kleines erinnern</span></label>
                 <label class="inline-check"><input type="checkbox" name="remind_small_snack" value="1" {% if user_settings.remind_small_snack %}checked{% endif %}><span>An kleine Zwischenmahlzeiten erinnern</span></label>
                 <label class="inline-check"><input type="checkbox" name="remind_nuts" value="1" {% if user_settings.remind_nuts %}checked{% endif %}><span>Heute schon an Nüsse gedacht?</span></label>
                 <label class="inline-check"><input type="checkbox" name="suggest_templates" value="1" {% if user_settings.suggest_templates %}checked{% endif %}><span>Häufig genutzte Tages- und Wochenvorlagen vorschlagen</span></label>

requirements.txt

@@ -2,3 +2,4 @@ Flask==3.1.1
 gunicorn==23.0.0
 pywebpush==2.3.0
 Pillow==11.2.1; python_version < "3.14"
+fpdf2==2.8.3