commit f234399d28ea068e18f45d4a677925f3a29d68b9
Author: neodk2004 <barac.daniel@gmail.com>
Date:   Sat Jul 18 10:19:28 2026 +0200

    Baseline commit: Pflegepilot Alpha v2 (lauffähiger Stand vor Refactoring)
    
    Fixt außerdem UnicodeEncodeError in start.py (▶-Zeichen crashte auf
    Windows-Konsolen mit cp1252-Codepage vor app.run()) durch UTF-8-Zwang
    auf stdout/stderr.

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..b5927ac
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,18 @@
+# Python
+__pycache__/
+*.pyc
+
+# SQLite DB - runtime data, may contain real patient data
+pflegepilot_alpha_v2/pflegepilot/db/*.db
+
+# Patient-generated files - never commit real patient data
+pflegepilot_alpha_v2/pflegepilot/static/briefe/
+pflegepilot_alpha_v2/pflegepilot/static/dokumente/
+pflegepilot_alpha_v2/pflegepilot/static/fotos/
+
+# Local Claude Code settings
+.claude/
+pflegepilot_alpha_v2/pflegepilot/.claude/settings.local.json
+
+# graphify output - regeneratable
+graphify-out/
diff --git a/.graphifyignore b/.graphifyignore
new file mode 100644
index 0000000..fb78eb2
--- /dev/null
+++ b/.graphifyignore
@@ -0,0 +1,3 @@
+pflegepilot_alpha_v2/pflegepilot/static/briefe/**
+pflegepilot_alpha_v2/pflegepilot/static/dokumente/**
+pflegepilot_alpha_v2/pflegepilot/static/fotos/**
diff --git a/Anleitung.md b/Anleitung.md
new file mode 100644
index 0000000..27f5a98
--- /dev/null
+++ b/Anleitung.md
@@ -0,0 +1,42 @@
+# Anleitung: So bauen wir den "Pflegepilot" 🚀
+
+Hallo! Keine Sorge, wenn du "keine Ahnung" hast. Das ist sogar gut, weil wir so alles ganz einfach halten. Hier ist dein Fahrplan, wie wir aus deiner Idee eine echte Hilfe für Menschen machen.
+
+## Was ist der Pflegepilot?
+Stell dir vor, jemand in der Familie wird alt oder krank. Plötzlich gibt es 1000 Formulare, Ämter und Begriffe wie "Pflegegrad", die niemand versteht. 
+Der **Pflegepilot** ist wie ein kluger Freund (eine KI), der Händchen hält, Formulare erklärt und sagt: "Mach als nächstes das hier."
+
+---
+
+## Schritt 1: Den "Dschungel" verstehen (Die Vorbereitung)
+Bevor wir programmieren, müssen wir wissen, wo es brennt.
+*   **Was wir tun:** Wir suchen uns ein echtes Problem aus. Zum Beispiel: "Wie bekomme ich einen Pflegegrad?"
+*   **Dein Job:** Überleg dir: Was war das Nervigste, was du oder Bekannte beim Thema Pflege erlebt haben? Schreib das auf.
+
+## Schritt 2: Die KI füttern (Das Wissen)
+Eine KI ist wie ein Baby: Sie weiß am Anfang nichts. Wir müssen ihr "Bücher" (Daten) geben.
+*   **Was wir tun:** Wir sammeln offizielle Infos von der Pflegekasse, Gesetze und einfache Erklärungen.
+*   **Dein Job:** Du sagst mir: "Hey, such mal alle Infos zum Thema 'Antrag auf Pflegegrad' zusammen."
+
+## Schritt 3: Den "Baby-Piloten" bauen (Der Prototyp)
+Wir bauen nicht sofort ein riesiges Raumschiff. Wir bauen erst mal ein Dreirad.
+*   **Was wir tun:** Wir erstellen eine einfache Chat-Seite. Man kann eine Frage stellen, und der Pflegepilot antwortet ganz einfach, ohne Beamtendeutsch.
+*   **Dein Job:** Du testest das Dreirad. Wenn die KI Quatsch redet, sagst du: "Stopp, das versteht doch keiner!"
+
+## Schritt 4: Firmen einladen (Die Entlastung)
+Pflegedienste haben zu viel Papierkram. 
+*   **Was wir tun:** Wir bringen der KI bei, wie sie den Pflegediensten beim Ausfüllen von Berichten hilft. So haben die mehr Zeit für die echten Menschen.
+*   **Dein Job:** Wir überlegen gemeinsam: Was hassen Pflegedienste am meisten? (Meistens ist es das Tippen am Computer).
+
+---
+
+## Wie wir jetzt konkret anfangen:
+
+1.  **Sammeln:** Wir suchen die wichtigsten Dokumente (PDFs von Ämtern).
+2.  **Strukturieren:** Wir bringen der KI bei, diese Dokumente zu lesen.
+3.  **Chatten:** Wir bauen ein Fenster, wo du fragen kannst: "Wie helfe ich meiner Oma?"
+
+**Keine Angst vor der Technik!** Ich (dein KI-Assistent) kümmere mich um den Code. Du bist der Chef, der sagt, ob es für normale Menschen verständlich ist.
+
+### Dein erster Auftrag:
+Sag mir einfach: **"Lass uns mit dem Thema 'Pflegegrad beantragen' anfangen."** Dann lege ich los und suche die ersten Infos für uns.
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..8fc8340
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,62 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Repository layout
+
+This is not a single project but a working directory with one active app plus reference/planning material:
+
+- **`pflegepilot_alpha_v2/pflegepilot/`** — the active codebase (Flask + SQLite web app). All code work happens here.
+- **`pflegepilot_alpha/`** — superseded v1. Source files have been deleted; only a stale `__pycache__` remains. Do not develop here.
+- **`pflegepilot_erp.html`** — a standalone static HTML mockup/prototype, not wired to the Flask app. Not part of the running system.
+- **`Anleitung.md`, `Leistungen.md`, `Leistungen2.md`, `Pflegegrad.md`, `Musterbrief.md`** — German-language domain reference notes (care-benefits catalog research, sample letters, project rationale) used as source material for `katalog.py` and the letter generators. Not code.
+- **`refactoring.md`** — the current architecture-change brief from the product owner (see "Planned architecture pivot" below). Read this before any structural work.
+
+No git repository is initialized in this directory.
+
+## Commands
+
+Run from `pflegepilot_alpha_v2/pflegepilot/`:
+
+```bash
+pip install flask
+python start.py        # initializes/migrates the SQLite DB, then serves on http://localhost:5050
+```
+
+`start.py` runs with `debug=False`; running `app.py` directly instead uses `debug=True` on the same port. There is no test suite, linter, or build step in this project.
+
+Default login after first start: `admin` / `admin` (created automatically by `init_db()` when the `nutzer` table is empty).
+
+## Architecture
+
+**Single-file Flask backend, vanilla-JS SPA frontend, zero build tooling.**
+
+- `app.py` — the entire backend: all `/api/*` routes, SQLite access, auth, SMTP email sending, file upload handling. There's no blueprint/module split — everything lives in this one file.
+- `templates/index.html` — the entire frontend. One Jinja template that is actually a client-rendered SPA: vanilla JS, string-templated HTML, no framework, no bundler. Key conventions in the `<script>` block:
+  - `go(name, extra)` is the client-side router; it maps a page name to a `pg*()` render function (`pgDash`, `pgPatienten`, `pgKatalog`, `pgBackend`, …).
+  - `S(id, html)` sets innerHTML by id; `R(html, title, actions)` sets the main content/title/toolbar in one call.
+  - `api(path, opts)` is the shared `fetch` wrapper for JSON API calls (raw `fetch` is used directly for multipart file uploads).
+  - PDF documents (Musterbrief, Widerspruch, Pflegetagebuch, Patientenakte) are rendered **client-side** via `html2pdf.js`, then the resulting blob is base64-uploaded to a server endpoint (e.g. `POST /api/patienten/<pid>/briefe`, `POST /api/patienten/<pid>/dokumente`) for permanent storage under `static/`.
+- `katalog.py` — static data module: `KATALOG`, a list of ~82 care-benefit entries (Pflegekasse/Krankenkasse services under SGB XI), each tagged with `zielgruppe` (target group: `alterspflege`/`beduerftige`/`behinderte`) and a `pflegegrad_min`/`pflegegrad_max` range, plus legal basis (`rechtsgrundlage`), amounts, and optional `abhaengigkeiten` (cross-references to related/conflicting benefits). Filtering helpers (`get_by_zielgruppe`, `get_by_pflegegrad`, `search`, …) are used both by `/api/katalog` and to compute a patient's `empfohlene_leistungen`.
+- `krankenkassen.py` — static directory of ~86 health/care insurers (GKV/PKV in Germany, SV in Austria, KVG in Switzerland) with postal addresses, used to auto-fill recipient addresses in generated letters. Has a `land` field (`DE`/`AT`/`CH`) with helpers `get_by_land`, `search(q, land=None)`.
+- `db/schema.sql` — base SQLite schema (`patienten`, `antraege`, `leistungen`, `aufgaben`, `pflegetagebuch`, `einstellungen`, `dokumente`) plus demo seed rows.
+- **Schema evolution pattern**: `init_db()` in `app.py` runs `schema.sql` once, then re-applies a hardcoded list of `ALTER TABLE` / `CREATE TABLE IF NOT EXISTS` statements on every startup, each wrapped in its own try/except so an already-applied migration is silently skipped. When adding a column or table, add a new entry to that list rather than editing `schema.sql` (existing DBs won't be recreated) — and keep entries idempotent/backward-compatible since this list re-runs on every process start.
+- **Auth**: session-cookie based. `_get_current_user()` / `_check_admin()` read `session["nutzer_id"]`; `login_required` / `admin_required` decorators guard individual routes, while `global_auth_check()` (a Flask `before_request` hook) blanket-blocks any `/api/*` path not in the small public allowlist (`/api/auth/login`, `/api/auth/me`, `/api/einstellungen/public`). Two roles exist: `admin` and `nutzer`. Passwords are hashed with `werkzeug.security` (PBKDF2).
+- **File storage**: everything is local under `static/` — `static/fotos/<patient_id>.<ext>` (profile photos), `static/briefe/<patient_id>/…` (generated letter PDFs), `static/dokumente/<patient_id>/…` (uploaded documents), `static/logo/` (company branding). No object storage/CDN involved.
+- **Settings**: a generic key-value `einstellungen` table (accessed via `get_setting()`) holds SMTP credentials, company branding/address, and an (unused-in-current-flow) Claude API token — surfaced through `/api/admin/einstellungen`.
+
+## Planned architecture pivot (see `refactoring.md`)
+
+The app currently runs as a **central multi-patient service**: any logged-in user can see all patients. The product owner has specified a pivot to:
+
+1. **Per-account patient isolation** — a logged-in user (a family member/informal caregiver) should only ever see their own 1–3 patients, with no way to browse or discover other patients. This is a real authorization boundary to add to every `/api/patienten*` (and related) route, not just a UI filter.
+2. **No-AI interview flow** — a plain web-form "interview" for onboarding a new patient, aimed at non-technical relatives, replacing/supplementing the current `pgNeu()` single-form patient creation.
+3. **Admin dashboard** — for the operator: lock/delete accounts, and export archived patient data under lawful (attorney/court) order, with GDPR (DSGVO) compliance as a hard requirement — this affects both the operator's own liability and every caregiver's/patient's rights.
+
+The user has explicitly asked to be asked clarifying questions about architecture, data model, and server structure before this refactor is implemented — don't assume a specific multi-tenancy design (e.g. per-user `nutzer_id` foreign key on `patienten` vs. a separate `familien`/account entity) without confirming it first.
+
+## Known constraints worth knowing before touching auth/security-sensitive code
+
+- `app.secret_key` in `app.py` is a hardcoded string, not loaded from an environment variable.
+- The default admin account (`admin`/`admin`) is created automatically and nothing forces a password change.
+- These are pre-existing conditions in the current alpha, relevant context if working on the auth/admin-dashboard parts of the refactor above.
diff --git a/Leistungen.md b/Leistungen.md
new file mode 100644
index 0000000..8ea1672
--- /dev/null
+++ b/Leistungen.md
@@ -0,0 +1,53 @@
+# Welche Hilfen und Gelder gibt es? (Leistungen) 💰
+
+Hier listen wir auf, was man von der Kasse bekommen kann. Es gibt zwei "Töpfe", aus denen Geld kommen kann: die **Krankenkasse** (für Medizin) und die **Pflegekasse** (für den Alltag).
+
+---
+
+## 1. Gesetzlich oder Privat – was ist der Unterschied? 🏥
+
+*   **Gesetzlich versichert (GKV):** Die meisten Menschen sind hier. Die Kasse bezahlt die Rechnungen oft direkt (z. B. beim Arzt oder Pflegedienst).
+*   **Privat versichert (PKV):** Hier bekommt man oft erst eine Rechnung, bezahlt sie selbst und holt sich das Geld dann von der Versicherung zurück.
+*   **Wichtig:** Die Leistungen für die Pflege sind bei beiden fast gleich! Niemand wird im Regen stehen gelassen.
+
+---
+
+## 2. Geld und Hilfe von der Pflegekasse 👵👴
+Das bekommst du, wenn du einen **Pflegegrad** (Stufe 1 bis 5) hast:
+
+### A. Geld für die Tasche (Pflegegeld)
+Wenn Angehörige oder Freunde die Pflege zu Hause machen, überweist die Kasse monatlich Geld direkt auf dein Konto. Du kannst damit machen, was du willst (z. B. den Helfern eine Freude machen).
+
+### B. Profi-Hilfe zu Hause (Pflegesachleistung)
+Wenn ein professioneller Pflegedienst kommt (zum Waschen oder Anziehen), bezahlt die Kasse diesen Dienst bis zu einem bestimmten Betrag.
+
+### C. Der "Gutschein" für Hilfe (Entlastungsbetrag)
+Jeder (ab Pflegegrad 1) bekommt **125 € im Monat**. Das ist wie ein Gutschein. Damit kann man jemanden bezahlen, der beim Putzen hilft, einkaufen geht oder einfach mal Zeit mit der Person verbringt.
+
+### D. Wenn die Helfer Urlaub brauchen (Verhinderungspflege)
+Wenn die Person, die normalerweise hilft, krank ist oder Urlaub macht, bezahlt die Kasse für ein paar Wochen eine Ersatz-Hilfe.
+
+### E. Mal woanders schlafen (Kurzzeitpflege)
+Wenn es zu Hause gar nicht mehr geht (z. B. nach dem Krankenhaus), kann man für kurze Zeit in ein Pflegeheim gehen. Die Kasse übernimmt einen großen Teil der Kosten.
+
+### F. Hilfe für die Wohnung (Wohnumfeldverbesserung)
+Wenn das Bad umgebaut werden muss (z. B. eine Dusche statt einer Wanne), gibt die Kasse bis zu **4.000 €** dazu.
+
+### G. Kleine Helfer (Pflegehilfsmittel)
+*   **Verbrauchssachen:** Man bekommt **40 € im Monat** für Dinge wie Einmalhandschuhe, Desinfektionsmittel oder Betteinlagen.
+*   **Technik:** Dinge wie ein Pflegebett oder ein Hausnotruf (der rote Knopf am Handgelenk) werden auch bezahlt oder geliehen.
+
+---
+
+## 3. Hilfe von der Krankenkasse 🩺
+Das gibt es auch ohne Pflegegrad, wenn ein Arzt es aufschreibt:
+
+*   **Medizinische Hilfe zu Hause:** Wenn jemand kommen muss, um Spritzen zu geben oder Verbände zu wechseln.
+*   **Haushaltshilfe:** Wenn man wegen einer Krankheit (oder nach einer OP) den Haushalt nicht alleine schafft.
+
+---
+
+## 4. Zusammenfassung für unseren "Pflegepiloten" 🤖
+Unsere KI muss den Usern helfen, das Maximum herauszuholen. Viele wissen zum Beispiel gar nichts von den 125 € (Punkt C) oder den 40 € für Handschuhe (Punkt G). 
+
+**Nächster Schritt:** Wir könnten eine Checkliste machen: "Hast du schon deine 125 € für diesen Monat genutzt?"
diff --git a/Leistungen2.md b/Leistungen2.md
new file mode 100644
index 0000000..48e0620
--- /dev/null
+++ b/Leistungen2.md
@@ -0,0 +1,86 @@
+# Komplette Liste aller Leistungen (Input für Pflegepilot) 📋
+
+Diese Liste enthält alle erdenkbaren Leistungen der Krankenkasse und Pflegekasse in Deutschland.
+
+---
+
+## 1. Leistungen der PFLEGEKASSE (Bei Pflegegrad 1-5)
+
+### Geld-Leistungen (Direkt aufs Konto)
+- **Pflegegeld:** Für Pflege durch Angehörige (Betrag steigt je nach Pflegegrad).
+- **Pflegeunterstützungsgeld:** Lohnersatz, wenn man kurzfristig (bis 10 Tage) die Pflege eines Angehörigen organisieren muss.
+- **Entlastungsbetrag (125 € / ab 2025: 131 €):** Monatliches Budget für Haushaltshilfe, Alltagsbegleiter oder Einkaufshilfe.
+
+### Sach-Leistungen (Profi-Hilfe)
+- **Pflegesachleistungen:** Budget für den ambulanten Pflegedienst (Waschen, Pflegen).
+- **Tages- und Nachtpflege:** Kosten für die Betreuung in einer Einrichtung tagsüber oder nachts.
+- **Vollstationäre Pflege:** Zuschuss zu den Kosten im Pflegeheim.
+- **Leistungszuschlag Pflegeheim:** Die Kasse zahlt extra dazu, je länger man im Heim wohnt (15% bis 75% Rabatt auf den Eigenanteil).
+
+### Flexi-Budgets (Ersatz-Pflege)
+- **Verhinderungspflege:** Geld für Ersatzkräfte, wenn die Hauptpflegeperson Urlaub macht oder krank ist.
+- **Kurzzeitpflege:** Vorübergehende Unterbringung im Heim (z. B. nach Krankenhausaufenthalt).
+- **Gemeinsamer Jahresbetrag (ab Juli 2025):** Zusammenfassung von Verhinderungs- und Kurzzeitpflege zu einem großen Topf (3.539 €).
+
+### Hilfsmittel & Wohnen
+- **Pflegehilfsmittel zum Verbrauch (40 € / ab 2025: 42 €):** Monatlich für Handschuhe, Bettschutzeinlagen, Desinfektion.
+- **Technische Pflegehilfsmittel:** Pflegebetten, Lagerungshilfen, Notrufsysteme (Leihgabe oder Zuschuss).
+- **Wohnumfeldverbesserung (bis 4.000 € / ab 2025: 4.180 €):** Zuschuss für Badumbau, Treppenlift, Türverbreiterung.
+- **Digitale Pflegeanwendungen (DiPA):** Apps, die bei der Pflege helfen (Zuschuss bis 50 € mtl.).
+
+### Sonstiges (Pflegekasse)
+- **Pflegekurse:** Kostenlose Schulungen für Angehörige.
+- **Rentenbeiträge für Pflegende:** Die Pflegekasse zahlt Renten-, Arbeitslosen- und Unfallversicherung für pflegende Angehörige.
+- **Wohngruppen-Zuschlag:** Extra Geld (ca. 214 €), wenn man in einer Pflege-WG lebt.
+
+---
+
+## 2. Leistungen der KRANKENKASSE (Medizinisch notwendig)
+
+### Behandlung & Vorsorge
+- **Ärztliche Behandlung:** Hausarzt, Facharzt, Zahnarzt.
+- **Medikamente:** Übernahme der Kosten (minus gesetzliche Zuzahlung).
+- **Krankenhausbehandlung:** Stationäre Aufenthalte und Operationen.
+- **Vorsorgeuntersuchungen:** Check-ups, Krebsfrüherkennung, Zahn-Vorsorge.
+- **Impfungen:** Alle von der STIKO empfohlenen Impfungen (oft auch Reiseimpfungen als Bonus).
+
+### Therapie & Heilmittel
+- **Physiotherapie / Krankengymnastik:** Auf Rezept.
+- **Ergotherapie:** Hilfe zur Selbstständigkeit im Alltag.
+- **Logopädie:** Sprach- und Sprechtherapie.
+- **Podologie:** Medizinische Fußpflege (besonders bei Diabetes).
+
+### Hilfsmittel (Krankenkasse)
+- **Sehhilfen:** Zuschüsse für Brillen (meist nur für Kinder oder bei Sehbehinderung).
+- **Hörgeräte:** Zuschuss zum Gerät und zur Anpassung.
+- **Prothesen / Orthesen:** Künstliche Gliedmaßen oder Schienen.
+- **Rollstühle / Gehhilfen:** Rollatoren, Rollstühle, Gehböcke.
+- **Kompressionsstrümpfe:** Bei Venenleiden.
+- **CPAP-Geräte:** Schlafapnoe-Masken.
+- **Digitale Gesundheitsanwendungen (DiGA):** "Apps auf Rezept" (z.B. gegen Rückenweh oder Angst).
+
+### Unterstützung im Alltag (Krankenkasse)
+- **Häusliche Krankenpflege (HKP):** Spritzen geben, Verband wechseln durch Pflegedienst (wenn kein Pflegegrad vorliegt).
+- **Haushaltshilfe:** Wenn man wegen Krankheit den Haushalt nicht führen kann (z.B. nach OP oder bei schwerer Krankheit).
+- **Fahrtkosten:** Krankentransport zum Arzt oder Krankenhaus (unter bestimmten Bedingungen).
+- **Krankengeld:** Lohnersatz bei langer Krankheit (nach 6 Wochen Lohnfortzahlung).
+
+### Zähne
+- **Zahnfüllungen:** Jetzt auch hochwertige Alternativen zu Amalgam (kostenfrei).
+- **Zahnersatz:** Festzuschuss für Kronen, Brücken, Prothesen (Bonusheft pflegen!).
+- **Kieferorthopädie:** Spangen für Kinder (bei Erwachsenen nur in schweren Fällen).
+
+---
+
+## 3. Leistungen für PRIVAT VERSICHERTE (PKV)
+
+- **Kostenerstattung:** Man bekommt fast die gleichen Leistungen wie oben, muss aber oft erst die Rechnung einreichen.
+- **Chefarzt / Einbettzimmer:** Je nach Wahltarif im Vertrag enthalten.
+- **Heilpraktiker:** Oft im Vertrag enthalten (anders als bei der GKV).
+- **Pflege-Pflichtversicherung:** Privat Versicherte haben eine eigene Pflegeversicherung, die EXAKT die gleichen Sätze zahlt wie die gesetzliche (z.B. Pflegegeld, 125 € Entlastungsbetrag).
+
+---
+
+## 4. Wichtig für den Pflegepiloten
+- **Kombinationsleistung:** Man kann Pflegegeld und Pflegesachleistung mischen (z. B. 50% Geld, 50% Pflegedienst).
+- **Zuzahlungsbefreiung:** Wenn man mehr als 2% (chronisch Kranke 1%) des Einkommens für Zuzahlungen ausgibt, kann man sich befreien lassen.
diff --git a/Musterbrief.md b/Musterbrief.md
new file mode 100644
index 0000000..ccf92a5
--- /dev/null
+++ b/Musterbrief.md
@@ -0,0 +1,47 @@
+# Muster-Brief: Antrag auf Pflege-Leistungen 📝
+
+Diesen Brief kannst du einfach kopieren. Er ist so geschrieben, dass die Krankenkasse sofort weiß, was zu tun ist. Alles in Klammern **[wie das hier]** musst du mit deinen echten Infos füllen.
+
+---
+
+### Der Brief-Inhalt:
+
+**Absender:**  
+[Dein Vorname und Nachname]  
+[Deine Straße und Hausnummer]  
+[Deine Postleitzahl und dein Wohnort]  
+[Deine Telefonnummer für Rückfragen]
+
+**Datum:** [Heutiges Datum]
+
+**An die:**  
+[Name der Krankenkasse, z. B. AOK Plus]  
+[Straße der Krankenkasse]  
+[Postleitzahl und Ort der Krankenkasse]
+
+
+**Betreff: Antrag auf Leistungen der Pflegekasse**
+
+Sehr geehrte Damen und Herren,
+
+hiermit stelle ich einen Antrag auf Leistungen der Pflegeversicherung für:
+
+**Name der Person:** [Vorname und Nachname der Person, die Hilfe braucht]  
+**Geburtsdatum:** [Wann wurde die Person geboren?]  
+**Versichertennummer:** [Diese Nummer steht auf der Gesundheitskarte der Person]  
+
+Bitte bestätigen Sie mir kurz, dass dieser Brief bei Ihnen angekommen ist. Senden Sie mir danach bitte alle weiteren Formulare zu, die Sie von mir benötigen.
+
+Mit freundlichen Grüßen,
+
+(Unterschrift)
+
+[Dein Vorname und Nachname]
+
+---
+
+### Was du jetzt tun musst:
+1.  **Ausfüllen:** Fülle die Lücken in den Klammern aus.
+2.  **Abschicken:** Per Post (am besten als "Einschreiben", dann hast du einen Beleg) oder per Fax. Manche Kassen nehmen das auch per E-Mail an.
+3.  **Warten:** Die Kasse schickt dir jetzt dicke Formulare zu. Keine Angst, dabei hilft dir später unser "Pflegepilot".
+4.  **Wichtig:** Behalte eine Kopie von dem Brief für deine Unterlagen!
diff --git a/Pflegegrad.md b/Pflegegrad.md
new file mode 100644
index 0000000..11fbca1
--- /dev/null
+++ b/Pflegegrad.md
@@ -0,0 +1,47 @@
+# Thema: Hilfe von der Pflegekasse bekommen (Schritt für Schritt) 📄
+
+**Wichtige Regel für dieses Projekt:** Wir benutzen keine komplizierten Fachwörter oder Abkürzungen. Wenn wir ein Wort benutzen müssen, das man nicht im Alltag verwendet, erklären wir es sofort. So versteht jeder – egal ob Enkel oder Oma – was zu tun ist.
+
+---
+
+## 1. Was ist das überhaupt? 🤔
+Ganz einfach: Wenn jemand Hilfe im Alltag braucht (z. B. beim Waschen, Anziehen oder Kochen), gibt es Geld und Unterstützung vom Staat. Damit man das bekommt, muss man beweisen, dass man Hilfe braucht. Das nennt man "einen Pflegegrad bekommen". Es gibt 5 Stufen: Stufe 1 heißt "ein bisschen Hilfe", Stufe 5 heißt "sehr viel Hilfe".
+
+---
+
+## 2. Der Fahrplan zum Erfolg 🗺️
+
+### Schritt A: Den Stein ins Rollen bringen (Der Antrag)
+Man muss kein langes Formular ausfüllen. Ein einfacher Satz an die Krankenkasse reicht: "Ich brauche Hilfe im Alltag und möchte Leistungen der Pflegekasse beantragen."
+*   **Warum das Datum wichtig ist:** Wenn du heute den Brief abschickst oder anrufst, zählt das Geld ab heute. Wartest du bis zum nächsten Monat, schenkst du der Kasse Geld.
+*   **Was wir tun:** Wir halten fest, an welchem Tag wir die Kasse informiert haben.
+
+### Schritt B: Der Besuch der Prüfer (Das Gutachten)
+Die Krankenkasse schickt jemanden vorbei, der sich alles genau anschaut. Früher hießen die oft "MDK" (Medizinischer Dienst), aber wir nennen sie einfach **die Prüfer**.
+*   **Was die Prüfer machen:** Sie kommen nach Hause und schauen: Kann die Person noch alleine Treppen steigen? Kann sie sich alleine waschen? Vergisst sie wichtige Dinge?
+*   **Vorbereitung ist alles:** Wir schreiben vorher in ein Heft (ein **Pflegetagebuch**), was im Alltag schwierig ist. Zum Beispiel: "Opa hat heute Hilfe beim Schuhebinden gebraucht." Das zeigen wir den Prüfern.
+
+### Schritt C: Der Brief mit der Antwort (Der Bescheid)
+Nach ein paar Wochen schickt die Krankenkasse einen Brief.
+*   **Gute Nachricht:** "Ja, du bekommst Hilfe!" (Pflegegrad genehmigt). Ab jetzt gibt es Geld oder Hilfe vom Pflegedienst.
+*   **Schlechte Nachricht:** "Nein, wir glauben, du brauchst keine Hilfe." (Antrag abgelehnt). 
+*   **Was wir dann tun:** Wir schreiben einen "Beschwerde-Brief" (das nennt man **Widerspruch**). Wir sagen: "Das stimmt nicht, die Person braucht doch Hilfe, schaut bitte nochmal genau hin."
+
+---
+
+## 3. Was unsere KI (der Pflegepilot) lernen muss 🤖
+Damit unsere KI wirklich eine Hilfe ist, muss sie diese Dinge ganz einfach erklären können:
+1.  **Wer ist meine Krankenkasse?** (Und wo schicke ich den Brief hin?)
+2.  **Welche Fragen stellen die Prüfer?** (Damit man keine Angst vor dem Besuch hat).
+3.  **Wie viel Zeit haben die?** (Die Krankenkasse muss normalerweise innerhalb von etwa 5 Wochen antworten).
+
+---
+
+## 4. Unsere nächsten Aufgaben (ToDo-Liste) 📝
+- [ ] Namen der großen Krankenkassen sammeln (damit wir wissen, wohin die Briefe gehen).
+- [ ] Einen ganz einfachen Muster-Brief schreiben (den man nur noch unterschreiben muss).
+- [ ] Eine Liste machen mit Dingen, die man den Prüfern zeigen sollte.
+
+---
+
+**Notiz für uns:** Wir bleiben bei dieser einfachen Sprache. Keine Abkürzungen wie "MDK" mehr ohne Erklärung.
diff --git a/pflegepilot_alpha_v2/pflegepilot/README.md b/pflegepilot_alpha_v2/pflegepilot/README.md
new file mode 100644
index 0000000..b038345
--- /dev/null
+++ b/pflegepilot_alpha_v2/pflegepilot/README.md
@@ -0,0 +1,325 @@
+# Pflegepilot Alpha 🏥
+
+Lokale Web-App zur Verwaltung von Pflegepatienten, Anträgen und Formularen.  
+Alle Daten bleiben **lokal** in einer SQLite-Datenbank – kein Cloud-Zwang.
+
+---
+
+## Schnellstart (3 Schritte)
+
+### Voraussetzungen
+- Python 3.9+ (bereits auf den meisten Systemen)
+- pip
+
+### 1. Abhängigkeiten installieren
+```bash
+pip install flask
+```
+
+> **Login:** Standard-Zugangsdaten nach Erststart: `admin` / `admin`  
+> Bitte im Backend unter **Nutzerverwaltung** sofort ändern.
+
+### 2. App starten
+```bash
+python start.py
+```
+
+### 3. Im Browser öffnen
+```
+http://localhost:5050
+```
+
+---
+
+## Funktionen
+
+| Bereich | Beschreibung |
+|---|---|
+| **Dashboard** | Übersicht Patienten, Anträge, Aufgaben |
+| **Patientenverwaltung** | CRUD mit Stammdaten & Pflegestatus |
+| **Antrag Pflegegrad** | Prozessführung + Pflegetagebuch-Checkliste |
+| **Widerspruch-Generator** | KI-gestützt nach SGB XI & SGG · PDF-Export |
+| **Musterbrief** | Erstantrag Live-Vorschau · PDF-Export |
+| **Leistungsrechner** | Alle Beträge Pflege-/Krankenkasse 2025 |
+| **Leistungskatalog** | 82 Leistungen mit Abhängigkeiten · direkte Patientenzuweisung |
+| **Patientenakte** | Profilfoto hochladen (JPEG/PNG) · direkt in der Akte klicken |
+| **Pflegetagebuch** | Alle 6 SGB XI-Begutachtungsmodule · Verlauf · MDK-Vorbereitung |
+| **Aufgabenverwaltung** | Fristen & Prioritäten |
+
+---
+
+## Widerspruch-Generator – Rechtliche Grundlagen
+
+Der Generator erzeugt Widersprüche nach:
+
+- **§ 15 SGB XI** – Pflegebedürftigkeit und Pflegegrade  
+- **§ 18 SGB XI** – Begutachtungsverfahren (MDK/MDS-Richtlinien)  
+- **§ 37 SGB XI** – Pflegegeld (materieller Schaden)  
+- **§ 84 SGG** – Widerspruchsfrist (1 Monat)  
+- **§ 86 SGG** – Widerspruchsrecht  
+- **§§ 36, 38a SGB XI** – Pflegesachleistungen  
+
+---
+
+## Datenschutz
+
+- Alle Daten lokal in `db/pflegepilot.db` (SQLite)
+- Kein Internetzugang erforderlich (außer KI-Widerspruchsgenerator)
+- Für Produktivbetrieb: Zugangsbeschränkung empfohlen
+
+---
+
+## Projektstruktur
+
+```
+pflegepilot/
+├── start.py              ← Hier starten
+├── app.py                ← Flask Backend + API
+├── katalog.py            ← 82 Leistungen mit Abhängigkeitsdaten
+├── krankenkassen.py      ← ~86 GKV/PKV/SV/KVG (DE, AT, CH) mit korrekten Adressen
+├── db/
+│   ├── schema.sql        ← Datenbankschema + Demo-Daten
+│   └── pflegepilot.db   ← Wird automatisch erstellt
+├── static/
+│   └── fotos/            ← Patientenfotos (JPEG/PNG)
+└── templates/
+    └── index.html        ← Vollständige SPA
+```
+
+---
+
+## Changelog
+
+### Alpha v1.0 (11.05.2026)
+
+**Österreich & Schweiz – Krankenkassen-Stammdaten**
+- `krankenkassen.py` um 26 Einträge für AT und CH erweitert (bisher nur DE)
+- **Österreich (SV)**: ÖGK Hauptstelle + alle 9 Landesstellen (Wien, NÖ, OÖ, Steiermark, Kärnten, Salzburg, Tirol, Vorarlberg, Burgenland), SVS (Selbständige), BVAEB (öffentlich Bedienstete)
+- **Schweiz (KVG)**: Helsana, CSS, SWICA, Sanitas, Concordia, Visana, KPT, Assura, Groupe Mutuel, Atupri, Sympany, EGK, Aquilana, Galenos, Sana24, Kolping
+- Neues Feld `land` (`"DE"` / `"AT"` / `"CH"`) in allen Einträgen – DE-Einträge nutzen `get("land","DE")` für Rückwärtskompatibilität
+- Neue Hilfsfunktionen: `get_by_land(land)`, `search(q, land=None)`, `get_all(land=None)` (optional gefiltert)
+- **API** `GET /api/krankenkassen`: neuer Query-Parameter `?land=AT|CH|DE` für länderspezifische Abfrage
+- **Dropdown im Frontend**: Länder-Tab-Leiste (🇩🇪 DE / 🇦🇹 AT / 🇨🇭 CH / Alle) direkt im Suchfeld-Overlay
+- Typ-Badges: SV (rot, AT) und KVG (amber, CH) ergänzen die bisherigen GKV (grün) / PKV (blau)
+- `getKKAdr()` ergänzt bei AT/CH den Ländercode in der postalischen Adresse
+
+---
+
+### Alpha v0.9 (11.05.2026)
+
+**E-Mail-Versand direkt aus der App**
+- Neuer Backend-Endpoint `POST /api/email/senden` – versendet E-Mail mit optionalem PDF-Anhang via SMTP (`smtplib` + STARTTLS)
+- Neuer Backend-Endpoint `POST /api/email/test` – sendet Test-E-Mail an die konfigurierte Absender-Adresse zur Verbindungsprüfung
+- Hilfsfunktion `_smtp_cfg()` liest SMTP-Einstellungen aus der `einstellungen`-Tabelle
+- Fehlermeldungen differenziert: Authentifizierungsfehler, Verbindungsfehler, fehlende Konfiguration
+- **Widerspruch-Generator**: neuer Button „E-Mail" in der Vorschau (erscheint nach „Widerspruch erstellen")
+- **Musterbrief**: neuer Button „E-Mail" neben PDF und Kopieren
+- `sendMailModal(typ)`: öffnet Modal mit vorausgefülltem Betreff, Empfänger (aus Patientenstammdaten wenn vorhanden), Anschreiben-Textarea und Checkbox „PDF-Anhang beifügen"
+- `sendMail(typ)`: generiert PDF on-the-fly via html2pdf, konvertiert zu Base64, sendet an API – mit Lade-Indikator im Button während des Versands
+- **Backend-Admin → E-Mail**: neuer „Test-E-Mail"-Button prüft SMTP-Konfiguration mit einem Klick
+
+---
+
+### Alpha v0.8 (11.05.2026)
+
+**Login / Mehrbenutzer**
+- Neue Datenbanktabelle `nutzer` (id, benutzername, passwort_hash, name, rolle, aktiv)
+- Passwörter gehasht mit `werkzeug.security` (PBKDF2-SHA256) – keine Klartextspeicherung
+- Standard-Admin `admin/admin` wird automatisch beim Erststart angelegt
+- Login-Overlay zeigt sich beim App-Start, solange kein gültiger Session-Cookie vorliegt
+- `before_request`-Hook schützt alle API-Routen außer `/api/auth/*` und `/api/einstellungen/public`
+- Neue Endpunkte: `POST /api/auth/login`, `POST /api/auth/logout`, `GET /api/auth/me`
+- Rollen: `admin` (vollständiger Zugriff, Backend, Nutzerverwaltung) und `nutzer` (Patientendaten)
+- Sidebar zeigt Anzeigename, Rolle und Abmelden-Button des angemeldeten Nutzers
+- Admin-Bereich in der Sidebar wird für Nutzer ohne Admin-Rolle ausgeblendet
+
+**Nutzerverwaltung (im Backend-Admin)**
+- Neue Endpunkte: `GET/POST /api/nutzer`, `PUT/DELETE /api/nutzer/<uid>`
+- Nutzer anlegen, Rolle ändern, Passwort zurücksetzen, Nutzer deaktivieren/löschen
+- Eigenen Account kann man nicht löschen (serverseitig verhindert)
+- Übersicht aller Nutzer mit Avatar, Anzeigename, Benutzername, Rolle, Status
+
+**Backend-Einstellungen – Firmen-Adresse**
+- Neue Felder: Straße, PLZ, Ort, Telefon, Betriebs-E-Mail
+- Öffentlicher Endpunkt `GET /api/einstellungen/public` gibt Branding-Daten (Name, Logo, Adresse) ohne Auth zurück – wird von `initApp()` genutzt
+- Firmen-Adresse steht in `_einstellungen` und fließt in PDF-Briefköpfe ein
+
+**Dokumenten-Upload – Verbesserungen**
+- Drag-&-Drop-Uploadbereich: Datei ablegen oder klicken zum Auswählen
+- Dateiname und Dateigröße werden direkt nach Auswahl angezeigt
+- Bezeichnung wird automatisch aus dem Dateinamen vorausgefüllt
+- Dokumentenliste: Bildvorschau (JPEG/PNG direkt als Thumbnail), separate Öffnen- und Download-Schaltflächen
+- PDFs mit rotem Icon deutlich gekennzeichnet
+
+---
+
+### Alpha v0.7 (11.05.2026)
+
+**Patiententagebuch – PDF-Export (MDK-fertig)**
+- `dlTB(pid)` exportiert alle Einträge als A4-PDF in Courier-Schrift
+- Deckblatt mit Patientenstammdaten, Versicherung, Pflegegrad und Zeitraum
+- Tabellarische Darstellung aller 6 SGB XI-Begutachtungsmodule (M1–M6) je Datum
+- Automatische Paginierung „Seite X von N" (via `addPageNums`)
+- Korrekte Seitenränder auf allen Seiten (`margin:[20,20,25,25]` mm)
+- Rechtlicher Hinweis: § 630f BGB Aufbewahrungspflicht 10 Jahre
+- Button direkt in der Patientenakte und im Pflegetagebuch-View
+
+**Erinnerungsfunktion für Tagebucheinträge (tägliche Browser-Notification)**
+- Neuer Endpoint `GET /api/tagebuch/reminder-status`: liefert alle aktiven Patienten mit Pflegegrad > 0 und ob heute ein Tagebucheintrag vorliegt
+- `checkTagebuchReminder()` wird bei App-Start und bei jedem Dashboard-Aufruf ausgeführt
+- Browser-Notification (einmal pro Tag, via `Notification API`): listet Patienten ohne heutigen Eintrag auf
+- Dashboard-Banner (gelb/amber): zeigt fehlende Patienten mit Direktlinks zum Tagebuch
+- Badge-Zähler am Navigations-Eintrag „Pflegetagebuch" (analog Aufgaben-Badge)
+- Benachrichtigungserlaubnis kann im Fristen-Kalender aktiviert werden
+
+**Automatische Fristenüberwachung – Tagebuch-Events**
+- `/api/kalender` enthält jetzt einen neuen Event-Typ `tagebuch_erinnerung`
+- Aktive Patienten mit Pflegegrad > 0 ohne heutigen Tagebucheintrag erscheinen im Fristen-Kalender
+- Priorisierung: `hoch` wenn letzter Eintrag ≥ 2 Tage zurückliegt, sonst `mittel`
+- `checkReminders()` berücksichtigt Tagebuch-Events für Browser-Notifications
+- Icon im Kalender: `ti-notebook`
+
+---
+
+### Alpha v0.6 (11.05.2026)
+
+**Widerspruch-Generator – Vollständiger Umbau (kein KI-API-Aufruf mehr)**
+- 30 vordefinierte Widerspruchsgründe nach Rechtsnorm organisiert (`WGRUENDE`-Konstante)
+- Normen: § 18 SGB XI (5), § 15 SGB XI (7), § 14 SGB XI (3), § 37 SGB XI (2), § 36/39/45b/40/43 SGB XI (je 1), § 33/24 SGB X (3), § 18 Abs. 3 SGB XI (2), Verfahrensrecht (3)
+- Auswahl per kollabierbare Checkbox-Gruppen mit Norm-Tag und Gruppenbezeichnung
+- Briefgenerierung vollständig lokal per Template – kein API-Call, kein Internetzugang nötig
+- Struktur: Briefkopf → Betreff → Sachverhalt → Rechtliche Begründung (nach Norm gruppiert) → Beweismittel → Antrag → Grußformel
+- KI-Endpoint `POST /api/widerspruch/generate` bleibt als Stub erhalten (gibt sofort `{"ok": true}`)
+- Neue CSS-Klassen: `.wg-group`, `.wg-group-hd`, `.wg-group-body`, `.wg-item`, `.wg-norm-tag`
+
+**PDF-Export – Korrekte Seitenränder & automatische Paginierung**
+- Alle PDF-Exporte (Musterbrief, Widerspruch, Pflegetagebuch, Patientenakte) verwenden jetzt html2pdf-native `margin`-Array `[25, 20, 28, 25]` mm statt CSS-Padding
+- CSS-Padding auf dem Exportcontainer auf `0` gesetzt – Randabstände gelten jetzt korrekt auf jeder Seite, nicht nur der ersten
+- Neue Hilfsfunktion `addPageNums(pdf)`: schreibt „Seite X von N" zentriert am Seitenfuß (H−9 mm) auf jede Seite
+- Umsetzung über jsPDF-Chain `.toPdf().get('pdf').then(pdf=>{ addPageNums(pdf); ... })` für saubere Trennung von Seitenzahl-Injection, Download und Server-Upload
+
+**Notizen in Patientenakte – Bearbeitung gemäß ISO 9001**
+- Notizen sind jetzt inline bearbeitbar – Klick auf „Bearbeiten" öffnet ein Modal mit vorausgefülltem Textarea und Pflichtfeld „Änderungsgrund"
+- Jede Änderung wird unveränderlich protokolliert: Inhalt vorher, Inhalt nachher, Änderungsgrund, Zeitstempel (ISO 9001:2015 Abschn. 7.5 – Lenkung dokumentierter Informationen)
+- Verlauf-Button (Uhren-Icon) neben „Bearbeiten": zeigt/versteckt den vollständigen Audit-Trail (rot = alter Text, grün = neuer Text)
+- Neue Datenbanktabelle `notizen_verlauf` (Migration automatisch beim Start)
+- Neue API-Endpoints:
+  - `POST /api/patienten/<pid>/notizen` – Notiz speichern + Verlaufseintrag anlegen (400 ohne Änderungsgrund)
+  - `GET /api/patienten/<pid>/notizen/verlauf` – Änderungshistorie abrufen (neueste zuerst)
+- Neue JS-Funktionen: `editNotizen(pid)`, `saveNotizen(pid)`, `loadNotizenVerlauf(pid)`, `escH(s)`
+
+---
+
+### Alpha v0.5.1 (10.05.2026)
+
+**PDF dauerhaft in Patientenakte hinterlegen**
+- PDFs werden jetzt serverseitig in `static/briefe/<patient_id>/` gespeichert
+- Gilt für Musterbrief (`dlM()`) und Widerspruch-Generator (`dlW()`)
+- Ablauf: `html2pdf` erzeugt Blob → Browser-Download → Base64-Upload an Server → Datei gespeichert
+- Neuer Endpoint `POST /api/patienten/<pid>/briefe` akzeptiert jetzt `pdf_base64` + `pdf_dateiname`
+- Neue Spalte `pdf_pfad` in Tabelle `antraege` (Migration automatisch beim Start)
+- Patientenakte: Antraege-Tabelle zeigt neue Spalte **Dokument** mit klickbarem „PDF öffnen"-Link
+- Zweifache Bestätigung per Toast: „PDF heruntergeladen" + „PDF dauerhaft gespeichert"
+
+---
+
+### Alpha v0.5 (10.05.2026)
+
+**Krankenkassen-Stammdaten (neue Datei `krankenkassen.py`)**
+- ~60 Kassen mit vollständigen Adressen: 12 AOK-Regionalverbände, TK, Barmer, DAK, KKH, hkk, HEK, Knappschaft, 4× IKK, 10+ BKK, und 17 PKV-Gesellschaften
+- Separate Einträge für GKV und PKV (Typ-Kennzeichnung)
+- Neuer API-Endpoint `GET /api/krankenkassen` (optional gefiltert per `?q=…`)
+
+**Searchable Dropdown für Krankenkassen**
+- Ersetzte alle bisherigen Dropdowns (8 Einträge) durch ein vollständiges Suchfeld
+- Live-Filterung nach Name, Kurzname und Ort (bis 70 Treffer gleichzeitig)
+- Jeder Eintrag zeigt Name, Ort und Typ-Badge (GKV grün / PKV blau)
+- Auswahl setzt Versicherungsart (GKV/PKV) im Formular automatisch
+
+**Musterbrief – Adresse automatisch aus Stammdaten**
+- KK-Empfänger im Musterbrief nutzt jetzt das Suchfeld
+- Vollständige Postanschrift (Straße + PLZ + Ort) wird automatisch in den Brief eingesetzt
+- Patientenauswahl befüllt Empfänger-Krankenkasse automatisch
+- `[Anschrift der Krankenkasse]` entfällt bei bekannten Kassen
+
+---
+
+### Alpha v0.4 (10.05.2026)
+
+**Patientenakte – Profilfoto**
+- Klick auf den Avatar-Kreis im Stammdaten-Header öffnet einen Datei-Dialog
+- Unterstützte Formate: JPEG, PNG, GIF, WebP
+- Foto wird lokal in `static/fotos/<patient_id>.ext` gespeichert und in der Akte angezeigt
+- Neuer Endpoint `POST /api/patienten/<pid>/foto` (Multipart/Form-Data)
+- Neue Spalte `foto_pfad` in Tabelle `patienten` (Migration automatisch beim Start)
+
+**Pflegetagebuch nach SGB XI**
+- Vollständige Struktur der 6 Begutachtungsmodule (Begutachtungsinstrument MDK):
+  - **Modul 1** – Mobilität (§ 14 Abs. 2 Nr. 1 SGB XI)
+  - **Modul 2** – Kognition & Kommunikation (§ 14 Abs. 2 Nr. 2/3 SGB XI)
+  - **Modul 4** – Selbstversorgung: Körperpflege, An-/Ausziehen, Ernährung (§ 14 Abs. 2 Nr. 4 SGB XI)
+  - **Modul 5** – Medizinische Anforderungen: Medikamente, Verbände, Injektionen (§ 14 Abs. 2 Nr. 5 SGB XI)
+  - **Modul 6** – Sozialleben & Alltagsgestaltung (§ 14 Abs. 2 Nr. 6 SGB XI)
+- Aufruf direkt aus Patientenakte (Schnellvorschau letzte 2 Einträge) oder über Seitenleiste
+- Einträge chronologisch gelistet, einzeln löschbar
+- Neue Endpoints: `GET /POST /api/patienten/<pid>/tagebuch`, `DELETE /api/tagebuch/<tid>`
+- Bestehende Tabelle `pflegetagebuch` aus Schema wird genutzt (kein Schema-Change)
+
+---
+
+### Alpha v0.3 (10.05.2026)
+
+**PDF-Export**
+- Musterbrief und Widerspruch-Generator exportieren jetzt als **A4-PDF** statt TXT
+- Rendering über `html2pdf.js` (client-seitig) – Umlaute und Sonderzeichen vollständig unterstützt
+- Brief-Layout in Courier-Schrift, druckfertig mit korrekten Seitenrändern
+
+**Leistungskatalog – Abhängigkeiten**
+- 22 von 82 Einträgen haben das neue Feld `abhaengigkeiten`
+- Drei Abhängigkeitstypen werden farblich unterschieden:
+  - **Rot – Voraussetzung**: z. B. alle Merkzeichen erfordern zuerst den Schwerbehindertenausweis
+  - **Blau – Gut kombinierbar**: z. B. Pflegegeld + Rentenbeiträge + ALV + Unfall für pflegende Angehörige
+  - **Orange – Ab 07/2025 ersetzt durch**: Gemeinsamer Jahresbetrag ersetzt Verhinderungs- und Kurzzeitpflege
+- Klick auf eine Abhängigkeit öffnet direkt deren Detailansicht
+
+**Leistungskatalog – Patientenzuweisung**
+- Leistungen lassen sich direkt aus dem Katalog einem Patienten zuweisen
+- Im Patientendetail öffnet „Alle Leistungen prüfen" den Katalog im Patienten-Kontext: alle Karten zeigen einen „Zuweisen"-Button
+- Beim Klick auf eine Katalog-Karte erscheint im Modal „[Patientenname] zuweisen"
+- Zugewiesene Leistungen sind im Patientendetail mit einem Katalog-Icon (📋) gekennzeichnet
+- Doppelzuweisungen werden serverseitig verhindert (HTTP 409)
+- Neue API-Endpoints:
+  - `POST /api/patienten/<pid>/leistungen/katalog` – Katalog-Leistung zuweisen
+  - `POST /api/leistungen/<lid>/deaktivieren` – Leistung deaktivieren
+
+**Datenbank**
+- Tabelle `patienten`: neue Spalte `zielgruppe` (Migration automatisch beim Start)
+- Tabelle `leistungen`: neue Spalte `katalog_id` – Verknüpfung zur Katalog-ID
+
+---
+
+### Alpha v0.3.1 (10.05.2026)
+
+**Bug #1 – Antrag-Formular: Patientendaten nach Auswahl**
+- Nach Auswahl eines Patienten im Dropdown erscheint jetzt eine Infobox mit Name, Zielgruppe, Pflegegrad, Krankenkasse und Anschrift
+- Bei Vorauswahl (Aufruf aus Patientendetail) wird die Infobox automatisch befüllt
+
+**Feature #2 – PDF-Dateiname & digitale Kopie**
+- PDF-Dateiname enthält jetzt Patientennachname, Antragstyp und Datum (z. B. `Huber_Erstantrag_2026-05-10.pdf`)
+- Nach dem PDF-Export wird automatisch eine Kopie des Brieftexts in der Patientenakte gespeichert (neuer Eintrag in der Antragsliste mit Status „PDF erstellt")
+- Gilt für Musterbrief und Widerspruch-Generator
+- Neuer Endpoint `POST /api/patienten/<pid>/briefe`
+
+---
+
+## Nächste Schritte (Beta-Plan)
+
+- [x] Login / Mehrbenutzer (Flask-Login) *(Alpha v0.8)*
+- [x] Dokumenten-Upload (Atteste, Gutachten) *(Alpha v0.8)*
+- [x] E-Mail-Versand direkt aus der App *(Alpha v0.9)*
+- [x] Automatische Fristenüberwachung mittels Kalender und Remindern *(Alpha v0.7)*
+- [x] Erweiterung um österreichische (ÖGK, SVS, BVAEB) und Schweizer Kassen (SWICA, Helsana, Sanitas…) *(Alpha v1.0)*
+- [x] Backend für Individuelle Einstellungen nach Betrieben (API-Token Claude, Mailadressen, Account-Verwaltung, Firmen-Logo) *(Alpha v0.8)*
+- [ ] Lizenz-Model entwickeln und implementieren
+- [x] Patiententagebuch – PDF-Export der Verlaufsdokumentation für MDK-Termin *(Alpha v0.7)*
+- [x] Erinnerungsfunktion für Tagebucheinträge (tägliche Browser-Notification) *(Alpha v0.7)*
\ No newline at end of file
diff --git a/pflegepilot_alpha_v2/pflegepilot/app.py b/pflegepilot_alpha_v2/pflegepilot/app.py
new file mode 100644
index 0000000..f4eed9d
--- /dev/null
+++ b/pflegepilot_alpha_v2/pflegepilot/app.py
@@ -0,0 +1,1050 @@
+"""
+Pflegepilot Alpha – Flask + SQLite Web-App
+Vollständig mit 82-Leistungen-Katalog integriert
+"""
+import sqlite3, os, json, re, base64, urllib.request, urllib.error, time, functools
+import smtplib
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from email.mime.base import MIMEBase
+from email import encoders
+from datetime import datetime, date, timedelta
+from flask import Flask, render_template, request, jsonify, g, session
+from werkzeug.security import generate_password_hash, check_password_hash
+from katalog import (KATALOG, get_all, get_by_zielgruppe, get_by_pflegegrad,
+                     get_by_kategorie, get_kategorien, search, get_by_id,
+                     get_widerspruch_paragraphen)
+from krankenkassen import KRANKENKASSEN, get_by_name as kk_by_name, get_by_land as kk_by_land
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DB_PATH  = os.path.join(BASE_DIR, "db", "pflegepilot.db")
+
+app = Flask(__name__)
+app.secret_key = "pflegepilot-alpha-2025"
+
+# ─── DB helpers ──────────────────────────────────────────────────────────────
+def get_db():
+    if "db" not in g:
+        g.db = sqlite3.connect(DB_PATH, detect_types=sqlite3.PARSE_DECLTYPES)
+        g.db.row_factory = sqlite3.Row
+        g.db.execute("PRAGMA foreign_keys = ON")
+    return g.db
+
+@app.teardown_appcontext
+def close_db(e=None):
+    db = g.pop("db", None)
+    if db: db.close()
+
+def init_db():
+    os.makedirs(os.path.join(BASE_DIR, "db"), exist_ok=True)
+    os.makedirs(os.path.join(BASE_DIR, "static", "fotos"), exist_ok=True)
+    os.makedirs(os.path.join(BASE_DIR, "static", "briefe"), exist_ok=True)
+    os.makedirs(os.path.join(BASE_DIR, "static", "logo"), exist_ok=True)
+    os.makedirs(os.path.join(BASE_DIR, "static", "dokumente"), exist_ok=True)
+    with app.app_context():
+        db = get_db()
+        with open(os.path.join(BASE_DIR, "db", "schema.sql")) as f:
+            db.executescript(f.read())
+        # Migrations für bestehende Datenbanken
+        for sql in [
+            "ALTER TABLE patienten ADD COLUMN zielgruppe TEXT DEFAULT 'alterspflege'",
+            "ALTER TABLE leistungen ADD COLUMN katalog_id TEXT",
+            "ALTER TABLE patienten ADD COLUMN foto_pfad TEXT",
+            "ALTER TABLE antraege ADD COLUMN pdf_pfad TEXT",
+            """CREATE TABLE IF NOT EXISTS einstellungen (
+                schluessel TEXT PRIMARY KEY,
+                wert TEXT
+            )""",
+            "ALTER TABLE patienten ADD COLUMN patient_status TEXT DEFAULT 'aktiv'",
+            "ALTER TABLE patienten ADD COLUMN status_datum TEXT",
+            "ALTER TABLE patienten ADD COLUMN archiv_frist TEXT",
+            "ALTER TABLE patienten ADD COLUMN archiv_hinweis TEXT",
+            """CREATE TABLE IF NOT EXISTS dokumente (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                patient_id INTEGER NOT NULL REFERENCES patienten(id) ON DELETE CASCADE,
+                typ TEXT NOT NULL DEFAULT 'sonstiges',
+                bezeichnung TEXT NOT NULL,
+                dateiname TEXT NOT NULL,
+                pfad TEXT NOT NULL,
+                datum TEXT,
+                notizen TEXT,
+                erstellt_am TEXT DEFAULT (datetime('now','localtime'))
+            )""",
+            """CREATE TABLE IF NOT EXISTS notizen_verlauf (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                patient_id INTEGER NOT NULL REFERENCES patienten(id) ON DELETE CASCADE,
+                notizen_alt TEXT,
+                notizen_neu TEXT NOT NULL,
+                aenderungsgrund TEXT NOT NULL,
+                geaendert_von TEXT DEFAULT 'Nutzer',
+                geaendert_am TEXT DEFAULT (datetime('now','localtime'))
+            )""",
+            """CREATE TABLE IF NOT EXISTS nutzer (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                benutzername TEXT UNIQUE NOT NULL,
+                passwort_hash TEXT NOT NULL,
+                name TEXT,
+                rolle TEXT DEFAULT 'nutzer',
+                aktiv INTEGER DEFAULT 1,
+                erstellt_am TEXT DEFAULT (datetime('now','localtime'))
+            )""",
+        ]:
+            try:
+                db.execute(sql)
+                db.commit()
+            except Exception:
+                pass
+        # Default-Admin anlegen wenn keine Nutzer vorhanden
+        if not db.execute("SELECT id FROM nutzer LIMIT 1").fetchone():
+            db.execute(
+                "INSERT INTO nutzer (benutzername, passwort_hash, name, rolle) VALUES (?,?,?,?)",
+                ("admin", generate_password_hash("admin"), "Administrator", "admin")
+            )
+            db.commit()
+
+# ─── Settings helper ─────────────────────────────────────────────────────────
+def get_setting(key, default=None):
+    try:
+        db = get_db()
+        row = db.execute("SELECT wert FROM einstellungen WHERE schluessel=?", (key,)).fetchone()
+        return row[0] if row else default
+    except Exception:
+        return default
+
+def _get_current_user():
+    uid = session.get("nutzer_id")
+    if not uid:
+        return None
+    try:
+        return get_db().execute(
+            "SELECT id, benutzername, name, rolle FROM nutzer WHERE id=? AND aktiv=1", (uid,)
+        ).fetchone()
+    except Exception:
+        return None
+
+def _check_admin():
+    u = _get_current_user()
+    return u is not None and u["rolle"] == "admin"
+
+def login_required(f):
+    @functools.wraps(f)
+    def decorated(*args, **kwargs):
+        if not _get_current_user():
+            return jsonify({"error": "Nicht angemeldet"}), 401
+        return f(*args, **kwargs)
+    return decorated
+
+def admin_required(f):
+    @functools.wraps(f)
+    def decorated(*args, **kwargs):
+        if not _check_admin():
+            return jsonify({"error": "Kein Zugriff"}), 403
+        return f(*args, **kwargs)
+    return decorated
+
+@app.before_request
+def global_auth_check():
+    # Immer erlaubt: Hauptseite, statische Dateien, Auth-Endpunkte, öffentliche Einstellungen
+    path = request.path
+    if not path.startswith("/api/"):
+        return None
+    public = {"/api/auth/login", "/api/auth/me", "/api/einstellungen/public"}
+    if path in public:
+        return None
+    if not _get_current_user():
+        return jsonify({"error": "Nicht angemeldet"}), 401
+
+# ─── API: Öffentliche Einstellungen (Branding) ───────────────────────────────
+@app.route("/api/einstellungen/public", methods=["GET"])
+def api_einstellungen_public():
+    db = get_db()
+    rows = db.execute("SELECT schluessel, wert FROM einstellungen").fetchall()
+    s = {r["schluessel"]: r["wert"] for r in rows}
+    result = {}
+    for key in ("firmenname", "firmen_logo", "firmen_strasse", "firmen_plz",
+                "firmen_ort", "firmen_tel"):
+        if s.get(key):
+            result[key] = s[key]
+    if s.get("firmen_logo"):
+        result["firmen_logo_url"] = "/static/logo/" + s["firmen_logo"]
+    return jsonify(result)
+
+# ─── API: Authentifizierung ───────────────────────────────────────────────────
+@app.route("/api/auth/me", methods=["GET"])
+def api_auth_me():
+    u = _get_current_user()
+    if not u:
+        return jsonify({"error": "Nicht angemeldet"}), 401
+    return jsonify({"id": u["id"], "benutzername": u["benutzername"],
+                    "name": u["name"] or u["benutzername"], "rolle": u["rolle"]})
+
+@app.route("/api/auth/login", methods=["POST"])
+def api_auth_login():
+    d = request.json or {}
+    benutzername = d.get("benutzername", "").strip()
+    passwort     = d.get("passwort", "")
+    db = get_db()
+    u = db.execute("SELECT * FROM nutzer WHERE benutzername=? AND aktiv=1",
+                   (benutzername,)).fetchone()
+    if not u or not check_password_hash(u["passwort_hash"], passwort):
+        return jsonify({"error": "Ungültige Zugangsdaten"}), 401
+    session["nutzer_id"] = u["id"]
+    return jsonify({"ok": True, "name": u["name"] or u["benutzername"], "rolle": u["rolle"]})
+
+@app.route("/api/auth/logout", methods=["POST"])
+def api_auth_logout():
+    session.clear()
+    return jsonify({"ok": True})
+
+# ─── API: Nutzerverwaltung (Admin) ────────────────────────────────────────────
+@app.route("/api/nutzer", methods=["GET"])
+@admin_required
+def api_nutzer_list():
+    db = get_db()
+    rows = db.execute(
+        "SELECT id, benutzername, name, rolle, aktiv, erstellt_am FROM nutzer ORDER BY erstellt_am"
+    ).fetchall()
+    return jsonify([dict(r) for r in rows])
+
+@app.route("/api/nutzer", methods=["POST"])
+@admin_required
+def api_nutzer_create():
+    d = request.json or {}
+    benutzername = (d.get("benutzername") or "").strip()
+    passwort     = d.get("passwort", "")
+    if not benutzername or not passwort:
+        return jsonify({"error": "Benutzername und Passwort erforderlich"}), 400
+    db = get_db()
+    try:
+        cur = db.execute(
+            "INSERT INTO nutzer (benutzername, passwort_hash, name, rolle) VALUES (?,?,?,?)",
+            (benutzername, generate_password_hash(passwort),
+             d.get("name", ""), d.get("rolle", "nutzer"))
+        )
+        db.commit()
+        return jsonify({"ok": True, "id": cur.lastrowid})
+    except Exception:
+        return jsonify({"error": "Benutzername bereits vergeben"}), 409
+
+@app.route("/api/nutzer/<int:uid>", methods=["PUT"])
+@admin_required
+def api_nutzer_update(uid):
+    d = request.json or {}
+    db = get_db()
+    if d.get("passwort"):
+        db.execute("UPDATE nutzer SET passwort_hash=? WHERE id=?",
+                   (generate_password_hash(d["passwort"]), uid))
+    db.execute("UPDATE nutzer SET name=?, rolle=?, aktiv=? WHERE id=?",
+               (d.get("name", ""), d.get("rolle", "nutzer"), int(d.get("aktiv", 1)), uid))
+    db.commit()
+    return jsonify({"ok": True})
+
+@app.route("/api/nutzer/<int:uid>", methods=["DELETE"])
+@admin_required
+def api_nutzer_delete(uid):
+    if uid == session.get("nutzer_id"):
+        return jsonify({"error": "Eigenen Account nicht löschbar"}), 400
+    db = get_db()
+    db.execute("DELETE FROM nutzer WHERE id=?", (uid,))
+    db.commit()
+    return jsonify({"ok": True})
+
+# ─── API: Admin / Backend-Einstellungen ──────────────────────────────────────
+@app.route("/api/admin/check", methods=["GET"])
+def api_admin_check():
+    return jsonify({"admin": _check_admin()})
+
+@app.route("/api/admin/logout", methods=["POST"])
+def api_admin_logout():
+    session.clear()
+    return jsonify({"ok": True})
+
+@app.route("/api/admin/einstellungen", methods=["GET"])
+def api_admin_get():
+    if not _check_admin():
+        return jsonify({"error": "Nicht autorisiert"}), 401
+    db = get_db()
+    rows = db.execute("SELECT schluessel, wert FROM einstellungen").fetchall()
+    s = {r["schluessel"]: r["wert"] for r in rows}
+    # Mask API token – show only last 4 chars
+    if s.get("claude_api_token"):
+        tok = s["claude_api_token"]
+        s["claude_api_token"] = "sk-ant-…" + tok[-6:] if len(tok) > 6 else "••••••••"
+        s["claude_api_token_set"] = True
+    # Never expose admin password or login via GET
+    s.pop("admin_password", None)
+    logo = s.get("firmen_logo", "")
+    if logo:
+        s["firmen_logo_url"] = "/static/logo/" + logo
+    return jsonify(s)
+
+@app.route("/api/admin/einstellungen", methods=["PUT"])
+def api_admin_save():
+    if not _check_admin():
+        return jsonify({"error": "Nicht autorisiert"}), 401
+    db = get_db()
+    d = request.json or {}
+    skip = {"firmen_logo"}          # handled by file upload
+    for key, val in d.items():
+        if key in skip:
+            continue
+        # Don't overwrite token if user sent masked placeholder
+        if key == "claude_api_token" and val.startswith("sk-ant-…"):
+            continue
+        db.execute(
+            "INSERT OR REPLACE INTO einstellungen (schluessel, wert) VALUES (?, ?)",
+            (key, val)
+        )
+    db.commit()
+    # Refresh session if admin password was changed
+    new_pw = d.get("admin_password", "")
+    if new_pw:
+        session["admin_pw"] = new_pw
+    return jsonify({"ok": True})
+
+@app.route("/api/admin/logo", methods=["POST"])
+def api_admin_logo():
+    if not _check_admin():
+        return jsonify({"error": "Nicht autorisiert"}), 401
+    if "logo" not in request.files:
+        return jsonify({"error": "Keine Datei"}), 400
+    file = request.files["logo"]
+    ext = os.path.splitext(file.filename)[1].lower()
+    if ext not in [".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg"]:
+        return jsonify({"error": "Ungültiges Format"}), 400
+    logo_dir = os.path.join(BASE_DIR, "static", "logo")
+    os.makedirs(logo_dir, exist_ok=True)
+    filename = f"firmenlogo{ext}"
+    file.save(os.path.join(logo_dir, filename))
+    db = get_db()
+    db.execute(
+        "INSERT OR REPLACE INTO einstellungen (schluessel, wert) VALUES (?, ?)",
+        ("firmen_logo", filename)
+    )
+    db.commit()
+    return jsonify({"ok": True, "logo": filename, "url": "/static/logo/" + filename})
+
+# ─── API: Patienten ──────────────────────────────────────────────────────────
+@app.route("/api/patienten", methods=["GET"])
+def api_patienten():
+    db = get_db()
+    q  = request.args.get("q", "")
+    pg = request.args.get("pflegegrad", "")
+    zg = request.args.get("zielgruppe", "")
+    sql = "SELECT * FROM patienten WHERE 1=1"
+    params = []
+    if q:
+        sql += " AND (vorname||' '||nachname LIKE ? OR krankenkasse LIKE ?)"
+        params += [f"%{q}%", f"%{q}%"]
+    if pg:
+        sql += " AND pflegegrad = ?"
+        params.append(int(pg))
+    if zg:
+        sql += " AND zielgruppe = ?"
+        params.append(zg)
+    sql += " ORDER BY nachname, vorname"
+    rows = db.execute(sql, params).fetchall()
+    return jsonify([dict(r) for r in rows])
+
+@app.route("/api/patienten/<int:pid>", methods=["GET"])
+def api_patient(pid):
+    db = get_db()
+    p = db.execute("SELECT * FROM patienten WHERE id=?", (pid,)).fetchone()
+    if not p: return jsonify({"error": "Nicht gefunden"}), 404
+    antraege   = db.execute("SELECT * FROM antraege WHERE patient_id=? ORDER BY erstellt_am DESC", (pid,)).fetchall()
+    leistungen = db.execute("SELECT * FROM leistungen WHERE patient_id=? AND aktiv=1", (pid,)).fetchall()
+    aufgaben   = db.execute("SELECT * FROM aufgaben WHERE patient_id=? AND erledigt=0 ORDER BY faellig_am", (pid,)).fetchall()
+    pd = dict(p)
+    # Empfohlene Leistungen aus Katalog
+    grad = pd.get("pflegegrad", 0) or 0
+    zg   = pd.get("zielgruppe", "alterspflege") or "alterspflege"
+    empfohlen = [l for l in KATALOG
+                 if zg in l.get("zielgruppe", [])
+                 and l.get("pflegegrad_min", 0) <= grad <= l.get("pflegegrad_max", 5)]
+    return jsonify({
+        "patient": pd,
+        "antraege": [dict(a) for a in antraege],
+        "leistungen": [dict(l) for l in leistungen],
+        "aufgaben": [dict(a) for a in aufgaben],
+        "empfohlene_leistungen": empfohlen[:15],
+    })
+
+@app.route("/api/patienten", methods=["POST"])
+def api_neuer_patient():
+    db = get_db()
+    d  = request.json
+    cur = db.execute("""
+        INSERT INTO patienten (vorname,nachname,geburtsdatum,strasse,plz,ort,
+            telefon,email,krankenkasse,versichertennummer,versicherungsart,
+            pflegegrad,pflegeperson,zielgruppe,notizen)
+        VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+    """, (d["vorname"], d["nachname"], d.get("geburtsdatum",""),
+          d.get("strasse",""), d.get("plz",""), d.get("ort",""),
+          d.get("telefon",""), d.get("email",""), d.get("krankenkasse",""),
+          d.get("versichertennummer",""), d.get("versicherungsart","GKV"),
+          int(d.get("pflegegrad",0)), d.get("pflegeperson",""),
+          d.get("zielgruppe","alterspflege"), d.get("notizen","")))
+    db.commit()
+    return jsonify({"id": cur.lastrowid, "ok": True})
+
+@app.route("/api/patienten/<int:pid>", methods=["PUT"])
+def api_update_patient(pid):
+    db = get_db()
+    d  = request.json
+    db.execute("""
+        UPDATE patienten SET vorname=?,nachname=?,geburtsdatum=?,strasse=?,plz=?,ort=?,
+            telefon=?,email=?,krankenkasse=?,versichertennummer=?,versicherungsart=?,
+            pflegegrad=?,pflegeperson=?,zielgruppe=?,notizen=?,geaendert_am=datetime('now','localtime')
+        WHERE id=?
+    """, (d["vorname"], d["nachname"], d.get("geburtsdatum",""),
+          d.get("strasse",""), d.get("plz",""), d.get("ort",""),
+          d.get("telefon",""), d.get("email",""), d.get("krankenkasse",""),
+          d.get("versichertennummer",""), d.get("versicherungsart","GKV"),
+          int(d.get("pflegegrad",0)), d.get("pflegeperson",""),
+          d.get("zielgruppe","alterspflege"), d.get("notizen",""), pid))
+    db.commit()
+    return jsonify({"ok": True})
+
+@app.route("/api/patienten/<int:pid>", methods=["DELETE"])
+def api_delete_patient(pid):
+    db = get_db()
+    db.execute("DELETE FROM patienten WHERE id=?", (pid,))
+    db.commit()
+    return jsonify({"ok": True})
+
+@app.route("/api/patienten/<int:pid>/notizen", methods=["POST"])
+def api_notizen_aendern(pid):
+    db = get_db()
+    d = request.json
+    neue_notiz = d.get("notizen", "")
+    grund = (d.get("aenderungsgrund") or "").strip()
+    if not grund:
+        return jsonify({"error": "Änderungsgrund erforderlich"}), 400
+    row = db.execute("SELECT notizen FROM patienten WHERE id=?", (pid,)).fetchone()
+    if not row:
+        return jsonify({"error": "Patient nicht gefunden"}), 404
+    alte_notiz = row[0] or ""
+    db.execute("""
+        INSERT INTO notizen_verlauf (patient_id, notizen_alt, notizen_neu, aenderungsgrund)
+        VALUES (?, ?, ?, ?)
+    """, (pid, alte_notiz, neue_notiz, grund))
+    db.execute("UPDATE patienten SET notizen=?, geaendert_am=datetime('now','localtime') WHERE id=?",
+               (neue_notiz, pid))
+    db.commit()
+    return jsonify({"ok": True})
+
+@app.route("/api/patienten/<int:pid>/notizen/verlauf", methods=["GET"])
+def api_notizen_verlauf(pid):
+    db = get_db()
+    rows = db.execute("""
+        SELECT id, notizen_alt, notizen_neu, aenderungsgrund, geaendert_von, geaendert_am
+        FROM notizen_verlauf WHERE patient_id=? ORDER BY geaendert_am DESC
+    """, (pid,)).fetchall()
+    return jsonify([dict(r) for r in rows])
+
+# ─── API: Anträge ─────────────────────────────────────────────────────────────
+@app.route("/api/antraege", methods=["POST"])
+def api_neuer_antrag():
+    db = get_db()
+    d  = request.json
+    cur = db.execute("""
+        INSERT INTO antraege (patient_id,typ,status,antragsdatum,beantragter_pflegegrad,
+            notizen,brief_text,leistung_ids)
+        VALUES (?,?,?,?,?,?,?,?)
+    """, (d["patient_id"], d.get("typ","erstantrag"), d.get("status","offen"),
+          d.get("antragsdatum",""), d.get("beantragter_pflegegrad",0),
+          d.get("notizen",""), d.get("brief_text",""),
+          json.dumps(d.get("leistung_ids",[]))))
+    db.commit()
+    db.execute("""INSERT INTO aufgaben (patient_id,titel,prioritaet,faellig_am,beschreibung)
+        VALUES (?,?,?,?,?)""",
+        (d["patient_id"], f"Antrag verfolgen – {d.get('typ','Antrag')}",
+         "hoch", d.get("antragsdatum",""), "Antrag eingereicht – Eingangsbestätigung abwarten"))
+    db.commit()
+    return jsonify({"id": cur.lastrowid, "ok": True})
+
+@app.route("/api/antraege/<int:aid>", methods=["PUT"])
+def api_update_antrag(aid):
+    db = get_db()
+    d  = request.json
+    db.execute("""
+        UPDATE antraege SET status=?,bescheid_datum=?,zugeteilter_pflegegrad=?,
+            gutachter_termin=?,widerspruch_frist=?,notizen=?,brief_text=?
+        WHERE id=?
+    """, (d.get("status","offen"), d.get("bescheid_datum",""),
+          d.get("zugeteilter_pflegegrad"), d.get("gutachter_termin",""),
+          d.get("widerspruch_frist",""), d.get("notizen",""),
+          d.get("brief_text",""), aid))
+    db.commit()
+    return jsonify({"ok": True})
+
+@app.route("/api/patienten/<int:pid>/pflegegrad", methods=["PATCH"])
+def api_patch_pflegegrad(pid):
+    db = get_db()
+    d = request.json
+    grad = d.get("pflegegrad")
+    if grad is None:
+        return jsonify({"error": "pflegegrad fehlt"}), 400
+    db.execute(
+        "UPDATE patienten SET pflegegrad=?, geaendert_am=datetime('now','localtime') WHERE id=?",
+        (int(grad), pid)
+    )
+    db.commit()
+    return jsonify({"ok": True})
+
+# ─── API: Aufgaben ────────────────────────────────────────────────────────────
+@app.route("/api/aufgaben", methods=["GET"])
+def api_aufgaben():
+    db = get_db()
+    rows = db.execute("""
+        SELECT a.*, p.vorname||' '||p.nachname AS patient_name
+        FROM aufgaben a LEFT JOIN patienten p ON a.patient_id=p.id
+        WHERE a.erledigt=0 ORDER BY a.faellig_am, a.prioritaet
+    """).fetchall()
+    return jsonify([dict(r) for r in rows])
+
+@app.route("/api/aufgaben/<int:aid>/erledigt", methods=["POST"])
+def api_aufgabe_erledigt(aid):
+    db = get_db()
+    db.execute("UPDATE aufgaben SET erledigt=1 WHERE id=?", (aid,))
+    db.commit()
+    return jsonify({"ok": True})
+
+@app.route("/api/aufgaben", methods=["POST"])
+def api_neue_aufgabe():
+    db = get_db()
+    d  = request.json
+    cur = db.execute("""INSERT INTO aufgaben (patient_id,titel,beschreibung,prioritaet,faellig_am)
+        VALUES (?,?,?,?,?)""",
+        (d.get("patient_id"), d["titel"], d.get("beschreibung",""),
+         d.get("prioritaet","normal"), d.get("faellig_am","")))
+    db.commit()
+    return jsonify({"id": cur.lastrowid, "ok": True})
+
+# ─── API: Dashboard ───────────────────────────────────────────────────────────
+@app.route("/api/dashboard", methods=["GET"])
+def api_dashboard():
+    db = get_db()
+    stats = {
+        "patienten":       db.execute("SELECT COUNT(*) FROM patienten").fetchone()[0],
+        "offene_antraege": db.execute("SELECT COUNT(*) FROM antraege WHERE status IN ('offen','in_pruefung')").fetchone()[0],
+        "bescheide":       db.execute("SELECT COUNT(*) FROM antraege WHERE status='in_pruefung'").fetchone()[0],
+        "widersprueche":   db.execute("SELECT COUNT(*) FROM antraege WHERE typ='widerspruch'").fetchone()[0],
+        "offene_aufgaben": db.execute("SELECT COUNT(*) FROM aufgaben WHERE erledigt=0").fetchone()[0],
+        "katalog_gesamt":  len(KATALOG),
+    }
+    recent = db.execute("""
+        SELECT p.id, p.vorname, p.nachname, p.pflegegrad, p.zielgruppe,
+               a.status, a.typ
+        FROM patienten p
+        LEFT JOIN antraege a ON a.id=(SELECT id FROM antraege WHERE patient_id=p.id ORDER BY erstellt_am DESC LIMIT 1)
+        ORDER BY p.geaendert_am DESC LIMIT 5
+    """).fetchall()
+    aufgaben = db.execute("""
+        SELECT a.*, p.vorname||' '||p.nachname AS patient_name
+        FROM aufgaben a LEFT JOIN patienten p ON a.patient_id=p.id
+        WHERE a.erledigt=0 ORDER BY a.faellig_am LIMIT 5
+    """).fetchall()
+    return jsonify({
+        "stats": stats,
+        "recent": [dict(r) for r in recent],
+        "aufgaben": [dict(a) for a in aufgaben],
+    })
+
+# ─── API: Leistungskatalog ────────────────────────────────────────────────────
+@app.route("/api/katalog", methods=["GET"])
+def api_katalog():
+    zg   = request.args.get("zielgruppe","")
+    grad = request.args.get("pflegegrad","")
+    kat  = request.args.get("kategorie","")
+    q    = request.args.get("q","")
+    data = KATALOG
+    if zg:   data = [l for l in data if zg in l.get("zielgruppe",[])]
+    if grad: data = [l for l in data if l.get("pflegegrad_min",0) <= int(grad) <= l.get("pflegegrad_max",5)]
+    if kat:  data = [l for l in data if l["kategorie"] == kat]
+    if q:    data = search(q) if not (zg or grad or kat) else [l for l in data if q.lower() in l["name"].lower() or q.lower() in l["kurz"].lower()]
+    return jsonify({"items": data, "total": len(data), "kategorien": get_kategorien()})
+
+@app.route("/api/katalog/<lid>", methods=["GET"])
+def api_katalog_item(lid):
+    item = get_by_id(lid)
+    if not item: return jsonify({"error":"Nicht gefunden"}), 404
+    return jsonify(item)
+
+@app.route("/api/katalog/patient/<int:pid>", methods=["GET"])
+def api_katalog_patient(pid):
+    """Alle passenden Leistungen für einen Patienten"""
+    db = get_db()
+    p = db.execute("SELECT * FROM patienten WHERE id=?", (pid,)).fetchone()
+    if not p: return jsonify({"error":"Nicht gefunden"}), 404
+    pd = dict(p)
+    grad = pd.get("pflegegrad",0) or 0
+    zg   = pd.get("zielgruppe","alterspflege") or "alterspflege"
+    data = [l for l in KATALOG
+            if zg in l.get("zielgruppe",[])
+            and l.get("pflegegrad_min",0) <= grad <= l.get("pflegegrad_max",5)]
+    by_kat = {}
+    for l in data:
+        k = l["kategorie"]
+        by_kat.setdefault(k, []).append(l)
+    return jsonify({"patient": pd, "by_kategorie": by_kat, "total": len(data)})
+
+# ─── API: Katalog-Leistung einem Patienten zuweisen ──────────────────────────
+@app.route("/api/patienten/<int:pid>/leistungen/katalog", methods=["POST"])
+def api_assign_katalog(pid):
+    db = get_db()
+    d = request.json
+    lid = d.get("katalog_id", "")
+    item = get_by_id(lid)
+    if not item:
+        return jsonify({"error": "Leistung nicht gefunden"}), 404
+    existing = db.execute(
+        "SELECT id FROM leistungen WHERE patient_id=? AND katalog_id=? AND aktiv=1",
+        (pid, lid)
+    ).fetchone()
+    if existing:
+        return jsonify({"error": "Leistung bereits zugewiesen", "already": True}), 409
+    # Numerischen Betrag extrahieren (erster Wert im Betrag-String)
+    betrag_str = item.get("betrag", "")
+    betrag = None
+    m = re.search(r'(\d[\d.]*)', betrag_str)
+    if m:
+        try:
+            betrag = float(m.group(1).replace(".", ""))
+        except Exception:
+            pass
+    db.execute("""
+        INSERT INTO leistungen (patient_id, typ, bezeichnung, betrag, einheit, aktiv, seit, katalog_id, notizen)
+        VALUES (?, ?, ?, ?, 'monatlich', 1, date('now','localtime'), ?, ?)
+    """, (pid, item["kategorie"], item["name"], betrag, lid, betrag_str))
+    db.commit()
+    return jsonify({"ok": True})
+
+@app.route("/api/leistungen/<int:lid>/deaktivieren", methods=["POST"])
+def api_leistung_deaktivieren(lid):
+    db = get_db()
+    db.execute("UPDATE leistungen SET aktiv=0 WHERE id=?", (lid,))
+    db.commit()
+    return jsonify({"ok": True})
+
+# ─── API: Widerspruch ─────────────────────────────────────────────────────────
+@app.route("/api/widerspruch/generate", methods=["POST"])
+def api_widerspruch():
+    return jsonify({"ok": True})
+
+# ─── API: Brief in Patientenakte speichern ───────────────────────────────────
+@app.route("/api/patienten/<int:pid>/briefe", methods=["POST"])
+def api_brief_speichern(pid):
+    db = get_db()
+    d = request.json
+    typ = d.get("typ", "musterbrief")
+    notizen = d.get("notizen", "")
+    brief_text = d.get("brief_text", "")
+    pdf_base64 = d.get("pdf_base64", "")
+    pdf_dateiname = d.get("pdf_dateiname", "")
+    pdf_pfad = None
+    if pdf_base64 and pdf_dateiname:
+        safe_name = re.sub(r'[^\w\-.]', '_', pdf_dateiname)
+        briefe_dir = os.path.join(BASE_DIR, "static", "briefe", str(pid))
+        os.makedirs(briefe_dir, exist_ok=True)
+        with open(os.path.join(briefe_dir, safe_name), 'wb') as fh:
+            fh.write(base64.b64decode(pdf_base64))
+        pdf_pfad = f"briefe/{pid}/{safe_name}"
+    cur = db.execute("""
+        INSERT INTO antraege (patient_id, typ, status, antragsdatum, notizen, brief_text, pdf_pfad)
+        VALUES (?, ?, 'erstellt', date('now','localtime'), ?, ?, ?)
+    """, (pid, typ, notizen, brief_text, pdf_pfad))
+    db.commit()
+    return jsonify({"id": cur.lastrowid, "ok": True, "pdf_pfad": pdf_pfad})
+
+# ─── API: Leistungsrechner ────────────────────────────────────────────────────
+@app.route("/api/leistungen/berechnen", methods=["POST"])
+def api_leistungen_berechnen():
+    d = request.json
+    grad = int(d.get("pflegegrad", 0))
+    zg   = d.get("zielgruppe", "alterspflege")
+    relevant = [l for l in KATALOG
+                if zg in l.get("zielgruppe",[])
+                and l.get("pflegegrad_min",0) <= grad <= l.get("pflegegrad_max",5)]
+    tabelle = {
+        0:{"pflegegeld":0,"sachleistung":0},
+        1:{"pflegegeld":0,"sachleistung":0},
+        2:{"pflegegeld":332,"sachleistung":761},
+        3:{"pflegegeld":573,"sachleistung":1432},
+        4:{"pflegegeld":765,"sachleistung":1778},
+        5:{"pflegegeld":947,"sachleistung":2200},
+    }
+    w = tabelle.get(grad, tabelle[0])
+    return jsonify({
+        "pflegegrad": grad,
+        "pflegegeld": w["pflegegeld"],
+        "sachleistung": w["sachleistung"],
+        "entlastungsbetrag": 131 if grad >= 1 else 0,
+        "hilfsmittel": 42 if grad >= 1 else 0,
+        "verhinderungspflege": 1612 if grad >= 2 else 0,
+        "kurzzeitpflege": 1774 if grad >= 2 else 0,
+        "wohnumfeld": 4180 if grad >= 1 else 0,
+        "relevant_count": len(relevant),
+        "relevant": relevant[:10],
+    })
+
+# ─── API: Krankenkassen ──────────────────────────────────────────────────────
+@app.route("/api/krankenkassen", methods=["GET"])
+def api_krankenkassen():
+    q    = request.args.get("q", "")
+    land = request.args.get("land", "")
+    from krankenkassen import search as kk_search, get_all as kk_all
+    if q:
+        data = kk_search(q, land=land or None)
+    elif land:
+        data = kk_by_land(land)
+    else:
+        data = kk_all()
+    return jsonify(data)
+
+# ─── API: Profilfoto ─────────────────────────────────────────────────────────
+@app.route("/api/patienten/<int:pid>/foto", methods=["POST"])
+def api_foto_upload(pid):
+    if "foto" not in request.files:
+        return jsonify({"error": "Keine Datei"}), 400
+    file = request.files["foto"]
+    if not file.filename:
+        return jsonify({"error": "Keine Datei"}), 400
+    ext = os.path.splitext(file.filename)[1].lower()
+    if ext not in [".jpg", ".jpeg", ".png", ".gif", ".webp"]:
+        return jsonify({"error": "Ungültiges Format"}), 400
+    fotos_dir = os.path.join(BASE_DIR, "static", "fotos")
+    os.makedirs(fotos_dir, exist_ok=True)
+    filename = f"{pid}{ext}"
+    file.save(os.path.join(fotos_dir, filename))
+    db = get_db()
+    db.execute("UPDATE patienten SET foto_pfad=? WHERE id=?", (filename, pid))
+    db.commit()
+    return jsonify({"ok": True, "foto_pfad": filename})
+
+# ─── API: Pflegetagebuch ──────────────────────────────────────────────────────
+@app.route("/api/patienten/<int:pid>/tagebuch", methods=["GET"])
+def api_tagebuch_list(pid):
+    db = get_db()
+    rows = db.execute(
+        "SELECT * FROM pflegetagebuch WHERE patient_id=? ORDER BY datum DESC, erstellt_am DESC",
+        (pid,)
+    ).fetchall()
+    return jsonify([dict(r) for r in rows])
+
+@app.route("/api/patienten/<int:pid>/tagebuch", methods=["POST"])
+def api_tagebuch_neu(pid):
+    db = get_db()
+    d = request.json
+    cur = db.execute("""
+        INSERT INTO pflegetagebuch
+            (patient_id, datum, koerperpflege, anziehen, ernaehrung,
+             mobilitaet, orientierung, medikamente, soziales, allgemein)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    """, (pid, d.get("datum",""), d.get("koerperpflege",""), d.get("anziehen",""),
+          d.get("ernaehrung",""), d.get("mobilitaet",""), d.get("orientierung",""),
+          d.get("medikamente",""), d.get("soziales",""), d.get("allgemein","")))
+    db.commit()
+    return jsonify({"id": cur.lastrowid, "ok": True})
+
+@app.route("/api/tagebuch/<int:tid>", methods=["DELETE"])
+def api_tagebuch_delete(tid):
+    db = get_db()
+    db.execute("DELETE FROM pflegetagebuch WHERE id=?", (tid,))
+    db.commit()
+    return jsonify({"ok": True})
+
+# ─── API: E-Mail-Versand ─────────────────────────────────────────────────────
+def _smtp_cfg():
+    db = get_db()
+    rows = db.execute("SELECT schluessel, wert FROM einstellungen").fetchall()
+    cfg  = {r["schluessel"]: r["wert"] for r in rows}
+    return {
+        "server":    cfg.get("email_smtp", "").strip(),
+        "port":      int(cfg.get("email_port", 587) or 587),
+        "user":      cfg.get("email_user", "").strip(),
+        "password":  cfg.get("email_pass", ""),
+        "absender":  (cfg.get("email_absender") or cfg.get("email_user", "")).strip(),
+        "firma":     cfg.get("firmenname", "Pflegepilot"),
+    }
+
+def _smtp_send(to, subject, body, pdf_base64="", pdf_dateiname="Dokument.pdf"):
+    c = _smtp_cfg()
+    if not c["server"] or not c["user"]:
+        raise ValueError("SMTP nicht konfiguriert – bitte unter Backend → E-Mail einrichten.")
+    msg = MIMEMultipart()
+    msg["From"]    = f"{c['firma']} <{c['absender']}>" if c["firma"] else c["absender"]
+    msg["To"]      = to
+    msg["Subject"] = subject
+    msg.attach(MIMEText(body + f"\n\n-- \n{c['firma']}", "plain", "utf-8"))
+    if pdf_base64:
+        data = base64.b64decode(pdf_base64)
+        part = MIMEBase("application", "pdf")
+        part.set_payload(data)
+        encoders.encode_base64(part)
+        safe = re.sub(r'[^\w\-.]', '_', pdf_dateiname)
+        part.add_header("Content-Disposition", f'attachment; filename="{safe}"')
+        msg.attach(part)
+    with smtplib.SMTP(c["server"], c["port"], timeout=15) as srv:
+        srv.ehlo()
+        srv.starttls()
+        srv.login(c["user"], c["password"])
+        srv.send_message(msg)
+
+@app.route("/api/email/senden", methods=["POST"])
+def api_email_senden():
+    d = request.json or {}
+    empfaenger  = (d.get("empfaenger") or "").strip()
+    betreff     = d.get("betreff") or "Nachricht von Pflegepilot"
+    nachricht   = d.get("nachricht") or ""
+    pdf_base64  = d.get("pdf_base64") or ""
+    pdf_name    = d.get("pdf_dateiname") or "Dokument.pdf"
+    if not empfaenger:
+        return jsonify({"error": "Empfänger-Adresse fehlt"}), 400
+    try:
+        _smtp_send(empfaenger, betreff, nachricht, pdf_base64, pdf_name)
+        return jsonify({"ok": True})
+    except ValueError as e:
+        return jsonify({"error": str(e)}), 400
+    except smtplib.SMTPAuthenticationError:
+        return jsonify({"error": "SMTP-Authentifizierung fehlgeschlagen – Benutzername/Passwort prüfen."}), 500
+    except smtplib.SMTPConnectError as e:
+        return jsonify({"error": f"Verbindung fehlgeschlagen: {e}"}), 500
+    except Exception as e:
+        return jsonify({"error": f"Fehler beim Versand: {e}"}), 500
+
+@app.route("/api/email/test", methods=["POST"])
+def api_email_test():
+    try:
+        c = _smtp_cfg()
+        if not c["server"] or not c["user"]:
+            return jsonify({"error": "SMTP nicht konfiguriert"}), 400
+        _smtp_send(
+            c["absender"],
+            "Pflegepilot – Test-E-Mail",
+            "Die SMTP-Konfiguration funktioniert korrekt.\n\nPflegepilot Alpha"
+        )
+        return jsonify({"ok": True})
+    except ValueError as e:
+        return jsonify({"error": str(e)}), 400
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+# ─── API: Kalender / Fristenüberwachung ──────────────────────────────────────
+@app.route("/api/kalender", methods=["GET"])
+def api_kalender():
+    db = get_db()
+    events = []
+    today_str = date.today().isoformat()
+
+    # Offene Aufgaben mit Fälligkeitsdatum
+    for r in db.execute("""
+        SELECT a.id, a.titel, a.beschreibung, a.faellig_am, a.prioritaet,
+               a.patient_id, p.vorname||' '||p.nachname AS pname
+        FROM aufgaben a LEFT JOIN patienten p ON a.patient_id=p.id
+        WHERE a.erledigt=0 AND a.faellig_am IS NOT NULL AND a.faellig_am != ''
+        ORDER BY a.faellig_am
+    """).fetchall():
+        events.append({"typ":"aufgabe","id":r["id"],"titel":r["titel"],
+                        "beschreibung":r["beschreibung"],"datum":r["faellig_am"],
+                        "prioritaet":r["prioritaet"],"patient_id":r["patient_id"],
+                        "patient_name":r["pname"],"ueberfaellig":r["faellig_am"]<today_str})
+
+    # Widerspruchsfristen
+    for r in db.execute("""
+        SELECT a.id, a.widerspruch_frist, a.patient_id,
+               p.vorname||' '||p.nachname AS pname
+        FROM antraege a LEFT JOIN patienten p ON a.patient_id=p.id
+        WHERE a.widerspruch_frist IS NOT NULL AND a.widerspruch_frist != ''
+              AND a.status='abgelehnt'
+        ORDER BY a.widerspruch_frist
+    """).fetchall():
+        events.append({"typ":"widerspruch_frist","id":r["id"],
+                        "titel":"⚖ Widerspruchsfrist läuft ab",
+                        "beschreibung":"Widerspruch gem. § 84 SGG einreichen",
+                        "datum":r["widerspruch_frist"],"prioritaet":"hoch",
+                        "patient_id":r["patient_id"],"patient_name":r["pname"],
+                        "ueberfaellig":r["widerspruch_frist"]<today_str})
+
+    # MDK-Gutachter-Termine
+    for r in db.execute("""
+        SELECT a.id, a.gutachter_termin, a.patient_id,
+               p.vorname||' '||p.nachname AS pname
+        FROM antraege a LEFT JOIN patienten p ON a.patient_id=p.id
+        WHERE a.gutachter_termin IS NOT NULL AND a.gutachter_termin != ''
+        ORDER BY a.gutachter_termin
+    """).fetchall():
+        events.append({"typ":"gutachter","id":r["id"],
+                        "titel":"🩺 MDK-Begutachtung",
+                        "beschreibung":"Pflegetagebuch bereitlegen, Arztberichte sammeln",
+                        "datum":r["gutachter_termin"],"prioritaet":"hoch",
+                        "patient_id":r["patient_id"],"patient_name":r["pname"],
+                        "ueberfaellig":r["gutachter_termin"]<today_str})
+
+    # Archivierungsfristen (Hinweis wenn Frist < 1 Jahr)
+    for r in db.execute("""
+        SELECT id, vorname||' '||nachname AS pname, archiv_frist, patient_status
+        FROM patienten
+        WHERE archiv_frist IS NOT NULL AND archiv_frist != ''
+        ORDER BY archiv_frist
+    """).fetchall():
+        try:
+            af = datetime.strptime(r["archiv_frist"], "%Y-%m-%d").date()
+            days_left = (af - date.today()).days
+            if days_left <= 365:
+                events.append({"typ":"archivierung","id":r["id"],
+                                "titel":"📁 Archivierungsfrist",
+                                "beschreibung":f"Akte {r['patient_status']} – Aufbewahrungsfrist endet",
+                                "datum":r["archiv_frist"],"prioritaet":"mittel",
+                                "patient_id":r["id"],"patient_name":r["pname"],
+                                "ueberfaellig":days_left<0})
+        except Exception:
+            pass
+
+    # Tagebuch-Erinnerung: aktive Patienten mit Pflegegrad und fehlendem heutigen Eintrag
+    for r in db.execute("""
+        SELECT p.id, p.vorname||' '||p.nachname AS pname, p.pflegegrad,
+               MAX(t.datum) AS letzter_tb,
+               SUM(CASE WHEN t.datum=? THEN 1 ELSE 0 END) AS heute
+        FROM patienten p
+        LEFT JOIN pflegetagebuch t ON t.patient_id=p.id
+        WHERE p.patient_status='aktiv' AND p.pflegegrad>0
+        GROUP BY p.id
+        HAVING heute=0
+    """, (today_str,)).fetchall():
+        letzter = r["letzter_tb"]
+        try:
+            tage_seit = (date.today() - datetime.strptime(letzter, "%Y-%m-%d").date()).days if letzter else 999
+        except Exception:
+            tage_seit = 999
+        events.append({"typ": "tagebuch_erinnerung", "id": r["id"],
+                        "titel": f"Pflegetagebuch führen – {r['pname']}",
+                        "beschreibung": f"Heute noch kein Eintrag · Letzter Eintrag: {letzter or 'nie'}",
+                        "datum": today_str, "prioritaet": "hoch" if tage_seit >= 2 else "mittel",
+                        "patient_id": r["id"], "patient_name": r["pname"],
+                        "ueberfaellig": tage_seit >= 2})
+
+    events.sort(key=lambda x: x["datum"] or "")
+    return jsonify(events)
+
+@app.route("/api/tagebuch/reminder-status", methods=["GET"])
+def api_tagebuch_reminder_status():
+    db = get_db()
+    today_str = date.today().isoformat()
+    rows = db.execute("""
+        SELECT p.id, p.vorname||' '||p.nachname AS name, p.pflegegrad,
+               MAX(t.datum) AS letzter_eintrag,
+               SUM(CASE WHEN t.datum=? THEN 1 ELSE 0 END) AS heute
+        FROM patienten p
+        LEFT JOIN pflegetagebuch t ON t.patient_id=p.id
+        WHERE p.patient_status='aktiv' AND p.pflegegrad>0
+        GROUP BY p.id
+    """, (today_str,)).fetchall()
+    return jsonify([{"id": r["id"], "name": r["name"], "pflegegrad": r["pflegegrad"],
+                     "letzter_eintrag": r["letzter_eintrag"], "heute": bool(r["heute"])}
+                    for r in rows])
+
+# ─── API: Dokumente ───────────────────────────────────────────────────────────
+@app.route("/api/patienten/<int:pid>/dokumente", methods=["GET"])
+def api_dokumente_list(pid):
+    db = get_db()
+    rows = db.execute(
+        "SELECT * FROM dokumente WHERE patient_id=? ORDER BY datum DESC, erstellt_am DESC",
+        (pid,)
+    ).fetchall()
+    return jsonify([dict(r) for r in rows])
+
+@app.route("/api/patienten/<int:pid>/dokumente", methods=["POST"])
+def api_dokument_upload(pid):
+    if "datei" not in request.files:
+        return jsonify({"error": "Keine Datei"}), 400
+    file = request.files["datei"]
+    typ         = request.form.get("typ", "sonstiges")
+    bezeichnung = request.form.get("bezeichnung", "") or file.filename
+    datum       = request.form.get("datum", "")
+    notizen     = request.form.get("notizen", "")
+    allowed = {".pdf",".jpg",".jpeg",".png",".gif",".webp",".doc",".docx",".txt",".eml"}
+    ext = os.path.splitext(file.filename)[1].lower()
+    if ext not in allowed:
+        return jsonify({"error": f"Format nicht erlaubt: {ext}"}), 400
+    dok_dir = os.path.join(BASE_DIR, "static", "dokumente", str(pid))
+    os.makedirs(dok_dir, exist_ok=True)
+    safe_name   = re.sub(r'[^\w\-.]', '_', file.filename)
+    unique_name = f"{int(time.time())}_{safe_name}"
+    file.save(os.path.join(dok_dir, unique_name))
+    pfad = f"dokumente/{pid}/{unique_name}"
+    db = get_db()
+    cur = db.execute("""
+        INSERT INTO dokumente (patient_id, typ, bezeichnung, dateiname, pfad, datum, notizen)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+    """, (pid, typ, bezeichnung, unique_name, pfad, datum, notizen))
+    db.commit()
+    return jsonify({"id": cur.lastrowid, "ok": True, "pfad": pfad})
+
+@app.route("/api/dokumente/<int:did>", methods=["DELETE"])
+def api_dokument_delete(did):
+    db = get_db()
+    row = db.execute("SELECT pfad FROM dokumente WHERE id=?", (did,)).fetchone()
+    if row:
+        full = os.path.join(BASE_DIR, "static", row["pfad"])
+        if os.path.exists(full):
+            os.remove(full)
+    db.execute("DELETE FROM dokumente WHERE id=?", (did,))
+    db.commit()
+    return jsonify({"ok": True})
+
+# ─── API: Patient archivieren / Status setzen ─────────────────────────────────
+@app.route("/api/patienten/<int:pid>/archivieren", methods=["PATCH"])
+def api_patient_archivieren(pid):
+    db  = get_db()
+    d   = request.json
+    status        = d.get("status", "archiviert")
+    status_datum  = d.get("status_datum", date.today().isoformat())
+    archiv_hinweis = d.get("archiv_hinweis", "")
+    # Aufbewahrungsfrist: 30 Jahre Verstorbene (§ 199 Abs. 2 BGB), sonst 10 Jahre (§ 630f BGB)
+    jahre = 30 if status == "verstorben" else 10
+    try:
+        dt = datetime.strptime(status_datum, "%Y-%m-%d")
+        archiv_frist = dt.replace(year=dt.year + jahre).strftime("%Y-%m-%d")
+    except Exception:
+        archiv_frist = ""
+    db.execute("""
+        UPDATE patienten
+        SET patient_status=?, status_datum=?, archiv_frist=?, archiv_hinweis=?,
+            geaendert_am=datetime('now','localtime')
+        WHERE id=?
+    """, (status, status_datum, archiv_frist, archiv_hinweis, pid))
+    db.commit()
+    return jsonify({"ok": True, "archiv_frist": archiv_frist, "jahre": jahre})
+
+# ─── API: Vollständige Patientenakte (für PDF-Export) ─────────────────────────
+@app.route("/api/patienten/<int:pid>/akte", methods=["GET"])
+def api_akte(pid):
+    db = get_db()
+    p  = db.execute("SELECT * FROM patienten WHERE id=?", (pid,)).fetchone()
+    if not p:
+        return jsonify({"error": "Nicht gefunden"}), 404
+    antraege  = db.execute("SELECT * FROM antraege WHERE patient_id=? ORDER BY erstellt_am DESC", (pid,)).fetchall()
+    leistungen= db.execute("SELECT * FROM leistungen WHERE patient_id=? ORDER BY seit DESC", (pid,)).fetchall()
+    aufgaben  = db.execute("SELECT * FROM aufgaben WHERE patient_id=? ORDER BY faellig_am", (pid,)).fetchall()
+    tagebuch  = db.execute("SELECT * FROM pflegetagebuch WHERE patient_id=? ORDER BY datum DESC", (pid,)).fetchall()
+    dokumente = db.execute("SELECT * FROM dokumente WHERE patient_id=? ORDER BY datum DESC", (pid,)).fetchall()
+    return jsonify({
+        "patient":    dict(p),
+        "antraege":   [dict(a) for a in antraege],
+        "leistungen": [dict(l) for l in leistungen],
+        "aufgaben":   [dict(a) for a in aufgaben],
+        "tagebuch":   [dict(t) for t in tagebuch],
+        "dokumente":  [dict(d) for d in dokumente],
+    })
+
+# ─── Hauptseite ───────────────────────────────────────────────────────────────
+@app.route("/")
+def index():
+    return render_template("index.html",
+                           katalog_count=len(KATALOG),
+                           kategorien=get_kategorien())
+
+if __name__ == "__main__":
+    init_db()
+    app.run(debug=True, port=5050, host="0.0.0.0")
diff --git a/pflegepilot_alpha_v2/pflegepilot/db/schema.sql b/pflegepilot_alpha_v2/pflegepilot/db/schema.sql
new file mode 100644
index 0000000..4df06e4
--- /dev/null
+++ b/pflegepilot_alpha_v2/pflegepilot/db/schema.sql
@@ -0,0 +1,126 @@
+-- Pflegepilot Alpha – SQLite Schema
+
+CREATE TABLE IF NOT EXISTS patienten (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    vorname TEXT NOT NULL,
+    nachname TEXT NOT NULL,
+    geburtsdatum TEXT,
+    strasse TEXT,
+    plz TEXT,
+    ort TEXT,
+    telefon TEXT,
+    email TEXT,
+    krankenkasse TEXT,
+    versichertennummer TEXT,
+    versicherungsart TEXT DEFAULT 'GKV',
+    pflegegrad INTEGER DEFAULT 0,
+    pflegeperson TEXT,
+    zielgruppe TEXT DEFAULT 'alterspflege',
+    notizen TEXT,
+    erstellt_am TEXT DEFAULT (datetime('now','localtime')),
+    geaendert_am TEXT DEFAULT (datetime('now','localtime')),
+    patient_status TEXT DEFAULT 'aktiv',
+    status_datum TEXT,
+    archiv_frist TEXT,
+    archiv_hinweis TEXT
+);
+
+CREATE TABLE IF NOT EXISTS antraege (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    patient_id INTEGER NOT NULL REFERENCES patienten(id) ON DELETE CASCADE,
+    typ TEXT NOT NULL, -- 'erstantrag', 'widerspruch', 'hoeherst'
+    status TEXT DEFAULT 'offen', -- 'offen', 'eingereicht', 'in_pruefung', 'genehmigt', 'abgelehnt'
+    antragsdatum TEXT,
+    bescheid_datum TEXT,
+    widerspruch_frist TEXT,
+    gutachter_termin TEXT,
+    beantragter_pflegegrad INTEGER,
+    zugeteilter_pflegegrad INTEGER,
+    notizen TEXT,
+    brief_text TEXT,
+    pdf_pfad TEXT,
+    erstellt_am TEXT DEFAULT (datetime('now','localtime'))
+);
+
+CREATE TABLE IF NOT EXISTS leistungen (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    patient_id INTEGER NOT NULL REFERENCES patienten(id) ON DELETE CASCADE,
+    typ TEXT NOT NULL,
+    bezeichnung TEXT NOT NULL,
+    betrag REAL,
+    einheit TEXT DEFAULT 'monatlich',
+    aktiv INTEGER DEFAULT 1,
+    seit TEXT,
+    katalog_id TEXT,
+    notizen TEXT
+);
+
+CREATE TABLE IF NOT EXISTS aufgaben (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    patient_id INTEGER REFERENCES patienten(id) ON DELETE CASCADE,
+    titel TEXT NOT NULL,
+    beschreibung TEXT,
+    faellig_am TEXT,
+    prioritaet TEXT DEFAULT 'normal', -- 'hoch', 'mittel', 'normal'
+    erledigt INTEGER DEFAULT 0,
+    erstellt_am TEXT DEFAULT (datetime('now','localtime'))
+);
+
+CREATE TABLE IF NOT EXISTS pflegetagebuch (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    patient_id INTEGER NOT NULL REFERENCES patienten(id) ON DELETE CASCADE,
+    datum TEXT NOT NULL,
+    koerperpflege TEXT,
+    anziehen TEXT,
+    ernaehrung TEXT,
+    mobilitaet TEXT,
+    orientierung TEXT,
+    medikamente TEXT,
+    soziales TEXT,
+    allgemein TEXT,
+    erstellt_am TEXT DEFAULT (datetime('now','localtime'))
+);
+
+CREATE TABLE IF NOT EXISTS einstellungen (
+    schluessel TEXT PRIMARY KEY,
+    wert TEXT
+);
+
+CREATE TABLE IF NOT EXISTS dokumente (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    patient_id INTEGER NOT NULL REFERENCES patienten(id) ON DELETE CASCADE,
+    typ TEXT NOT NULL DEFAULT 'sonstiges',
+    bezeichnung TEXT NOT NULL,
+    dateiname TEXT NOT NULL,
+    pfad TEXT NOT NULL,
+    datum TEXT,
+    notizen TEXT,
+    erstellt_am TEXT DEFAULT (datetime('now','localtime'))
+);
+
+-- Demo-Daten
+INSERT OR IGNORE INTO patienten (id,vorname,nachname,geburtsdatum,strasse,plz,ort,telefon,krankenkasse,versichertennummer,versicherungsart,pflegegrad,pflegeperson,notizen)
+VALUES
+(1,'Erika','Huber','1942-03-12','Hauptstraße 4','82256','Fürstenfeldbruck','08141/55432','AOK Bayern','A123456789','GKV',3,'Tochter (privat)','Demenz, leichte Einschränkungen Mobilität'),
+(2,'Klaus','Meier','1938-11-07','Bahnhofstr. 21','80331','München','089/123456','TK','B987654321','GKV',0,'Pflegedienst ambulant','Antrag läuft – Gutachter-Termin offen'),
+(3,'Inge','Müller','1950-06-23','Rosenweg 7','82256','Fürstenfeldbruck','08141/77821','Barmer','C555444333','GKV',2,'Ehemann','Widerspruch eingereicht – Grad zu niedrig');
+
+INSERT OR IGNORE INTO antraege (id,patient_id,typ,status,antragsdatum,bescheid_datum,beantragter_pflegegrad,zugeteilter_pflegegrad,notizen)
+VALUES
+(1,1,'erstantrag','genehmigt','2025-01-15','2025-02-22',3,3,'Erstantrag genehmigt, Grad 3'),
+(2,2,'erstantrag','in_pruefung','2025-04-02',NULL,3,NULL,'Gutachter-Termin noch nicht vereinbart'),
+(3,3,'erstantrag','abgelehnt','2024-11-10','2025-01-05',3,2,'Nur Grad 2 – Widerspruch eingereicht');
+
+INSERT OR IGNORE INTO leistungen (patient_id,typ,bezeichnung,betrag,einheit,seit)
+VALUES
+(1,'pflegegeld','Pflegegeld Grad 3',573,'monatlich','2025-03-01'),
+(1,'entlastung','Entlastungsbetrag',131,'monatlich','2025-03-01'),
+(1,'hilfsmittel','Pflegehilfsmittel Verbrauch',42,'monatlich','2025-03-01'),
+(3,'pflegegeld','Pflegegeld Grad 2',332,'monatlich','2025-02-01'),
+(3,'entlastung','Entlastungsbetrag',131,'monatlich','2025-02-01');
+
+INSERT OR IGNORE INTO aufgaben (patient_id,titel,prioritaet,faellig_am,beschreibung)
+VALUES
+(2,'Gutachter-Termin vereinbaren','hoch','2025-05-13','Krankenkasse anrufen und Termin für MDK-Gutachter festlegen'),
+(3,'Widerspruchsbescheid abwarten','mittel','2025-05-16','Krankenkasse hat 3 Monate Zeit – ggf. nachfassen'),
+(1,'Entlastungsbetrag Mai abrufen','normal','2025-05-31','Monatliche 131 € über anerkannte Stelle abrechnen');
diff --git a/pflegepilot_alpha_v2/pflegepilot/katalog.py b/pflegepilot_alpha_v2/pflegepilot/katalog.py
new file mode 100644
index 0000000..f252bf9
--- /dev/null
+++ b/pflegepilot_alpha_v2/pflegepilot/katalog.py
@@ -0,0 +1,1344 @@
+# ============================================================
+#  PFLEGEPILOT – Vollständiger Leistungskatalog Deutschland
+#  Alterspflege · Bedürftigen-Pflege · Behinderten-Pflege
+#  Stand: 2025
+# ============================================================
+
+KATALOG = [
+
+  # ══════════════════════════════════════════════════════════
+  #  1. PFLEGEKASSE  (SGB XI)
+  # ══════════════════════════════════════════════════════════
+  {
+    "id": "pk_pflegegeld",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Pflegegeld",
+    "kurz": "Monatliches Geld bei häuslicher Pflege durch Angehörige",
+    "rechtsgrundlage": "§ 37 SGB XI",
+    "betrag": "332 € (Grad 2) · 573 € (Grad 3) · 765 € (Grad 4) · 947 € (Grad 5)",
+    "voraussetzung": "Pflegegrad 2–5; Pflege durch nicht-professionelle Person",
+    "pflegegrad_min": 2, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Kein Verfallsdatum, monatlich",
+    "tags": ["geld", "haeuslich", "angehoerige"]
+  },
+  {
+    "id": "pk_sachleistung",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Pflegesachleistung (ambulanter Pflegedienst)",
+    "kurz": "Professioneller Pflegedienst kommt nach Hause",
+    "rechtsgrundlage": "§ 36 SGB XI",
+    "betrag": "761 € (Grad 2) · 1.432 € (Grad 3) · 1.778 € (Grad 4) · 2.200 € (Grad 5)",
+    "voraussetzung": "Pflegegrad 2–5; zugelassener Pflegedienst",
+    "pflegegrad_min": 2, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Monatlich, nicht übertragbar",
+    "tags": ["sach", "pflegedienst", "haeuslich"]
+  },
+  {
+    "id": "pk_kombination",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Kombinationsleistung (Geld + Sachleistung)",
+    "kurz": "Mischung aus Pflegegeld und professionellem Pflegedienst",
+    "rechtsgrundlage": "§ 38 SGB XI",
+    "betrag": "Anteilig (z. B. 50 % Sachleistung = 50 % Pflegegeld)",
+    "voraussetzung": "Pflegegrad 2–5",
+    "pflegegrad_min": 2, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Monatlich wählbar",
+    "tags": ["kombi", "flexibel", "haeuslich"],
+    "abhaengigkeiten": [
+      {"id": "pk_pflegegeld",   "typ": "ergaenzt", "name": "Pflegegeld (§ 37 SGB XI)"},
+      {"id": "pk_sachleistung", "typ": "ergaenzt", "name": "Pflegesachleistung (§ 36 SGB XI)"},
+    ]
+  },
+  {
+    "id": "pk_entlastung",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Entlastungsbetrag",
+    "kurz": "Monatliches Budget für Haushaltshilfe, Alltagsbegleiter, Betreuung",
+    "rechtsgrundlage": "§ 45b SGB XI",
+    "betrag": "131 € / Monat (ab 2025); übertragbar ins Folgejahr",
+    "voraussetzung": "Pflegegrad 1–5",
+    "pflegegrad_min": 1, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Übertrag bis 30.6. des Folgejahres möglich",
+    "tags": ["entlastung", "haushalt", "betreuung", "alltagshelfer"]
+  },
+  {
+    "id": "pk_verhinderung",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Verhinderungspflege",
+    "kurz": "Ersatzpflege wenn Hauptpflegeperson Urlaub/Krankheit hat",
+    "rechtsgrundlage": "§ 39 SGB XI",
+    "betrag": "bis 1.612 € / Jahr (bis zu 6 Wochen)",
+    "voraussetzung": "Pflegegrad 2–5; Hauptpflegeperson min. 6 Monate aktiv",
+    "pflegegrad_min": 2, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Antrag vor oder während Verhinderung; Jahresbudget",
+    "tags": ["verhinderung", "urlaub", "ersatz", "entlastung"]
+  },
+  {
+    "id": "pk_kurzzeitpflege",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Kurzzeitpflege",
+    "kurz": "Vorübergehende Pflege im Heim (z. B. nach Krankenhaus)",
+    "rechtsgrundlage": "§ 42 SGB XI",
+    "betrag": "bis 1.774 € / Jahr (bis zu 8 Wochen)",
+    "voraussetzung": "Pflegegrad 2–5",
+    "pflegegrad_min": 2, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Jährliches Budget; bis Ende des Jahres",
+    "tags": ["kurzzeit", "heim", "krankenhaus", "uebergang"]
+  },
+  {
+    "id": "pk_jahresbetrag",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Gemeinsamer Jahresbetrag (Verhinderung + Kurzzeit)",
+    "kurz": "Flexibler Gesamttopf aus Verhinderungs- und Kurzzeitpflege (ab 07/2025)",
+    "rechtsgrundlage": "§ 39 / § 42 SGB XI (neu ab 07.2025)",
+    "betrag": "3.539 € / Jahr (flexibel einsetzbar)",
+    "voraussetzung": "Pflegegrad 2–5; ab Juli 2025",
+    "pflegegrad_min": 2, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Jahresbudget",
+    "tags": ["jahresbetrag", "flexibel", "kurzzeit", "verhinderung", "neu2025"],
+    "abhaengigkeiten": [
+      {"id": "pk_verhinderung",   "typ": "ersetzt_ab_07_2025", "name": "Verhinderungspflege (§ 39 SGB XI)"},
+      {"id": "pk_kurzzeitpflege", "typ": "ersetzt_ab_07_2025", "name": "Kurzzeitpflege (§ 42 SGB XI)"},
+    ]
+  },
+  {
+    "id": "pk_tagespflege",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Tages- und Nachtpflege",
+    "kurz": "Betreuung tagsüber oder nachts in einer Einrichtung",
+    "rechtsgrundlage": "§ 41 SGB XI",
+    "betrag": "689 € (Grad 2) · 1.298 € (Grad 3) · 1.612 € (Grad 4) · 1.995 € (Grad 5)",
+    "voraussetzung": "Pflegegrad 2–5; teilstationäre Einrichtung",
+    "pflegegrad_min": 2, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Monatlich",
+    "tags": ["tagespflege", "nachtpflege", "teilstationaer", "einrichtung"]
+  },
+  {
+    "id": "pk_stationaer",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Vollstationäre Pflege (Pflegeheim)",
+    "kurz": "Zuschuss für dauerhafte Pflege im Pflegeheim",
+    "rechtsgrundlage": "§ 43 SGB XI",
+    "betrag": "770 € (Grad 2) · 1.262 € (Grad 3) · 1.775 € (Grad 4) · 2.005 € (Grad 5)",
+    "voraussetzung": "Pflegegrad 2–5; vollstationäres Pflegeheim",
+    "pflegegrad_min": 2, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Monatlich",
+    "tags": ["stationaer", "pflegeheim", "dauerpflege"]
+  },
+  {
+    "id": "pk_leistungszuschlag",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Leistungszuschlag im Pflegeheim",
+    "kurz": "Je länger im Heim, desto mehr Zuschuss (15–75 % auf Eigenanteil)",
+    "rechtsgrundlage": "§ 43c SGB XI",
+    "betrag": "15 % (1. Jahr) · 30 % (2. Jahr) · 50 % (3. Jahr) · 75 % (ab 4. Jahr)",
+    "voraussetzung": "Vollstationäre Pflege Grad 2–5",
+    "pflegegrad_min": 2, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse (automatisch)",
+    "frist": "Automatisch, kein gesonderter Antrag",
+    "tags": ["zuschlag", "heim", "eigenanteil", "zeitbonus"],
+    "abhaengigkeiten": [
+      {"id": "pk_stationaer", "typ": "benoetigt", "name": "Vollstationäre Pflege (§ 43 SGB XI)"},
+    ]
+  },
+  {
+    "id": "pk_hilfsmittel_verbrauch",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Pflegehilfsmittel zum Verbrauch",
+    "kurz": "Monatliches Budget für Einmalhandschuhe, Bettschutz, Desinfektionsmittel",
+    "rechtsgrundlage": "§ 40 Abs. 2 SGB XI",
+    "betrag": "42 € / Monat",
+    "voraussetzung": "Pflegegrad 1–5",
+    "pflegegrad_min": 1, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Monatlich; nicht übertragbar",
+    "tags": ["hilfsmittel", "verbrauch", "handschuhe", "hygiene"]
+  },
+  {
+    "id": "pk_hilfsmittel_tech",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Technische Pflegehilfsmittel",
+    "kurz": "Pflegebett, Hausnotruf, Lagerungshilfen – Leihe oder Zuschuss",
+    "rechtsgrundlage": "§ 40 Abs. 1 SGB XI",
+    "betrag": "Bis zu 100 % der Kosten (Leihe) oder Zuschuss",
+    "voraussetzung": "Pflegegrad 1–5; ärztliche/pflegerische Verordnung",
+    "pflegegrad_min": 1, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Antrag vor Anschaffung",
+    "tags": ["hilfsmittel", "pflegebett", "hausnotruf", "technik"]
+  },
+  {
+    "id": "pk_wohnumfeld",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Wohnumfeldverbesserung",
+    "kurz": "Badumbau, Treppenlift, Türverbreiterung, Rampen",
+    "rechtsgrundlage": "§ 40 Abs. 4 SGB XI",
+    "betrag": "bis 4.180 € je Maßnahme (mehrfach möglich; WG bis 16.720 €)",
+    "voraussetzung": "Pflegegrad 1–5; häusliche Pflege",
+    "pflegegrad_min": 1, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Antrag VOR Beginn der Maßnahme!",
+    "tags": ["wohnen", "umbau", "barrierefrei", "treppenlift", "bad"]
+  },
+  {
+    "id": "pk_dipa",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Digitale Pflegeanwendungen (DiPA)",
+    "kurz": "Zuschuss für zugelassene Pflege-Apps",
+    "rechtsgrundlage": "§ 40a SGB XI",
+    "betrag": "bis 50 € / Monat",
+    "voraussetzung": "Pflegegrad 1–5; DiPA-Verzeichnis-App",
+    "pflegegrad_min": 1, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Monatlich",
+    "tags": ["digital", "app", "technik", "dipa"]
+  },
+  {
+    "id": "pk_pflegekurse",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Pflegekurse für Angehörige",
+    "kurz": "Kostenlose Schulungen für pflegende Familienmitglieder",
+    "rechtsgrundlage": "§ 45 SGB XI",
+    "betrag": "kostenlos",
+    "voraussetzung": "Angehörige von Pflegebedürftigen",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Jederzeit buchbar",
+    "tags": ["schulung", "kurs", "angehoerige", "bildung"]
+  },
+  {
+    "id": "pk_rente",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Rentenbeiträge für Pflegende",
+    "kurz": "Pflegekasse zahlt Rentenbeiträge für pflegende Angehörige",
+    "rechtsgrundlage": "§ 44 SGB XI",
+    "betrag": "Abhängig von Pflegegrad und Pflegeumfang",
+    "voraussetzung": "Mind. 10 Std./Woche Pflege; Pflegegrad 2–5; nicht mehr als 30 Std./Woche erwerbstätig",
+    "pflegegrad_min": 2, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Antrag bei Pflegekasse",
+    "tags": ["rente", "sozialversicherung", "angehoerige", "altersvorsorge"],
+    "abhaengigkeiten": [
+      {"id": "pk_pflegegeld", "typ": "ergaenzt", "name": "Pflegegeld (§ 37 SGB XI)"},
+      {"id": "pk_alo",        "typ": "ergaenzt", "name": "Arbeitslosenversicherung für Pflegende (§ 44a SGB XI)"},
+      {"id": "pk_unfall",     "typ": "ergaenzt", "name": "Unfallversicherung für Pflegende (§ 44 SGB XI)"},
+    ]
+  },
+  {
+    "id": "pk_alo",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Arbeitslosenversicherung für Pflegende",
+    "kurz": "Pflegekasse übernimmt ALV-Beiträge für pflegende Angehörige",
+    "rechtsgrundlage": "§ 44a SGB XI",
+    "betrag": "Beitragsübernahme durch Pflegekasse",
+    "voraussetzung": "Pflege wegen Angehöriger aus Beruf ausgestiegen",
+    "pflegegrad_min": 2, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Antrag bei Pflegekasse",
+    "tags": ["arbeitslosigkeit", "sozialversicherung", "angehoerige"],
+    "abhaengigkeiten": [
+      {"id": "pk_rente",  "typ": "ergaenzt", "name": "Rentenbeiträge für Pflegende (§ 44 SGB XI)"},
+      {"id": "pk_unfall", "typ": "ergaenzt", "name": "Unfallversicherung für Pflegende (§ 44 SGB XI)"},
+    ]
+  },
+  {
+    "id": "pk_unfall",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Unfallversicherung für Pflegende",
+    "kurz": "Gesetzliche Unfallversicherung während der Pflegetätigkeit",
+    "rechtsgrundlage": "§ 44 SGB XI",
+    "betrag": "Beitragsübernahme durch Pflegekasse",
+    "voraussetzung": "Pflegetätigkeit mind. 10 Std./Woche",
+    "pflegegrad_min": 2, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse (automatisch)",
+    "frist": "Automatisch, kein gesonderter Antrag",
+    "tags": ["unfall", "versicherung", "angehoerige", "schutz"],
+    "abhaengigkeiten": [
+      {"id": "pk_rente", "typ": "ergaenzt", "name": "Rentenbeiträge für Pflegende (§ 44 SGB XI)"},
+      {"id": "pk_alo",   "typ": "ergaenzt", "name": "Arbeitslosenversicherung für Pflegende (§ 44a SGB XI)"},
+    ]
+  },
+  {
+    "id": "pk_pflegeunterstuetzung",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Pflegeunterstützungsgeld",
+    "kurz": "Lohnersatz wenn man kurzfristig Pflege organisieren muss (bis 10 Tage)",
+    "rechtsgrundlage": "§ 44a SGB XI",
+    "betrag": "bis 90 % des Nettogehalts; bis 10 Arbeitstage",
+    "voraussetzung": "Akute Pflegesituation; Beschäftigter",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Antrag unverzüglich nach Ereignis",
+    "tags": ["lohnersatz", "akut", "kurzzeit", "beruf"]
+  },
+  {
+    "id": "pk_wg_zuschlag",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Wohngruppen-Zuschlag (Pflege-WG)",
+    "kurz": "Extra-Budget für gemeinschaftliches Wohnen mit Pflege",
+    "rechtsgrundlage": "§ 38a SGB XI",
+    "betrag": "214 € / Monat je Bewohner",
+    "voraussetzung": "Pflegegrad 1–5; anerkannte ambulant betreute WG; mind. 3 Bewohner",
+    "pflegegrad_min": 1, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Monatlich",
+    "tags": ["wg", "gemeinschaft", "ambulant", "wohnen"],
+    "abhaengigkeiten": [
+      {"id": "pk_entlastung", "typ": "ergaenzt", "name": "Entlastungsbetrag (§ 45b SGB XI)"},
+      {"id": "pk_pflegegeld", "typ": "ergaenzt", "name": "Pflegegeld (§ 37 SGB XI)"},
+    ]
+  },
+  {
+    "id": "pk_beratungsbesuch",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Beratungsbesuche (Qualitätssicherung)",
+    "kurz": "Pflicht-Beratungsbesuche bei Pflegegeld-Bezug (§ 37 Abs. 3)",
+    "rechtsgrundlage": "§ 37 Abs. 3 SGB XI",
+    "betrag": "kostenlos (Pflicht bei Pflegegeld)",
+    "voraussetzung": "Pflegegeld-Bezug; Grad 2–3: halbjährlich; Grad 4–5: vierteljährlich",
+    "pflegegrad_min": 2, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse (beauftragter Dienst)",
+    "frist": "Halbjährlich oder vierteljährlich",
+    "tags": ["beratung", "qualitaet", "pflicht", "heimbesuch"],
+    "abhaengigkeiten": [
+      {"id": "pk_pflegegeld", "typ": "benoetigt", "name": "Pflegegeld (§ 37 SGB XI) – Pflicht bei Pflegegeld-Bezug"},
+    ]
+  },
+  {
+    "id": "pk_stationaer_behindert",
+    "kategorie": "Pflegekasse (SGB XI)",
+    "zielgruppe": ["behinderte"],
+    "name": "Vollstationäre Pflege in Behinderteneinrichtungen",
+    "kurz": "Pflegekassen-Zuschuss für Pflege in anerkannten Behinderteneinrichtungen",
+    "rechtsgrundlage": "§ 43a SGB XI",
+    "betrag": "bis 266 € / Monat (Ergänzungsleistung)",
+    "voraussetzung": "Pflegegrad 4–5; vollstationäre Einrichtung der Behindertenhilfe",
+    "pflegegrad_min": 4, "pflegegrad_max": 5,
+    "antragsteller": "Pflegekasse",
+    "frist": "Monatlich",
+    "tags": ["behindert", "stationaer", "einrichtung"]
+  },
+
+  # ══════════════════════════════════════════════════════════
+  #  2. KRANKENKASSE  (SGB V)
+  # ══════════════════════════════════════════════════════════
+  {
+    "id": "kk_hkp",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Häusliche Krankenpflege (HKP)",
+    "kurz": "Medizinische Pflege zu Hause: Spritzen, Verbände, Katheter",
+    "rechtsgrundlage": "§ 37 SGB V",
+    "betrag": "Kosten nach ärztlicher Verordnung; Zuzahlung möglich",
+    "voraussetzung": "Ärztliche Verordnung; häusliche Versorgung möglich",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse (mit Rezept)",
+    "frist": "Vor Beginn der Maßnahme",
+    "tags": ["medizin", "haeuslich", "verordnung", "pflege"]
+  },
+  {
+    "id": "kk_haushaltshilfe",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Haushaltshilfe (medizinisch bedingt)",
+    "kurz": "Haushaltshilfe bei Krankheit / nach OP wenn Haushalt nicht führbar",
+    "rechtsgrundlage": "§ 38 SGB V",
+    "betrag": "Kosten der Haushaltshilfe; Zuzahlung 10 €/Tag",
+    "voraussetzung": "Krankenhausbehandlung oder schwere Erkrankung; Kind unter 12 im Haushalt oder Behinderung",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse",
+    "frist": "Antrag zeitnah bei Eintritt der Situation",
+    "tags": ["haushalt", "krankheit", "kind", "nachop"]
+  },
+  {
+    "id": "kk_soziotherapie",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["beduerftige", "behinderte"],
+    "name": "Soziotherapie",
+    "kurz": "Begleitung und Unterstützung für psychisch Kranke im Alltag",
+    "rechtsgrundlage": "§ 37a SGB V",
+    "betrag": "bis 120 Stunden in 3 Jahren; Kostenübernahme durch Kasse",
+    "voraussetzung": "Schwere psychische Erkrankung; ärztliche Verordnung",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse (mit Rezept)",
+    "frist": "Verordnung durch Facharzt",
+    "tags": ["psychisch", "begleitung", "sozial", "ambulant"]
+  },
+  {
+    "id": "kk_physio",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Physiotherapie / Krankengymnastik",
+    "kurz": "Bewegungstherapie auf Rezept",
+    "rechtsgrundlage": "§ 32 SGB V",
+    "betrag": "Kassenleistung; Zuzahlung 10 % + 10 € je Verordnung",
+    "voraussetzung": "Ärztliche Verordnung",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse (mit Rezept)",
+    "frist": "Verordnung einlösen innerhalb 28 Tage",
+    "tags": ["physio", "bewegung", "rezept", "heilmittel"]
+  },
+  {
+    "id": "kk_ergo",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Ergotherapie",
+    "kurz": "Alltagskompetenzen stärken, Selbstständigkeit erhalten",
+    "rechtsgrundlage": "§ 32 SGB V",
+    "betrag": "Kassenleistung; Zuzahlung 10 % + 10 €",
+    "voraussetzung": "Ärztliche Verordnung",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse (mit Rezept)",
+    "frist": "Verordnung einlösen innerhalb 28 Tage",
+    "tags": ["ergo", "alltag", "selbstaendigkeit", "rezept"]
+  },
+  {
+    "id": "kk_logo",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Logopädie",
+    "kurz": "Sprach-, Sprech- und Schlucktherapie",
+    "rechtsgrundlage": "§ 32 SGB V",
+    "betrag": "Kassenleistung; Zuzahlung 10 % + 10 €",
+    "voraussetzung": "Ärztliche Verordnung",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse (mit Rezept)",
+    "frist": "Verordnung einlösen innerhalb 28 Tage",
+    "tags": ["sprache", "schluck", "therapie", "rezept"]
+  },
+  {
+    "id": "kk_podo",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["alterspflege", "beduerftige"],
+    "name": "Podologie (medizinische Fußpflege)",
+    "kurz": "Medizinische Fußpflege besonders bei Diabetes / Durchblutungsstörungen",
+    "rechtsgrundlage": "§ 32 SGB V",
+    "betrag": "Kassenleistung bei Indikation; Zuzahlung",
+    "voraussetzung": "Ärztliche Verordnung; Diagnose Diabetes/AVK",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse (mit Rezept)",
+    "frist": "Verordnung einlösen",
+    "tags": ["fuss", "diabetes", "durchblutung", "rezept"]
+  },
+  {
+    "id": "kk_hoergeraet",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Hörgerät",
+    "kurz": "Zuschuss für Hörgeräte bei Hörminderung",
+    "rechtsgrundlage": "§ 33 SGB V",
+    "betrag": "786 € Festzuschuss je Ohr (HNO-Verordnung)",
+    "voraussetzung": "HNO-Verordnung; Hörminderung ab 30 dB",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse",
+    "frist": "Antrag vor Anschaffung",
+    "tags": ["hoer", "hilfsmittel", "hoergeraet"]
+  },
+  {
+    "id": "kk_rollstuhl",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Rollstuhl / Rollator / Gehhilfen",
+    "kurz": "Mobilitätshilfen auf Verordnung",
+    "rechtsgrundlage": "§ 33 SGB V",
+    "betrag": "Kassenleistung (Leihe oder Kauf); Eigenanteil möglich",
+    "voraussetzung": "Ärztliche Verordnung; Notwendigkeit nachgewiesen",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse",
+    "frist": "Antrag vor Anschaffung",
+    "tags": ["rollstuhl", "rollator", "mobilitaet", "hilfsmittel"]
+  },
+  {
+    "id": "kk_sehhilfe",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Sehhilfen (Brille / Kontaktlinsen)",
+    "kurz": "Zuschuss für Sehhilfen bei schwerer Sehbeeinträchtigung oder Kinder",
+    "rechtsgrundlage": "§ 33 SGB V",
+    "betrag": "Festzuschüsse gestaffelt nach Stärke",
+    "voraussetzung": "Kinder bis 18; Erwachsene bei Sehbehinderung (Visus ≤ 0,3 oder Fehlsicht ≥ 6 dpt)",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse",
+    "frist": "Antrag vor Anschaffung",
+    "tags": ["sehen", "brille", "sehhilfe", "hilfsmittel"]
+  },
+  {
+    "id": "kk_prothese",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["behinderte", "beduerftige"],
+    "name": "Prothesen / Orthesen",
+    "kurz": "Künstliche Gliedmaßen, Schienen, orthopädische Hilfsmittel",
+    "rechtsgrundlage": "§ 33 SGB V",
+    "betrag": "Kassenleistung; ggf. Mehrkostenzuzahlung",
+    "voraussetzung": "Ärztliche Verordnung",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse",
+    "frist": "Antrag vor Versorgung",
+    "tags": ["prothese", "orthese", "hilfsmittel", "amputation"]
+  },
+  {
+    "id": "kk_kompression",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["alterspflege", "beduerftige"],
+    "name": "Kompressionsstrümpfe",
+    "kurz": "Bei Venenleiden, Lymphödem, Thromboseprophylaxe",
+    "rechtsgrundlage": "§ 33 SGB V",
+    "betrag": "Kassenleistung; Zuzahlung 10 %",
+    "voraussetzung": "Ärztliche Verordnung; Diagnose",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse",
+    "frist": "Verordnung einlösen",
+    "tags": ["kompression", "venen", "lymph", "hilfsmittel"]
+  },
+  {
+    "id": "kk_cpap",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["alterspflege", "beduerftige"],
+    "name": "CPAP / Beatmungsgeräte",
+    "kurz": "Schlafapnoe-Maske und Beatmungsgeräte",
+    "rechtsgrundlage": "§ 33 SGB V",
+    "betrag": "Kassenleistung (Leihe)",
+    "voraussetzung": "Ärztliche Verordnung; Schlafapnoe-Diagnose",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse",
+    "frist": "Verordnung einlösen",
+    "tags": ["cpap", "schlaf", "apnoe", "beatmung"]
+  },
+  {
+    "id": "kk_diga",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["beduerftige", "behinderte"],
+    "name": "Digitale Gesundheitsanwendungen (DiGA)",
+    "kurz": "Apps auf Rezept (z. B. gegen Rückenschmerzen, Angst, Depression)",
+    "rechtsgrundlage": "§ 33a SGB V",
+    "betrag": "Kassenleistung; 12 Monate Nutzung",
+    "voraussetzung": "Ärztliches Rezept; DiGA-Verzeichnis (BfArM)",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse",
+    "frist": "Verordnung einlösen",
+    "tags": ["digital", "app", "rezept", "diga", "psyche"]
+  },
+  {
+    "id": "kk_krankengeld",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["beduerftige"],
+    "name": "Krankengeld",
+    "kurz": "Lohnersatz nach 6 Wochen Arbeitsunfähigkeit",
+    "rechtsgrundlage": "§ 44 SGB V",
+    "betrag": "70 % des Bruttogehalts (max. 90 % Netto); bis 78 Wochen",
+    "voraussetzung": "GKV-Mitglied; Arbeitsunfähigkeit",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse",
+    "frist": "Spätestens am Tag nach Ablauf der 6 Wochen melden",
+    "tags": ["lohnersatz", "krankheit", "arbeit", "geld"]
+  },
+  {
+    "id": "kk_kinderpflege",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["beduerftige"],
+    "name": "Kinderpflegekrankengeld",
+    "kurz": "Lohnersatz wenn Kind krank ist und Betreuung nötig",
+    "rechtsgrundlage": "§ 45 SGB V",
+    "betrag": "70 % Brutto; 10 Tage/Jahr je Elternteil (20 bei Alleinerziehenden); 15 Tage bei Behinderung",
+    "voraussetzung": "Kind unter 12; GKV-Mitglied; ärztliches Attest",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse",
+    "frist": "Attest zeitnah einreichen",
+    "tags": ["kind", "krank", "eltern", "lohnersatz"]
+  },
+  {
+    "id": "kk_sapv",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["alterspflege", "beduerftige"],
+    "name": "Spezialisierte ambulante Palliativversorgung (SAPV)",
+    "kurz": "Palliativ-Team kommt nach Hause für schwerstkranke Menschen",
+    "rechtsgrundlage": "§ 37b SGB V",
+    "betrag": "Kassenleistung; keine Zuzahlung",
+    "voraussetzung": "Unheilbare Erkrankung; Sterbephase; ärztliche Verordnung",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse (mit Verordnung)",
+    "frist": "Unverzüglich bei Bedarf",
+    "tags": ["palliativ", "sterben", "hospiz", "schwerstkrank"]
+  },
+  {
+    "id": "kk_hospiz",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["alterspflege", "beduerftige"],
+    "name": "Stationäre Hospizversorgung",
+    "kurz": "Würdevolle Sterbebegleitung im Hospiz",
+    "rechtsgrundlage": "§ 39a SGB V",
+    "betrag": "95 % der Kosten durch GKV/PPV; Rest durch Hospiz/Spenden",
+    "voraussetzung": "Sterbephase; Aufnahme ins Hospiz",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse",
+    "frist": "Bei Bedarf",
+    "tags": ["hospiz", "sterben", "palliativ", "stationaer"]
+  },
+  {
+    "id": "kk_reha",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Stationäre Rehabilitation (Reha)",
+    "kurz": "Stationäre Wiederherstellung der Gesundheit nach Erkrankung/OP",
+    "rechtsgrundlage": "§ 40 SGB V",
+    "betrag": "Kassenleistung; Zuzahlung 10 €/Tag (max. 28 Tage/Jahr)",
+    "voraussetzung": "Ärztliche Verordnung; Indikation",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse",
+    "frist": "Antrag vor Maßnahme; alle 4 Jahre (Ausnahmen möglich)",
+    "tags": ["reha", "erholung", "klinik", "nachbehandlung"]
+  },
+  {
+    "id": "kk_mutter_kind",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["beduerftige"],
+    "name": "Mutter-Kind-Kur / Vater-Kind-Kur",
+    "kurz": "Kurklinik für erschöpfte pflegende Eltern mit Kindern",
+    "rechtsgrundlage": "§ 41 SGB V",
+    "betrag": "Kassenleistung; geringe Zuzahlung",
+    "voraussetzung": "Medizinische Notwendigkeit; Erschöpfung durch Pflegepflichten",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse",
+    "frist": "Antrag bei Hausarzt + Kasse",
+    "tags": ["mutter", "kind", "kur", "erholung", "eltern"]
+  },
+  {
+    "id": "kk_fahrtkosten",
+    "kategorie": "Krankenkasse (SGB V)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Krankentransport / Fahrtkostenerstattung",
+    "kurz": "Übernahme der Fahrkosten zum Arzt / Krankenhaus bei Notwendigkeit",
+    "rechtsgrundlage": "§ 60 SGB V",
+    "betrag": "Vollständige Übernahme bei Krankentransport; Taxizuschuss 13 € Eigenanteil",
+    "voraussetzung": "Pflegegrad 3–5 oder Schwerbehinderung; ärztliche Verordnung",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Krankenkasse",
+    "frist": "Verordnung vor Fahrt; Antrag innerhalb 4 Wochen",
+    "tags": ["fahrt", "transport", "arzt", "krankenwagen"]
+  },
+
+  # ══════════════════════════════════════════════════════════
+  #  3. EINGLIEDERUNGSHILFE  (SGB IX)
+  # ══════════════════════════════════════════════════════════
+  {
+    "id": "eh_assistenz",
+    "kategorie": "Eingliederungshilfe (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Assistenzleistungen",
+    "kurz": "Persönliche Assistenz für behinderte Menschen im Alltag und Beruf",
+    "rechtsgrundlage": "§ 78 SGB IX",
+    "betrag": "Individuell; nach Bedarf; kein fester Betrag",
+    "voraussetzung": "Wesentliche Behinderung (§ 99 SGB IX); Antrag beim Träger der Eingliederungshilfe",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Träger Eingliederungshilfe (Sozialamt/Landschaftsverband)",
+    "frist": "Antrag schriftlich; Bedarfsfeststellung",
+    "tags": ["assistenz", "behindert", "alltag", "beruf", "persoenlich"]
+  },
+  {
+    "id": "eh_heilpaed",
+    "kategorie": "Eingliederungshilfe (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Heilpädagogische Leistungen",
+    "kurz": "Förderung für Kinder mit Behinderung vor der Einschulung",
+    "rechtsgrundlage": "§ 79 SGB IX",
+    "betrag": "Kostenübernahme durch Eingliederungshilfeträger",
+    "voraussetzung": "Behinderung oder drohende Behinderung; Kinder bis Schuleintritt",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Träger Eingliederungshilfe",
+    "frist": "Frühzeitig beantragen",
+    "tags": ["kind", "behinderung", "foerderung", "paedagogik", "fruehfoerderung"]
+  },
+  {
+    "id": "eh_teilhabe_arbeit",
+    "kategorie": "Eingliederungshilfe (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Leistungen zur Teilhabe am Arbeitsleben",
+    "kurz": "Berufsförderung, Umschulung, Arbeitsplatzausstattung für Behinderte",
+    "rechtsgrundlage": "§§ 49–63 SGB IX",
+    "betrag": "Variabel; Kosten der Maßnahme",
+    "voraussetzung": "Behinderung; Beeinträchtigung der Erwerbsfähigkeit",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Rentenversicherung / Agentur für Arbeit / Eingliederungshilfe",
+    "frist": "Antrag bei zuständigem Träger",
+    "tags": ["arbeit", "beruf", "umschulung", "foerderung", "behindert"]
+  },
+  {
+    "id": "eh_werkstatt",
+    "kategorie": "Eingliederungshilfe (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Werkstatt für behinderte Menschen (WfbM)",
+    "kurz": "Geschützte Beschäftigung für Menschen, die dem allgemeinen Arbeitsmarkt nicht zugänglich sind",
+    "rechtsgrundlage": "§§ 57–58 SGB IX",
+    "betrag": "Werkstattlohn + Grundsicherung; Fahrtkosten übernommen",
+    "voraussetzung": "Wesentliche Behinderung; nicht arbeitsfähig am 1. Arbeitsmarkt",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Eingliederungshilfe / Rentenversicherung",
+    "frist": "Antrag bei Eingliederungshilfe",
+    "tags": ["werkstatt", "beschaeftigung", "behindert", "arbeit", "wfbm"]
+  },
+  {
+    "id": "eh_budget_arbeit",
+    "kategorie": "Eingliederungshilfe (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Budget für Arbeit",
+    "kurz": "Lohnkostenzuschuss für Arbeitgeber als Alternative zur Werkstatt",
+    "rechtsgrundlage": "§ 61 SGB IX",
+    "betrag": "bis 75 % des Mindestlohns als Lohnkostenzuschuss",
+    "voraussetzung": "Behinderung; Anspruch auf WfbM-Leistungen",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Eingliederungshilfe",
+    "frist": "Antrag vor Arbeitsbeginn",
+    "tags": ["arbeit", "lohn", "zuschuss", "alterativ", "werkstatt"]
+  },
+  {
+    "id": "eh_persbudget",
+    "kategorie": "Eingliederungshilfe (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Persönliches Budget",
+    "kurz": "Geldleistung statt Sachleistung – selbst organisierte Hilfe",
+    "rechtsgrundlage": "§ 29 SGB IX",
+    "betrag": "Individuell; entspricht dem Sachleistungswert",
+    "voraussetzung": "Anspruch auf Eingliederungshilfe oder andere Reha-Leistungen",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Zuständiger Reha-Träger",
+    "frist": "Antrag beim Träger",
+    "tags": ["persoenliches", "budget", "selbst", "geld", "flexibel"],
+    "abhaengigkeiten": [
+      {"id": "eh_assistenz", "typ": "alternativ", "name": "Assistenzleistungen (§ 78 SGB IX) – Sachleistung statt Geld"},
+    ]
+  },
+  {
+    "id": "eh_wohnen",
+    "kategorie": "Eingliederungshilfe (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Besondere Wohnformen / Unterstütztes Wohnen",
+    "kurz": "Ambulant betreutes Wohnen, Wohngemeinschaften für Behinderte",
+    "rechtsgrundlage": "§ 78 SGB IX",
+    "betrag": "Kostenübernahme individuell",
+    "voraussetzung": "Wesentliche Behinderung; Bedarf an Betreuung",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Eingliederungshilfe",
+    "frist": "Antrag vor Einzug",
+    "tags": ["wohnen", "betreuung", "betreut", "wg", "behindert"]
+  },
+  {
+    "id": "eh_kfz",
+    "kategorie": "Eingliederungshilfe (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Kraftfahrzeughilfe",
+    "kurz": "Zuschuss zu Kfz-Kauf und -Umbau für Behinderte",
+    "rechtsgrundlage": "KfzHV; § 49 SGB IX",
+    "betrag": "bis 9.500 € (Kauf); Umbaukosten voll übernommen",
+    "voraussetzung": "Behinderung verhindert ÖPNV-Nutzung; Berufstätigkeit",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Rentenversicherung / Agentur für Arbeit",
+    "frist": "Antrag vor Anschaffung",
+    "tags": ["auto", "kfz", "fahren", "mobilitaet", "umbau"]
+  },
+  {
+    "id": "eh_kommunikation",
+    "kategorie": "Eingliederungshilfe (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Kommunikationshilfen / Dolmetscherleistungen",
+    "kurz": "Gebärdensprachdolmetscher, Kommunikationshilfen für Gehörlose",
+    "rechtsgrundlage": "§ 82 SGB IX; KHV",
+    "betrag": "Kostenübernahme durch Träger",
+    "voraussetzung": "Hör- oder Sprachbehinderung",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Eingliederungshilfe / Rentenversicherung",
+    "frist": "Antrag vor Bedarf",
+    "tags": ["gehoerlos", "gebaerden", "kommunikation", "dolmetscher"]
+  },
+  {
+    "id": "eh_schulbegleitung",
+    "kategorie": "Eingliederungshilfe (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Schulbegleitung / Integrationshilfe",
+    "kurz": "Persönliche Unterstützung behinderter Kinder in der Schule",
+    "rechtsgrundlage": "§ 112 SGB IX",
+    "betrag": "Kostenübernahme; variabel nach Bedarf",
+    "voraussetzung": "Wesentliche Behinderung; schulpflichtiges Kind",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Eingliederungshilfe (Jugendamt / Sozialamt)",
+    "frist": "Antrag vor Schuljahresbeginn",
+    "tags": ["schule", "kind", "begleitung", "inklusion", "integration"]
+  },
+
+  # ══════════════════════════════════════════════════════════
+  #  4. GRUNDSICHERUNG / SOZIALHILFE  (SGB XII)
+  # ══════════════════════════════════════════════════════════
+  {
+    "id": "gs_grundsicherung",
+    "kategorie": "Grundsicherung / Sozialhilfe (SGB XII)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Grundsicherung im Alter und bei Erwerbsminderung",
+    "kurz": "Existenzsicherung für Ältere (ab 67) und dauerhaft Erwerbsgeminderte",
+    "rechtsgrundlage": "§§ 41–46b SGB XII",
+    "betrag": "Regelbedarf 563 € (2025) + Kosten Unterkunft + Mehrbedarf",
+    "voraussetzung": "Bedürftigkeit; ab 67 Jahre ODER dauerhafte volle Erwerbsminderung",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Sozialamt",
+    "frist": "Antrag bei Sozialamt; rückwirkend 1 Monat möglich",
+    "tags": ["grundsicherung", "existenz", "alter", "arm", "mindestsicherung"]
+  },
+  {
+    "id": "gs_hilfe_pflege",
+    "kategorie": "Grundsicherung / Sozialhilfe (SGB XII)",
+    "zielgruppe": ["alterspflege", "beduerftige"],
+    "name": "Hilfe zur Pflege (Sozialhilfe)",
+    "kurz": "Übernahme von Pflegekosten für Bedürftige ohne ausreichende Mittel",
+    "rechtsgrundlage": "§§ 61–66 SGB XII",
+    "betrag": "Aufstockung wenn Pflegekasse und Eigenkapital nicht reichen",
+    "voraussetzung": "Bedürftigkeit; Pflegekassenleistungen nicht ausreichend",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Sozialamt",
+    "frist": "Antrag unverzüglich",
+    "tags": ["sozialhilfe", "pflege", "bedürftig", "aufstockung", "heim"],
+    "abhaengigkeiten": [
+      {"id": "pk_pflegegeld",   "typ": "ergaenzt", "name": "Pflegegeld (§ 37 SGB XI) – wird aufgestockt"},
+      {"id": "pk_sachleistung", "typ": "ergaenzt", "name": "Pflegesachleistung (§ 36 SGB XI) – wird aufgestockt"},
+    ]
+  },
+  {
+    "id": "gs_hilfe_gesundheit",
+    "kategorie": "Grundsicherung / Sozialhilfe (SGB XII)",
+    "zielgruppe": ["beduerftige"],
+    "name": "Hilfe zur Gesundheit (für Nicht-GKV-Versicherte)",
+    "kurz": "Krankheitskosten für Menschen ohne Krankenversicherung",
+    "rechtsgrundlage": "§§ 47–52 SGB XII",
+    "betrag": "Wie GKV-Leistungen; individuell",
+    "voraussetzung": "Keine GKV/PKV; Bedürftigkeit",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Sozialamt",
+    "frist": "Antrag bei Bedarf",
+    "tags": ["gesundheit", "krank", "sozialhilfe", "unversichert"]
+  },
+  {
+    "id": "gs_blindenhilfe",
+    "kategorie": "Grundsicherung / Sozialhilfe (SGB XII)",
+    "zielgruppe": ["behinderte"],
+    "name": "Blindenhilfe (Bundesleistung)",
+    "kurz": "Monatliche Unterstützung für blinde Menschen",
+    "rechtsgrundlage": "§ 72 SGB XII",
+    "betrag": "ca. 77 € / Monat (Bundessatz; Anrechnung Landesblindengeld)",
+    "voraussetzung": "Blindheit (Visus ≤ 0,02 oder Gesichtsfeld < 5°)",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Sozialamt",
+    "frist": "Antrag bei Sozialamt",
+    "tags": ["blind", "sehen", "behinderung", "monatlich"]
+  },
+
+  # ══════════════════════════════════════════════════════════
+  #  5. SCHWERBEHINDERTENRECHT  (SGB IX Teil 3)
+  # ══════════════════════════════════════════════════════════
+  {
+    "id": "sb_ausweis",
+    "kategorie": "Schwerbehindertenrecht (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Schwerbehindertenausweis",
+    "kurz": "Amtlicher Ausweis ab GdB 50 – Zugang zu Nachteilsausgleichen",
+    "rechtsgrundlage": "§§ 152ff SGB IX",
+    "betrag": "kostenlos",
+    "voraussetzung": "GdB (Grad der Behinderung) mind. 50",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Versorgungsamt",
+    "frist": "Antrag beim Versorgungsamt",
+    "tags": ["ausweis", "schwerbehinderung", "gdb", "nachteilsausgleich"]
+  },
+  {
+    "id": "sb_merkzeichen_g",
+    "kategorie": "Schwerbehindertenrecht (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Merkzeichen G – Erhebliche Gehbehinderung",
+    "kurz": "Berechtigt zu Parkerleichterungen und ÖPNV-Vergünstigungen",
+    "rechtsgrundlage": "§ 228 SGB IX",
+    "betrag": "Nachteilsausgleiche (kein Geld direkt)",
+    "voraussetzung": "GdB mind. 50 + erhebliche Gehbehinderung",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Versorgungsamt",
+    "frist": "Mit Schwerbehindertenausweis-Antrag",
+    "tags": ["merkzeichen", "gehen", "parken", "oepnv"],
+    "abhaengigkeiten": [
+      {"id": "sb_ausweis",  "typ": "benoetigt", "name": "Schwerbehindertenausweis (§ 152ff SGB IX)"},
+      {"id": "sb_freifahrt","typ": "ergaenzt",  "name": "ÖPNV-Freifahrt / Wertmarke (§§ 228–232 SGB IX)"},
+    ]
+  },
+  {
+    "id": "sb_merkzeichen_ag",
+    "kategorie": "Schwerbehindertenrecht (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Merkzeichen aG – Außergewöhnliche Gehbehinderung",
+    "kurz": "Blauer Parkausweis; nahezu keine Gehfähigkeit",
+    "rechtsgrundlage": "§ 229 SGB IX",
+    "betrag": "Blauer EU-Parkausweis",
+    "voraussetzung": "GdB mind. 80 + nahezu vollständige Gehunfähigkeit",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Versorgungsamt",
+    "frist": "Antrag beim Versorgungsamt",
+    "tags": ["merkzeichen", "parken", "blauer-ausweis", "rollstuhl"],
+    "abhaengigkeiten": [
+      {"id": "sb_ausweis",     "typ": "benoetigt", "name": "Schwerbehindertenausweis (§ 152ff SGB IX)"},
+      {"id": "sb_merkzeichen_g","typ": "ergaenzt", "name": "Merkzeichen G – Erhebliche Gehbehinderung"},
+      {"id": "sb_freifahrt",   "typ": "ergaenzt",  "name": "ÖPNV-Freifahrt kostenlos (§§ 228–232 SGB IX)"},
+    ]
+  },
+  {
+    "id": "sb_merkzeichen_b",
+    "kategorie": "Schwerbehindertenrecht (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Merkzeichen B – Notwendigkeit ständiger Begleitung",
+    "kurz": "Begleitperson fährt im ÖPNV kostenlos mit",
+    "rechtsgrundlage": "§ 228 SGB IX",
+    "betrag": "Kostenfreie Mitnahme Begleitperson",
+    "voraussetzung": "Hilfelosigkeit im Verkehr",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Versorgungsamt",
+    "frist": "Antrag beim Versorgungsamt",
+    "tags": ["merkzeichen", "begleitperson", "oepnv", "freifahrt"],
+    "abhaengigkeiten": [
+      {"id": "sb_ausweis",  "typ": "benoetigt", "name": "Schwerbehindertenausweis (§ 152ff SGB IX)"},
+      {"id": "sb_freifahrt","typ": "ergaenzt",  "name": "ÖPNV-Freifahrt / Wertmarke (§§ 228–232 SGB IX)"},
+    ]
+  },
+  {
+    "id": "sb_merkzeichen_h",
+    "kategorie": "Schwerbehindertenrecht (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Merkzeichen H – Hilflosigkeit",
+    "kurz": "Höherer Steuerpauschbetrag; Befreiung Rundfunkbeitrag; Kfz-Steuerbefreiung",
+    "rechtsgrundlage": "§ 33b EStG; § 229 SGB IX",
+    "betrag": "Steuerpauschbetrag 7.400 €; ARD/ZDF-Befreiung; Kfz-Steuerfrei",
+    "voraussetzung": "GdB mind. 50 + ständige Hilfe bei Alltagsverrichtungen",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Versorgungsamt",
+    "frist": "Antrag beim Versorgungsamt",
+    "tags": ["merkzeichen", "hilfslos", "steuer", "rundfunk", "kfz"],
+    "abhaengigkeiten": [
+      {"id": "sb_ausweis",   "typ": "benoetigt", "name": "Schwerbehindertenausweis (§ 152ff SGB IX)"},
+      {"id": "land_rundfunk","typ": "ergaenzt",  "name": "Rundfunkbeitragsbefreiung (§ 4 RBStV)"},
+    ]
+  },
+  {
+    "id": "sb_merkzeichen_bl",
+    "kategorie": "Schwerbehindertenrecht (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Merkzeichen Bl – Blindheit",
+    "kurz": "Alle Vergünstigungen von H + zusätzliche Blindenhilfe",
+    "rechtsgrundlage": "§ 229 SGB IX",
+    "betrag": "Pauschbetrag 7.400 €; ÖPNV-Freifahrt; Blindenhilfe",
+    "voraussetzung": "Blindheit (Visus ≤ 0,02)",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Versorgungsamt",
+    "frist": "Antrag beim Versorgungsamt",
+    "tags": ["blind", "merkzeichen", "freifahrt", "steuer"],
+    "abhaengigkeiten": [
+      {"id": "sb_ausweis",          "typ": "benoetigt", "name": "Schwerbehindertenausweis (§ 152ff SGB IX)"},
+      {"id": "sb_merkzeichen_h",    "typ": "ergaenzt",  "name": "Merkzeichen H – Hilflosigkeit"},
+      {"id": "gs_blindenhilfe",     "typ": "ergaenzt",  "name": "Blindenhilfe (§ 72 SGB XII)"},
+      {"id": "land_landesblindengeld","typ": "ergaenzt","name": "Bayerisches Blindengeld (BayBlindG)"},
+    ]
+  },
+  {
+    "id": "sb_merkzeichen_gl",
+    "kategorie": "Schwerbehindertenrecht (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Merkzeichen GL – Gehörlosigkeit",
+    "kurz": "Vergünstigungen für gehörlose Menschen",
+    "rechtsgrundlage": "§ 228 SGB IX",
+    "betrag": "Dolmetscherkosten; Telefonkostenausgleich",
+    "voraussetzung": "Gehörlosigkeit",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Versorgungsamt",
+    "frist": "Antrag beim Versorgungsamt",
+    "tags": ["gehoerlos", "merkzeichen", "dolmetscher"],
+    "abhaengigkeiten": [
+      {"id": "sb_ausweis",      "typ": "benoetigt", "name": "Schwerbehindertenausweis (§ 152ff SGB IX)"},
+      {"id": "eh_kommunikation","typ": "ergaenzt",  "name": "Kommunikationshilfen / Dolmetscherleistungen (§ 82 SGB IX)"},
+    ]
+  },
+  {
+    "id": "sb_freifahrt",
+    "kategorie": "Schwerbehindertenrecht (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "ÖPNV-Freifahrt / Wertmarke",
+    "kurz": "Kostenloser Nahverkehr für Schwerbehinderte",
+    "rechtsgrundlage": "§§ 228–232 SGB IX",
+    "betrag": "Wertmarke 91 €/Jahr (oder kostenlos bei Merkzeichen H/Bl/aG)",
+    "voraussetzung": "Schwerbehindertenausweis mit Merkzeichen G, aG, H, Bl, GL oder B",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Versorgungsamt",
+    "frist": "Jährliche Wertmarke beantragen",
+    "tags": ["bus", "bahn", "freifahrt", "nahverkehr", "oepnv"],
+    "abhaengigkeiten": [
+      {"id": "sb_ausweis", "typ": "benoetigt", "name": "Schwerbehindertenausweis (§ 152ff SGB IX)"},
+    ]
+  },
+  {
+    "id": "sb_zusatzurlaub",
+    "kategorie": "Schwerbehindertenrecht (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Zusatzurlaub für Schwerbehinderte",
+    "kurz": "5 Tage Urlaub zusätzlich für Arbeitnehmer mit Schwerbehinderung",
+    "rechtsgrundlage": "§ 208 SGB IX",
+    "betrag": "5 Arbeitstage mehr Urlaub",
+    "voraussetzung": "GdB mind. 50; Beschäftigung",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Arbeitgeber (automatisch)",
+    "frist": "Gilt automatisch; ggf. beim Arbeitgeber anzeigen",
+    "tags": ["urlaub", "arbeit", "schwerbehindert"],
+    "abhaengigkeiten": [
+      {"id": "sb_ausweis", "typ": "benoetigt", "name": "Schwerbehindertenausweis (§ 152ff SGB IX)"},
+    ]
+  },
+  {
+    "id": "sb_kuendigungsschutz",
+    "kategorie": "Schwerbehindertenrecht (SGB IX)",
+    "zielgruppe": ["behinderte"],
+    "name": "Besonderer Kündigungsschutz",
+    "kurz": "Kündigung bedarf Zustimmung des Integrationsamts",
+    "rechtsgrundlage": "§§ 168–175 SGB IX",
+    "betrag": "Rechtsschutz (kein Geldbetrag)",
+    "voraussetzung": "GdB mind. 50; Arbeitnehmer",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Integrationsamt (automatisch geschützt)",
+    "frist": "Bei Kündigung: Widerspruch / Integrationsamt einschalten",
+    "tags": ["kuendigung", "schutz", "arbeit", "integrationsamt"],
+    "abhaengigkeiten": [
+      {"id": "sb_ausweis", "typ": "benoetigt", "name": "Schwerbehindertenausweis (§ 152ff SGB IX)"},
+    ]
+  },
+
+  # ══════════════════════════════════════════════════════════
+  #  6. STEUERLICHE ENTLASTUNGEN
+  # ══════════════════════════════════════════════════════════
+  {
+    "id": "st_pflegepausch",
+    "kategorie": "Steuerliche Entlastungen",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Pflegepauschbetrag",
+    "kurz": "Steuerpauschbetrag für pflegende Angehörige",
+    "rechtsgrundlage": "§ 33b Abs. 6 EStG",
+    "betrag": "600 € (Grad 2–3) · 1.100 € (Grad 4) · 1.800 € (Grad 5 / Merkzeichen H)",
+    "voraussetzung": "Pflege mind. Pflegegrad 2; häusliche Pflege; kein Entgelt",
+    "pflegegrad_min": 2, "pflegegrad_max": 5,
+    "antragsteller": "Finanzamt (Steuererklärung)",
+    "frist": "Steuererklärung; bis 31.7. des Folgejahres",
+    "tags": ["steuer", "pauschbetrag", "pflege", "angehoerige"],
+    "abhaengigkeiten": [
+      {"id": "pk_pflegegeld", "typ": "ergaenzt", "name": "Pflegegeld (§ 37 SGB XI) – Nachweis der Pflegetätigkeit"},
+    ]
+  },
+  {
+    "id": "st_behindpausch",
+    "kategorie": "Steuerliche Entlastungen",
+    "zielgruppe": ["behinderte"],
+    "name": "Behinderten-Pauschbetrag",
+    "kurz": "Steuerpauschbetrag für Menschen mit Behinderung",
+    "rechtsgrundlage": "§ 33b EStG",
+    "betrag": "384 € (GdB 20) bis 7.400 € (GdB 100 oder blind)",
+    "voraussetzung": "GdB mind. 20",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Finanzamt (Steuererklärung)",
+    "frist": "Steuererklärung",
+    "tags": ["steuer", "pauschbetrag", "behinderung", "gdb"]
+  },
+  {
+    "id": "st_haushaltsnahe",
+    "kategorie": "Steuerliche Entlastungen",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Haushaltsnahe Dienstleistungen & Pflegekosten",
+    "kurz": "Steuerermäßigung für Pflegedienst, Haushaltshilfe, Handwerker",
+    "rechtsgrundlage": "§ 35a EStG",
+    "betrag": "20 % der Lohnkosten; max. 4.000 € Steuerersparnis/Jahr",
+    "voraussetzung": "Rechnung und Überweisung; kein Barzahlung; eigener Haushalt",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Finanzamt (Steuererklärung)",
+    "frist": "Steuererklärung",
+    "tags": ["steuer", "haushalt", "handwerker", "pflegedienst", "ermaessigung"]
+  },
+  {
+    "id": "st_ag_belastung",
+    "kategorie": "Steuerliche Entlastungen",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Außergewöhnliche Belastungen (Pflegekosten)",
+    "kurz": "Abzug von Pflegeheimkosten und medizinischen Kosten die Zumutbarkeitsgrenze übersteigen",
+    "rechtsgrundlage": "§ 33 EStG",
+    "betrag": "Steuerminderung; abhängig von Einkommen und Zumutbarkeitsgrenze",
+    "voraussetzung": "Kosten übersteigen zumutbare Eigenbelastung",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Finanzamt (Steuererklärung)",
+    "frist": "Steuererklärung",
+    "tags": ["steuer", "belastung", "pflegeheim", "kosten", "arzt"]
+  },
+
+  # ══════════════════════════════════════════════════════════
+  #  7. WOHNEN & BAUEN
+  # ══════════════════════════════════════════════════════════
+  {
+    "id": "wohn_kfw",
+    "kategorie": "Wohnen & Bauen",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "KfW-Programm Altersgerecht Umbauen (455-B)",
+    "kurz": "Zinsgünstiger Kredit für barrierefreien Umbau",
+    "rechtsgrundlage": "KfW-Programm 455-B",
+    "betrag": "bis 50.000 € Kredit; oder Tilgungszuschuss 12,5 %",
+    "voraussetzung": "Eigentümer oder Mieter mit Genehmigung; Bestandsgebäude",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "KfW (über Hausbank beantragen)",
+    "frist": "Antrag VOR Beginn der Maßnahme",
+    "tags": ["kfw", "umbau", "barrierefrei", "kredit", "wohnen"],
+    "abhaengigkeiten": [
+      {"id": "pk_wohnumfeld", "typ": "ergaenzt", "name": "Wohnumfeldverbesserung Pflegekasse (§ 40 Abs. 4 SGB XI)"},
+    ]
+  },
+  {
+    "id": "wohn_wohngeld",
+    "kategorie": "Wohnen & Bauen",
+    "zielgruppe": ["beduerftige", "alterspflege"],
+    "name": "Wohngeld",
+    "kurz": "Staatlicher Zuschuss zu den Wohnkosten für einkommensschwache Haushalte",
+    "rechtsgrundlage": "WoGG",
+    "betrag": "Variabel; durchschnittlich ca. 370 € / Monat (2024)",
+    "voraussetzung": "Geringes Einkommen; kein SGB II/XII Bezug",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Wohngeldbehörde (Gemeinde/Stadt)",
+    "frist": "Antrag jederzeit; rückwirkend 1 Monat",
+    "tags": ["wohnen", "miete", "zuschuss", "geld", "arm"]
+  },
+  {
+    "id": "wohn_sozialer",
+    "kategorie": "Wohnen & Bauen",
+    "zielgruppe": ["beduerftige", "alterspflege", "behinderte"],
+    "name": "Sozialer Wohnungsbau / Sozialwohnung",
+    "kurz": "Vergünstigte Miete in geförderten Wohnungen",
+    "rechtsgrundlage": "Landesgesetze (je Bundesland)",
+    "betrag": "Mietreduktion; variabel",
+    "voraussetzung": "Wohnberechtigungsschein (WBS); Einkommensgrenzen",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Gemeinde / Wohnungsbaugesellschaft",
+    "frist": "Antrag WBS beim Wohnungsamt",
+    "tags": ["wohnen", "sozialwohnung", "miete", "wbs"]
+  },
+
+  # ══════════════════════════════════════════════════════════
+  #  8. LANDESLEISTUNGEN
+  # ══════════════════════════════════════════════════════════
+  {
+    "id": "land_bayernpflegegeld",
+    "kategorie": "Landesleistungen (Bayern)",
+    "zielgruppe": ["alterspflege", "beduerftige", "behinderte"],
+    "name": "Bayerisches Pflegegeld (Landespflegegeld)",
+    "kurz": "Zusätzliches Pflegegeld des Freistaats Bayern",
+    "rechtsgrundlage": "BayPflegeG",
+    "betrag": "1.000 € / Jahr (einmalige Jahresleistung)",
+    "voraussetzung": "Wohnsitz Bayern; Pflegegrad 2–5; häusliche Pflege",
+    "pflegegrad_min": 2, "pflegegrad_max": 5,
+    "antragsteller": "Bayerisches Landesamt für Pflege (LfP)",
+    "frist": "Jährlich beantragen; bis 31.12. für das laufende Jahr",
+    "tags": ["bayern", "landespflegegeld", "extra", "jaehrlich"],
+    "abhaengigkeiten": [
+      {"id": "pk_pflegegeld", "typ": "ergaenzt", "name": "Pflegegeld (§ 37 SGB XI) – Bundespflegegeld"},
+    ]
+  },
+  {
+    "id": "land_landesblindengeld",
+    "kategorie": "Landesleistungen (Bayern)",
+    "zielgruppe": ["behinderte"],
+    "name": "Bayerisches Blindengeld",
+    "kurz": "Monatliches Landesgeld für blinde Menschen in Bayern",
+    "rechtsgrundlage": "BayBlindG",
+    "betrag": "ca. 636 € / Monat (ab 18); 318 € unter 18 (2025)",
+    "voraussetzung": "Wohnsitz Bayern; Blindheit",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Versorgungsamt / Bezirk",
+    "frist": "Antrag beim Versorgungsamt",
+    "tags": ["blind", "bayern", "geld", "monatlich"]
+  },
+  {
+    "id": "land_rundfunk",
+    "kategorie": "Landesleistungen (Allgemein)",
+    "zielgruppe": ["beduerftige", "behinderte"],
+    "name": "Rundfunkbeitragsbefreiung / -ermäßigung",
+    "kurz": "Befreiung vom GEZ-Beitrag (Rundfunkbeitrag 18,36 €/Monat)",
+    "rechtsgrundlage": "§ 4 RBStV",
+    "betrag": "Vollständige Befreiung oder Ermäßigung auf 5,99 €",
+    "voraussetzung": "Grundsicherung, Blindheit (Merkz. Bl), taubblind, GdB 80+ mit best. Merkzeichen",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "ARD ZDF Deutschlandradio Beitragsservice",
+    "frist": "Antrag jederzeit; rückwirkend auf Antragsdatum",
+    "tags": ["rundfunk", "gez", "befreiung", "blind", "arm"]
+  },
+
+  # ══════════════════════════════════════════════════════════
+  #  9. BÜRGERGELD / SGB II
+  # ══════════════════════════════════════════════════════════
+  {
+    "id": "alg_buergergeld",
+    "kategorie": "Bürgergeld (SGB II)",
+    "zielgruppe": ["beduerftige"],
+    "name": "Bürgergeld",
+    "kurz": "Grundsicherung für Arbeitsuchende (ehem. Hartz IV)",
+    "rechtsgrundlage": "SGB II",
+    "betrag": "Regelbedarf 563 € (2025) + Unterkunft + Heizung",
+    "voraussetzung": "Erwerbsfähig; bedürftig; 15–67 Jahre",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Jobcenter",
+    "frist": "Antrag sofort bei Bedürftigkeit; rückwirkend 1 Monat",
+    "tags": ["buergergeld", "grundsicherung", "arbeit", "hartz", "jobcenter"]
+  },
+  {
+    "id": "alg_mehrbedarf",
+    "kategorie": "Bürgergeld (SGB II)",
+    "zielgruppe": ["behinderte", "beduerftige"],
+    "name": "Mehrbedarf für Behinderte (Bürgergeld)",
+    "kurz": "Aufschlag auf Bürgergeld für behinderte Leistungsempfänger",
+    "rechtsgrundlage": "§ 21 SGB II",
+    "betrag": "35 % des Regelbedarfs (197 €/Monat bei 563 € Regelbedarf)",
+    "voraussetzung": "Schwerbehinderung; Bürgergeld-Bezug; Eingliederungshilfe",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Jobcenter",
+    "frist": "Mit Bürgergeld-Antrag",
+    "tags": ["mehrbedarf", "behinderung", "buergergeld", "aufschlag"]
+  },
+
+  # ══════════════════════════════════════════════════════════
+  #  10. RENTENVERSICHERUNG / SOZIALE ENTSCHÄDIGUNG
+  # ══════════════════════════════════════════════════════════
+  {
+    "id": "rv_reha",
+    "kategorie": "Rentenversicherung (DRV)",
+    "zielgruppe": ["beduerftige", "behinderte"],
+    "name": "Medizinische Rehabilitation (DRV)",
+    "kurz": "Reha zur Erhaltung der Erwerbsfähigkeit",
+    "rechtsgrundlage": "§ 15 SGB VI",
+    "betrag": "Kostenübernahme + Übergangsgeld 70 % Brutto",
+    "voraussetzung": "Gefährdete oder geminderte Erwerbsfähigkeit",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Deutsche Rentenversicherung",
+    "frist": "Antrag bei DRV; alle 4 Jahre",
+    "tags": ["rente", "reha", "erwerb", "drv"]
+  },
+  {
+    "id": "rv_erwminderung",
+    "kategorie": "Rentenversicherung (DRV)",
+    "zielgruppe": ["beduerftige", "behinderte"],
+    "name": "Erwerbsminderungsrente",
+    "kurz": "Rente wegen teilweiser oder voller Erwerbsminderung",
+    "rechtsgrundlage": "§§ 43–44 SGB VI",
+    "betrag": "Individuell; abhängig von Versicherungsjahren",
+    "voraussetzung": "Weniger als 3 Std./Tag (voll) oder 3–6 Std./Tag (teilweise) arbeitsfähig",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Deutsche Rentenversicherung",
+    "frist": "Antrag bei DRV",
+    "tags": ["rente", "erwerbsminderung", "behinderung", "drv"]
+  },
+  {
+    "id": "se_sgb14",
+    "kategorie": "Soziale Entschädigung (SGB XIV)",
+    "zielgruppe": ["beduerftige", "behinderte"],
+    "name": "Leistungen der Sozialen Entschädigung",
+    "kurz": "Entschädigung bei Schäden durch Krieg, Impfschäden, Gewalttaten",
+    "rechtsgrundlage": "SGB XIV (ehem. OEG, BVG, ImpfSchAusglG)",
+    "betrag": "Individuell; Versorgungsrente, Pflegezulagen, Heilbehandlung",
+    "voraussetzung": "Schaden durch anerkanntes Ereignis (Gewalt, Impfung, Kriegsfolge)",
+    "pflegegrad_min": 0, "pflegegrad_max": 5,
+    "antragsteller": "Versorgungsamt / Landesbehörde",
+    "frist": "Antrag ohne Frist; möglichst zeitnah",
+    "tags": ["entschaedigung", "gewalt", "impfung", "krieg", "opfer"]
+  },
+]
+
+# ── Hilfsfunktionen ────────────────────────────────────────────────────────
+
+def get_all():
+    return KATALOG
+
+def get_by_zielgruppe(zg):
+    return [l for l in KATALOG if zg in l.get("zielgruppe", [])]
+
+def get_by_pflegegrad(grad):
+    return [l for l in KATALOG
+            if l.get("pflegegrad_min", 0) <= grad <= l.get("pflegegrad_max", 5)]
+
+def get_by_kategorie(kat):
+    return [l for l in KATALOG if l["kategorie"] == kat]
+
+def get_kategorien():
+    seen = set()
+    result = []
+    for l in KATALOG:
+        if l["kategorie"] not in seen:
+            seen.add(l["kategorie"])
+            result.append(l["kategorie"])
+    return result
+
+def get_zielgruppen():
+    return ["alterspflege", "beduerftige", "behinderte"]
+
+def search(query):
+    q = query.lower()
+    return [l for l in KATALOG if
+            q in l["name"].lower() or
+            q in l["kurz"].lower() or
+            q in l.get("rechtsgrundlage","").lower() or
+            any(q in t for t in l.get("tags", []))]
+
+def get_by_id(lid):
+    for l in KATALOG:
+        if l["id"] == lid:
+            return l
+    return None
+
+def get_widerspruch_paragraphen(pflegegrad=None, zielgruppe=None):
+    """Relevante Rechtsnormen für Widerspruch"""
+    base = [
+        ("§ 15 SGB XI", "Pflegebedürftigkeit und Pflegegrade"),
+        ("§ 18 SGB XI", "Begutachtungsverfahren (MDS-Richtlinien)"),
+        ("§ 37 SGB XI", "Pflegegeld – materieller Schaden"),
+        ("§ 36 SGB XI", "Pflegesachleistungen"),
+        ("§ 84 SGG",    "Widerspruchsfrist (1 Monat ab Bekanntgabe)"),
+        ("§ 86 SGG",    "Widerspruchsrecht gegen Verwaltungsakt"),
+        ("§ 33 SGB X",  "Begründungspflicht des Verwaltungsakts"),
+        ("§ 24 SGB X",  "Anhörungsrecht vor Erlass eines Bescheids"),
+    ]
+    if pflegegrad and pflegegrad >= 1:
+        base += [
+            ("§ 45b SGB XI", "Entlastungsbetrag 131 €/Monat"),
+            ("§ 40 SGB XI",  "Pflegehilfsmittel und Wohnumfeldverbesserung"),
+        ]
+    if zielgruppe == "behinderte":
+        base += [
+            ("§ 99 SGB IX", "Leistungsberechtigte Eingliederungshilfe"),
+            ("§ 43a SGB XI", "Pflegeleistungen in Behinderteneinrichtungen"),
+        ]
+    return base
diff --git a/pflegepilot_alpha_v2/pflegepilot/krankenkassen.py b/pflegepilot_alpha_v2/pflegepilot/krankenkassen.py
new file mode 100644
index 0000000..4ac91b3
--- /dev/null
+++ b/pflegepilot_alpha_v2/pflegepilot/krankenkassen.py
@@ -0,0 +1,405 @@
+"""
+Pflegepilot – Krankenkassen-Stammdaten
+Adressen Stand 2025. Vor Verwendung bitte auf Aktualität prüfen.
+Pflegegrad-Bescheide werden meist über die zuständige Pflegekasse abgewickelt,
+die in der Regel identisch mit der Krankenkasse ist.
+"""
+
+KRANKENKASSEN = [
+
+    # ── GKV: AOK ──────────────────────────────────────────────────────────────
+    {"name": "AOK Bayern – Die Gesundheitskasse",
+     "kurzname": "AOK Bayern", "typ": "GKV",
+     "strasse": "Carl-Wery-Straße 28", "plz": "81739", "ort": "München"},
+
+    {"name": "AOK Baden-Württemberg",
+     "kurzname": "AOK BW", "typ": "GKV",
+     "strasse": "Presselstraße 19", "plz": "70191", "ort": "Stuttgart"},
+
+    {"name": "AOK Berlin-Brandenburg",
+     "kurzname": "AOK BE/BB", "typ": "GKV",
+     "strasse": "Wilhelmstraße 1", "plz": "10963", "ort": "Berlin"},
+
+    {"name": "AOK Bremen/Bremerhaven",
+     "kurzname": "AOK Bremen", "typ": "GKV",
+     "strasse": "Bürgermeister-Smidt-Straße 95", "plz": "28195", "ort": "Bremen"},
+
+    {"name": "AOK Hessen",
+     "kurzname": "AOK Hessen", "typ": "GKV",
+     "strasse": "Berner Straße 2", "plz": "60437", "ort": "Frankfurt am Main"},
+
+    {"name": "AOK Niedersachsen",
+     "kurzname": "AOK Niedersachsen", "typ": "GKV",
+     "strasse": "Hildesheimer Straße 273", "plz": "30519", "ort": "Hannover"},
+
+    {"name": "AOK Nordost – Die Gesundheitskasse",
+     "kurzname": "AOK Nordost", "typ": "GKV",
+     "strasse": "Warnowufer 54", "plz": "18057", "ort": "Rostock"},
+
+    {"name": "AOK NordWest – Die Gesundheitskasse",
+     "kurzname": "AOK NordWest", "typ": "GKV",
+     "strasse": "Kopenhagener Straße 1", "plz": "44269", "ort": "Dortmund"},
+
+    {"name": "AOK PLUS – Die Gesundheitskasse für Sachsen und Thüringen",
+     "kurzname": "AOK PLUS", "typ": "GKV",
+     "strasse": "Sternplatz 7", "plz": "01067", "ort": "Dresden"},
+
+    {"name": "AOK Rheinland/Hamburg – Die Gesundheitskasse",
+     "kurzname": "AOK Rheinland/HH", "typ": "GKV",
+     "strasse": "Kaiserstraße 80", "plz": "40479", "ort": "Düsseldorf"},
+
+    {"name": "AOK Rheinland-Pfalz/Saarland – Die Gesundheitskasse",
+     "kurzname": "AOK RLP/SL", "typ": "GKV",
+     "strasse": "Virchowstraße 30", "plz": "67304", "ort": "Eisenberg"},
+
+    {"name": "AOK Sachsen-Anhalt – Die Gesundheitskasse",
+     "kurzname": "AOK ST", "typ": "GKV",
+     "strasse": "Doctor-Eisenbart-Ring 2", "plz": "39120", "ort": "Magdeburg"},
+
+    # ── GKV: Große Kassen ─────────────────────────────────────────────────────
+    {"name": "Barmer",
+     "kurzname": "Barmer", "typ": "GKV",
+     "strasse": "Lichtscheider Straße 89", "plz": "42285", "ort": "Wuppertal"},
+
+    {"name": "DAK-Gesundheit",
+     "kurzname": "DAK", "typ": "GKV",
+     "strasse": "Nagelsweg 27–31", "plz": "20097", "ort": "Hamburg"},
+
+    {"name": "Techniker Krankenkasse",
+     "kurzname": "TK", "typ": "GKV",
+     "strasse": "Bramfelder Straße 140", "plz": "22305", "ort": "Hamburg"},
+
+    {"name": "KKH – Kaufmännische Krankenkasse",
+     "kurzname": "KKH", "typ": "GKV",
+     "strasse": "Karl-Wiechert-Allee 61", "plz": "30625", "ort": "Hannover"},
+
+    {"name": "HEK – Hanseatische Krankenkasse",
+     "kurzname": "HEK", "typ": "GKV",
+     "strasse": "Wandsbeker Zollstraße 86–90", "plz": "22041", "ort": "Hamburg"},
+
+    {"name": "hkk – Handelskrankenkasse",
+     "kurzname": "hkk", "typ": "GKV",
+     "strasse": "Martinistraße 26", "plz": "28195", "ort": "Bremen"},
+
+    {"name": "Knappschaft",
+     "kurzname": "Knappschaft", "typ": "GKV",
+     "strasse": "Pieperstraße 14–28", "plz": "44789", "ort": "Bochum"},
+
+    # ── GKV: IKK ──────────────────────────────────────────────────────────────
+    {"name": "IKK classic",
+     "kurzname": "IKK classic", "typ": "GKV",
+     "strasse": "Tannenstraße 4", "plz": "01099", "ort": "Dresden"},
+
+    {"name": "IKK gesund plus",
+     "kurzname": "IKK gesund plus", "typ": "GKV",
+     "strasse": "Guerickestraße 2", "plz": "39104", "ort": "Magdeburg"},
+
+    {"name": "IKK Nord",
+     "kurzname": "IKK Nord", "typ": "GKV",
+     "strasse": "Heßstraße 35", "plz": "20097", "ort": "Hamburg"},
+
+    {"name": "IKK Südwest",
+     "kurzname": "IKK Südwest", "typ": "GKV",
+     "strasse": "Europaallee 9", "plz": "67657", "ort": "Kaiserslautern"},
+
+    # ── GKV: BKK ──────────────────────────────────────────────────────────────
+    {"name": "BKK VBU",
+     "kurzname": "BKK VBU", "typ": "GKV",
+     "strasse": "Koppenstraße 4–46", "plz": "10243", "ort": "Berlin"},
+
+    {"name": "BKK firmus",
+     "kurzname": "BKK firmus", "typ": "GKV",
+     "strasse": "Gewerbering 4", "plz": "27356", "ort": "Rotenburg (Wümme)"},
+
+    {"name": "BKK ProVita",
+     "kurzname": "BKK ProVita", "typ": "GKV",
+     "strasse": "Am Westpark 8", "plz": "81373", "ort": "München"},
+
+    {"name": "energie BKK",
+     "kurzname": "energie BKK", "typ": "GKV",
+     "strasse": "Lübeckertordamm 1–3", "plz": "20099", "ort": "Hamburg"},
+
+    {"name": "mhplus BKK",
+     "kurzname": "mhplus", "typ": "GKV",
+     "strasse": "Eisenbahnstraße 66", "plz": "73207", "ort": "Plochingen"},
+
+    {"name": "Novitas BKK",
+     "kurzname": "Novitas", "typ": "GKV",
+     "strasse": "Wintgensstraße 27", "plz": "47058", "ort": "Duisburg"},
+
+    {"name": "Pronova BKK",
+     "kurzname": "Pronova BKK", "typ": "GKV",
+     "strasse": "Harrlachweg 1", "plz": "68163", "ort": "Mannheim"},
+
+    {"name": "R+V Betriebskrankenkasse",
+     "kurzname": "R+V BKK", "typ": "GKV",
+     "strasse": "Raiffeisenplatz 1", "plz": "65189", "ort": "Wiesbaden"},
+
+    {"name": "SBK – Siemens-Betriebskrankenkasse",
+     "kurzname": "SBK", "typ": "GKV",
+     "strasse": "Heimeranstraße 31", "plz": "80339", "ort": "München"},
+
+    {"name": "Vivida BKK",
+     "kurzname": "Vivida BKK", "typ": "GKV",
+     "strasse": "Wilhelm-Beck-Straße 6–8", "plz": "88662", "ort": "Überlingen"},
+
+    {"name": "mkk – meine krankenkasse",
+     "kurzname": "mkk", "typ": "GKV",
+     "strasse": "Maximilianstraße 2", "plz": "83435", "ort": "Bad Reichenhall"},
+
+    {"name": "WMF BKK",
+     "kurzname": "WMF BKK", "typ": "GKV",
+     "strasse": "Eberhardstraße 14", "plz": "73312", "ort": "Geislingen an der Steige"},
+
+    # ── GKV: Weitere ──────────────────────────────────────────────────────────
+    {"name": "BIG direkt gesund",
+     "kurzname": "BIG", "typ": "GKV",
+     "strasse": "Westhellweg 41", "plz": "44137", "ort": "Dortmund"},
+
+    {"name": "Heimat Krankenkasse",
+     "kurzname": "Heimat KK", "typ": "GKV",
+     "strasse": "Bielefeldstraße 1", "plz": "33606", "ort": "Bielefeld"},
+
+    {"name": "Viactiv Krankenkasse",
+     "kurzname": "Viactiv", "typ": "GKV",
+     "strasse": "Huyssenallee 52–56", "plz": "45128", "ort": "Essen"},
+
+    {"name": "actimonda BKK",
+     "kurzname": "actimonda", "typ": "GKV",
+     "strasse": "Brunnenstraße 1", "plz": "45128", "ort": "Essen"},
+
+    {"name": "Audi BKK",
+     "kurzname": "Audi BKK", "typ": "GKV",
+     "strasse": "Ettingerstraße 1", "plz": "85045", "ort": "Ingolstadt"},
+
+    {"name": "BMW BKK",
+     "kurzname": "BMW BKK", "typ": "GKV",
+     "strasse": "Moosacher Straße 90", "plz": "80809", "ort": "München"},
+
+    # ── PKV: Private Krankenversicherung ──────────────────────────────────────
+    {"name": "Allianz Private Krankenversicherungs-AG",
+     "kurzname": "Allianz PKV", "typ": "PKV",
+     "strasse": "Königinstraße 28", "plz": "80802", "ort": "München"},
+
+    {"name": "AXA Krankenversicherung AG",
+     "kurzname": "AXA", "typ": "PKV",
+     "strasse": "Colonia-Allee 10–20", "plz": "51067", "ort": "Köln"},
+
+    {"name": "Barmenia Krankenversicherung a.G.",
+     "kurzname": "Barmenia", "typ": "PKV",
+     "strasse": "Kronprinzenallee 12–18", "plz": "42094", "ort": "Wuppertal"},
+
+    {"name": "Continentale Krankenversicherung a.G.",
+     "kurzname": "Continentale", "typ": "PKV",
+     "strasse": "Ruhrallee 92", "plz": "44139", "ort": "Dortmund"},
+
+    {"name": "Debeka Krankenversicherungsverein a.G.",
+     "kurzname": "Debeka", "typ": "PKV",
+     "strasse": "Ferdinand-Sauerbruch-Straße 18", "plz": "56058", "ort": "Koblenz"},
+
+    {"name": "DKV Deutsche Krankenversicherung AG",
+     "kurzname": "DKV", "typ": "PKV",
+     "strasse": "Aachener Straße 300", "plz": "50933", "ort": "Köln"},
+
+    {"name": "Gothaer Krankenversicherung AG",
+     "kurzname": "Gothaer", "typ": "PKV",
+     "strasse": "Gothaer Allee 1", "plz": "50969", "ort": "Köln"},
+
+    {"name": "Hallesche Krankenversicherung a.G.",
+     "kurzname": "Hallesche", "typ": "PKV",
+     "strasse": "Reinsburgstraße 10", "plz": "70178", "ort": "Stuttgart"},
+
+    {"name": "HanseMerkur Krankenversicherung AG",
+     "kurzname": "HanseMerkur", "typ": "PKV",
+     "strasse": "Siegfried-Wedells-Platz 1", "plz": "20354", "ort": "Hamburg"},
+
+    {"name": "Inter Krankenversicherung AG",
+     "kurzname": "Inter", "typ": "PKV",
+     "strasse": "Erzbergerstraße 9–15", "plz": "68165", "ort": "Mannheim"},
+
+    {"name": "LVM Krankenversicherung AG",
+     "kurzname": "LVM", "typ": "PKV",
+     "strasse": "Kolde-Ring 21", "plz": "48126", "ort": "Münster"},
+
+    {"name": "Münchener Verein Krankenversicherung a.G.",
+     "kurzname": "Münchener Verein", "typ": "PKV",
+     "strasse": "Pettenkoferstraße 19", "plz": "80336", "ort": "München"},
+
+    {"name": "NÜRNBERGER Krankenversicherung AG",
+     "kurzname": "NÜRNBERGER", "typ": "PKV",
+     "strasse": "Ostendstraße 100", "plz": "90334", "ort": "Nürnberg"},
+
+    {"name": "ottonova Krankenversicherung AG",
+     "kurzname": "ottonova", "typ": "PKV",
+     "strasse": "Maximiliansplatz 5", "plz": "80333", "ort": "München"},
+
+    {"name": "R+V Krankenversicherung AG",
+     "kurzname": "R+V PKV", "typ": "PKV",
+     "strasse": "Raiffeisenplatz 1", "plz": "65189", "ort": "Wiesbaden"},
+
+    {"name": "SDK – Süddeutsche Krankenversicherung a.G.",
+     "kurzname": "SDK", "typ": "PKV",
+     "strasse": "Raiffeisenplatz 1", "plz": "70736", "ort": "Fellbach"},
+
+    {"name": "Signal Iduna Krankenversicherung AG",
+     "kurzname": "Signal Iduna", "typ": "PKV",
+     "strasse": "Joseph-Scherer-Straße 3", "plz": "44139", "ort": "Dortmund"},
+
+    {"name": "UNIVERSA Krankenversicherung a.G.",
+     "kurzname": "UNIVERSA", "typ": "PKV",
+     "strasse": "Sulzbacher Straße 1–7", "plz": "90489", "ort": "Nürnberg"},
+
+    {"name": "Württembergische Krankenversicherung AG",
+     "kurzname": "WKV", "typ": "PKV",
+     "strasse": "Gutenbergstraße 30", "plz": "70176", "ort": "Stuttgart"},
+
+    {"name": "Bayerische Beamtenkrankenkasse AG",
+     "kurzname": "BBKK", "typ": "PKV",
+     "strasse": "Maximilianstraße 53", "plz": "81537", "ort": "München"},
+
+    {"name": "Mecklenburgische Krankenversicherung AG",
+     "kurzname": "Mecklenburgische", "typ": "PKV",
+     "strasse": "Platz der Göttinger Sieben 1", "plz": "30169", "ort": "Hannover"},
+
+    # ── Österreich: Sozialversicherung (SV) ───────────────────────────────────
+    # Österreichische Gesundheitskasse – Hauptstelle
+    {"name": "Österreichische Gesundheitskasse",
+     "kurzname": "ÖGK", "typ": "SV", "land": "AT",
+     "strasse": "Kundmanngasse 21", "plz": "1031", "ort": "Wien"},
+
+    # ÖGK Landesstellen
+    {"name": "ÖGK Landesstelle Wien",
+     "kurzname": "ÖGK Wien", "typ": "SV", "land": "AT",
+     "strasse": "Wienerbergstraße 15–19", "plz": "1100", "ort": "Wien"},
+
+    {"name": "ÖGK Landesstelle Niederösterreich",
+     "kurzname": "ÖGK NÖ", "typ": "SV", "land": "AT",
+     "strasse": "Kremser Landstraße 3", "plz": "3100", "ort": "St. Pölten"},
+
+    {"name": "ÖGK Landesstelle Oberösterreich",
+     "kurzname": "ÖGK OÖ", "typ": "SV", "land": "AT",
+     "strasse": "Gruberstraße 77", "plz": "4021", "ort": "Linz"},
+
+    {"name": "ÖGK Landesstelle Steiermark",
+     "kurzname": "ÖGK Stmk", "typ": "SV", "land": "AT",
+     "strasse": "Josef-Pongratz-Platz 1", "plz": "8011", "ort": "Graz"},
+
+    {"name": "ÖGK Landesstelle Kärnten",
+     "kurzname": "ÖGK Ktn", "typ": "SV", "land": "AT",
+     "strasse": "Kempfstraße 8", "plz": "9021", "ort": "Klagenfurt"},
+
+    {"name": "ÖGK Landesstelle Salzburg",
+     "kurzname": "ÖGK Sbg", "typ": "SV", "land": "AT",
+     "strasse": "Engelbert-Weiß-Weg 10", "plz": "5020", "ort": "Salzburg"},
+
+    {"name": "ÖGK Landesstelle Tirol",
+     "kurzname": "ÖGK Tirol", "typ": "SV", "land": "AT",
+     "strasse": "Klara-Pölt-Weg 2", "plz": "6020", "ort": "Innsbruck"},
+
+    {"name": "ÖGK Landesstelle Vorarlberg",
+     "kurzname": "ÖGK Vbg", "typ": "SV", "land": "AT",
+     "strasse": "Jahngasse 4", "plz": "6850", "ort": "Dornbirn"},
+
+    {"name": "ÖGK Landesstelle Burgenland",
+     "kurzname": "ÖGK Bgld", "typ": "SV", "land": "AT",
+     "strasse": "Esterházyplatz 3", "plz": "7001", "ort": "Eisenstadt"},
+
+    # Weitere AT Sozialversicherungsträger
+    {"name": "Sozialversicherungsanstalt der Selbständigen",
+     "kurzname": "SVS", "typ": "SV", "land": "AT",
+     "strasse": "Wiedner Hauptstraße 84–86", "plz": "1051", "ort": "Wien"},
+
+    {"name": "Versicherungsanstalt öffentlich Bediensteter, Eisenbahnen und Bergbau",
+     "kurzname": "BVAEB", "typ": "SV", "land": "AT",
+     "strasse": "Josefstädter Straße 80", "plz": "1080", "ort": "Wien"},
+
+    # ── Schweiz: Krankenversicherung nach KVG ─────────────────────────────────
+    {"name": "Helsana Versicherungen AG",
+     "kurzname": "Helsana", "typ": "KVG", "land": "CH",
+     "strasse": "Zürichstrasse 130", "plz": "8600", "ort": "Dübendorf"},
+
+    {"name": "CSS Versicherung AG",
+     "kurzname": "CSS", "typ": "KVG", "land": "CH",
+     "strasse": "Tribschenstraße 21", "plz": "6005", "ort": "Luzern"},
+
+    {"name": "SWICA Krankenversicherung AG",
+     "kurzname": "SWICA", "typ": "KVG", "land": "CH",
+     "strasse": "Römerstraße 38", "plz": "8401", "ort": "Winterthur"},
+
+    {"name": "Sanitas Krankenversicherung",
+     "kurzname": "Sanitas", "typ": "KVG", "land": "CH",
+     "strasse": "Jägergasse 3", "plz": "8021", "ort": "Zürich"},
+
+    {"name": "Concordia Schweizerische Kranken- und Unfallversicherung AG",
+     "kurzname": "Concordia", "typ": "KVG", "land": "CH",
+     "strasse": "Bundesplatz 15", "plz": "6003", "ort": "Luzern"},
+
+    {"name": "Visana Versicherungen AG",
+     "kurzname": "Visana", "typ": "KVG", "land": "CH",
+     "strasse": "Weltpoststrasse 19", "plz": "3015", "ort": "Bern"},
+
+    {"name": "KPT Krankenkasse AG",
+     "kurzname": "KPT", "typ": "KVG", "land": "CH",
+     "strasse": "Wankdorfallee 3", "plz": "3014", "ort": "Bern"},
+
+    {"name": "Assura-Basis SA",
+     "kurzname": "Assura", "typ": "KVG", "land": "CH",
+     "strasse": "Avenue Charles-Ferdinand-Ramuz 70", "plz": "1009", "ort": "Pully"},
+
+    {"name": "Groupe Mutuel Versicherungen GmbH",
+     "kurzname": "Groupe Mutuel", "typ": "KVG", "land": "CH",
+     "strasse": "Rue des Cèdres 5", "plz": "1919", "ort": "Martigny"},
+
+    {"name": "Atupri Gesundheitsversicherung",
+     "kurzname": "Atupri", "typ": "KVG", "land": "CH",
+     "strasse": "Zieglerstrasse 29", "plz": "3007", "ort": "Bern"},
+
+    {"name": "Sympany AG",
+     "kurzname": "Sympany", "typ": "KVG", "land": "CH",
+     "strasse": "Peter Merian-Weg 4", "plz": "4052", "ort": "Basel"},
+
+    {"name": "EGK Gesundheitskasse",
+     "kurzname": "EGK", "typ": "KVG", "land": "CH",
+     "strasse": "Brislachstrasse 2", "plz": "4242", "ort": "Laufen"},
+
+    {"name": "Aquilana Versicherungen",
+     "kurzname": "Aquilana", "typ": "KVG", "land": "CH",
+     "strasse": "Bruggerstrasse 46", "plz": "5401", "ort": "Baden"},
+
+    {"name": "Galenos Krankenversicherung AG",
+     "kurzname": "Galenos", "typ": "KVG", "land": "CH",
+     "strasse": "Militärstrasse 36", "plz": "8004", "ort": "Zürich"},
+
+    {"name": "Sana24 AG",
+     "kurzname": "Sana24", "typ": "KVG", "land": "CH",
+     "strasse": "Weltpoststrasse 19", "plz": "3015", "ort": "Bern"},
+
+    {"name": "Kolping Krankenkasse AG",
+     "kurzname": "Kolping", "typ": "KVG", "land": "CH",
+     "strasse": "Raemistrasse 5", "plz": "8024", "ort": "Zürich"},
+]
+
+def get_all(land=None):
+    if land:
+        return [k for k in KRANKENKASSEN if k.get("land", "DE") == land]
+    return KRANKENKASSEN
+
+def get_by_land(land):
+    return [k for k in KRANKENKASSEN if k.get("land", "DE") == land]
+
+def get_by_name(name):
+    name_l = name.lower()
+    for k in KRANKENKASSEN:
+        if k["name"].lower() == name_l or k["kurzname"].lower() == name_l:
+            return k
+    return None
+
+def search(q, land=None):
+    q = q.lower()
+    results = [k for k in KRANKENKASSEN
+               if q in k["name"].lower()
+               or q in (k["kurzname"] or "").lower()
+               or q in k["ort"].lower()]
+    if land:
+        results = [k for k in results if k.get("land", "DE") == land]
+    return results
diff --git a/pflegepilot_alpha_v2/pflegepilot/start.py b/pflegepilot_alpha_v2/pflegepilot/start.py
new file mode 100644
index 0000000..1cced54
--- /dev/null
+++ b/pflegepilot_alpha_v2/pflegepilot/start.py
@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+"""
+Pflegepilot Alpha – Startskript
+Initialisiert die SQLite-Datenbank und startet den Webserver.
+"""
+import os, sys
+
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8")
+    sys.stderr.reconfigure(encoding="utf-8")
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, BASE_DIR)
+
+from app import app, init_db
+
+if __name__ == "__main__":
+    print("=" * 55)
+    print("  Pflegepilot Alpha – Lokaler Server")
+    print("=" * 55)
+    print("  Datenbank wird initialisiert…")
+    init_db()
+    print("  OK – SQLite Datenbank bereit")
+    print()
+    print("  ▶  Öffne im Browser: http://localhost:5050")
+    print("  Strg+C zum Beenden")
+    print("=" * 55)
+    app.run(debug=False, port=5050, host="127.0.0.1")
diff --git a/pflegepilot_alpha_v2/pflegepilot/static/logo/firmenlogo.png b/pflegepilot_alpha_v2/pflegepilot/static/logo/firmenlogo.png
new file mode 100644
index 0000000..ca06a34
Binary files /dev/null and b/pflegepilot_alpha_v2/pflegepilot/static/logo/firmenlogo.png differ
diff --git a/pflegepilot_alpha_v2/pflegepilot/templates/index.html b/pflegepilot_alpha_v2/pflegepilot/templates/index.html
new file mode 100644
index 0000000..01edf4d
--- /dev/null
+++ b/pflegepilot_alpha_v2/pflegepilot/templates/index.html
@@ -0,0 +1,2141 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Pflegepilot Alpha</title>
+<link href="https://fonts.googleapis.com/css2?family=IBM+Plex+Sans:wght@400;500&family=IBM+Plex+Mono:wght@400;500&display=swap" rel="stylesheet">
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@tabler/icons-webfont@3.11.0/dist/tabler-icons.min.css">
+<script src="https://cdnjs.cloudflare.com/ajax/libs/html2pdf.js/0.10.1/html2pdf.bundle.min.js"></script>
+<style>
+*{box-sizing:border-box;margin:0;padding:0}
+:root{
+  --bg:#f5f4f0;--surface:#fff;--border:#e5e2d8;--border2:#ccc8bb;
+  --text:#1a1a18;--muted:#6b6960;--hint:#9c9990;
+  --green:#1D9E75;--gbg:#E1F5EE;--gdk:#085041;--gmd:#0F6E56;
+  --ambg:#FAEEDA;--amtx:#854F0B;
+  --blbg:#E6F1FB;--bltx:#185FA5;
+  --rdbg:#FCEBEB;--rdtx:#A32D2D;
+  --grbg:#F1EFE8;--grtx:#5F5E5A;
+  --pubg:#EEEDFE;--putx:#3C3489;
+  --cobg:#FAECE7;--cotx:#993C1D;
+  --r:8px;--rl:12px;
+}
+body{font-family:'IBM Plex Sans',sans-serif;background:var(--bg);color:var(--text);font-size:14px;line-height:1.5}
+.app{display:flex;height:100vh;overflow:hidden}
+.sb{width:228px;min-width:228px;background:var(--surface);border-right:1px solid var(--border);display:flex;flex-direction:column;overflow:hidden}
+.sb-logo{padding:16px;border-bottom:1px solid var(--border)}
+.sb-name{font-size:15px;font-weight:500;display:flex;align-items:center;gap:7px}
+.sb-name i{color:var(--green);font-size:19px}
+.sb-ver{font-size:11px;color:var(--hint);margin-top:2px;font-family:'IBM Plex Mono',monospace}
+.sb-nav{flex:1;overflow-y:auto;padding:4px 0}
+.sb-sec{font-size:10px;font-weight:500;color:var(--hint);text-transform:uppercase;letter-spacing:.07em;padding:11px 14px 3px}
+.ni{display:flex;align-items:center;gap:8px;padding:8px 14px;cursor:pointer;font-size:13px;color:var(--muted);transition:all .1s;border-left:2px solid transparent}
+.ni:hover{background:var(--bg);color:var(--text)}
+.ni.on{background:var(--gbg);color:var(--gdk);border-left-color:var(--green);font-weight:500}
+.ni i{font-size:16px;width:17px;flex-shrink:0}
+.ni .nbadge{margin-left:auto;background:var(--rdbg);color:var(--rdtx);font-size:10.5px;padding:1px 7px;border-radius:9px}
+.sb-foot{padding:11px 14px;border-top:1px solid var(--border);font-size:11.5px;color:var(--hint);display:flex;align-items:center;gap:6px}
+.sb-admin{border-top:1px solid var(--border);padding:4px 0 2px}
+.ni[data-p="backend"].on{background:var(--blbg);color:var(--bltx);border-left-color:var(--bltx)}
+.ni[data-p="backend"]:hover{background:var(--blbg);color:var(--bltx)}
+.admin-pill{font-size:10px;padding:1px 7px;border-radius:9px;background:var(--ambg);color:var(--amtx);margin-left:auto;font-weight:500}
+.api-token-wrap{position:relative}
+.api-token-wrap input{padding-right:38px}
+.api-token-wrap button{position:absolute;right:6px;top:50%;transform:translateY(-50%);background:none;border:none;cursor:pointer;color:var(--muted);padding:4px}
+.logo-preview{width:80px;height:80px;object-fit:contain;border-radius:var(--r);border:1px solid var(--border);background:var(--bg);padding:6px}
+.logo-empty{width:80px;height:80px;border-radius:var(--r);border:2px dashed var(--border2);display:flex;align-items:center;justify-content:center;color:var(--hint);font-size:22px;cursor:pointer}
+.sb-logo-img{height:28px;object-fit:contain}
+.login-card{max-width:360px;margin:60px auto 0}
+.frist-item{display:flex;gap:10px;padding:9px 0;border-bottom:1px solid var(--border);align-items:flex-start}
+.frist-item:last-child{border:none}
+.frist-dot{width:10px;height:10px;border-radius:50%;flex-shrink:0;margin-top:4px}
+.fd-red{background:var(--rdtx)}
+.fd-amber{background:var(--amtx)}
+.fd-blue{background:var(--bltx)}
+.fd-green{background:var(--gmd)}
+.fd-gray{background:var(--hint)}
+.dok-row{display:flex;align-items:center;gap:8px;padding:7px 0;border-bottom:1px solid var(--border);font-size:13px}
+.dok-row:last-child{border:none}
+.dok-icon{width:28px;height:28px;border-radius:6px;display:flex;align-items:center;justify-content:center;font-size:14px;flex-shrink:0}
+.archiv-banner{background:var(--ambg);border:1px solid var(--amtx);color:var(--amtx);border-radius:var(--r);padding:8px 12px;font-size:12.5px;display:flex;align-items:center;gap:7px;margin-bottom:10px}
+.archiv-banner.verstorben{background:var(--grbg);border-color:var(--grtx);color:var(--grtx)}
+.archiv-banner.archiviert{background:var(--blbg);border-color:var(--bltx);color:var(--bltx)}
+.akte-export{font-family:"Courier New",Courier,monospace;font-size:9.5pt;line-height:1.7;padding:0;color:#111;background:#fff}
+.akte-h1{font-size:16pt;font-weight:bold;border-bottom:2px solid #111;padding-bottom:4px;margin-bottom:12px}
+.akte-h2{font-size:12pt;font-weight:bold;margin:14px 0 6px;border-left:3px solid #333;padding-left:7px}
+.akte-h3{font-size:10.5pt;font-weight:bold;margin:10px 0 3px;color:#333}
+.akte-table{width:100%;border-collapse:collapse;margin-bottom:8px}
+.akte-table td,.akte-table th{border:1px solid #ccc;padding:4px 7px;font-size:9pt}
+.akte-table th{background:#f0f0f0;font-weight:bold}
+.akte-footer{border-top:1px solid #999;margin-top:14px;padding-top:6px;font-size:8pt;color:#555}
+.wg-group{border:1px solid var(--border);border-radius:var(--r);margin-bottom:7px;overflow:hidden}
+.wg-group-hd{display:flex;align-items:center;justify-content:space-between;padding:8px 12px;background:var(--bg);cursor:pointer;user-select:none;font-size:12.5px;font-weight:500;gap:8px}
+.wg-group-hd:hover{background:var(--border)}
+.wg-group-body{padding:8px 12px;display:flex;flex-direction:column;gap:4px;border-top:1px solid var(--border)}
+.wg-item{display:flex;align-items:flex-start;gap:7px;font-size:12.5px;cursor:pointer;padding:3px 0;line-height:1.4}
+.wg-item input[type=checkbox]{margin-top:2px;flex-shrink:0;cursor:pointer;width:auto}
+.wg-norm-tag{font-size:10px;font-weight:600;background:var(--blbg);color:var(--bltx);border-radius:4px;padding:1px 6px;white-space:nowrap}
+.main{flex:1;display:flex;flex-direction:column;overflow:hidden}
+.topbar{background:var(--surface);border-bottom:1px solid var(--border);padding:0 20px;height:52px;display:flex;align-items:center;gap:10px;flex-shrink:0}
+.ptitle{font-size:15px;font-weight:500;flex:1}
+.content{flex:1;overflow-y:auto;padding:18px;display:flex;flex-direction:column;gap:14px}
+.btn{display:inline-flex;align-items:center;gap:5px;padding:7px 13px;border:1px solid var(--border2);border-radius:var(--r);background:var(--surface);color:var(--text);cursor:pointer;font-size:13px;font-family:'IBM Plex Sans',sans-serif;transition:all .12s;white-space:nowrap}
+.btn:hover{background:var(--bg)}
+.btn-p{background:var(--green);border-color:var(--green);color:#fff}
+.btn-p:hover{background:var(--gmd)}
+.btn-sm{padding:5px 10px;font-size:12px}
+.btn-ico{padding:6px 8px}
+.card{background:var(--surface);border:1px solid var(--border);border-radius:var(--rl);padding:15px 17px}
+.ch{display:flex;align-items:center;justify-content:space-between;margin-bottom:13px}
+.ct{font-size:11.5px;font-weight:500;color:var(--muted);text-transform:uppercase;letter-spacing:.04em}
+.g2{display:grid;grid-template-columns:1fr 1fr;gap:13px}
+.g3{display:grid;grid-template-columns:repeat(3,1fr);gap:13px}
+.g4{display:grid;grid-template-columns:repeat(4,1fr);gap:13px}
+.metric{background:var(--bg);border-radius:var(--r);padding:12px 14px;border:1px solid var(--border)}
+.ml{font-size:12px;color:var(--muted)}
+.mv{font-size:24px;font-weight:500;margin-top:2px;line-height:1}
+.badge{display:inline-flex;align-items:center;padding:2px 9px;border-radius:9px;font-size:12px;font-weight:500;white-space:nowrap}
+.b-g{background:var(--gbg);color:var(--gdk)}
+.b-a{background:var(--ambg);color:var(--amtx)}
+.b-b{background:var(--blbg);color:var(--bltx)}
+.b-r{background:var(--rdbg);color:var(--rdtx)}
+.b-gr{background:var(--grbg);color:var(--grtx)}
+.b-p{background:var(--pubg);color:var(--putx)}
+.b-c{background:var(--cobg);color:var(--cotx)}
+.b-out{background:transparent;border:1px solid var(--border2);color:var(--muted)}
+.tw{overflow-x:auto}
+table{width:100%;border-collapse:collapse}
+th{text-align:left;padding:8px 11px;font-size:11.5px;font-weight:500;color:var(--muted);border-bottom:1px solid var(--border)}
+td{padding:9px 11px;border-bottom:1px solid var(--border);font-size:13px;vertical-align:middle}
+tr:last-child td{border-bottom:none}
+tr:hover td{background:var(--bg)}
+.tl{color:var(--gmd);cursor:pointer;font-weight:500}
+.tl:hover{text-decoration:underline}
+.av{width:28px;height:28px;border-radius:50%;display:inline-flex;align-items:center;justify-content:center;font-size:11px;font-weight:500;flex-shrink:0}
+.av1{background:var(--gbg);color:var(--gdk)}
+.av2{background:var(--blbg);color:var(--bltx)}
+.av3{background:var(--ambg);color:var(--amtx)}
+.av4{background:var(--cobg);color:var(--cotx)}
+.av5{background:var(--pubg);color:var(--putx)}
+.fg{display:grid;gap:11px}
+.fg.c2{grid-template-columns:1fr 1fr}
+.fg.c3{grid-template-columns:1fr 1fr 1fr}
+.fgrp{display:flex;flex-direction:column;gap:4px}
+.fgrp label{font-size:12px;font-weight:500;color:var(--muted)}
+input,select,textarea{border:1px solid var(--border2);border-radius:var(--r);padding:7px 10px;font-size:13px;font-family:'IBM Plex Sans',sans-serif;background:var(--surface);color:var(--text);width:100%;transition:border .12s}
+input:focus,select:focus,textarea:focus{outline:none;border-color:var(--green);box-shadow:0 0 0 3px rgba(29,158,117,.1)}
+textarea{resize:vertical;min-height:80px}
+.slabel{font-size:11px;font-weight:500;color:var(--hint);text-transform:uppercase;letter-spacing:.05em;padding-bottom:7px;border-bottom:1px solid var(--border);margin-bottom:2px}
+.step{display:flex;gap:10px;padding:8px 0;border-bottom:1px solid var(--border)}
+.step:last-child{border:none}
+.si{width:25px;height:25px;border-radius:50%;display:flex;align-items:center;justify-content:center;font-size:11px;flex-shrink:0;margin-top:1px}
+.s-ok{background:var(--gbg);color:var(--gmd)}
+.s-go{background:var(--blbg);color:var(--bltx)}
+.s-no{background:var(--grbg);color:var(--grtx)}
+.sb2 .t{font-size:13px;font-weight:500}
+.sb2 .d{font-size:12px;color:var(--muted);margin-top:2px}
+.alert{display:flex;gap:10px;padding:11px 13px;border-radius:var(--r);border:1px solid}
+.alert i{font-size:17px;margin-top:1px;flex-shrink:0}
+.a-info{background:var(--blbg);border-color:#B5D4F4;color:var(--bltx)}
+.a-warn{background:var(--ambg);border-color:#FAC775;color:var(--amtx)}
+.a-ok{background:var(--gbg);border-color:#9FE1CB;color:var(--gmd)}
+.alert p{font-size:13px;line-height:1.5}
+.lr{display:flex;align-items:center;justify-content:space-between;padding:8px 0;border-bottom:1px solid var(--border)}
+.lr:last-child{border:none}
+.lv{font-size:14px;font-weight:500;color:var(--gmd)}
+.prog{height:5px;background:var(--bg);border-radius:4px;overflow:hidden}
+.pf{height:100%;background:var(--green);border-radius:4px;transition:width .3s}
+.kkat{display:grid;grid-template-columns:repeat(auto-fill,minmax(290px,1fr));gap:12px}
+.kcard{background:var(--surface);border:1px solid var(--border);border-radius:var(--rl);padding:14px 16px;cursor:pointer;transition:border-color .12s,box-shadow .12s}
+.kcard:hover{border-color:var(--green);box-shadow:0 2px 8px rgba(29,158,117,.12)}
+.kcard-head{display:flex;align-items:flex-start;justify-content:space-between;gap:8px;margin-bottom:8px}
+.kcard-name{font-size:13.5px;font-weight:500;line-height:1.3}
+.kcard-kurz{font-size:12.5px;color:var(--muted);line-height:1.4;margin-bottom:8px}
+.kcard-foot{display:flex;align-items:center;gap:6px;flex-wrap:wrap}
+.kcard-recht{font-size:11px;font-family:'IBM Plex Mono',monospace;color:var(--bltx);background:var(--blbg);padding:2px 7px;border-radius:5px}
+.kcard-betrag{font-size:12px;color:var(--gmd);font-weight:500}
+.kat-group-title{font-size:13px;font-weight:500;padding:10px 0 6px;border-bottom:1px solid var(--border);margin-bottom:8px;display:flex;align-items:center;gap:8px}
+.kat-group-title .cnt{font-size:11px;background:var(--grbg);color:var(--grtx);padding:1px 8px;border-radius:9px;font-weight:400}
+.brief{background:var(--bg);border:1px solid var(--border);border-radius:var(--r);padding:18px;font-family:'IBM Plex Mono',monospace;font-size:12px;line-height:1.85;white-space:pre-wrap;min-height:280px}
+.spin-wrap{display:flex;align-items:center;gap:9px;color:var(--muted);font-size:13px;padding:10px 0}
+.spin{width:16px;height:16px;border:2px solid var(--border2);border-top-color:var(--green);border-radius:50%;animation:sp .7s linear infinite}
+@keyframes sp{to{transform:rotate(360deg)}}
+.mbg{position:fixed;inset:0;background:rgba(0,0,0,.3);z-index:100;display:flex;align-items:center;justify-content:center}
+.modal{background:var(--surface);border-radius:var(--rl);padding:22px;width:640px;max-width:95vw;max-height:88vh;overflow-y:auto;border:1px solid var(--border)}
+.modal-t{font-size:15px;font-weight:500;margin-bottom:14px;display:flex;align-items:center;justify-content:space-between}
+.toast{position:fixed;bottom:22px;right:22px;background:var(--text);color:#fff;padding:9px 16px;border-radius:var(--r);font-size:13px;z-index:200;animation:tu .18s ease;display:flex;align-items:center;gap:7px}
+@keyframes tu{from{transform:translateY(8px);opacity:0}to{transform:translateY(0);opacity:1}}
+.zg-wrap{display:flex;gap:8px;margin-bottom:14px;flex-wrap:wrap}
+.zg-pill{display:flex;align-items:center;gap:6px;padding:7px 14px;border-radius:20px;border:1px solid var(--border2);cursor:pointer;font-size:13px;color:var(--muted);transition:all .12s}
+.zg-pill.on{border-color:var(--green);background:var(--gbg);color:var(--gdk);font-weight:500}
+.zg-pill i{font-size:15px}
+.hidden{display:none!important}
+.fl{display:flex}.ic{align-items:center}.g8{gap:8px}.g12{gap:12px}.mla{margin-left:auto}
+.mt2{margin-top:8px}.mt3{margin-top:12px}.mt4{margin-top:16px}
+.mb3{margin-bottom:12px}.mb4{margin-bottom:16px}
+.muted{color:var(--muted)}.sm{font-size:12px}.w5{font-weight:500}
+.tag{display:inline-flex;padding:2px 8px;border-radius:var(--r);background:var(--bg);border:1px solid var(--border);font-size:12px;color:var(--muted)}
+.mono{font-family:'IBM Plex Mono',monospace}
+.para-tag{font-size:11px;font-family:'IBM Plex Mono',monospace;background:var(--blbg);color:var(--bltx);padding:3px 8px;border-radius:5px;display:inline-block;margin:2px}
+.divider{height:1px;background:var(--border);margin:14px 0}
+.gfield{padding:5px 0;font-size:13.5px}
+.kk-wrap{position:relative}
+.kk-dd{position:absolute;top:calc(100% + 2px);left:0;right:0;background:var(--surface);border:1px solid var(--border2);border-radius:var(--r);max-height:240px;overflow-y:auto;z-index:80;box-shadow:0 4px 14px rgba(0,0,0,.1);display:none}
+.kk-dd.open{display:block}
+.kk-opt{padding:7px 11px;cursor:pointer;display:flex;align-items:center;gap:8px;border-bottom:1px solid var(--border);font-size:13px}
+.kk-opt:last-child{border:none}
+.kk-opt:hover,.kk-opt.sel{background:var(--bg)}
+.kk-opt-name{flex:1;font-weight:500;line-height:1.3}
+.kk-opt-ort{font-size:11.5px;color:var(--muted);white-space:nowrap}
+.kk-tabs{display:flex;gap:4px;padding:6px 8px 5px;border-bottom:1px solid var(--border);flex-shrink:0}
+.kk-tab{padding:2px 9px;border-radius:8px;font-size:11px;cursor:pointer;color:var(--muted);user-select:none;transition:all .12s}
+.kk-tab:hover{background:var(--bg);color:var(--tx)}
+.kk-tab.active{background:var(--green);color:#fff;font-weight:600}
+.pat-foto-btn{cursor:pointer;flex-shrink:0;border-radius:50%;transition:box-shadow .12s}
+.pat-foto-btn:hover{box-shadow:0 0 0 3px rgba(29,158,117,.22)}
+.pat-foto-img{width:52px;height:52px;border-radius:50%;object-fit:cover;border:2px solid var(--border);display:block}
+.pat-foto-empty{width:52px!important;height:52px!important;font-size:16px!important}
+/* ── Login-Overlay ── */
+.lo-overlay{position:fixed;inset:0;background:linear-gradient(135deg,#0f2027 0%,#1d4e3a 50%,#0f2027 100%);display:flex;align-items:center;justify-content:center;z-index:9999;padding:20px}
+.lo-box{background:var(--surface);border-radius:16px;padding:36px 32px 28px;width:100%;max-width:380px;box-shadow:0 20px 60px rgba(0,0,0,.4)}
+.lo-header{text-align:center;margin-bottom:28px}
+.lo-icon{font-size:42px;color:var(--green);display:block;margin-bottom:8px}
+.lo-title{font-size:22px;font-weight:600;margin-bottom:4px}
+.lo-subtitle{font-size:12.5px;color:var(--muted)}
+.lo-btn{width:100%;padding:11px;font-size:14px;margin-top:6px}
+.lo-hint{text-align:center;font-size:12px;color:var(--muted);margin-top:14px;padding:8px;background:var(--bg);border-radius:var(--r)}
+/* ── Sidebar User-Widget ── */
+.sb-user{padding:10px 14px;border-top:1px solid var(--border);display:flex;align-items:center;gap:8px}
+.sb-user-info{flex:1;min-width:0}
+.sb-user-name{font-size:12.5px;font-weight:500;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block}
+.sb-user-role{font-size:10px;color:var(--muted)}
+/* ── Nutzer-Tabelle im Backend ── */
+.nutzer-row{display:flex;align-items:center;gap:8px;padding:8px 0;border-bottom:1px solid var(--border);font-size:13px}
+.nutzer-row:last-child{border:none}
+/* ── Drag&Drop Upload ── */
+.drop-zone{border:2px dashed var(--border);border-radius:var(--r);padding:24px;text-align:center;cursor:pointer;transition:all .15s;color:var(--muted);font-size:13px;margin-bottom:10px}
+.drop-zone.over{border-color:var(--green);background:var(--gbg);color:var(--gtx)}
+.drop-zone i{font-size:28px;display:block;margin-bottom:6px}
+</style>
+</head>
+<body>
+<div class="lo-overlay" id="lo-overlay">
+  <div class="lo-box">
+    <div class="lo-header">
+      <i class="ti ti-heartbeat lo-icon"></i>
+      <div class="lo-title">Pflegepilot</div>
+      <div class="lo-subtitle" id="lo-brand">Sicher · Lokal · DSGVO-konform</div>
+    </div>
+    <div class="fg">
+      <div class="fgrp"><label>Benutzername</label><input id="lo-user" placeholder="admin" autocomplete="username" onkeydown="if(event.key==='Enter')doLogin()"></div>
+      <div class="fgrp"><label>Passwort</label><input id="lo-pw" type="password" placeholder="••••••" autocomplete="current-password" onkeydown="if(event.key==='Enter')doLogin()"></div>
+    </div>
+    <button class="btn btn-p lo-btn" onclick="doLogin()"><i class="ti ti-login"></i>Anmelden</button>
+    <div id="lo-err" style="color:var(--rdtx);text-align:center;font-size:12.5px;min-height:18px;margin-top:8px"></div>
+    <div class="lo-hint"><i class="ti ti-info-circle"></i> Standard-Zugangsdaten: <strong>admin / admin</strong><br>Bitte nach dem ersten Login ändern.</div>
+  </div>
+</div>
+<div class="app">
+  <div class="sb">
+    <div class="sb-logo" id="sb-logo">
+      <div class="sb-name"><i class="ti ti-heartbeat" id="sb-logo-icon"></i><span id="sb-logo-name">Pflegepilot</span></div>
+      <div class="sb-ver" id="sb-firmenname">Alpha v0.5 · SQLite · 82 Leistungen</div>
+    </div>
+    <nav class="sb-nav">
+      <div class="sb-sec">Übersicht</div>
+      <div class="ni on" data-p="dashboard"><i class="ti ti-layout-dashboard"></i>Dashboard</div>
+      <div class="sb-sec">Patienten</div>
+      <div class="ni" data-p="patienten"><i class="ti ti-users"></i>Patientenliste</div>
+      <div class="ni" data-p="neu"><i class="ti ti-user-plus"></i>Neuer Patient</div>
+      <div class="ni" data-p="tagebuch"><i class="ti ti-notebook"></i>Pflegetagebuch<span class="nbadge" id="tb-reminder-badge" style="display:none">!</span></div>
+      <div class="sb-sec">Leistungskatalog</div>
+      <div class="ni" data-p="katalog"><i class="ti ti-list-details"></i>Alle 82 Leistungen</div>
+      <div class="ni" data-p="rechner"><i class="ti ti-calculator"></i>Leistungsrechner</div>
+      <div class="sb-sec">Formulare &amp; Recht</div>
+      <div class="ni" data-p="antrag"><i class="ti ti-file-text"></i>Antrag Pflegegrad</div>
+      <div class="ni" data-p="widerspruch"><i class="ti ti-gavel"></i>Widerspruch-Generator</div>
+      <div class="ni" data-p="musterbrief"><i class="ti ti-mail"></i>Musterbrief</div>
+      <div class="sb-sec">Aufgaben &amp; Fristen</div>
+      <div class="ni" data-p="aufgaben"><i class="ti ti-bell"></i>Offene Aufgaben<span class="nbadge" id="abadge">–</span></div>
+      <div class="ni" data-p="kalender"><i class="ti ti-calendar-event"></i>Fristen &amp; Kalender<span class="nbadge" id="kbadge" style="display:none">!</span></div>
+    </nav>
+    <div class="sb-admin">
+      <div class="ni" data-p="backend"><i class="ti ti-settings-2"></i>Backend<span class="admin-pill">Admin</span></div>
+    </div>
+    <div class="sb-user" id="sb-user" style="display:none">
+      <div class="sb-user-info">
+        <span class="sb-user-name" id="sb-user-name">–</span>
+        <span class="sb-user-role" id="sb-user-role"></span>
+      </div>
+      <button class="btn btn-sm btn-ico" onclick="doLogout()" title="Abmelden"><i class="ti ti-logout"></i></button>
+    </div>
+    <div class="sb-foot"><i class="ti ti-shield-lock" style="color:var(--green)"></i>Alle Daten lokal · SQLite</div>
+  </div>
+  <div class="main">
+    <div class="topbar">
+      <div class="ptitle" id="ptitle">Dashboard</div>
+      <div id="tactions"></div>
+    </div>
+    <div class="content" id="content"><div class="spin-wrap"><div class="spin"></div>Lade…</div></div>
+  </div>
+</div>
+<div class="mbg hidden" id="modal">
+  <div class="modal">
+    <div class="modal-t" id="modal-t">–<button class="btn btn-sm btn-ico" onclick="CM()"><i class="ti ti-x"></i></button></div>
+    <div id="modal-b"></div>
+  </div>
+</div>
+<script>
+const API='';
+let curPage='dashboard';
+let katalogData=[];
+let katPid=null;
+let katPatName=null;
+let mPatId=null;
+let kkData=null;
+const kkCB={};
+let _einstellungen={};
+let curUser=null;
+
+document.querySelectorAll('.ni[data-p]').forEach(el=>{
+  el.addEventListener('click',()=>go(el.dataset.p));
+});
+function go(name,extra){
+  curPage=name;
+  document.querySelectorAll('.ni').forEach(e=>e.classList.remove('on'));
+  const el=document.querySelector('.ni[data-p="'+name+'"]');
+  if(el)el.classList.add('on');
+  ({dashboard:pgDash,patienten:pgPatienten,neu:pgNeu,katalog:pgKatalog,rechner:pgRechner,
+    antrag:pgAntrag,widerspruch:pgWiderspruch,musterbrief:pgMuster,aufgaben:pgAufgaben,tagebuch:pgTagebuch,
+    kalender:pgKalender,backend:pgBackend})[name]?.(extra);
+}
+async function api(path,opts={}){
+  const r=await fetch(API+path,{headers:{'Content-Type':'application/json'},...opts});
+  return r.json();
+}
+function S(id,h){const e=document.getElementById(id);if(e)e.innerHTML=h;}
+function R(html,title,actions){S('content',html);if(title)S('ptitle',title);if(actions!==undefined)S('tactions',actions);}
+function av(name,i){const n=(i%5)+1,p=(name||'?').split(' '),s=(p[0]?.[0]||'')+(p[1]?.[0]||'');return '<div class="av av'+n+'">'+s.toUpperCase()+'</div>';}
+function fdate(d){if(!d)return'–';try{return new Date(d).toLocaleDateString('de-DE');}catch{return d;}}
+function toFilename(s){return(s||'').replace(/ä/g,'ae').replace(/ö/g,'oe').replace(/ü/g,'ue').replace(/Ä/g,'Ae').replace(/Ö/g,'Oe').replace(/Ü/g,'Ue').replace(/ß/g,'ss').replace(/[^a-zA-Z0-9]+/g,'_').replace(/^_|_$/g,'');}
+function isoDate(){return new Date().toISOString().slice(0,10);}
+function toast(m,ok=true){const t=document.createElement('div');t.className='toast';t.innerHTML='<i class="ti ti-'+(ok?'check':'alert-triangle')+'"></i>'+m;document.body.appendChild(t);setTimeout(()=>t.remove(),2800);}
+function escH(s){return(s||'').replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');}
+function editNotizen(pid){
+  const el=document.getElementById('notiz-display-'+pid);
+  const current=el?el.dataset.notiz:'';
+  OM('Notizen bearbeiten',
+    '<p class="sm muted mb3" style="line-height:1.5">Änderungen werden gemäß <strong>ISO 9001:2015 Abschn. 7.5</strong> mit Zeitstempel und Änderungsgrund protokolliert und sind unveränderlich archiviert.</p>'+
+    '<div class="fg"><label class="lb">Notiz</label><textarea id="nz_text" rows="5" class="inp" style="resize:vertical">'+escH(current)+'</textarea></div>'+
+    '<div class="fg mt3"><label class="lb">Änderungsgrund <span style="color:#e74c3c">*</span></label>'+
+    '<input id="nz_grund" class="inp" placeholder="z. B. Aktualisierung nach MDK-Termin, Statusänderung …"></div>'+
+    '<div class="alert a-warn mt3"><i class="ti ti-shield-check"></i><p>Jede Änderung wird mit Datum, Inhalt vorher/nachher und Änderungsgrund im Audit-Trail gespeichert.</p></div>'+
+    '<div class="fl g8 mt3" style="justify-content:flex-end">'+
+    '<button class="btn" onclick="CM()">Abbrechen</button>'+
+    '<button class="btn btn-p" onclick="saveNotizen('+pid+')"><i class="ti ti-device-floppy"></i>Speichern &amp; protokollieren</button>'+
+    '</div>'
+  );
+}
+async function saveNotizen(pid){
+  const text=document.getElementById('nz_text')?.value||'';
+  const grund=(document.getElementById('nz_grund')?.value||'').trim();
+  if(!grund){toast('Bitte Änderungsgrund angeben',false);return;}
+  const r=await api('/api/patienten/'+pid+'/notizen',{method:'POST',body:JSON.stringify({notizen:text,aenderungsgrund:grund})});
+  if(r.ok){CM();toast('Notiz gespeichert & protokolliert ✓');loadPat(pid);}
+  else toast('Fehler beim Speichern',false);
+}
+async function loadNotizenVerlauf(pid){
+  const el=document.getElementById('nverlauf-'+pid);
+  if(!el)return;
+  if(!el.classList.contains('hidden')){el.classList.add('hidden');return;}
+  el.innerHTML='<div class="sm muted">Lade Verlauf…</div>';
+  el.classList.remove('hidden');
+  const rows=await api('/api/patienten/'+pid+'/notizen/verlauf');
+  if(!Array.isArray(rows)||!rows.length){el.innerHTML='<p class="sm muted">Noch keine Änderungshistorie vorhanden.</p>';return;}
+  el.innerHTML='<div class="sm" style="font-weight:500;margin-bottom:6px"><i class="ti ti-history"></i> Änderungshistorie – '+rows.length+' Einträge (ISO 9001 Audit-Trail)</div>'+
+  rows.map(r=>'<div style="border:1px solid var(--border);border-radius:var(--r);padding:8px 10px;margin-bottom:6px;font-size:12px">'+
+    '<div class="fl ic g8 mb1" style="justify-content:space-between">'+
+    '<span style="font-weight:500;font-size:11.5px">'+escH(r.geaendert_am)+'</span>'+
+    '<span class="tag" style="font-size:10px">'+escH(r.geaendert_von||'Nutzer')+'</span>'+
+    '</div>'+
+    '<div class="muted" style="margin-bottom:5px;font-size:11.5px"><strong>Grund:</strong> '+escH(r.aenderungsgrund)+'</div>'+
+    '<div style="background:#fff0f0;padding:5px 8px;border-radius:4px;margin-bottom:4px;border-left:3px solid #e05;white-space:pre-wrap;font-size:11.5px;color:#555">'+escH(r.notizen_alt||'(leer)')+'</div>'+
+    '<div style="background:#f0fff4;padding:5px 8px;border-radius:4px;border-left:3px solid #27ae60;white-space:pre-wrap;font-size:11.5px;color:#333">'+escH(r.notizen_neu||'(leer)')+'</div>'+
+    '</div>').join('');
+}
+function addPageNums(pdf){
+  const n=pdf.internal.getNumberOfPages();
+  const W=pdf.internal.pageSize.getWidth();
+  const H=pdf.internal.pageSize.getHeight();
+  pdf.setFont('helvetica','normal');pdf.setFontSize(8);pdf.setTextColor(120,120,120);
+  for(let i=1;i<=n;i++){
+    pdf.setPage(i);
+    pdf.text('Seite '+i+' von '+n,W/2,H-9,{align:'center'});
+  }
+}
+function OM(title,html){S('modal-t',title+'<button class="btn btn-sm btn-ico" onclick="CM()"><i class="ti ti-x"></i></button>');S('modal-b',html);document.getElementById('modal').classList.remove('hidden');}
+function CM(){document.getElementById('modal').classList.add('hidden');}
+async function refreshBadge(){
+  const d=await api('/api/aufgaben');
+  const e=document.getElementById('abadge');if(e)e.textContent=d.length||'0';
+  const kal=await api('/api/kalender');
+  const today=isoDate();
+  const dring=kal.filter(k=>k.ueberfaellig||(k.prioritaet==='hoch'&&k.datum<=today.slice(0,7)+'-31'));
+  const kb=document.getElementById('kbadge');
+  if(kb){if(dring.length>0){kb.style.display='';kb.textContent=dring.length;}else kb.style.display='none';}
+  checkReminders(kal);
+  checkTagebuchReminder();
+}
+
+const ZGL={'alterspflege':'Alterspflege','beduerftige':'Bedürftigen-Pflege','behinderte':'Behinderten-Pflege'};
+const ZGI={'alterspflege':'ti-walk','beduerftige':'ti-heart-handshake','behinderte':'ti-wheelchair'};
+const ZGB={'alterspflege':'b-g','beduerftige':'b-b','behinderte':'b-p'};
+function zg_badge(zg){return '<span class="badge '+( ZGB[zg]||'b-gr')+'"><i class="ti '+(ZGI[zg]||'ti-user')+'" style="margin-right:3px;font-size:12px"></i>'+(ZGL[zg]||zg)+'</span>';}
+function bdg(s){const m={genehmigt:'b-g',in_pruefung:'b-a',offen:'b-gr',abgelehnt:'b-r',eingereicht:'b-b',widerspruch:'b-b',erstellt:'b-p'};const l={genehmigt:'Genehmigt',in_pruefung:'In Prüfung',offen:'Offen',abgelehnt:'Abgelehnt',eingereicht:'Eingereicht',widerspruch:'Widerspruch',erstellt:'PDF erstellt'};return '<span class="badge '+(m[s]||'b-gr')+'">'+(l[s]||s)+'</span>';}
+function prio(p){const m={hoch:'b-r',mittel:'b-a',normal:'b-gr'};const l={hoch:'Hoch',mittel:'Mittel',normal:'Normal'};return '<span class="badge '+(m[p]||'b-gr')+'">'+(l[p]||p)+'</span>';}
+function gfield(label,val){return '<div class="fgrp"><label>'+label+'</label><div class="gfield">'+(val||'–')+'</div></div>';}
+
+function katIcon(k){
+  if(k.includes('Pflegekasse'))return'ti-shield-heart';
+  if(k.includes('Krankenkasse'))return'ti-stethoscope';
+  if(k.includes('Eingliederung'))return'ti-wheelchair';
+  if(k.includes('Grundsicherung')||k.includes('Sozialhilfe'))return'ti-building-bank';
+  if(k.includes('Schwerbehinderung'))return'ti-certificate';
+  if(k.includes('Steuer'))return'ti-receipt-tax';
+  if(k.includes('Wohnen'))return'ti-home';
+  if(k.includes('Landes'))return'ti-map-pin';
+  if(k.includes('Bürgergeld'))return'ti-cash';
+  if(k.includes('Renten'))return'ti-building-community';
+  if(k.includes('Entschädigung'))return'ti-scale';
+  return'ti-list';
+}
+
+function kcard(l){
+  const zgi=(l.zielgruppe||[]).map(z=>'<i class="ti '+ZGI[z]+'" title="'+ZGL[z]+'" style="font-size:13px;color:var(--muted)"></i>').join('');
+  const b=(l.betrag||'').split('·')[0].split('(')[0].replace(/^(bis|ab) /,'').trim().slice(0,28);
+  const deps=(l.abhaengigkeiten||[]).length;
+  const depsBadge=deps?'<span style="font-size:10px;background:var(--blbg);color:var(--bltx);padding:1px 6px;border-radius:5px;margin-left:auto"><i class="ti ti-link" style="font-size:10px"></i> '+deps+'</span>':'';
+  const assignBtn=katPid?'<button class="btn btn-sm btn-p" style="padding:3px 9px;font-size:11px;margin-left:auto" onclick="event.stopPropagation();assignL(\''+l.id+'\')"><i class="ti ti-user-plus"></i>Zuweisen</button>':'';
+  return '<div class="kcard" onclick=\'showL('+JSON.stringify(l).replace(/'/g,"&#39;")+')\'>'+
+    '<div class="kcard-head"><div class="kcard-name">'+l.name+'</div><div class="fl ic g8">'+zgi+'</div></div>'+
+    '<div class="kcard-kurz">'+l.kurz+'</div>'+
+    '<div class="kcard-foot"><span class="kcard-recht">'+l.rechtsgrundlage+'</span>'+
+    (b?'<span class="kcard-betrag">'+b+'</span>':'')+
+    (katPid?assignBtn:depsBadge)+'</div></div>';
+}
+
+function depTypInfo(typ){
+  const m={
+    'benoetigt':       ['b-r','ti-alert-triangle','Voraussetzung'],
+    'ergaenzt':        ['b-b','ti-link','Gut kombinierbar mit'],
+    'ersetzt_ab_07_2025':['b-a','ti-refresh','Ab 07/2025 ersetzt durch'],
+    'alternativ':      ['b-gr','ti-arrows-exchange','Alternative zu'],
+    'automatisch_mit': ['b-g','ti-plug-connected','Automatisch mit'],
+  };
+  return m[typ]||['b-gr','ti-info-circle',typ];
+}
+async function showLById(id){
+  let item=katalogData.find(l=>l.id===id);
+  if(!item){const r=await api('/api/katalog/'+id);if(!r.error)item=r;}
+  if(item)showL(item);
+}
+async function assignL(lid){
+  if(!katPid){toast('Kein Patient ausgewählt',false);return;}
+  const r=await api('/api/patienten/'+katPid+'/leistungen/katalog',{method:'POST',body:JSON.stringify({katalog_id:lid})});
+  if(r.already){toast('Leistung bereits zugewiesen',false);return;}
+  if(r.ok){toast('Leistung dem Patienten zugewiesen ✓');CM();}
+  else toast(r.error||'Fehler beim Zuweisen',false);
+}
+function showL(l){
+  const zgs=(l.zielgruppe||[]).map(z=>zg_badge(z)).join(' ');
+  const deps=(l.abhaengigkeiten||[]);
+  const depsHtml=deps.length?
+    '<div class="divider"></div>'+
+    '<div class="slabel" style="margin-bottom:8px">Abhängigkeiten & Zusammenhänge</div>'+
+    deps.map(dep=>{
+      const[cls,icon,lbl]=depTypInfo(dep.typ);
+      return '<div style="display:flex;align-items:center;gap:8px;padding:7px 0;border-bottom:1px solid var(--border)">'+
+        '<span class="badge '+cls+'" style="font-size:11px;white-space:nowrap;flex-shrink:0"><i class="ti '+icon+'" style="margin-right:3px;font-size:11px"></i>'+lbl+'</span>'+
+        '<span style="font-size:13px;color:var(--gmd);cursor:pointer" onclick="showLById(\''+dep.id+'\')">'+dep.name+'</span>'+
+        '</div>';
+    }).join(''):'';
+  const assignBtn=katPid?
+    '<button class="btn btn-p" onclick="assignL(\''+l.id+'\')"><i class="ti ti-user-plus"></i>'+katPatName+' zuweisen</button>':'';
+  OM('<span style="font-size:14px;font-weight:500">'+l.name+'</span>',
+    '<div class="mb3">'+zgs+'</div>'+
+    '<span class="para-tag" style="margin-bottom:12px">'+l.rechtsgrundlage+'</span>'+
+    '<div class="fg mt3">'+
+    gfield('Beschreibung',l.kurz)+
+    gfield('Betrag / Leistungsumfang',l.betrag)+
+    gfield('Voraussetzung',l.voraussetzung)+
+    gfield('Pflegegrad',l.pflegegrad_min>0?(l.pflegegrad_min===l.pflegegrad_max?'Grad '+l.pflegegrad_min:'Grad '+l.pflegegrad_min+' – '+l.pflegegrad_max):'Alle Grade')+
+    gfield('Antrag bei',l.antragsteller)+
+    gfield('Frist / Hinweis',l.frist)+
+    '</div>'+
+    depsHtml+
+    '<div class="fl g8 mt4">'+assignBtn+
+    '<button class="btn '+(katPid?'':'btn-p')+'" onclick="CM()"><i class="ti ti-check"></i>'+(katPid?'Abbrechen':'Verstanden')+'</button></div>');
+}
+
+// ── Reminder / Browser-Notifications ─────────────────────
+function checkReminders(events){
+  if(!events||!events.length)return;
+  const today=isoDate();
+  const stored=JSON.parse(localStorage.getItem('pp_shown_reminders')||'[]');
+  const urgent=events.filter(e=>e.ueberfaellig||e.datum===today);
+  urgent.forEach(e=>{
+    const key=e.typ+'_'+e.id+'_'+today;
+    if(stored.includes(key))return;
+    stored.push(key);
+    if(Notification.permission==='granted'){
+      new Notification('Pflegepilot – Frist!',{
+        body:(e.patient_name?e.patient_name+': ':'')+e.titel+' · '+fdate(e.datum),
+        icon:'/static/logo/firmenlogo.png'
+      });
+    }
+  });
+  localStorage.setItem('pp_shown_reminders',JSON.stringify(stored.slice(-200)));
+}
+async function reqNotifPerm(){
+  if(Notification.permission==='default'){
+    const p=await Notification.requestPermission();
+    if(p==='granted')toast('Browser-Benachrichtigungen aktiviert ✓');
+    else toast('Benachrichtigungen abgelehnt – bitte in Browser-Einstellungen erlauben',false);
+  }
+}
+async function checkTagebuchReminder(){
+  const today=isoDate();
+  const storeKey='pp_tb_check_'+today;
+  const notifKey='pp_tb_notif_'+today;
+  let data;
+  try{data=await api('/api/tagebuch/reminder-status');}catch{return;}
+  if(!Array.isArray(data)||!data.length)return;
+  const fehlend=data.filter(p=>!p.heute);
+  // Tagebuch-Erinnerungs-Badge (Anzahl Patienten ohne heutigen Eintrag)
+  const tbb=document.getElementById('tb-reminder-badge');
+  if(tbb){tbb.textContent=fehlend.length||'';tbb.style.display=fehlend.length?'':'none';}
+  // Browser-Notification (einmal pro Tag)
+  const notifSent=localStorage.getItem(notifKey);
+  if(!notifSent&&fehlend.length&&Notification.permission==='granted'){
+    new Notification('Pflegepilot – Pflegetagebuch',{
+      body:fehlend.map(p=>p.name).join(', ')+': Heute noch kein Eintrag!',
+      icon:'/static/logo/firmenlogo.png'
+    });
+    localStorage.setItem(notifKey,'1');
+  }
+  // Dashboard-Banner aktualisieren
+  const banner=document.getElementById('tb-reminder-banner');
+  if(!banner)return;
+  if(!fehlend.length){banner.style.display='none';return;}
+  banner.style.display='';
+  banner.innerHTML='<div class="alert a-warn" style="padding:9px 13px"><i class="ti ti-notebook" style="font-size:18px"></i>'+
+    '<div style="flex:1"><div style="font-weight:500;margin-bottom:4px">Pflegetagebuch heute noch nicht geführt ('+fehlend.length+' Patient'+(fehlend.length>1?'en':'')+')</div>'+
+    '<div class="fl g8" style="flex-wrap:wrap">'+
+    fehlend.map(p=>'<button class="btn btn-sm" onclick="pgTagebuch('+p.id+')"><i class="ti ti-notebook"></i>'+escH(p.name)+'</button>').join('')+
+    '</div></div></div>';
+}
+
+// ── Kalender / Fristenüberwachung ─────────────────────────
+async function pgKalender(){
+  R('<div class="spin-wrap"><div class="spin"></div>Lade…</div>','Fristen & Kalender');
+  const events=await api('/api/kalender');
+  const today=isoDate();
+  function tage(datum){
+    const d=(new Date(datum)-new Date(today))/(1000*60*60*24);
+    if(d<0)return '<span style="color:var(--rdtx);font-weight:500">'+Math.abs(Math.round(d))+' Tage überfällig</span>';
+    if(d===0)return '<span style="color:var(--amtx);font-weight:500">Heute</span>';
+    if(d<=7)return '<span style="color:var(--amtx)">in '+Math.round(d)+' Tagen</span>';
+    return '<span style="color:var(--muted)">in '+Math.round(d)+' Tagen</span>';
+  }
+  function dotClass(e){
+    if(e.ueberfaellig)return'fd-red';
+    const d=(new Date(e.datum)-new Date(today))/(1000*60*60*24);
+    if(d<=7)return'fd-amber';
+    if(e.typ==='widerspruch_frist')return'fd-red';
+    if(e.typ==='gutachter')return'fd-blue';
+    return'fd-green';
+  }
+  const typIcon={aufgabe:'ti-checkbox',widerspruch_frist:'ti-gavel',gutachter:'ti-stethoscope',archivierung:'ti-archive',tagebuch_erinnerung:'ti-notebook'};
+  const groups=[
+    {label:'Überfällig',items:events.filter(e=>e.ueberfaellig)},
+    {label:'Diese Woche',items:events.filter(e=>!e.ueberfaellig&&e.datum>=today&&e.datum<=new Date(Date.now()+7*864e5).toISOString().split('T')[0])},
+    {label:'Nächste 30 Tage',items:events.filter(e=>!e.ueberfaellig&&e.datum>new Date(Date.now()+7*864e5).toISOString().split('T')[0]&&e.datum<=new Date(Date.now()+30*864e5).toISOString().split('T')[0])},
+    {label:'Später',items:events.filter(e=>!e.ueberfaellig&&e.datum>new Date(Date.now()+30*864e5).toISOString().split('T')[0])},
+  ];
+  const notifBtn=Notification.permission==='granted'
+    ?'<span class="badge b-g"><i class="ti ti-bell-check"></i> Benachrichtigungen aktiv</span>'
+    :'<button class="btn btn-sm" onclick="reqNotifPerm()"><i class="ti ti-bell"></i>Benachrichtigungen aktivieren</button>';
+  R('<div class="fl g8 mb3" style="justify-content:flex-end">'+notifBtn+'</div>'+
+    (events.length===0?'<div class="card"><p class="muted">Keine offenen Fristen – alles im grünen Bereich ✓</p></div>':
+    groups.filter(g=>g.items.length).map(g=>
+      '<div class="card mb3"><div class="ch"><span class="ct">'+g.label+
+      ' <span class="badge '+(g.label==='Überfällig'?'b-r':'b-gr')+'" style="font-size:11px">'+g.items.length+'</span></span></div>'+
+      g.items.map(e=>
+        '<div class="frist-item">'+
+        '<div class="frist-dot '+dotClass(e)+'"></div>'+
+        '<div style="flex:1">'+
+        '<div style="font-size:13px;font-weight:500"><i class="ti '+(typIcon[e.typ]||'ti-clock')+'" style="margin-right:4px"></i>'+e.titel+'</div>'+
+        (e.patient_name?'<div class="sm muted" style="cursor:pointer;color:var(--gmd)" onclick="loadPat('+e.patient_id+')">'+e.patient_name+'</div>':'')+
+        (e.beschreibung?'<div class="sm muted">'+e.beschreibung+'</div>':'')+
+        '</div>'+
+        '<div style="text-align:right;flex-shrink:0"><div class="sm" style="margin-bottom:2px">'+fdate(e.datum)+'</div>'+tage(e.datum)+'</div>'+
+        '</div>'
+      ).join('')+'</div>'
+    ).join('')),
+  'Fristen & Kalender',
+  '<button class="btn" onclick="go(\'aufgaben\')"><i class="ti ti-plus"></i>Neue Aufgabe</button>');
+}
+
+// ── Tagebuch PDF-Export für MDK ───────────────────────────
+async function dlTB(pid){
+  const [d,entries]=await Promise.all([api('/api/patienten/'+pid),api('/api/patienten/'+pid+'/tagebuch')]);
+  const p=d.patient;
+  if(!entries.length){toast('Keine Einträge zum Exportieren',false);return;}
+  const firmenname=_einstellungen.firmenname||'Pflegepilot';
+  const today=new Date().toLocaleDateString('de-DE');
+  const rows=entries.map(e=>`
+    <tr style="page-break-inside:avoid">
+      <td style="font-weight:bold;white-space:nowrap;vertical-align:top;padding:5px 8px;border:1px solid #ccc">${fdate(e.datum)}</td>
+      <td style="padding:5px 8px;border:1px solid #ccc">
+        ${e.mobilitaet?'<div><strong>M1 Mobilität:</strong> '+e.mobilitaet+'</div>':''}
+        ${e.orientierung?'<div><strong>M2 Kognition:</strong> '+e.orientierung+'</div>':''}
+        ${e.koerperpflege?'<div><strong>M4 Körperpflege:</strong> '+e.koerperpflege+'</div>':''}
+        ${e.anziehen?'<div><strong>M4 Anziehen:</strong> '+e.anziehen+'</div>':''}
+        ${e.ernaehrung?'<div><strong>M4 Ernährung:</strong> '+e.ernaehrung+'</div>':''}
+        ${e.medikamente?'<div><strong>M5 Medikamente:</strong> '+e.medikamente+'</div>':''}
+        ${e.soziales?'<div><strong>M6 Soziales:</strong> '+e.soziales+'</div>':''}
+        ${e.allgemein?'<div><strong>Besonderheiten:</strong> '+e.allgemein+'</div>':''}
+      </td>
+    </tr>`).join('');
+  const html=`<div class="akte-export" style="font-family:'Courier New',Courier,monospace;font-size:9.5pt;line-height:1.7;padding:0;color:#111;background:#fff">
+    <div style="text-align:center;margin-bottom:16px">
+      <div style="font-size:14pt;font-weight:bold">PFLEGETAGEBUCH</div>
+      <div style="font-size:10pt">gem. § 14/15 SGB XI – Begutachtungsinstrument MDK</div>
+      <div style="font-size:9pt;color:#555;margin-top:4px">${firmenname} · Erstellt: ${today}</div>
+    </div>
+    <table style="width:100%;border-collapse:collapse;margin-bottom:12px;font-size:9pt">
+      <tr><th style="text-align:left;background:#f0f0f0;border:1px solid #ccc;padding:4px 8px">Patient</th><td style="border:1px solid #ccc;padding:4px 8px"><strong>${p.vorname} ${p.nachname}</strong>, geb. ${fdate(p.geburtsdatum)}</td></tr>
+      <tr><th style="text-align:left;background:#f0f0f0;border:1px solid #ccc;padding:4px 8px">Versicherung</th><td style="border:1px solid #ccc;padding:4px 8px">${p.krankenkasse||'–'} · Nr. ${p.versichertennummer||'–'}</td></tr>
+      <tr><th style="text-align:left;background:#f0f0f0;border:1px solid #ccc;padding:4px 8px">Pflegegrad</th><td style="border:1px solid #ccc;padding:4px 8px">Grad ${p.pflegegrad||'kein Antrag'}</td></tr>
+      <tr><th style="text-align:left;background:#f0f0f0;border:1px solid #ccc;padding:4px 8px">Zeitraum</th><td style="border:1px solid #ccc;padding:4px 8px">${fdate(entries[entries.length-1].datum)} – ${fdate(entries[0].datum)} (${entries.length} Einträge)</td></tr>
+    </table>
+    <div style="font-size:8pt;border:1px solid #ccc;background:#fffbe6;padding:6px 10px;margin-bottom:12px">
+      <strong>Module gem. Begutachtungsinstrument (BI):</strong> M1 Mobilität · M2 Kognition &amp; Kommunikation · M4 Selbstversorgung · M5 Medizinische Anforderungen · M6 Alltagsgestaltung
+    </div>
+    <table style="width:100%;border-collapse:collapse;font-size:9pt">
+      <thead><tr>
+        <th style="background:#f0f0f0;border:1px solid #ccc;padding:5px 8px;white-space:nowrap">Datum</th>
+        <th style="background:#f0f0f0;border:1px solid #ccc;padding:5px 8px;text-align:left">Dokumentation nach SGB XI-Modulen</th>
+      </tr></thead>
+      <tbody>${rows}</tbody>
+    </table>
+    <div style="border-top:1px solid #999;margin-top:16px;padding-top:6px;font-size:7.5pt;color:#555">
+      Dieses Pflegetagebuch dient als Grundlage für die MDK-Begutachtung nach § 18 SGB XI.
+      Aufbewahrung gem. § 630f BGB mind. 10 Jahre. Erstellt mit ${firmenname} / Pflegepilot Alpha.
+    </div>
+  </div>`;
+  const el=document.createElement('div');el.innerHTML=html;
+  const namePart=toFilename(p.nachname||'Patient');
+  const fname='Pflegetagebuch_'+namePart+'_'+isoDate()+'.pdf';
+  html2pdf().set({margin:[20,20,25,25],filename:fname,html2canvas:{scale:2,useCORS:true},jsPDF:{unit:'mm',format:'a4',orientation:'portrait'}})
+    .from(el.firstChild).toPdf().get('pdf').then(addPageNums).save();
+  toast('Tagebuch-PDF wird erstellt: '+fname);
+}
+
+// ── Dokumente (Upload-Modal) ───────────────────────────────
+function dokUploadModal(pid){
+  const today=isoDate();
+  OM('Dokument hochladen',
+    '<div class="drop-zone" id="dkdrop" onclick="document.getElementById(\'dkfile\').click()">'+
+    '<i class="ti ti-cloud-upload"></i>'+
+    '<div>Datei hier ablegen oder klicken zum Auswählen</div>'+
+    '<div class="sm muted mt2" id="dkfname">PDF, JPG, PNG, DOC, TXT · max. 20 MB</div>'+
+    '</div>'+
+    '<input type="file" id="dkfile" accept=".pdf,.jpg,.jpeg,.png,.gif,.doc,.docx,.txt,.eml" style="display:none" onchange="dkFileChosen(this)">'+
+    '<div class="fg">'+
+    '<div class="fgrp"><label>Dokumenttyp *</label><select id="dktyp">'+
+    ['attest:Ärztliches Attest','gutachten:MDK-Gutachten / Gegengutachten',
+     'bescheid:Pflegegrad-Bescheid','widerspruchsbescheid:Widerspruchsbescheid',
+     'krankenhausbericht:Krankenhausbericht / Entlassbrief',
+     'pflegedienst:Pflegedienst-Dokumentation','rezept:Rezept / Verordnung',
+     'sonstiges:Sonstiges Dokument'
+    ].map(x=>{const[v,l]=x.split(':');return'<option value="'+v+'">'+l+'</option>';}).join('')+
+    '</select></div>'+
+    '<div class="fgrp"><label>Bezeichnung</label><input id="dkbez" placeholder="z. B.: MDK-Gutachten vom 10.05.2026"></div>'+
+    '<div class="fgrp"><label>Dokumentdatum</label><input id="dkdat" type="date" value="'+today+'"></div>'+
+    '<div class="fgrp"><label>Notizen</label><textarea id="dknotiz" rows="2" placeholder="optional"></textarea></div>'+
+    '</div>'+
+    '<div class="fl g8 mt3" style="justify-content:flex-end">'+
+    '<button class="btn" onclick="CM()">Abbrechen</button>'+
+    '<button class="btn btn-p" onclick="saveDok('+pid+')"><i class="ti ti-upload"></i>Hochladen</button>'+
+    '</div>');
+  // Drag & Drop verdrahten (kurz nach DOM-Aufbau)
+  setTimeout(()=>{
+    const dz=document.getElementById('dkdrop');
+    if(!dz)return;
+    dz.addEventListener('dragover',e=>{e.preventDefault();dz.classList.add('over');});
+    dz.addEventListener('dragleave',()=>dz.classList.remove('over'));
+    dz.addEventListener('drop',e=>{
+      e.preventDefault();dz.classList.remove('over');
+      const f=e.dataTransfer.files[0];if(!f)return;
+      const dt=new DataTransfer();dt.items.add(f);
+      const inp=document.getElementById('dkfile');inp.files=dt.files;
+      dkFileChosen(inp);
+    });
+  },50);
+}
+function dkFileChosen(inp){
+  const f=inp.files[0];if(!f)return;
+  const nm=document.getElementById('dkfname');
+  if(nm)nm.innerHTML='<strong>'+escH(f.name)+'</strong> · '+(f.size>1048576?(f.size/1048576).toFixed(1)+' MB':(f.size/1024).toFixed(0)+' KB');
+  const bez=document.getElementById('dkbez');
+  if(bez&&!bez.value)bez.value=f.name.replace(/\.[^.]+$/,'');
+  const dz=document.getElementById('dkdrop');
+  if(dz)dz.style.borderColor='var(--green)';
+}
+async function saveDok(pid){
+  const file=document.getElementById('dkfile')?.files[0];
+  if(!file){toast('Bitte Datei auswählen',false);return;}
+  const fd=new FormData();
+  fd.append('datei',file);
+  fd.append('typ',document.getElementById('dktyp')?.value||'sonstiges');
+  fd.append('bezeichnung',document.getElementById('dkbez')?.value||file.name);
+  fd.append('datum',document.getElementById('dkdat')?.value||'');
+  fd.append('notizen',document.getElementById('dknotiz')?.value||'');
+  const r=await fetch('/api/patienten/'+pid+'/dokumente',{method:'POST',body:fd});
+  const j=await r.json();
+  if(j.ok){CM();toast('Dokument gespeichert ✓');loadPat(pid);}
+  else toast(j.error||'Fehler beim Hochladen',false);
+}
+async function delDok(did,pid){
+  if(!confirm('Dokument unwiderruflich löschen?'))return;
+  await api('/api/dokumente/'+did,{method:'DELETE'});
+  toast('Dokument gelöscht');loadPat(pid);
+}
+
+// ── Patient archivieren ────────────────────────────────────
+function archivierenModal(pid,pname){
+  const today=isoDate();
+  OM('Patientenakte archivieren',
+    '<div class="alert a-warn mb4"><i class="ti ti-alert-triangle"></i>'+
+    '<p><strong>Aufbewahrungspflicht beachten:</strong><br>'+
+    '§ 630f BGB: <strong>10 Jahre</strong> ab letztem Patientenkontakt (Aktiv / Verzogen)<br>'+
+    '§ 199 Abs. 2 BGB: <strong>30 Jahre</strong> bei Verstorbenen<br>'+
+    'PBV: Buchführungsunterlagen mind. 10 Jahre</p></div>'+
+    '<div class="fg mb4">'+
+    '<div class="fgrp"><label>Patient</label><input value="'+pname+'" disabled></div>'+
+    '<div class="fgrp"><label>Status *</label>'+
+    '<select id="arch-st" onchange="archivToggle()">'+
+    '<option value="archiviert">Archiviert (allgemein)</option>'+
+    '<option value="verstorben">Verstorben</option>'+
+    '<option value="verzogen">Verzogen / Kasse gewechselt</option>'+
+    '</select></div>'+
+    '<div class="fgrp"><label id="arch-dat-lbl">Datum des Ereignisses *</label>'+
+    '<input id="arch-dat" type="date" value="'+today+'" oninput="archivFristCalc()"></div>'+
+    '<div id="arch-frist-info" class="alert a-info" style="padding:8px 12px;font-size:12.5px"><i class="ti ti-calendar-time"></i>'+
+    '<p>Aufbewahrungsfrist wird berechnet…</p></div>'+
+    '<div class="fgrp"><label>Hinweis / Grund (intern)</label>'+
+    '<textarea id="arch-hint" rows="2" placeholder="z. B.: Verstorben im Klinikum, Benachrichtigung durch Tochter"></textarea></div>'+
+    '</div>'+
+    '<div class="fl g8" style="justify-content:flex-end">'+
+    '<button class="btn" onclick="CM()">Abbrechen</button>'+
+    '<button class="btn btn-sm btn-p" onclick="dlAkte('+pid+')"><i class="ti ti-file-type-pdf"></i>Akte zuerst exportieren</button>'+
+    '<button class="btn btn-p" onclick="saveArchiv('+pid+')"><i class="ti ti-archive"></i>Archivieren</button>'+
+    '</div>');
+  archivFristCalc();
+}
+function archivToggle(){
+  const s=document.getElementById('arch-st')?.value;
+  const lbl=document.getElementById('arch-dat-lbl');
+  if(lbl)lbl.textContent=s==='verstorben'?'Sterbedatum *':s==='verzogen'?'Auszugsdatum *':'Datum des Ereignisses *';
+  archivFristCalc();
+}
+function archivFristCalc(){
+  const s=document.getElementById('arch-st')?.value;
+  const dat=document.getElementById('arch-dat')?.value;
+  const el=document.getElementById('arch-frist-info');
+  if(!el||!dat)return;
+  const jahre=s==='verstorben'?30:10;
+  try{
+    const d=new Date(dat);d.setFullYear(d.getFullYear()+jahre);
+    el.innerHTML='<i class="ti ti-calendar-time"></i><p>Aufbewahrungsfrist bis: <strong>'+
+      d.toLocaleDateString('de-DE')+'</strong> ('+jahre+' Jahre gem. '+(s==='verstorben'?'§ 199 Abs. 2 BGB':'§ 630f BGB')+')</p>';
+  }catch(e){}
+}
+async function saveArchiv(pid){
+  const status=document.getElementById('arch-st')?.value;
+  const dat=document.getElementById('arch-dat')?.value;
+  const hint=document.getElementById('arch-hint')?.value;
+  if(!dat){toast('Bitte Datum eingeben',false);return;}
+  const r=await api('/api/patienten/'+pid+'/archivieren',{method:'PATCH',body:JSON.stringify({
+    status,status_datum:dat,archiv_hinweis:hint
+  })});
+  if(r.ok){
+    CM();
+    toast('Akte archiviert · Aufbewahrungsfrist bis '+fdate(r.archiv_frist)+' ('+r.jahre+' Jahre)');
+    loadPat(pid);
+  } else toast('Fehler',false);
+}
+
+// ── Vollständige Patientenakte als PDF exportieren ─────────
+async function dlAkte(pid){
+  toast('Akte wird vorbereitet…');
+  const d=await api('/api/patienten/'+pid+'/akte');
+  const p=d.patient;
+  const firmenname=_einstellungen.firmenname||'Pflegepilot';
+  const today=new Date().toLocaleDateString('de-DE');
+  const archivInfo=p.archiv_frist
+    ?'<div style="background:#fff3cd;border:1px solid #ffc107;padding:6px 10px;font-size:8pt;margin-bottom:10px">'+
+     '⚠ Aufbewahrungspflicht bis: <strong>'+fdate(p.archiv_frist)+'</strong> '+
+     (p.patient_status==='verstorben'?'(30 J. gem. § 199 Abs. 2 BGB)':'(10 J. gem. § 630f BGB)')+'</div>':
+    '<div style="background:#e8f5e9;border:1px solid #4caf50;padding:6px 10px;font-size:8pt;margin-bottom:10px">'+
+     'Aufbewahrungspflicht: 10 Jahre nach letztem Kontakt (§ 630f BGB)</div>';
+  const statusMap={aktiv:'Aktiv',verstorben:'Verstorben',verzogen:'Verzogen',archiviert:'Archiviert'};
+  let html=`<div style="font-family:'Courier New',Courier,monospace;font-size:9.5pt;line-height:1.7;padding:0;color:#111;background:#fff">
+    <div style="text-align:center;margin-bottom:14px;border-bottom:2px solid #111;padding-bottom:10px">
+      <div style="font-size:15pt;font-weight:bold">PATIENTENAKTE</div>
+      <div style="font-size:9pt;color:#555">${firmenname} · Exportiert: ${today}</div>
+    </div>
+    ${archivInfo}
+    <div style="font-size:12pt;font-weight:bold;border-left:3px solid #333;padding-left:8px;margin:12px 0 6px">Stammdaten</div>
+    <table style="width:100%;border-collapse:collapse;font-size:9pt;margin-bottom:10px">
+      <tr><td style="background:#f5f5f5;border:1px solid #ccc;padding:4px 8px;font-weight:bold;width:35%">Name</td><td style="border:1px solid #ccc;padding:4px 8px">${p.vorname} ${p.nachname}</td></tr>
+      <tr><td style="background:#f5f5f5;border:1px solid #ccc;padding:4px 8px;font-weight:bold">Geburtsdatum</td><td style="border:1px solid #ccc;padding:4px 8px">${fdate(p.geburtsdatum)||'–'}</td></tr>
+      <tr><td style="background:#f5f5f5;border:1px solid #ccc;padding:4px 8px;font-weight:bold">Anschrift</td><td style="border:1px solid #ccc;padding:4px 8px">${p.strasse||''}, ${p.plz||''} ${p.ort||''}</td></tr>
+      <tr><td style="background:#f5f5f5;border:1px solid #ccc;padding:4px 8px;font-weight:bold">Krankenkasse</td><td style="border:1px solid #ccc;padding:4px 8px">${p.krankenkasse||'–'} · Nr. ${p.versichertennummer||'–'} (${p.versicherungsart||'GKV'})</td></tr>
+      <tr><td style="background:#f5f5f5;border:1px solid #ccc;padding:4px 8px;font-weight:bold">Pflegegrad</td><td style="border:1px solid #ccc;padding:4px 8px">Grad ${p.pflegegrad||'keiner'}</td></tr>
+      <tr><td style="background:#f5f5f5;border:1px solid #ccc;padding:4px 8px;font-weight:bold">Status</td><td style="border:1px solid #ccc;padding:4px 8px">${statusMap[p.patient_status]||'Aktiv'}${p.status_datum?' ('+fdate(p.status_datum)+')':''}</td></tr>
+      ${p.notizen?'<tr><td style="background:#f5f5f5;border:1px solid #ccc;padding:4px 8px;font-weight:bold">Notizen</td><td style="border:1px solid #ccc;padding:4px 8px">'+p.notizen+'</td></tr>':''}
+    </table>`;
+  if(d.antraege.length){
+    html+=`<div style="font-size:12pt;font-weight:bold;border-left:3px solid #333;padding-left:8px;margin:12px 0 6px">Anträge (${d.antraege.length})</div>
+    <table style="width:100%;border-collapse:collapse;font-size:8.5pt;margin-bottom:10px">
+      <tr style="background:#f5f5f5"><th style="border:1px solid #ccc;padding:4px 8px">Typ</th><th style="border:1px solid #ccc;padding:4px 8px">Datum</th><th style="border:1px solid #ccc;padding:4px 8px">Grad</th><th style="border:1px solid #ccc;padding:4px 8px">Status</th><th style="border:1px solid #ccc;padding:4px 8px">Bescheid</th></tr>
+      ${d.antraege.map(a=>`<tr><td style="border:1px solid #ccc;padding:4px 8px">${a.typ}</td><td style="border:1px solid #ccc;padding:4px 8px">${fdate(a.antragsdatum)}</td><td style="border:1px solid #ccc;padding:4px 8px">${a.beantragter_pflegegrad?'Grad '+a.beantragter_pflegegrad:'–'}</td><td style="border:1px solid #ccc;padding:4px 8px">${a.status}</td><td style="border:1px solid #ccc;padding:4px 8px">${fdate(a.bescheid_datum)||'–'}</td></tr>`).join('')}
+    </table>`;
+  }
+  if(d.leistungen.length){
+    html+=`<div style="font-size:12pt;font-weight:bold;border-left:3px solid #333;padding-left:8px;margin:12px 0 6px">Leistungen (${d.leistungen.length})</div>
+    <table style="width:100%;border-collapse:collapse;font-size:8.5pt;margin-bottom:10px">
+      <tr style="background:#f5f5f5"><th style="border:1px solid #ccc;padding:4px 8px">Bezeichnung</th><th style="border:1px solid #ccc;padding:4px 8px">Betrag</th><th style="border:1px solid #ccc;padding:4px 8px">Seit</th></tr>
+      ${d.leistungen.map(l=>`<tr><td style="border:1px solid #ccc;padding:4px 8px">${l.bezeichnung}</td><td style="border:1px solid #ccc;padding:4px 8px">${l.betrag?l.betrag.toFixed(0)+' €/mtl.':'–'}</td><td style="border:1px solid #ccc;padding:4px 8px">${fdate(l.seit)||'–'}</td></tr>`).join('')}
+    </table>`;
+  }
+  if(d.dokumente.length){
+    const dtypLabel={attest:'Attest',gutachten:'Gutachten',bescheid:'Bescheid',widerspruchsbescheid:'Widerspruchsbescheid',krankenhausbericht:'Krankenhausbericht',pflegedienst:'Pflegedienst',rezept:'Rezept',sonstiges:'Sonstiges'};
+    html+=`<div style="font-size:12pt;font-weight:bold;border-left:3px solid #333;padding-left:8px;margin:12px 0 6px">Dokumente (${d.dokumente.length})</div>
+    <table style="width:100%;border-collapse:collapse;font-size:8.5pt;margin-bottom:10px">
+      <tr style="background:#f5f5f5"><th style="border:1px solid #ccc;padding:4px 8px">Typ</th><th style="border:1px solid #ccc;padding:4px 8px">Bezeichnung</th><th style="border:1px solid #ccc;padding:4px 8px">Datum</th><th style="border:1px solid #ccc;padding:4px 8px">Datei</th></tr>
+      ${d.dokumente.map(k=>`<tr><td style="border:1px solid #ccc;padding:4px 8px">${dtypLabel[k.typ]||k.typ}</td><td style="border:1px solid #ccc;padding:4px 8px">${k.bezeichnung}</td><td style="border:1px solid #ccc;padding:4px 8px">${fdate(k.datum)||'–'}</td><td style="border:1px solid #ccc;padding:4px 8px;font-size:8pt">${k.dateiname}</td></tr>`).join('')}
+    </table>`;
+  }
+  if(d.tagebuch.length){
+    html+=`<div style="font-size:12pt;font-weight:bold;border-left:3px solid #333;padding-left:8px;margin:12px 0 6px">Pflegetagebuch (${d.tagebuch.length} Einträge)</div>
+    <table style="width:100%;border-collapse:collapse;font-size:8pt;margin-bottom:10px">
+      <tr style="background:#f5f5f5"><th style="border:1px solid #ccc;padding:4px 8px;white-space:nowrap">Datum</th><th style="border:1px solid #ccc;padding:4px 8px;text-align:left">Dokumentation</th></tr>
+      ${d.tagebuch.map(e=>'<tr style="page-break-inside:avoid"><td style="border:1px solid #ccc;padding:4px 8px;vertical-align:top;white-space:nowrap">'+fdate(e.datum)+'</td><td style="border:1px solid #ccc;padding:4px 8px;font-size:7.5pt">'+[e.mobilitaet&&'M1: '+e.mobilitaet,e.orientierung&&'M2: '+e.orientierung,e.koerperpflege&&'M4 KP: '+e.koerperpflege,e.anziehen&&'M4 Az: '+e.anziehen,e.ernaehrung&&'M4 Er: '+e.ernaehrung,e.medikamente&&'M5: '+e.medikamente,e.soziales&&'M6: '+e.soziales,e.allgemein&&'Allg.: '+e.allgemein].filter(Boolean).join(' | ')+'</td></tr>').join('')}
+    </table>`;
+  }
+  html+=`<div style="border-top:1px solid #999;margin-top:16px;padding-top:6px;font-size:7.5pt;color:#555">
+    Aufbewahrungspflicht: ${p.patient_status==='verstorben'?'30 Jahre gem. § 199 Abs. 2 BGB':'10 Jahre gem. § 630f BGB + § 84 SGB XI + PBV'} ·
+    Erstellt mit ${firmenname} / Pflegepilot Alpha · ${today}
+  </div></div>`;
+  const el=document.createElement('div');el.innerHTML=html;
+  const fname='Patientenakte_'+toFilename(p.nachname||'Patient')+'_'+isoDate()+'.pdf';
+  html2pdf().set({margin:[20,20,25,25],filename:fname,html2canvas:{scale:2,useCORS:true},jsPDF:{unit:'mm',format:'a4',orientation:'portrait'}})
+    .from(el.firstChild).toPdf().get('pdf').then(addPageNums).save();
+  toast('Akte-PDF wird erstellt: '+fname);
+}
+
+// ── App-Init (Einstellungen laden, Sidebar anpassen) ──────
+async function initApp(){
+  // Auth prüfen
+  const me=await fetch('/api/auth/me').then(r=>r.json()).catch(()=>({error:true}));
+  if(me.error){
+    document.getElementById('lo-overlay').style.display='flex';
+    return;
+  }
+  curUser=me;
+  document.getElementById('lo-overlay').style.display='none';
+  const uw=document.getElementById('sb-user');
+  if(uw){uw.style.display='flex';}
+  const un=document.getElementById('sb-user-name');if(un)un.textContent=me.name||me.benutzername;
+  const ur=document.getElementById('sb-user-role');if(ur)ur.textContent=me.rolle==='admin'?'Administrator':'Nutzer';
+  // Admin-nav nur für admin sichtbar
+  const adm=document.querySelector('.sb-admin');
+  if(adm)adm.style.display=me.rolle==='admin'?'':'none';
+  // Öffentliche Einstellungen / Branding
+  try{
+    const s=await api('/api/einstellungen/public');
+    _einstellungen={..._einstellungen,...s};
+    const fn=s.firmenname;
+    if(fn){document.getElementById('sb-logo-name').textContent=fn;document.getElementById('sb-firmenname').textContent=fn+' · Pflegepilot';}
+    if(s.firmen_logo_url){
+      const icon=document.getElementById('sb-logo-icon');
+      if(icon){icon.outerHTML='<img src="'+s.firmen_logo_url+'" class="sb-logo-img" id="sb-logo-img">';}
+    }
+  }catch(e){}
+}
+async function doLogin(){
+  const u=(document.getElementById('lo-user')?.value||'').trim();
+  const p=document.getElementById('lo-pw')?.value||'';
+  const err=document.getElementById('lo-err');
+  if(!u||!p){if(err)err.textContent='Bitte Benutzername und Passwort eingeben';return;}
+  if(err)err.textContent='';
+  const r=await fetch('/api/auth/login',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({benutzername:u,passwort:p})}).then(x=>x.json()).catch(()=>({error:'Verbindungsfehler'}));
+  if(r.ok){
+    document.getElementById('lo-pw').value='';
+    await initApp();
+    refreshBadge();
+    go('dashboard');
+  } else {
+    if(err)err.textContent=r.error||'Anmeldung fehlgeschlagen';
+  }
+}
+async function doLogout(){
+  await fetch('/api/auth/logout',{method:'POST'});
+  curUser=null;
+  document.getElementById('lo-overlay').style.display='flex';
+  document.getElementById('lo-user').value='';
+  document.getElementById('lo-pw').value='';
+  const uw=document.getElementById('sb-user');if(uw)uw.style.display='none';
+}
+
+// ── Backend / Admin-Einstellungen ─────────────────────────
+async function pgBackend(){
+  if(!curUser||curUser.rolle!=='admin'){
+    R('<div class="card login-card"><div class="alert a-warn"><i class="ti ti-lock"></i><p>Dieser Bereich ist nur für Administratoren zugänglich.</p></div></div>','Backend-Einstellungen');
+    return;
+  }
+  R('<div class="spin-wrap"><div class="spin"></div></div>','Backend-Einstellungen');
+  const [s,nutzer]=await Promise.all([api('/api/admin/einstellungen'),api('/api/nutzer')]);
+  const logoHtml=s.firmen_logo_url
+    ?'<img src="'+s.firmen_logo_url+'" class="logo-preview" id="logo-prv"><br>'
+    :'<div class="logo-empty" onclick="document.getElementById(\'logo-fi\').click()"><i class="ti ti-photo-up"></i></div>';
+
+  R(
+    // ── Zeile 1 ──
+    '<div class="g2">'+
+    // Betrieb
+    '<div class="card">'+
+    '<div class="ch"><span class="ct">Betrieb</span></div>'+
+    '<div class="fg mb4">'+
+    '<div class="fgrp"><label>Firmenname / Betriebsname</label><input id="e-firmenname" value="'+(s.firmenname||'')+'" placeholder="Muster Pflegedienst GmbH"></div>'+
+    '<div class="fgrp"><label>Firmen-Logo</label>'+
+    '<div style="display:flex;align-items:center;gap:12px;margin-top:4px">'+logoHtml+
+    '<div><input type="file" id="logo-fi" accept="image/*" style="display:none" onchange="uploadLogo(this)">'+
+    '<button class="btn btn-sm" onclick="document.getElementById(\'logo-fi\').click()"><i class="ti ti-upload"></i>Logo hochladen</button>'+
+    '<div class="muted sm mt2">JPEG, PNG, SVG · Empfohlen: 200×200 px</div></div></div></div>'+
+    '<div class="fg c2 mb4">'+
+    '<div class="fgrp"><label>Straße &amp; Hausnummer</label><input id="e-firmen_strasse" value="'+(s.firmen_strasse||'')+'" placeholder="Musterstraße 1"></div>'+
+    '<div class="fgrp"><label>PLZ / Ort</label><div class="fl g8"><input id="e-firmen_plz" value="'+(s.firmen_plz||'')+'" placeholder="82256" style="width:80px"><input id="e-firmen_ort" value="'+(s.firmen_ort||'')+'" placeholder="Fürstenfeldbruck"></div></div>'+
+    '<div class="fgrp"><label>Telefon</label><input id="e-firmen_tel" value="'+(s.firmen_tel||'')+'" placeholder="08141/..."></div>'+
+    '<div class="fgrp"><label>E-Mail (Betrieb)</label><input id="e-firmen_email" value="'+(s.firmen_email||'')+'" placeholder="info@muster.de"></div>'+
+    '</div></div>'+
+    '<div class="fl g8" style="justify-content:flex-end">'+
+    '<button class="btn btn-p" onclick="saveEinst([\'firmenname\',\'firmen_strasse\',\'firmen_plz\',\'firmen_ort\',\'firmen_tel\',\'firmen_email\'])"><i class="ti ti-check"></i>Speichern</button></div>'+
+    '</div>'+
+    // KI
+    '<div class="card">'+
+    '<div class="ch"><span class="ct">KI – Claude API</span>'+
+    (s.claude_api_token_set?'<span class="badge b-g"><i class="ti ti-circle-check"></i> Aktiv</span>':'<span class="badge b-gr">Nicht konfiguriert</span>')+'</div>'+
+    '<div class="alert a-info mb4"><i class="ti ti-sparkles"></i><p>API-Token für zukünftige KI-Funktionen (Widerspruch-Vorschläge, Zusammenfassungen). Format: sk-ant-…</p></div>'+
+    '<div class="fg mb4"><div class="fgrp"><label>Claude API-Token</label>'+
+    '<div class="api-token-wrap"><input id="e-claude_api_token" type="password" value="'+(s.claude_api_token||'')+'" placeholder="sk-ant-api03-…">'+
+    '<button onclick="var i=document.getElementById(\'e-claude_api_token\');i.type=i.type===\'password\'?\'text\':\'password\'"><i class="ti ti-eye"></i></button></div>'+
+    '<div class="muted sm mt2">Token unter console.anthropic.com erstellen</div></div></div>'+
+    '<div class="fl g8" style="justify-content:flex-end">'+
+    '<button class="btn btn-p" onclick="saveEinst([\'claude_api_token\'])"><i class="ti ti-check"></i>Speichern</button></div>'+
+    '</div>'+
+    '</div>'+
+
+    // ── Zeile 2 ──
+    '<div class="g2 mt3">'+
+    // E-Mail SMTP
+    '<div class="card">'+
+    '<div class="ch"><span class="ct">E-Mail (SMTP)</span><span class="badge b-gr">Beta</span></div>'+
+    '<div class="fg mb4">'+
+    '<div class="fgrp"><label>Absender-Adresse</label><input id="e-email_absender" value="'+(s.email_absender||'')+'" placeholder="pflege@muster.de"></div>'+
+    '<div class="fg c2"><div class="fgrp"><label>SMTP-Server</label><input id="e-email_smtp" value="'+(s.email_smtp||'')+'" placeholder="smtp.gmail.com"></div>'+
+    '<div class="fgrp"><label>Port</label><input id="e-email_port" value="'+(s.email_port||'')+'" placeholder="587"></div></div>'+
+    '<div class="fgrp"><label>SMTP-Benutzer</label><input id="e-email_user" value="'+(s.email_user||'')+'" placeholder="user@muster.de"></div>'+
+    '<div class="fgrp"><label>SMTP-Passwort</label><input id="e-email_pass" type="password" value="'+(s.email_pass||'')+'" placeholder="••••••"></div>'+
+    '</div>'+
+    '<div class="fl g8" style="justify-content:flex-end">'+
+    '<button class="btn" onclick="testEmail()"><i class="ti ti-send"></i>Test-E-Mail</button>'+
+    '<button class="btn btn-p" onclick="saveEinst([\'email_absender\',\'email_smtp\',\'email_port\',\'email_user\',\'email_pass\'])"><i class="ti ti-check"></i>Speichern</button></div>'+
+    '</div>'+
+
+    // Nutzerverwaltung
+    '<div class="card">'+
+    '<div class="ch"><span class="ct">Nutzerverwaltung</span>'+
+    '<button class="btn btn-sm btn-p" onclick="newNutzerModal()"><i class="ti ti-user-plus"></i>Neu</button></div>'+
+    '<div id="nutzer-list">'+
+    (nutzer.length===0?'<p class="muted sm">Keine Nutzer vorhanden.</p>':
+    nutzer.map(n=>'<div class="nutzer-row">'+
+      '<div class="av av'+(n.rolle==='admin'?'1':'3')+'" style="width:30px;height:30px;font-size:11px;flex-shrink:0">'+(n.benutzername[0]||'?').toUpperCase()+'</div>'+
+      '<div style="flex:1"><div class="w5" style="font-size:13px">'+escH(n.name||n.benutzername)+'</div>'+
+      '<div class="sm muted">@'+escH(n.benutzername)+' · '+(n.rolle==='admin'?'Admin':'Nutzer')+(n.aktiv?'':' · <span style="color:var(--rdtx)">Inaktiv</span>')+'</div></div>'+
+      '<button class="btn btn-sm" onclick="editNutzerModal('+JSON.stringify(n)+')"><i class="ti ti-edit"></i></button>'+
+      (n.id!==curUser?.id?'<button class="btn btn-sm btn-ico" style="color:var(--rdtx)" onclick="delNutzer('+n.id+')"><i class="ti ti-trash"></i></button>':'')+
+      '</div>').join(''))+
+    '</div></div>'+
+    '</div>',
+    'Backend-Einstellungen',
+    '<span class="badge b-b" style="padding:6px 12px"><i class="ti ti-settings-2" style="margin-right:4px"></i>Admin</span>');
+}
+async function adminLogout(){await doLogout();}
+async function testEmail(){
+  const btn=event?.target;
+  if(btn){btn.disabled=true;btn.innerHTML='<i class="ti ti-loader-2"></i>Sende…';}
+  const r=await api('/api/email/test',{method:'POST'});
+  if(btn){btn.disabled=false;btn.innerHTML='<i class="ti ti-send"></i>Test-E-Mail';}
+  if(r.ok)toast('Test-E-Mail erfolgreich gesendet ✓ (an Absender-Adresse)');
+  else toast(r.error||'Fehler beim Senden',false);
+}
+function newNutzerModal(){
+  OM('Neuer Nutzer',
+    '<div class="fg"><div class="fgrp"><label>Benutzername *</label><input id="nu-user" placeholder="max.muster"></div>'+
+    '<div class="fgrp"><label>Anzeigename</label><input id="nu-name" placeholder="Max Muster"></div>'+
+    '<div class="fgrp"><label>Passwort *</label><input id="nu-pw" type="password" placeholder="Sicheres Passwort"></div>'+
+    '<div class="fgrp"><label>Rolle</label><select id="nu-rolle"><option value="nutzer">Nutzer</option><option value="admin">Administrator</option></select></div></div>'+
+    '<div class="fl g8 mt3" style="justify-content:flex-end">'+
+    '<button class="btn" onclick="CM()">Abbrechen</button>'+
+    '<button class="btn btn-p" onclick="saveNutzer()"><i class="ti ti-check"></i>Anlegen</button></div>');
+}
+function editNutzerModal(n){
+  OM('Nutzer bearbeiten – '+escH(n.benutzername),
+    '<div class="fg"><div class="fgrp"><label>Anzeigename</label><input id="eu-name" value="'+escH(n.name||'')+'"></div>'+
+    '<div class="fgrp"><label>Rolle</label><select id="eu-rolle"><option value="nutzer"'+(n.rolle==='nutzer'?' selected':'')+'>Nutzer</option><option value="admin"'+(n.rolle==='admin'?' selected':'')+'>Administrator</option></select></div>'+
+    '<div class="fgrp"><label>Status</label><select id="eu-aktiv"><option value="1"'+(n.aktiv?' selected':'')+'>Aktiv</option><option value="0"'+(!n.aktiv?' selected':'')+'>Inaktiv</option></select></div>'+
+    '<div class="fgrp"><label>Neues Passwort (leer = unverändert)</label><input id="eu-pw" type="password" placeholder="Neues Passwort …"></div></div>'+
+    '<div class="fl g8 mt3" style="justify-content:flex-end">'+
+    '<button class="btn" onclick="CM()">Abbrechen</button>'+
+    '<button class="btn btn-p" onclick="updateNutzer('+n.id+')"><i class="ti ti-check"></i>Speichern</button></div>');
+}
+async function saveNutzer(){
+  const r=await api('/api/nutzer',{method:'POST',body:JSON.stringify({
+    benutzername:document.getElementById('nu-user')?.value||'',
+    name:document.getElementById('nu-name')?.value||'',
+    passwort:document.getElementById('nu-pw')?.value||'',
+    rolle:document.getElementById('nu-rolle')?.value||'nutzer'
+  })});
+  if(r.ok){CM();toast('Nutzer angelegt ✓');pgBackend();}
+  else toast(r.error||'Fehler',false);
+}
+async function updateNutzer(uid){
+  const r=await api('/api/nutzer/'+uid,{method:'PUT',body:JSON.stringify({
+    name:document.getElementById('eu-name')?.value||'',
+    rolle:document.getElementById('eu-rolle')?.value||'nutzer',
+    aktiv:document.getElementById('eu-aktiv')?.value||'1',
+    passwort:document.getElementById('eu-pw')?.value||''
+  })});
+  if(r.ok){CM();toast('Nutzer aktualisiert ✓');pgBackend();}
+  else toast(r.error||'Fehler',false);
+}
+async function delNutzer(uid){
+  if(!confirm('Nutzer wirklich löschen?'))return;
+  const r=await api('/api/nutzer/'+uid,{method:'DELETE'});
+  if(r.ok){toast('Nutzer gelöscht');pgBackend();}
+  else toast(r.error||'Fehler',false);
+}
+async function saveEinst(keys){
+  const d={};
+  keys.forEach(k=>{const el=document.getElementById('e-'+k);if(el)d[k]=el.value;});
+  const r=await api('/api/admin/einstellungen',{method:'PUT',body:JSON.stringify(d)});
+  if(r.ok){toast('Einstellungen gespeichert ✓');initApp();}
+  else toast(r.error||'Fehler',false);
+}
+async function uploadLogo(input){
+  const fd=new FormData();fd.append('logo',input.files[0]);
+  const r=await fetch('/api/admin/logo',{method:'POST',body:fd});
+  const j=await r.json();
+  if(j.ok){toast('Logo gespeichert ✓');initApp();pgBackend();}
+  else toast(j.error||'Fehler',false);
+}
+
+// ── Dashboard ─────────────────────────────────────────────
+async function pgDash(){
+  R('<div class="spin-wrap"><div class="spin"></div>Lade…</div>','Dashboard',
+    '<button class="btn btn-p" onclick="go(\'neu\')"><i class="ti ti-user-plus"></i>Neuer Patient</button>');
+  const d=await api('/api/dashboard');const s=d.stats;
+  R('<div id="tb-reminder-banner" style="display:none;margin-bottom:14px"></div>'+
+    '<div class="g4">'+
+    '<div class="metric"><div class="ml">Patienten</div><div class="mv">'+s.patienten+'</div></div>'+
+    '<div class="metric"><div class="ml">Offene Anträge</div><div class="mv">'+s.offene_antraege+'</div></div>'+
+    '<div class="metric"><div class="ml">Offene Aufgaben</div><div class="mv">'+s.offene_aufgaben+'</div></div>'+
+    '<div class="metric"><div class="ml">Leistungen im Katalog</div><div class="mv">'+s.katalog_gesamt+'</div><div style="margin-top:4px"><span class="badge b-b">3 Zielgruppen</span></div></div>'+
+    '</div>'+
+    '<div class="g2">'+
+    '<div class="card"><div class="ch"><span class="ct">Aktuelle Patienten</span><button class="btn btn-sm" onclick="go(\'patienten\')">Alle</button></div>'+
+    '<div class="tw"><table><thead><tr><th>Name</th><th>Grad</th><th>Zielgruppe</th><th>Status</th></tr></thead><tbody>'+
+    d.recent.map((p,i)=>'<tr><td><div class="fl ic g8">'+av(p.vorname+' '+p.nachname,i)+'<span class="tl" onclick="loadPat('+p.id+')">'+p.vorname+' '+p.nachname+'</span></div></td><td>'+
+      (p.pflegegrad?'<span class="badge b-out">Grad '+p.pflegegrad+'</span>':'<span class="muted sm">–</span>')+'</td><td>'+zg_badge(p.zielgruppe||'alterspflege')+'</td><td>'+bdg(p.status||'offen')+'</td></tr>').join('')+
+    '</tbody></table></div></div>'+
+    '<div class="card"><div class="ch"><span class="ct">Offene Aufgaben</span><button class="btn btn-sm" onclick="go(\'aufgaben\')">Alle</button></div>'+
+    (d.aufgaben.length===0?'<p class="muted sm">Keine offenen Aufgaben.</p>':
+    d.aufgaben.map(a=>'<div class="step"><div class="si '+(a.prioritaet==='hoch'?'s-go':'s-no')+'"><i class="ti ti-clock"></i></div>'+
+      '<div class="sb2"><div class="t">'+a.titel+'</div><div class="d">'+(a.patient_name||'')+' · '+fdate(a.faellig_am)+'</div></div></div>').join(''))+
+    '</div></div>'+
+    '<div class="card"><div class="ch"><span class="ct">Schnellzugriff</span></div>'+
+    '<div class="fl g8" style="flex-wrap:wrap">'+
+    '<button class="btn" onclick="go(\'katalog\')"><i class="ti ti-list-details"></i>Leistungskatalog (82)</button>'+
+    '<button class="btn" onclick="go(\'widerspruch\')"><i class="ti ti-gavel"></i>Widerspruch erstellen</button>'+
+    '<button class="btn" onclick="go(\'antrag\')"><i class="ti ti-file-plus"></i>Neuer Antrag</button>'+
+    '<button class="btn" onclick="go(\'rechner\')"><i class="ti ti-calculator"></i>Leistungsrechner</button>'+
+    '<button class="btn" onclick="go(\'musterbrief\')"><i class="ti ti-mail"></i>Musterbrief</button>'+
+    '</div></div>',
+    'Dashboard',
+    '<button class="btn btn-p" onclick="go(\'neu\')"><i class="ti ti-user-plus"></i>Neuer Patient</button>');
+  checkTagebuchReminder();
+}
+
+// ── Patienten ─────────────────────────────────────────────
+async function pgPatienten(){
+  R('<div class="spin-wrap"><div class="spin"></div>Lade…</div>','Patientenliste');
+  const data=await api('/api/patienten');
+  R('<div class="card" style="padding:11px 14px"><div class="fl ic g8">'+
+    '<input placeholder="Suchen…" id="sq" oninput="filterPat()" style="flex:1;max-width:260px">'+
+    '<select id="sg" onchange="filterPat()"><option value="">Alle Grade</option>'+[0,1,2,3,4,5].map(g=>'<option value="'+g+'">'+(g===0?'Kein Grad':'Grad '+g)+'</option>').join('')+'</select>'+
+    '<select id="szg" onchange="filterPat()"><option value="">Alle Zielgruppen</option><option value="alterspflege">Alterspflege</option><option value="beduerftige">Bedürftigen-Pflege</option><option value="behinderte">Behinderten-Pflege</option></select>'+
+    '</div></div><div class="card"><div id="pattable"></div></div>',
+    'Patientenliste',
+    '<button class="btn btn-p" onclick="go(\'neu\')"><i class="ti ti-user-plus"></i>Neuer Patient</button>');
+  renderPT(data);
+}
+function renderPT(data){
+  if(!data.length){S('pattable','<p class="muted sm" style="padding:8px">Keine Patienten.</p>');return;}
+  S('pattable','<div class="tw"><table><thead><tr><th>Name</th><th>Geburtsdatum</th><th>Krankenkasse</th><th>Grad</th><th>Zielgruppe</th><th></th></tr></thead><tbody>'+
+    data.map((p,i)=>{
+      const archiv=p.patient_status&&p.patient_status!=='aktiv';
+      const stLabel={verstorben:'Verstorben',verzogen:'Verzogen',archiviert:'Archiviert'};
+      return '<tr'+(archiv?' style="opacity:.72"':'')+'>'+
+        '<td><div class="fl ic g8">'+av(p.vorname+' '+p.nachname,i)+
+        '<div><span class="tl" onclick="loadPat('+p.id+')">'+p.vorname+' '+p.nachname+'</span>'+
+        (archiv?'<span class="badge b-gr" style="margin-left:6px;font-size:10px">'+(stLabel[p.patient_status]||p.patient_status)+'</span>':'')+
+        '</div></div></td>'+
+        '<td>'+fdate(p.geburtsdatum)+'</td>'+
+        '<td>'+(p.krankenkasse||'–')+'</td>'+
+        '<td>'+(p.pflegegrad?'<span class="badge b-out">Grad '+p.pflegegrad+'</span>':'<span class="muted">–</span>')+'</td>'+
+        '<td>'+zg_badge(p.zielgruppe||'alterspflege')+'</td>'+
+        '<td><div class="fl g8">'+
+        '<button class="btn btn-sm btn-ico" onclick="loadPat('+p.id+')" title="Anzeigen"><i class="ti ti-eye"></i></button>'+
+        '<button class="btn btn-sm btn-ico" style="color:var(--rdtx)" onclick="delPat('+p.id+',\''+p.vorname+' '+p.nachname+'\')" title="Löschen"><i class="ti ti-trash"></i></button>'+
+        '</div></td></tr>';
+    }).join('')+
+    '</tbody></table></div>');
+}
+async function filterPat(){
+  let url='/api/patienten?';
+  const q=document.getElementById('sq')?.value||'';const g=document.getElementById('sg')?.value||'';const zg=document.getElementById('szg')?.value||'';
+  if(q)url+='q='+encodeURIComponent(q)+'&';if(g)url+='pflegegrad='+g+'&';if(zg)url+='zielgruppe='+zg;
+  renderPT(await api(url));
+}
+async function delPat(id,name){
+  if(!confirm('Patient "'+name+'" löschen?'))return;
+  await api('/api/patienten/'+id,{method:'DELETE'});
+  toast(name+' gelöscht');refreshBadge();pgPatienten();
+}
+
+// ── Patient Detail ────────────────────────────────────────
+async function loadPat(id){
+  katPid=id;
+  R('<div class="spin-wrap"><div class="spin"></div>Lade…</div>','Patient');
+  const d=await api('/api/patienten/'+id);const p=d.patient;
+  katPatName=p.vorname+' '+p.nachname;
+  const emp=d.empfohlene_leistungen||[];const initials=((p.vorname?.[0]||'')+(p.nachname?.[0]||'')).toUpperCase();
+  R('<div class="alert a-info mb3"><i class="ti ti-shield-lock"></i><p><strong>Datenschutz:</strong> Personenbezogene Daten. Nur befugtes Personal (§ 4 BDSG).</p></div>'+
+    '<div class="g2">'+
+    '<div class="card"><div class="ch"><span class="ct">Stammdaten</span>'+
+    '<div class="pat-foto-btn" onclick="document.getElementById(\'fi_'+id+'\').click()" title="Profilfoto hochladen / ändern">'+
+    (p.foto_pfad?'<img src="/static/fotos/'+p.foto_pfad+'" class="pat-foto-img">':'<div class="av av1 pat-foto-empty">'+initials+'</div>')+
+    '</div></div>'+
+    '<input type="file" id="fi_'+id+'" accept="image/*" style="display:none" onchange="uploadFoto('+id+',this)">'+
+    '<div class="fg c2">'+
+    gfield('Vorname',p.vorname)+gfield('Nachname',p.nachname)+
+    gfield('Geburtsdatum',fdate(p.geburtsdatum))+gfield('Vers.-Nummer',p.versichertennummer||'–')+
+    gfield('Krankenkasse',p.krankenkasse||'–')+gfield('Versicherung',p.versicherungsart||'GKV')+
+    '<div class="fgrp" style="grid-column:1/-1">'+gfield('Anschrift',(p.strasse?p.strasse+', ':'')+p.plz+' '+p.ort)+'</div>'+
+    gfield('Telefon',p.telefon||'–')+gfield('E-Mail',p.email||'–')+
+    '</div><div class="divider"></div>'+
+    '<div class="fl ic g8"><span class="ct">Zielgruppe:</span>'+zg_badge(p.zielgruppe||'alterspflege')+'</div>'+
+    '<div class="mt3" id="notiz-block-'+id+'">'+
+    '<div class="fl ic g8 mb2" style="justify-content:space-between">'+
+    '<span class="sm" style="font-weight:500">Notizen</span>'+
+    '<div class="fl g6">'+
+    '<button class="btn btn-sm" onclick="loadNotizenVerlauf('+id+')" title="Änderungshistorie (ISO 9001)"><i class="ti ti-history"></i></button>'+
+    '<button class="btn btn-sm btn-p" onclick="editNotizen('+id+')"><i class="ti ti-edit"></i>Bearbeiten</button>'+
+    '</div></div>'+
+    '<div id="notiz-display-'+id+'" data-notiz="'+(p.notizen||'').replace(/&/g,'&amp;').replace(/"/g,'&quot;')+'" style="padding:9px;background:var(--bg);border-radius:var(--r);font-size:12.5px;white-space:pre-wrap;min-height:38px">'+(p.notizen||'<em class="muted" style="opacity:.6">Noch keine Notizen hinterlegt.</em>')+'</div>'+
+    '<div id="nverlauf-'+id+'" class="hidden" style="margin-top:8px"></div>'+
+    '</div>'+
+    '</div>'+
+    '<div>'+
+    '<div class="card mb3"><div class="ch"><span class="ct">Pflegestatus</span></div>'+
+    '<div class="lr"><span>Pflegegrad</span><span class="badge '+(p.pflegegrad>=1?'b-g':'b-gr')+'">'+(p.pflegegrad?'Grad '+p.pflegegrad:'Kein Antrag')+'</span></div>'+
+    (d.antraege.length?'<div class="lr"><span>Letzter Antrag</span><span>'+bdg(d.antraege[0].status)+'</span></div>':'')+
+    '<div class="mt3"><div class="sm muted">Prozessfortschritt</div><div class="prog mt2"><div class="pf" style="width:'+(p.pflegegrad?(p.pflegegrad/5*100):15)+'%"></div></div></div></div>'+
+    '<div class="card"><div class="ch"><span class="ct">Aktive Leistungen</span></div>'+
+    (d.leistungen.length===0?'<p class="muted sm">Noch keine hinterlegt. <span class="tl" onclick="go(\'katalog\',{pid:'+id+'})">Aus Katalog zuweisen →</span></p>':
+    d.leistungen.map(l=>'<div class="lr"><span>'+(l.katalog_id?'<i class="ti ti-list-details" title="Aus Leistungskatalog zugewiesen" style="color:var(--bltx);margin-right:5px;font-size:12px"></i>':'')+l.bezeichnung+'</span>'+
+    '<span class="lv">'+(l.betrag?l.betrag.toFixed(0)+' €/mtl.':(l.notizen?l.notizen.split('·')[0].split('(')[0].trim().slice(0,22):'–'))+'</span></div>').join(''))+
+    '</div></div></div>'+
+    '<div class="card"><div class="ch"><span class="ct">Passende Leistungen aus Katalog ('+emp.length+' für Grad '+(p.pflegegrad||0)+' · '+( ZGL[p.zielgruppe]||p.zielgruppe)+')</span>'+
+    '<button class="btn btn-sm" onclick="go(\'katalog\',{pid:'+id+'})"><i class="ti ti-list-details"></i>Alle anzeigen</button></div>'+
+    '<div class="kkat">'+emp.slice(0,6).map(l=>kcard(l)).join('')+'</div></div>'+
+    '<div class="g2">'+
+    '<div class="card"><div class="ch"><span class="ct">Anträge</span><button class="btn btn-sm" onclick="go(\'antrag\','+id+')"><i class="ti ti-plus"></i>Neu</button></div>'+
+    (d.antraege.length===0?'<p class="muted sm">Noch kein Antrag.</p>':
+    '<div class="tw"><table><thead><tr><th>Typ</th><th>Datum</th><th>Grad</th><th>Status</th><th>Dokument</th><th></th></tr></thead><tbody>'+
+    d.antraege.map(a=>'<tr><td><span class="tag">'+a.typ+'</span></td><td>'+fdate(a.antragsdatum)+'</td><td>'+(a.beantragter_pflegegrad?'Grad '+a.beantragter_pflegegrad:'–')+'</td><td>'+bdg(a.status)+'</td><td>'+(a.pdf_pfad?'<a href="/static/'+a.pdf_pfad+'" target="_blank" class="tl" style="white-space:nowrap"><i class="ti ti-file-type-pdf"></i> PDF öffnen</a>':'–')+'</td>'+
+    '<td><button class="btn btn-sm" onclick="bescheidModal('+a.id+','+id+','+(a.beantragter_pflegegrad||1)+',\''+a.typ+'\')"><i class="ti ti-edit"></i>Bescheid</button></td></tr>').join('')+'</tbody></table></div>')+
+    '</div>'+
+    '<div class="card"><div class="ch"><span class="ct">Aufgaben</span></div>'+
+    (d.aufgaben.length===0?'<p class="muted sm">Keine offenen Aufgaben.</p>':
+    d.aufgaben.map(a=>'<div class="step"><div class="si '+(a.prioritaet==='hoch'?'s-go':'s-no')+'"><i class="ti ti-clock"></i></div>'+
+      '<div class="sb2" style="flex:1"><div class="t">'+a.titel+'</div><div class="d">Fällig: '+fdate(a.faellig_am)+' · '+prio(a.prioritaet)+'</div></div>'+
+      '<button class="btn btn-sm" onclick="erlA('+a.id+')">✓</button></div>').join(''))+
+    '</div></div>'+
+    '<div class="card mb3"><div class="ch"><span class="ct">Pflegetagebuch</span>'+
+    '<div class="fl g8">'+
+    '<button class="btn btn-sm" onclick="dlTB('+id+')"><i class="ti ti-file-type-pdf"></i>PDF MDK</button>'+
+    '<button class="btn btn-sm btn-p" onclick="pgTagebuch('+id+')"><i class="ti ti-notebook"></i>Führen &amp; ansehen</button>'+
+    '</div></div>'+
+    '<div class="alert a-info" style="padding:8px 11px;margin-bottom:9px"><i class="ti ti-info-circle"></i>'+
+    '<p>Hilfebedarf gem. <strong>§ 14/15 SGB XI</strong> – Grundlage für MDK-Begutachtung (6 Module). Täglich dokumentieren!</p></div>'+
+    '<div id="tbsummary" class="sm muted">Lade…</div></div>'+
+    '<div class="card mb3" id="dkcard"><div class="ch"><span class="ct">Dokumente</span>'+
+    '<button class="btn btn-sm btn-p" onclick="dokUploadModal('+id+')"><i class="ti ti-upload"></i>Hochladen</button></div>'+
+    '<div id="dklist" class="sm muted">Lade…</div></div>'+
+    (p.patient_status&&p.patient_status!=='aktiv'?
+      '<div class="archiv-banner '+(p.patient_status)+'" style="margin-bottom:10px">'+
+      '<i class="ti ti-archive"></i>'+
+      '<div>Status: <strong>'+(p.patient_status==='verstorben'?'Verstorben':p.patient_status==='verzogen'?'Verzogen':'Archiviert')+'</strong>'+
+      (p.status_datum?' · '+fdate(p.status_datum):'')+
+      (p.archiv_frist?' · <strong>Aufbewahrungsfrist bis '+fdate(p.archiv_frist)+'</strong>':'')+
+      (p.patient_status==='verstorben'?' (30 J. gem. § 199 Abs. 2 BGB)':' (10 J. gem. § 630f BGB)')+
+      '</div></div>':'')+
+    '<div class="fl g8 mt2" style="flex-wrap:wrap">'+
+    '<button class="btn" onclick="go(\'patienten\')"><i class="ti ti-arrow-left"></i>Zurück</button>'+
+    '<button class="btn" onclick="go(\'widerspruch\','+id+')"><i class="ti ti-gavel"></i>Widerspruch</button>'+
+    '<button class="btn" onclick="dlAkte('+id+')"><i class="ti ti-file-type-pdf"></i>Akte exportieren</button>'+
+    '<button class="btn btn-p" onclick="go(\'katalog\',{pid:'+id+'})"><i class="ti ti-list-details"></i>Alle Leistungen prüfen</button>'+
+    '<button class="btn" style="margin-left:auto;color:var(--amtx);border-color:var(--amtx)" onclick="archivierenModal('+id+',\''+p.vorname+' '+p.nachname+'\')"><i class="ti ti-archive"></i>Archivieren</button>'+
+    '</div>',
+    p.vorname+' '+p.nachname);
+  // Tagebuch-Vorschau laden
+  api('/api/patienten/'+id+'/tagebuch').then(entries=>{
+    const el=document.getElementById('tbsummary');if(!el)return;
+    if(!entries.length){el.innerHTML='<p>Noch keine Einträge. <span class="tl" onclick="pgTagebuch('+id+')">Jetzt beginnen →</span></p>';return;}
+    el.innerHTML='<span class="badge b-b">'+entries.length+' Einträge</span> &nbsp;· zuletzt '+fdate(entries[0].datum)+
+      '<div class="mt2">'+entries.slice(0,2).map(e=>'<div class="lr"><span class="w5 sm">'+fdate(e.datum)+'</span>'+
+      '<span class="muted sm">'+([e.mobilitaet,e.koerperpflege,e.allgemein].filter(Boolean)[0]||'–').slice(0,50)+'</span></div>').join('')+'</div>';
+  });
+  // Dokumente laden
+  const dtypIcon={attest:'ti-stethoscope',gutachten:'ti-report-medical',bescheid:'ti-mail',
+    widerspruchsbescheid:'ti-gavel',krankenhausbericht:'ti-building-hospital',
+    pflegedienst:'ti-heart-handshake',rezept:'ti-pill',sonstiges:'ti-file'};
+  api('/api/patienten/'+id+'/dokumente').then(docs=>{
+    const el=document.getElementById('dklist');if(!el)return;
+    if(!docs.length){el.innerHTML='<p>Noch keine Dokumente hochgeladen. <span class="tl" onclick="dokUploadModal('+id+')">Jetzt hochladen →</span></p>';return;}
+    el.innerHTML=docs.map(dk=>{
+      const isImg=/\.(jpg|jpeg|png|gif|webp)$/i.test(dk.dateiname||'');
+      const isPdf=/\.pdf$/i.test(dk.dateiname||'');
+      return '<div class="dok-row">'+
+      (isImg?'<img src="/static/'+dk.pfad+'" style="width:36px;height:36px;object-fit:cover;border-radius:6px;flex-shrink:0;cursor:pointer" onclick="window.open(\'/static/'+dk.pfad+'\',\'_blank\')" title="Vorschau">':
+       '<div class="dok-icon" style="background:'+(isPdf?'#fff0f0':'var(--blbg)')+';color:'+(isPdf?'#e05':'var(--bltx)')+'"><i class="ti '+(dtypIcon[dk.typ]||'ti-file')+'"></i></div>')+
+      '<div style="flex:1;min-width:0"><div class="w5" style="font-size:13px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis">'+escH(dk.bezeichnung)+'</div>'+
+      '<div class="sm muted">'+(dk.typ||'Dokument')+(dk.datum?' · '+fdate(dk.datum):'')+'</div></div>'+
+      '<a href="/static/'+dk.pfad+'" target="_blank" class="btn btn-sm" title="Öffnen"><i class="ti ti-external-link"></i></a>'+
+      '<a href="/static/'+dk.pfad+'" download class="btn btn-sm" title="Download"><i class="ti ti-download"></i></a>'+
+      '<button class="btn btn-sm btn-ico" style="color:var(--rdtx)" onclick="delDok('+dk.id+','+id+')" title="Löschen"><i class="ti ti-trash"></i></button>'+
+      '</div>';
+    }).join('');
+  });
+}
+
+// ── Neuer Patient ─────────────────────────────────────────
+function pgNeu(){
+  R('<div class="card">'+
+    '<div class="slabel mb3">Zielgruppe *</div>'+
+    '<div class="zg-wrap mb4">'+
+    '<div class="zg-pill on" id="zg-alt" onclick="setZG(\'alterspflege\')"><i class="ti ti-walk"></i>Alterspflege</div>'+
+    '<div class="zg-pill" id="zg-bed" onclick="setZG(\'beduerftige\')"><i class="ti ti-heart-handshake"></i>Bedürftigen-Pflege</div>'+
+    '<div class="zg-pill" id="zg-beh" onclick="setZG(\'behinderte\')"><i class="ti ti-wheelchair"></i>Behinderten-Pflege</div>'+
+    '</div><input type="hidden" id="fzg" value="alterspflege">'+
+    '<div class="slabel mb3">Persönliche Daten</div>'+
+    '<div class="fg c3 mb4">'+
+    '<div class="fgrp"><label>Vorname *</label><input id="fvn" placeholder="Vorname"></div>'+
+    '<div class="fgrp"><label>Nachname *</label><input id="fnn" placeholder="Nachname"></div>'+
+    '<div class="fgrp"><label>Geburtsdatum</label><input id="fgeb" type="date"></div>'+
+    '</div><div class="fg c2 mb4">'+
+    '<div class="fgrp"><label>Straße &amp; Hausnummer</label><input id="fstr" placeholder="Musterstraße 1"></div>'+
+    '<div class="fgrp"><label>PLZ / Ort</label><div class="fl g8"><input id="fplz" placeholder="82256" style="width:85px"><input id="fort" placeholder="Fürstenfeldbruck"></div></div>'+
+    '<div class="fgrp"><label>Telefon</label><input id="ftel" placeholder="08141/..."></div>'+
+    '<div class="fgrp"><label>E-Mail</label><input id="fmail" placeholder="optional"></div>'+
+    '</div><div class="slabel mb3">Krankenversicherung</div>'+
+    '<div class="fg c3 mb4">'+
+    '<div class="fgrp"><label>Krankenkasse *</label><div class="kk-wrap"><input id="fkk_s" placeholder="Krankenkasse suchen…" autocomplete="off"><input type="hidden" id="fkk"></div></div>'+
+    '<div class="fgrp"><label>Versichertennummer</label><input id="fvnr" placeholder="A000000000"></div>'+
+    '<div class="fgrp"><label>Versicherungsart</label><select id="fvart"><option value="GKV">Gesetzlich (GKV)</option><option value="PKV">Privat (PKV)</option></select></div>'+
+    '</div><div class="slabel mb3">Pflegesituation</div>'+
+    '<div class="fg c3 mb4">'+
+    '<div class="fgrp"><label>Aktueller Pflegegrad</label><select id="fgrad"><option value="0">Noch kein Antrag</option>'+[1,2,3,4,5].map(g=>'<option value="'+g+'">Grad '+g+'</option>').join('')+'</select></div>'+
+    '<div class="fgrp"><label>Pflegeperson</label><select id="fpp">'+['Angehörige (privat)','Ambulanter Pflegedienst','Stationäres Pflegeheim','Kombination'].map(x=>'<option>'+x+'</option>').join('')+'</select></div>'+
+    '<div class="fgrp"><label>Antragsdatum</label><input id="fadt" type="date"></div>'+
+    '</div><div class="fgrp mb4"><label>Notizen / Diagnosen</label>'+
+    '<textarea id="fnotiz" rows="3" placeholder="z. B. Demenz, Diabetes, Mobilitätseinschränkungen…"></textarea></div>'+
+    '<div class="fl g8" style="justify-content:flex-end">'+
+    '<button class="btn" onclick="go(\'patienten\')"><i class="ti ti-x"></i>Abbrechen</button>'+
+    '<button class="btn btn-p" onclick="saveNeu()"><i class="ti ti-check"></i>Patient anlegen</button>'+
+    '</div></div>','Neuer Patient');
+  kkSearch('fkk_s','fkk','',kk=>{
+    const v=document.getElementById('fvart');
+    if(v&&kk)v.value=kk.typ;
+  });
+}
+function setZG(zg){
+  document.getElementById('fzg').value=zg;
+  const m={alterspflege:'alt',beduerftige:'bed',behinderte:'beh'};
+  Object.values(m).forEach(k=>document.getElementById('zg-'+k)?.classList.remove('on'));
+  document.getElementById('zg-'+m[zg])?.classList.add('on');
+}
+async function saveNeu(){
+  const g=id=>document.getElementById(id)?.value||'';
+  const data={vorname:g('fvn'),nachname:g('fnn'),geburtsdatum:g('fgeb'),strasse:g('fstr'),plz:g('fplz'),ort:g('fort'),
+    telefon:g('ftel'),email:g('fmail'),krankenkasse:g('fkk'),versichertennummer:g('fvnr'),versicherungsart:g('fvart'),
+    pflegegrad:g('fgrad'),pflegeperson:g('fpp'),zielgruppe:g('fzg'),notizen:g('fnotiz')};
+  if(!data.vorname||!data.nachname){toast('Vor- und Nachname erforderlich',false);return;}
+  const r=await api('/api/patienten',{method:'POST',body:JSON.stringify(data)});
+  toast('Patient '+data.vorname+' '+data.nachname+' angelegt');refreshBadge();loadPat(r.id);
+}
+
+// ── Leistungskatalog ──────────────────────────────────────
+async function pgKatalog(opts){
+  katPid=opts?.pid||null;
+  if(!katPid)katPatName=null;
+  R('<div class="spin-wrap"><div class="spin"></div>Lade Katalog…</div>','Leistungskatalog');
+  const d=await api('/api/katalog');
+  katalogData=d.items;
+  const banner=katPid?'<div class="alert a-info mb3"><i class="ti ti-user-check"></i><p>Kontext: <strong>'+katPatName+'</strong> – Klicken Sie auf <span class="badge b-g" style="font-size:11px">Zuweisen</span> um Leistungen diesem Patienten direkt zuzuweisen.</p></div>':'';
+  R(banner+
+    '<div class="card" style="padding:11px 14px">'+
+    '<div class="fl ic g8" style="flex-wrap:wrap;gap:10px">'+
+    '<input placeholder="Leistung suchen…" id="kq" oninput="filterK()" style="flex:1;min-width:160px;max-width:280px">'+
+    '<select id="kzg" onchange="filterK()"><option value="">Alle Zielgruppen</option><option value="alterspflege">Alterspflege</option><option value="beduerftige">Bedürftigen-Pflege</option><option value="behinderte">Behinderten-Pflege</option></select>'+
+    '<select id="kkat" onchange="filterK()"><option value="">Alle Kategorien</option>'+d.kategorien.map(k=>'<option>'+k+'</option>').join('')+'</select>'+
+    '<select id="kgrad" onchange="filterK()"><option value="">Alle Grade</option>'+[0,1,2,3,4,5].map(g=>'<option value="'+g+'">'+(g===0?'Kein Grad':'Grad '+g)+'</option>').join('')+'</select>'+
+    '<span id="kcount" class="badge b-b">'+d.total+' Leistungen</span>'+
+    '</div></div>'+
+    '<div id="kbody"></div>',
+    katPid?'Leistungskatalog – '+katPatName:'Leistungskatalog – 82 deutsche Leistungen',
+    '<span class="badge b-g" style="padding:6px 12px"><i class="ti ti-shield-check" style="margin-right:4px"></i>Stand 2025</span>');
+  renderK(katalogData);
+}
+function filterK(){
+  const q=(document.getElementById('kq')?.value||'').toLowerCase();
+  const zg=document.getElementById('kzg')?.value||'';
+  const kat=document.getElementById('kkat')?.value||'';
+  const grad=document.getElementById('kgrad')?.value;
+  let data=katalogData;
+  if(zg)data=data.filter(l=>(l.zielgruppe||[]).includes(zg));
+  if(kat)data=data.filter(l=>l.kategorie===kat);
+  if(grad!==''&&grad!=null)data=data.filter(l=>l.pflegegrad_min<=parseInt(grad)&&l.pflegegrad_max>=parseInt(grad));
+  if(q)data=data.filter(l=>l.name.toLowerCase().includes(q)||l.kurz.toLowerCase().includes(q)||(l.rechtsgrundlage||'').toLowerCase().includes(q)||(l.tags||[]).some(t=>t.includes(q)));
+  const e=document.getElementById('kcount');if(e)e.textContent=data.length+' Leistungen';
+  renderK(data);
+}
+function renderK(data){
+  if(!data.length){S('kbody','<div class="card muted sm">Keine Leistungen gefunden.</div>');return;}
+  const groups={};data.forEach(l=>{groups[l.kategorie]=groups[l.kategorie]||[];groups[l.kategorie].push(l);});
+  S('kbody',Object.entries(groups).map(([kat,items])=>
+    '<div class="card"><div class="kat-group-title"><i class="ti '+katIcon(kat)+'" style="color:var(--green)"></i>'+kat+'<span class="cnt">'+items.length+'</span></div>'+
+    '<div class="kkat">'+items.map(l=>kcard(l)).join('')+'</div></div>').join(''));
+}
+
+// ── Leistungsrechner ──────────────────────────────────────
+function pgRechner(){
+  R('<div class="g2">'+
+    '<div class="card"><div class="ch"><span class="ct">Leistungsrechner 2025</span></div>'+
+    '<div class="fg mb4">'+
+    '<div class="fgrp"><label>Zielgruppe</label><select id="rzg" onchange="calcR()"><option value="alterspflege">Alterspflege</option><option value="beduerftige">Bedürftigen-Pflege</option><option value="behinderte">Behinderten-Pflege</option></select></div>'+
+    '<div class="fgrp"><label>Pflegegrad</label><select id="rg" onchange="calcR()">'+
+    [0,1,2,3,4,5].map(g=>'<option value="'+g+'">'+(g===0?'Kein Antrag':g===1?'Grad 1 – geringfügig':g===2?'Grad 2 – erheblich':g===3?'Grad 3 – schwer':g===4?'Grad 4 – schwerste':' Grad 5 – besondere Anforderungen')+'</option>').join('')+
+    '</select></div></div>'+
+    '<div id="rresult"></div>'+
+    '<div class="alert a-info mt3"><i class="ti ti-info-circle"></i><p>PKV-Versicherte erhalten identische Leistungen (§ 23 SGB XI). Stand 2025.</p></div></div>'+
+    '<div class="card"><div class="ch"><span class="ct">Passende Leistungen aus Katalog</span></div><div id="rkat" class="muted sm">Pflegegrad wählen…</div></div>'+
+    '</div>','Leistungsrechner');calcR();
+}
+async function calcR(){
+  const grad=document.getElementById('rg')?.value||0;const zg=document.getElementById('rzg')?.value||'alterspflege';
+  const d=await api('/api/leistungen/berechnen',{method:'POST',body:JSON.stringify({pflegegrad:grad,zielgruppe:zg})});
+  const rows=[['Pflegegeld (monatlich)',d.pflegegeld],['Pflegesachleistung (monatlich)',d.sachleistung],
+    ['Entlastungsbetrag (monatlich)',d.entlastungsbetrag],['Pflegehilfsmittel Verbrauch (mtl.)',d.hilfsmittel],
+    ['Verhinderungspflege (jährlich)',d.verhinderungspflege],['Kurzzeitpflege (jährlich)',d.kurzzeitpflege],
+    ['Wohnumfeldverbesserung (einmalig max.)',d.wohnumfeld]];
+  const total=d.pflegegeld+d.sachleistung+d.entlastungsbetrag+d.hilfsmittel;
+  S('rresult',rows.filter(([,v])=>v>0).map(([n,v])=>'<div class="lr"><span>'+n+'</span><span class="lv">'+v.toLocaleString('de-DE')+' €</span></div>').join('')+
+    (parseInt(grad)>0?'<div class="lr" style="background:var(--gbg);padding:10px 9px;border-radius:var(--r);margin-top:10px"><span class="w5">Mögliches Monatsbudget</span><span class="lv" style="font-size:17px">'+total.toLocaleString('de-DE')+' €</span></div>':'<p class="muted sm mt2">Bitte Pflegegrad wählen.</p>'));
+  S('rkat','<div class="sm muted mb3">'+d.relevant_count+' passende Leistungen für '+ZGL[zg]+', Grad '+grad+'</div>'+
+    (d.relevant||[]).slice(0,8).map(l=>kcard(l)).join(''));
+}
+
+// ── Antrag ────────────────────────────────────────────────
+async function pgAntrag(prefillPid){
+  const pts=await api('/api/patienten');
+  R('<div class="g2">'+
+    '<div>'+
+    '<div class="card mb3"><div class="ch"><span class="ct">Schritt-für-Schritt (§ 18 SGB XI)</span></div>'+
+    '<div class="step"><div class="si s-ok"><i class="ti ti-check"></i></div><div class="sb2"><div class="t">A – Antrag stellen</div><div class="d">Einfaches Schreiben reicht. Datum ist wichtig – Leistungen gelten ab Antragsdatum!</div></div></div>'+
+    '<div class="step"><div class="si s-go"><i class="ti ti-user-search"></i></div><div class="sb2"><div class="t">B – Gutachter-Besuch (MDK / MDS)</div><div class="d">Gutachter kommen nach Hause. Pflegetagebuch vorbereiten (§ 18 SGB XI).</div></div></div>'+
+    '<div class="step"><div class="si s-no"><i class="ti ti-mail"></i></div><div class="sb2"><div class="t">C – Bescheid abwarten</div><div class="d">Kasse hat 25 Arbeitstage (§ 18 Abs. 3b SGB XI). Ca. 5 Wochen.</div></div></div>'+
+    '<div class="step"><div class="si s-no"><i class="ti ti-gavel"></i></div><div class="sb2"><div class="t">D – Ggf. Widerspruch</div><div class="d">Bei Ablehnung: Widerspruch binnen 1 Monat (§ 84 SGG)!</div></div></div>'+
+    '</div>'+
+    '<div class="card"><div class="ch"><span class="ct">Antrag anlegen</span></div><div class="fg mb4">'+
+    '<div class="fgrp"><label>Patient</label><select id="apid" onchange="fillAntragPat()"><option value="">– Patient wählen –</option>'+
+    pts.map(p=>'<option value="'+p.id+'"'+(prefillPid==p.id?' selected':'')+'>'+p.vorname+' '+p.nachname+'</option>').join('')+'</select></div>'+
+    '<div id="apinfo"></div>'+
+    '<div class="fgrp"><label>Antragstyp</label><select id="atyp">'+
+    ['erstantrag:Erstantrag Pflegegrad','hoeherst:Höherstufungsantrag','widerspruch:Widerspruch',
+     'reha:Reha-Antrag (§ 40 SGB V)','eingliederung:Eingliederungshilfe (SGB IX)',
+     'grundsicherung:Grundsicherung (§ 41 SGB XII)'].map(x=>{const[v,l]=x.split(':');return'<option value="'+v+'">'+l+'</option>';}).join('')+'</select></div>'+
+    '<div class="fg c2">'+
+    '<div class="fgrp"><label>Antragsdatum</label><input type="date" id="adt"></div>'+
+    '<div class="fgrp"><label>Beantragter Pflegegrad</label><select id="agrad">'+[1,2,3,4,5].map(g=>'<option value="'+g+'">Grad '+g+'</option>').join('')+'</select></div>'+
+    '</div><div class="fgrp"><label>Notizen</label><textarea id="anotiz" rows="2"></textarea></div></div>'+
+    '<div class="fl g8" style="justify-content:flex-end"><button class="btn btn-p" onclick="saveA()"><i class="ti ti-check"></i>Antrag anlegen</button></div></div>'+
+    '</div>'+
+    '<div class="card"><div class="ch"><span class="ct">Pflegetagebuch-Checkliste</span></div>'+
+    '<div class="alert a-info mb3"><i class="ti ti-info-circle"></i><p>Täglich <strong>vor dem Gutachter-Besuch</strong> dokumentieren. Heft beim Besuch vorzeigen!</p></div>'+
+    [['Körperpflege (§ 14 SGB XI)','Waschen, Duschen, Haare, Zähne, Rasur'],
+     ['An- und Ausziehen','Kleidung, Schuhe, Inkontinenzversorgung'],
+     ['Ernährung','Essen/Trinken, Zubereitung'],
+     ['Mobilität','Aufstehen, Gehen, Treppen, Stürze'],
+     ['Kognition & Orientierung','Vergessen, Verwirrtheit, Rhythmus'],
+     ['Medikamente','Selbstständige Einnahme, Dosierung'],
+     ['Verhaltensauffälligkeiten','Unruhe, Aggression, Ängste'],
+     ['Nächtlicher Hilfebedarf','Aufstehen, Lagerung, Inkontinenz'],
+     ['Soziale Aktivitäten','Kontakte, Hobbys, Selbstständigkeit'],
+     ['Haushaltsführung','Kochen, Putzen, Einkaufen'],
+    ].map(([t,d])=>'<div class="fl g8 mb3" style="align-items:flex-start"><input type="checkbox" style="width:auto;margin-top:3px;flex-shrink:0"><div><div class="w5" style="font-size:13px">'+t+'</div><div class="muted sm">'+d+'</div></div></div>').join('')+
+    '</div></div>','Antrag Pflegegrad');
+  if(prefillPid)fillAntragPat();
+}
+async function fillAntragPat(){
+  const pid=document.getElementById('apid')?.value;
+  const el=document.getElementById('apinfo');
+  if(!el)return;
+  if(!pid){el.innerHTML='';return;}
+  const d=await api('/api/patienten/'+pid);const p=d.patient;
+  el.innerHTML='<div class="alert a-info" style="padding:9px 13px;margin-bottom:12px">'+
+    '<i class="ti ti-user" style="font-size:17px"></i>'+
+    '<div style="line-height:1.6">'+
+    '<strong>'+p.vorname+' '+p.nachname+'</strong> '+zg_badge(p.zielgruppe||'alterspflege')+
+    (p.pflegegrad?' <span class="badge b-out">Grad '+p.pflegegrad+'</span>':' <span class="badge b-gr">Kein Pflegegrad</span>')+
+    '<br><span class="sm muted">'+(p.krankenkasse||'–')+(p.versichertennummer?' · '+p.versichertennummer:'')+
+    (p.strasse?' · '+p.strasse+', '+p.plz+' '+p.ort:'')+
+    '</span></div></div>';
+}
+async function saveA(){
+  const g=id=>document.getElementById(id)?.value||'';
+  const data={patient_id:g('apid'),typ:g('atyp'),antragsdatum:g('adt'),beantragter_pflegegrad:g('agrad'),notizen:g('anotiz'),status:'offen'};
+  if(!data.patient_id){toast('Bitte Patient wählen',false);return;}
+  await api('/api/antraege',{method:'POST',body:JSON.stringify(data)});
+  toast('Antrag angelegt');refreshBadge();
+}
+
+function bescheidModal(aid, pid, beantragterGrad, typ){
+  const today=new Date().toISOString().split('T')[0];
+  OM('Bescheid erfassen',
+    '<div class="fg mb4">'+
+    '<div class="fgrp"><label>Ergebnis</label>'+
+    '<select id="bst" onchange="bescheidToggle()">'+
+    '<option value="eingereicht">Eingereicht</option>'+
+    '<option value="in_pruefung">In Prüfung (MDK-Termin)</option>'+
+    '<option value="genehmigt">Genehmigt ✓</option>'+
+    '<option value="abgelehnt">Abgelehnt ✗</option>'+
+    '</select></div>'+
+    '<div class="fgrp"><label>Bescheiddatum</label><input type="date" id="bbd" value="'+today+'"></div>'+
+    '</div>'+
+    '<div id="b-gen" class="fg mb4" style="display:none">'+
+    '<div class="alert a-ok" style="padding:9px 13px;margin-bottom:12px"><i class="ti ti-circle-check"></i>'+
+    '<p>Der zugeteilte Pflegegrad wird automatisch in der Patientenakte übernommen.</p></div>'+
+    '<div class="fgrp"><label>Zugeteilter Pflegegrad</label>'+
+    '<select id="bzug">'+[1,2,3,4,5].map(g=>'<option value="'+g+'"'+(g==beantragterGrad?' selected':'')+'>Grad '+g+'</option>').join('')+'</select></div>'+
+    '</div>'+
+    '<div id="b-abl" style="display:none">'+
+    '<div class="alert a-warn" style="padding:9px 13px;margin-bottom:12px"><i class="ti ti-alert-triangle"></i>'+
+    '<p><strong>Widerspruchsfrist: 1 Monat</strong> ab Bescheiddatum (§ 84 SGG).<br>'+
+    'Widerspruch muss schriftlich bei der Krankenkasse eingehen.</p></div>'+
+    '</div>'+
+    '<div class="fl g8" style="justify-content:flex-end">'+
+    '<button class="btn" onclick="CM()">Abbrechen</button>'+
+    '<button class="btn btn-p" onclick="saveBescheid('+aid+','+pid+')"><i class="ti ti-check"></i>Speichern</button>'+
+    '</div>'
+  );
+}
+function bescheidToggle(){
+  const s=document.getElementById('bst')?.value;
+  document.getElementById('b-gen').style.display=(s==='genehmigt')?'block':'none';
+  document.getElementById('b-abl').style.display=(s==='abgelehnt')?'block':'none';
+}
+async function saveBescheid(aid, pid){
+  const g=id=>document.getElementById(id)?.value||'';
+  const status=g('bst');
+  const bescheid_datum=g('bbd');
+  const zugeteilter=status==='genehmigt'?parseInt(g('bzug')):null;
+  // Widerspruchsfrist = Bescheiddatum + 1 Monat
+  let wfrist='';
+  if(status==='abgelehnt'&&bescheid_datum){
+    const d=new Date(bescheid_datum);d.setMonth(d.getMonth()+1);
+    wfrist=d.toISOString().split('T')[0];
+  }
+  await api('/api/antraege/'+aid,{method:'PUT',body:JSON.stringify({
+    status,bescheid_datum,zugeteilter_pflegegrad:zugeteilter,widerspruch_frist:wfrist
+  })});
+  if(status==='genehmigt'&&zugeteilter){
+    await api('/api/patienten/'+pid+'/pflegegrad',{method:'PATCH',body:JSON.stringify({pflegegrad:zugeteilter})});
+    CM();
+    toast('Pflegegrad '+zugeteilter+' genehmigt – Patientenakte aktualisiert ✓');
+  } else if(status==='abgelehnt'){
+    CM();
+    const wf=wfrist?new Date(wfrist).toLocaleDateString('de-DE'):'';
+    const t=document.createElement('div');
+    t.className='toast';t.style.cssText='background:var(--danger);max-width:460px;line-height:1.5';
+    t.innerHTML='<i class="ti ti-alert-triangle"></i><span>Antrag abgelehnt'+(wf?'<br><small>Widerspruchsfrist: <strong>'+wf+'</strong></small>':'')+'</span>'+
+      '<button class="btn btn-sm" style="background:#fff2;color:#fff;margin-left:10px;white-space:nowrap" onclick="this.closest(\'.toast\').remove();go(\'widerspruch\','+pid+')">'+
+      '<i class="ti ti-gavel"></i>Widerspruch</button>';
+    document.body.appendChild(t);setTimeout(()=>t.remove(),9000);
+  } else {
+    CM();toast('Status aktualisiert');
+  }
+  refreshBadge();
+  loadPat(pid);
+}
+
+// ── Widerspruch ───────────────────────────────────────────
+const WGRUENDE=[
+  {id:'w18_1',norm:'§ 18 SGB XI',group:'Begutachtungsverfahren',label:'Begutachtung war zu kurz und oberflächlich',text:'Die Begutachtung durch den Medizinischen Dienst war nach § 18 SGB XI und den MDS-Begutachtungsrichtlinien unzureichend. Die zur Verfügung stehende Zeit reichte nicht aus, alle 6 Begutachtungsmodule ordnungsgemäß zu prüfen. Eine rechtskonforme Bewertung aller Selbstständigkeitskriterien war unter diesen Umständen nicht möglich.'},
+  {id:'w18_2',norm:'§ 18 SGB XI',group:'Begutachtungsverfahren',label:'Kein persönlicher Hausbesuch (Telefonbegutachtung)',text:'Gemäß § 18 Abs. 2 SGB XI ist die Begutachtung grundsätzlich im gewohnten Wohnumfeld des Pflegebedürftigen durchzuführen. Eine telefonische Begutachtung ermöglicht keine vollständige Beurteilung der Selbstständigkeit in allen Lebensbereichen und entspricht nicht den Anforderungen der MDS-Begutachtungsrichtlinien.'},
+  {id:'w18_3',norm:'§ 18 SGB XI',group:'Begutachtungsverfahren',label:'Angaben der Pflegeperson wurden nicht berücksichtigt',text:'Die Angaben der Pflegeperson und pflegenden Angehörigen zum tatsächlichen Pflegebedarf wurden während der Begutachtung nicht oder unzureichend berücksichtigt. Nach den MDS-Begutachtungsrichtlinien sind Aussagen von Pflegepersonen wesentlicher Bestandteil der Beurteilung.'},
+  {id:'w18_4',norm:'§ 18 SGB XI',group:'Begutachtungsverfahren',label:'Pflegetagebuch und Nachweise wurden ignoriert',text:'Das über mehrere Wochen geführte Pflegetagebuch sowie vorliegende schriftliche Nachweise über den tatsächlichen Hilfebedarf wurden im Begutachtungsverfahren nicht berücksichtigt. Diese Dokumentation belegt eindeutig einen höheren Pflegebedarf als im Bescheid festgestellt.'},
+  {id:'w18_5',norm:'§ 18 SGB XI',group:'Begutachtungsverfahren',label:'Nicht alle 6 Begutachtungsmodule vollständig geprüft',text:'Die Begutachtung hat nicht alle 6 Module des Begutachtungsinstruments nach § 14 SGB XI vollständig erfasst. Eine rechtskonforme Pflegegradeinstufung setzt die vollständige Prüfung und Gewichtung aller Module voraus. Einzelne Module wurden unzureichend oder gar nicht bewertet.'},
+  {id:'w15_1',norm:'§ 15 SGB XI',group:'Pflegegradeinstufung',label:'Hilfebedarf bei Mobilität unterschätzt (Modul 1)',text:'Der Hilfebedarf im Bereich Mobilität (Modul 1 nach § 14 Abs. 2 Nr. 1 SGB XI) wurde nicht korrekt erfasst. Die Fähigkeit zur Positionsveränderung, zum Gehen, Treppensteigen und zur Außenmobilität ist erheblich eingeschränkt und erfordert regelmäßige Assistenz oder vollständige Übernahme durch eine Pflegeperson.'},
+  {id:'w15_2',norm:'§ 15 SGB XI',group:'Pflegegradeinstufung',label:'Kognition und Kommunikation falsch bewertet (Modul 2/3)',text:'Die kognitiven und kommunikativen Fähigkeiten (Module 2 und 3 nach § 14 Abs. 2 Nr. 2+3 SGB XI) wurden nicht korrekt beurteilt. Vorhandene Einschränkungen bei Orientierung, Gedächtnis, Entscheidungsfindung und Kommunikation wurden unterschätzt und nicht ihrem tatsächlichen Ausmaß entsprechend in die Einstufung einbezogen.'},
+  {id:'w15_3',norm:'§ 15 SGB XI',group:'Pflegegradeinstufung',label:'Selbstversorgung unvollständig erfasst (Modul 4)',text:'Der Hilfebedarf bei der Selbstversorgung (Modul 4 nach § 14 Abs. 2 Nr. 4 SGB XI) – insbesondere bei Körperpflege, An- und Auskleiden sowie Ernährung – wurde nicht vollständig erfasst. Der tatsächliche Unterstützungsbedarf ist erheblich höher als im Gutachten festgestellt.'},
+  {id:'w15_4',norm:'§ 15 SGB XI',group:'Pflegegradeinstufung',label:'Medizinische Anforderungen nicht berücksichtigt (Modul 5)',text:'Medizinisch bedingte Anforderungen (Modul 5 nach § 14 Abs. 2 Nr. 5 SGB XI) wie Verabreichung von Medikamenten, Wundversorgung, Injektionen oder andere ärztlich angeordnete Maßnahmen wurden im Begutachtungsverfahren nicht ausreichend berücksichtigt.'},
+  {id:'w15_5',norm:'§ 15 SGB XI',group:'Pflegegradeinstufung',label:'Alltagsgestaltung und soziales Leben unterschätzt (Modul 6)',text:'Erhebliche Einschränkungen in der Gestaltung des Alltagslebens und sozialer Kontakte (Modul 6 nach § 14 Abs. 2 Nr. 6 SGB XI) wurden nicht ausreichend gewürdigt. Die Unfähigkeit, selbstständig Aktivitäten zu planen oder soziale Kontakte zu pflegen, erfordert regelmäßige Unterstützung.'},
+  {id:'w15_6',norm:'§ 15 SGB XI',group:'Pflegegradeinstufung',label:'Nächtlicher Pflegebedarf nicht erfasst',text:'Der nächtliche Pflegebedarf wurde im Begutachtungsverfahren nicht ausreichend erfasst. Die Pflegeperson muss den Versicherten mehrfach pro Nacht unterstützen (z. B. Lagerungswechsel, Toilettengänge, Medikamentengabe). Dieser erhebliche nächtliche Aufwand ist bei der Pflegegradeinstufung zwingend zu berücksichtigen.'},
+  {id:'w15_7',norm:'§ 15 SGB XI',group:'Pflegegradeinstufung',label:'Demenz / kognitive Erkrankung nicht ausreichend gewürdigt',text:'Die vorliegende Demenzerkrankung bzw. kognitive Einschränkung und die daraus resultierenden Beeinträchtigungen wurden im Begutachtungsverfahren nicht hinreichend berücksichtigt. Gemäß § 15 Abs. 3 SGB XI sind kognitive Einschränkungen gleichwertig mit körperlichen Einschränkungen zu bewerten.'},
+  {id:'w14_1',norm:'§ 14 SGB XI',group:'Begriff der Pflegebedürftigkeit',label:'Dauerhaftigkeit des Hilfebedarfs nicht korrekt bewertet',text:'Die Dauerhaftigkeit des Hilfebedarfs (§ 14 Abs. 1 SGB XI: voraussichtlich für mindestens 6 Monate) wurde nicht korrekt berücksichtigt. Der Hilfebedarf besteht nachweislich seit mehr als 6 Monaten durchgehend und ist nach ärztlicher Einschätzung dauerhafter Natur.'},
+  {id:'w14_2',norm:'§ 14 SGB XI',group:'Begriff der Pflegebedürftigkeit',label:'Selbstständigkeitsverlust in mehreren Lebensbereichen ignoriert',text:'Der Verlust der Selbstständigkeit besteht in mehreren Lebensbereichen gleichzeitig. Diese kumulative Beeinträchtigung erfordert nach § 14 SGB XI eine höhere Einstufung als im angefochtenen Bescheid vorgenommen.'},
+  {id:'w14_3',norm:'§ 14 SGB XI',group:'Begriff der Pflegebedürftigkeit',label:'Tagesabhängige Schwankungen (gute/schlechte Tage) nicht berücksichtigt',text:'Die tagesabhängigen Schwankungen des Gesundheitszustands wurden nicht korrekt in die Begutachtung einbezogen. Gemäß den MDS-Richtlinien ist bei schwankenden Verläufen der überwiegende Hilfebedarf maßgeblich – nicht der günstigste Tagesbefund zum Zeitpunkt der Begutachtung.'},
+  {id:'w37_1',norm:'§ 37 SGB XI',group:'Pflegegeld',label:'Materieller Schaden durch zu niedrigen Pflegegrad',text:'Durch die fehlerhafte Einstufung entsteht ein unmittelbarer materieller Schaden: Der Versicherte erhält nicht das ihm zustehende Pflegegeld nach § 37 SGB XI in der dem tatsächlichen Pflegebedarf entsprechenden Höhe. Die Differenz zwischen zuerkanntem und beantragtem Pflegegrad verursacht einen monatlichen Vermögensschaden.'},
+  {id:'w37_2',norm:'§ 37 SGB XI',group:'Pflegegeld',label:'Pflegende Angehörige erbringen erhebliche Pflegeleistungen',text:'Die pflegenden Angehörigen erbringen täglich einen erheblichen Zeitaufwand für die Pflege. Dieser private Pflegeaufwand, der andernfalls durch professionelle Pflegekräfte zu erbringen wäre, rechtfertigt den Anspruch auf das höhere Pflegegeld gemäß § 37 SGB XI.'},
+  {id:'w36_1',norm:'§ 36 SGB XI',group:'Pflegesachleistungen',label:'Sachleistungsanspruch durch falschen Pflegegrad nicht nutzbar',text:'Durch die fehlerhafte Einstufung ist der Versicherte nicht in der Lage, die ihm zustehenden Pflegesachleistungen nach § 36 SGB XI vollständig in Anspruch zu nehmen. Der tatsächliche Pflegeaufwand übersteigt den zuerkannten Leistungsrahmen erheblich.'},
+  {id:'w39_1',norm:'§ 39 SGB XI',group:'Verhinderungspflege',label:'Verhinderungspflege durch falschen Pflegegrad eingeschränkt',text:'Der Anspruch auf Verhinderungspflege gemäß § 39 SGB XI ist durch den zu niedrig festgesetzten Pflegegrad eingeschränkt. Die tatsächliche Pflegesituation erfordert regelmäßige Vertretung der Pflegeperson, was durch die korrekte Pflegegradeinstufung in vollem Umfang ermöglicht würde.'},
+  {id:'w45b_1',norm:'§ 45b SGB XI',group:'Entlastungsbetrag',label:'Entlastungsbetrag-Anspruch nicht korrekt berücksichtigt',text:'Der Anspruch auf den Entlastungsbetrag nach § 45b SGB XI wurde im Rahmen des Bescheids nicht korrekt berücksichtigt. Ein höherer Pflegegrad würde den Entlastungsbetrag und damit die Unterstützungsmöglichkeiten für pflegende Angehörige deutlich verbessern.'},
+  {id:'w40_1',norm:'§ 40 SGB XI',group:'Pflegehilfsmittel',label:'Pflegehilfsmittel nicht ausreichend berücksichtigt',text:'Notwendige Pflegehilfsmittel nach § 40 SGB XI wurden im Begutachtungsverfahren nicht ausreichend berücksichtigt. Der tatsächliche Bedarf an technischen Hilfsmitteln und Verbrauchsartikeln zur Erleichterung der Pflege entspricht einem höheren Pflegegrad.'},
+  {id:'w43_1',norm:'§ 43 SGB XI',group:'Vollstationäre Pflege',label:'Leistungen vollstationärer Pflege unzureichend',text:'Die Leistungen der vollstationären Pflege nach § 43 SGB XI sind durch den zu niedrig festgesetzten Pflegegrad unzureichend. Der tatsächliche Pflegeaufwand in der stationären Einrichtung entspricht einem höheren Pflegegrad.'},
+  {id:'w33_1',norm:'§ 33 SGB X',group:'Begründungspflicht',label:'Bescheid ist unzureichend begründet',text:'Der Bescheid entspricht nicht den Anforderungen des § 33 SGB X an die Begründungspflicht. Die Begründung lässt nicht erkennen, von welchem Sachverhalt die Behörde ausgegangen ist und warum der beantragte höhere Pflegegrad abgelehnt wurde.'},
+  {id:'w33_2',norm:'§ 33 SGB X',group:'Begründungspflicht',label:'Begründung ohne individuelle Patientenumstände',text:'Die Begründung des Bescheids enthält keine Ausführungen zu den individuellen Lebensumständen des Versicherten. Nach § 33 SGB X muss die Begründung erkennen lassen, welche Erwägungen für die Entscheidung maßgebend waren.'},
+  {id:'w24_1',norm:'§ 24 SGB X',group:'Anhörungsrecht',label:'Anhörung vor Bescheiderlass unterblieben',text:'Vor Erlass des belastenden Verwaltungsakts wurde keine Anhörung nach § 24 Abs. 1 SGB X durchgeführt. Dem Versicherten wurde keine Möglichkeit gegeben, vor der Entscheidung Stellung zu nehmen. Dieser Verfahrensfehler begründet die Rechtswidrigkeit des Bescheids.'},
+  {id:'w18f_1',norm:'§ 18 Abs. 3 SGB XI',group:'Begutachtungsfristen',label:'Begutachtungsfrist von 25 Arbeitstagen überschritten',text:'Die in § 18 Abs. 3 SGB XI vorgeschriebene Begutachtungsfrist von 25 Arbeitstagen wurde nicht eingehalten. Die Überschreitung stellt eine Pflichtverletzung der Pflegekasse dar, die im Rahmen des Widerspruchsverfahrens zu berücksichtigen ist.'},
+  {id:'w18f_2',norm:'§ 18 Abs. 3 SGB XI',group:'Begutachtungsfristen',label:'Keine schriftliche Begutachtungsempfehlung erhalten',text:'Die gesetzlich vorgeschriebene schriftliche Begutachtungsempfehlung gemäß § 18 SGB XI wurde dem Versicherten nicht in der vorgesehenen Form zugeleitet. Ohne vollständige Begutachtungsempfehlung ist eine sachgerechte Überprüfung des Begutachtungsergebnisses nicht möglich.'},
+  {id:'wv_1',norm:'Verfahrensrecht',group:'Verfahrensrecht',label:'Widerspruch gegen Ablehnung des Erstantrags',text:'Mit dem vorliegenden Bescheid wurde der Erstantrag auf Feststellung von Pflegebedürftigkeit zu Unrecht abgelehnt bzw. ein zu niedriger Pflegegrad festgestellt. Dies entspricht nicht dem tatsächlichen Pflegebedarf. Es wird ausdrücklich um vollständige Überprüfung und Neubescheidung gebeten.'},
+  {id:'wv_2',norm:'Verfahrensrecht',group:'Verfahrensrecht',label:'Widerspruch gegen Ablehnung der Höherstufung',text:'Der Antrag auf Höherstufung des Pflegegrades wurde zu Unrecht abgelehnt. Der Gesundheitszustand des Versicherten hat sich seit der letzten Begutachtung wesentlich verschlechtert, was eine höhere Einstufung begründet. Eine erneute Begutachtung unter Berücksichtigung der aktuellen Situation ist erforderlich.'},
+  {id:'wv_3',norm:'Verfahrensrecht',group:'Verfahrensrecht',label:'Begutachtungsgutachten enthält sachliche Fehler',text:'Das dem Bescheid zugrundeliegende Begutachtungsgutachten enthält sachliche Fehler und unzutreffende Feststellungen. Die im Gutachten beschriebene Pflegesituation entspricht nicht der tatsächlichen Situation des Versicherten. Es wird die Übersendung des vollständigen Begutachtungsgutachtens gem. § 25 SGB X beantragt.'},
+];
+async function pgWiderspruch(prefillPid){
+  const pts=await api('/api/patienten');
+  const norms=[...new Map(WGRUENDE.map(g=>[g.norm,g.group])).entries()];
+  const wgHtml=norms.map(([norm,group],idx)=>{
+    const items=WGRUENDE.filter(g=>g.norm===norm);
+    return '<div class="wg-group">'+
+      '<div class="wg-group-hd" onclick="const b=this.nextElementSibling;b.style.display=b.style.display===\'none\'?\'\':\'none\'">'+
+      '<span><span class="wg-norm-tag">'+norm+'</span>&ensp;'+group+'</span>'+
+      '<i class="ti ti-chevron-down" style="font-size:13px;flex-shrink:0"></i></div>'+
+      '<div class="wg-group-body"'+(idx>1?' style="display:none"':'')+'>'+
+      items.map(g=>'<label class="wg-item"><input type="checkbox" id="wg_'+g.id+'"><span>'+g.label+'</span></label>').join('')+
+      '</div></div>';
+  }).join('');
+  R('<div class="alert a-warn mb3"><i class="ti ti-scale"></i><p><strong>Rechtlicher Hinweis:</strong> Widerspruch nach <strong>§ 84 SGG</strong> – Frist <strong>1 Monat</strong> ab Bescheiddatum. Bei komplexen Fällen: VdK, SoVD oder Rechtsanwalt hinzuziehen.</p></div>'+
+    '<div class="g2" style="align-items:start">'+
+    '<div class="card"><div class="ch"><span class="ct">Widerspruchsdaten</span></div>'+
+    '<div class="slabel mb3">Zielgruppe</div>'+
+    '<div class="zg-wrap mb4">'+
+    '<div class="zg-pill on" id="wzg-alt" onclick="setWZG(\'alterspflege\')"><i class="ti ti-walk"></i>Alterspflege</div>'+
+    '<div class="zg-pill" id="wzg-bed" onclick="setWZG(\'beduerftige\')"><i class="ti ti-heart-handshake"></i>Bedürftig</div>'+
+    '<div class="zg-pill" id="wzg-beh" onclick="setWZG(\'behinderte\')"><i class="ti ti-wheelchair"></i>Behindert</div>'+
+    '</div><input type="hidden" id="wzg" value="alterspflege">'+
+    '<div class="fg mb4">'+
+    '<div class="fg c2">'+
+    '<div class="fgrp"><label>Patient wählen</label><select id="wpid" onchange="fillWP()"><option value="">– wählen –</option>'+
+    pts.map(p=>'<option value="'+p.id+'"'+(prefillPid==p.id?' selected':'')+'>'+p.vorname+' '+p.nachname+'</option>').join('')+'</select></div>'+
+    '<div class="fgrp"><label>Name</label><input id="wname" placeholder="Vorname Nachname"></div>'+
+    '</div>'+
+    '<div class="fg c2">'+
+    '<div class="fgrp"><label>Geburtsdatum</label><input id="wgeb" type="date"></div>'+
+    '<div class="fgrp"><label>Versichertennummer</label><input id="wvnr" placeholder="A000000000"></div>'+
+    '</div>'+
+    '<div class="fgrp"><label>Krankenkasse (Empfänger)</label><div class="kk-wrap"><input id="wkk_s" placeholder="Krankenkasse suchen…" autocomplete="off"><input type="hidden" id="wkk"></div></div>'+
+    '<div class="fgrp"><label>Patientenanschrift</label><input id="waddr" placeholder="Straße, PLZ Ort"></div>'+
+    '</div>'+
+    '<div class="slabel mb3">Bescheid</div>'+
+    '<div class="fg mb4">'+
+    '<div class="fg c2"><div class="fgrp"><label>Bescheiddatum *</label><input id="wbd" type="date"></div><div class="fgrp"><label>Aktenzeichen</label><input id="waz" placeholder="optional"></div></div>'+
+    '<div class="fg c2">'+
+    '<div class="fgrp"><label>Zugeteilter Pflegegrad</label><select id="wist">'+[0,1,2,3,4,5].map(g=>'<option value="'+g+'">'+(g===0?'Kein Grad':'Grad '+g)+'</option>').join('')+'</select></div>'+
+    '<div class="fgrp"><label>Erwarteter Pflegegrad</label><select id="wsoll">'+[1,2,3,4,5].map(g=>'<option value="'+g+'">Grad '+g+'</option>').join('')+'</select></div>'+
+    '</div></div>'+
+    '<div class="slabel mb2">Widerspruchsgründe auswählen <span style="color:var(--rdtx)">*</span></div>'+
+    '<div style="margin-bottom:14px">'+wgHtml+'</div>'+
+    '<div class="fgrp mb4"><label>Beigefügte Beweismittel</label>'+
+    '<div style="display:grid;grid-template-columns:1fr 1fr;gap:6px 12px;margin-top:4px">'+
+    [['wb1','Pflegetagebuch'],['wb2','Ärztliche Atteste / Facharztberichte'],
+     ['wb3','Schriftliche Diagnosen'],['wb4','Fotodokumentation'],
+     ['wb5','Angehörigen-Aussagen'],['wb6','Gegengutachten (§ 18 SGB XI)'],
+     ['wb7','Krankenhausberichte'],['wb8','Pflegedienst-Dokumentation']].map(([i,l])=>
+    '<label style="display:flex;align-items:center;gap:7px;font-size:12.5px;cursor:pointer"><input type="checkbox" id="'+i+'" style="width:auto"> '+l+'</label>').join('')+
+    '</div></div>'+
+    '<button class="btn btn-p" style="width:100%" onclick="genW()"><i class="ti ti-file-text"></i>Widerspruch erstellen</button>'+
+    '</div>'+
+    '<div class="card" style="display:flex;flex-direction:column">'+
+    '<div class="ch"><span class="ct">Widerspruch-Vorschau</span><div class="fl g8">'+
+    '<button class="btn btn-sm hidden" id="wcopy" onclick="cpW()"><i class="ti ti-copy"></i>Kopieren</button>'+
+    '<button class="btn btn-sm hidden" id="wdl" onclick="dlW()"><i class="ti ti-file-type-pdf"></i>PDF</button>'+
+    '<button class="btn btn-sm hidden" id="wmail" onclick="sendMailModal(\'widerspruch\')"><i class="ti ti-send"></i>E-Mail</button>'+
+    '</div></div>'+
+    '<div id="wpreview" class="brief" style="flex:1">Widerspruch erscheint hier nach dem Klick auf „Widerspruch erstellen".\n\nBitte:\n1. Patientendaten ausfüllen\n2. Bescheiddatum eingeben\n3. Widerspruchsgründe auswählen (mindestens 1)\n4. „Widerspruch erstellen" klicken</div>'+
+    '<div class="alert a-info mt3" style="font-size:12px"><i class="ti ti-send" style="font-size:16px"></i>'+
+    '<p>Brief ausdrucken und <strong>per Einschreiben mit Rückschein</strong> versenden. Kopie aufbewahren!</p></div>'+
+    '</div></div>',
+    'Widerspruch-Generator',
+    '<span class="badge b-b" style="padding:6px 12px"><i class="ti ti-gavel" style="margin-right:4px"></i>§ 84 SGG · 1-Monats-Frist</span>');
+  kkSearch('wkk_s','wkk','');
+  if(typeof prefillPid==='number'){document.getElementById('wpid').value=prefillPid;fillWP();}
+}
+function setWZG(zg){
+  document.getElementById('wzg').value=zg;
+  const m={alterspflege:'alt',beduerftige:'bed',behinderte:'beh'};
+  Object.values(m).forEach(k=>document.getElementById('wzg-'+k)?.classList.remove('on'));
+  document.getElementById('wzg-'+m[zg])?.classList.add('on');
+}
+async function fillWP(){
+  const pid=document.getElementById('wpid')?.value;if(!pid)return;
+  const d=await api('/api/patienten/'+pid);const p=d.patient;
+  const sv=(id,v)=>{const e=document.getElementById(id);if(e&&v)e.value=v;};
+  sv('wname',p.vorname+' '+p.nachname);sv('wgeb',p.geburtsdatum);sv('wvnr',p.versichertennummer);
+  sv('waddr',(p.strasse?p.strasse+', ':'')+p.plz+' '+p.ort);
+  if(p.krankenkasse)selKK('wkk_s','wkk',p.krankenkasse);
+  if(p.pflegegrad)sv('wist',p.pflegegrad);
+  if(p.zielgruppe)setWZG(p.zielgruppe);
+}
+function genW(){
+  const g=id=>document.getElementById(id)?.value||'';
+  const cb=id=>!!document.getElementById(id)?.checked;
+  if(!g('wbd')){toast('Bitte Bescheiddatum eingeben',false);return;}
+  const sel=WGRUENDE.filter(gr=>cb('wg_'+gr.id));
+  if(!sel.length){toast('Bitte mindestens einen Widerspruchsgrund auswählen',false);return;}
+  const beweise=[
+    cb('wb1')&&'Pflegetagebuch',cb('wb2')&&'Ärztliche Atteste / Facharztberichte',
+    cb('wb3')&&'Schriftliche Diagnosen',cb('wb4')&&'Fotodokumentation',
+    cb('wb5')&&'Angehörigen-Aussagen',cb('wb6')&&'Gegengutachten (§ 18 SGB XI)',
+    cb('wb7')&&'Krankenhausberichte',cb('wb8')&&'Pflegedienst-Dokumentation'
+  ].filter(Boolean);
+  const wname=g('wname')||'[Patient]';
+  const bd=g('wbd');
+  const bdF=bd?new Date(bd).toLocaleDateString('de-DE'):'[Datum]';
+  const today=new Date().toLocaleDateString('de-DE');
+  const istGrad=parseInt(g('wist')||0);
+  const sollGrad=parseInt(g('wsoll')||3);
+  const kk=g('wkk')||g('wkk_s')||'[Krankenkasse]';
+  const kkAdresse=getKKAdr(kk);
+  const addr=g('waddr')||'[Adresse]';
+  const geb=g('wgeb');const gebF=geb?new Date(geb).toLocaleDateString('de-DE'):'';
+  const vnr=g('wvnr');const az=g('waz');
+  const normen=[...new Map(sel.map(gr=>[gr.norm,gr])).keys()];
+  let t='';
+  t+=wname+'\n'+addr+'\n\n';
+  t+=today+'\n\n';
+  t+=kk+'\n'+kkAdresse+'\n\n';
+  t+='─'.repeat(55)+'\n';
+  t+='Widerspruch gegen Bescheid vom '+bdF+'\n';
+  if(vnr)t+='Versichertennummer: '+vnr+'\n';
+  if(az)t+='Aktenzeichen: '+az+'\n';
+  t+='─'.repeat(55)+'\n\n';
+  t+='Sehr geehrte Damen und Herren,\n\n';
+  t+='hiermit erhebe ich fristgerecht Widerspruch gemäß § 84 Abs. 1 SGG gegen den\n';
+  t+='Bescheid vom '+bdF+', mit dem '+(istGrad===0?'kein Pflegegrad':'Pflegegrad '+istGrad)+'\n';
+  t+='zuerkannt wurde. Ich beantrage die Feststellung von Pflegegrad '+sollGrad+'.\n\n';
+  t+='I. SACHVERHALT\n\n';
+  t+=wname+(gebF?', geboren am '+gebF:'');
+  t+=', ist pflegebedürftig im Sinne des § 14 SGB XI.\n';
+  t+='Der mit Bescheid vom '+bdF+' festgestellte '+(istGrad===0?'fehlende Pflegegrad':'Pflegegrad '+istGrad)+'\n';
+  t+='entspricht nicht dem tatsächlichen Pflegebedarf.\n\n';
+  t+='II. RECHTLICHE BEGRÜNDUNG\n\n';
+  normen.forEach((norm,ni)=>{
+    const items=sel.filter(gr=>gr.norm===norm);
+    t+=(ni+1)+'. '+norm+' – '+items[0].group+'\n\n';
+    items.forEach(gr=>{t+=gr.text+'\n\n';});
+  });
+  if(beweise.length){
+    t+='III. BEWEISMITTEL\n\nFolgende Unterlagen werden beigefügt:\n\n';
+    beweise.forEach((b,i)=>{t+=(i+1)+'. '+b+'\n';});
+    t+='\n';
+  }
+  t+=(beweise.length?'IV':'III')+'. ANTRAG\n\n';
+  t+='Es wird beantragt:\n\n';
+  t+='1. Den Bescheid vom '+bdF+' aufzuheben.\n';
+  t+='2. Einen neuen Bescheid mit Pflegegrad '+sollGrad+' zu erlassen.\n';
+  t+='3. Eine erneute Begutachtung durch einen unabhängigen Gutachter nach § 18 SGB XI\n   durchzuführen.\n';
+  t+='4. Den Eingang dieses Widerspruchs schriftlich zu bestätigen.\n\n';
+  t+='Der Widerspruch wird innerhalb der Frist des § 84 Abs. 1 SGG (1 Monat ab\n';
+  t+='Zustellung des Bescheids) fristgerecht eingelegt.\n\n';
+  t+='Mit freundlichen Grüßen,\n\n\n';
+  t+=wname;
+  document.getElementById('wpreview').textContent=t;
+  document.getElementById('wcopy').classList.remove('hidden');
+  document.getElementById('wdl').classList.remove('hidden');
+  document.getElementById('wmail').classList.remove('hidden');
+  toast('Widerspruch erstellt ✓');
+}
+function cpW(){navigator.clipboard.writeText(document.getElementById('wpreview')?.textContent||'');toast('Kopiert');}
+
+async function sendMailModal(typ){
+  const pid=typ==='widerspruch'
+    ?document.getElementById('wpid')?.value
+    :mPatId;
+  const previewId=typ==='widerspruch'?'wpreview':'mpreview';
+  const t=document.getElementById(previewId)?.textContent||'';
+  if(!t.trim()){toast('Erst '+(typ==='widerspruch'?'Widerspruch erstellen':'Brief vorschau anzeigen'),false);return;}
+  let empfaenger='',betreff='';
+  if(typ==='widerspruch'){
+    const kk=document.getElementById('wkk')?.value||document.getElementById('wkk_s')?.value||'';
+    betreff='Widerspruch gemäß § 84 SGG';
+    const wn=document.getElementById('wname')?.value||'';
+    if(wn)betreff+=' – '+wn;
+  } else {
+    betreff='Antrag auf Pflegeleistungen';
+    const mn=document.getElementById('mn')?.value||'';
+    if(mn)betreff+=' – '+mn;
+  }
+  if(pid){
+    try{const d=await api('/api/patienten/'+pid);if(d.patient?.email)empfaenger=d.patient.email;}catch(e){}
+  }
+  OM('E-Mail senden – '+(typ==='widerspruch'?'Widerspruch':'Musterbrief'),
+    '<div class="fg">'+
+    '<div class="fgrp"><label>Empfänger (An) <span style="color:#e74c3c">*</span></label>'+
+    '<input id="ml-to" value="'+escH(empfaenger)+'" placeholder="empfaenger@krankenkasse.de"></div>'+
+    '<div class="fgrp"><label>Betreff</label><input id="ml-subj" value="'+escH(betreff)+'"></div>'+
+    '<div class="fgrp"><label>Anschreiben (E-Mail-Text)</label>'+
+    '<textarea id="ml-body" rows="5" class="inp">Sehr geehrte Damen und Herren,\n\nanbei übersende ich das beigefügte Dokument zu Ihrer Kenntnisnahme.\n\nFür Rückfragen stehe ich Ihnen gerne zur Verfügung.\n\nMit freundlichen Grüßen</textarea></div>'+
+    '<label class="fl ic g8" style="font-size:13px;cursor:pointer;margin-top:6px">'+
+    '<input type="checkbox" id="ml-pdf" checked style="width:auto;cursor:pointer"> Dokument als PDF-Anhang beifügen</label>'+
+    '</div>'+
+    '<div class="alert a-info mt3" style="padding:8px 11px"><i class="ti ti-info-circle"></i>'+
+    '<p class="sm">SMTP-Einstellungen unter <strong>Backend → E-Mail (SMTP)</strong> konfigurieren. Versand erfolgt über Ihren eigenen Mailserver.</p></div>'+
+    '<div class="fl g8 mt3" style="justify-content:flex-end">'+
+    '<button class="btn" onclick="CM()">Abbrechen</button>'+
+    '<button class="btn btn-p" id="ml-send-btn" onclick="sendMail(\''+typ+'\')"><i class="ti ti-send"></i>Senden</button>'+
+    '</div>'
+  );
+}
+
+async function sendMail(typ){
+  const to=(document.getElementById('ml-to')?.value||'').trim();
+  const subj=document.getElementById('ml-subj')?.value||'';
+  const body=document.getElementById('ml-body')?.value||'';
+  const withPdf=document.getElementById('ml-pdf')?.checked;
+  if(!to){toast('Empfänger-Adresse eingeben',false);return;}
+  const btn=document.getElementById('ml-send-btn');
+  if(btn){btn.disabled=true;btn.innerHTML='<i class="ti ti-loader-2"></i>Wird gesendet…';}
+  const previewId=typ==='widerspruch'?'wpreview':'mpreview';
+  const t=document.getElementById(previewId)?.textContent||'';
+  let pdf_base64='',pdf_dateiname='';
+  if(withPdf){
+    const rawName=typ==='widerspruch'
+      ?(document.getElementById('wname')?.value||'Widerspruch')
+      :(document.getElementById('mn')?.value||'Brief');
+    const namePart=toFilename(rawName.trim().split(' ').pop()||rawName);
+    pdf_dateiname=(typ==='widerspruch'?'Widerspruch_':'Brief_')+namePart+'_'+isoDate()+'.pdf';
+    const el=document.createElement('div');
+    el.style.cssText='font-family:"Courier New",Courier,monospace;font-size:10.5pt;line-height:1.9;padding:0;white-space:pre-wrap;color:#111;background:#fff;word-break:break-word;';
+    el.textContent=t;
+    try{
+      await new Promise((res,rej)=>{
+        html2pdf().set({margin:[25,20,28,25],filename:pdf_dateiname,html2canvas:{scale:2,useCORS:true},jsPDF:{unit:'mm',format:'a4',orientation:'portrait'}})
+          .from(el).toPdf().get('pdf').then(pdf=>{addPageNums(pdf);pdf_base64=pdf.output('datauristring').split(',')[1];res();}).catch(rej);
+      });
+    }catch(e){
+      toast('PDF-Generierung fehlgeschlagen',false);
+      if(btn){btn.disabled=false;btn.innerHTML='<i class="ti ti-send"></i>Senden';}
+      return;
+    }
+  }
+  const r=await api('/api/email/senden',{method:'POST',body:JSON.stringify({
+    empfaenger:to,betreff:subj,nachricht:body,pdf_base64,pdf_dateiname
+  })});
+  if(r.ok){CM();toast('E-Mail erfolgreich gesendet ✓');}
+  else{
+    toast(r.error||'Fehler beim Senden',false);
+    if(btn){btn.disabled=false;btn.innerHTML='<i class="ti ti-send"></i>Senden';}
+  }
+}
+
+function dlW(){
+  const t=document.getElementById('wpreview')?.textContent||'';
+  if(!t.trim()){toast('Kein Text zum Exportieren',false);return;}
+  const el=document.createElement('div');
+  el.style.cssText='font-family:"Courier New",Courier,monospace;font-size:10.5pt;line-height:1.9;padding:0;white-space:pre-wrap;color:#111;background:#fff;word-break:break-word;';
+  el.textContent=t;
+  const wname=document.getElementById('wname')?.value||'';
+  const nameParts=wname.trim().split(' ');
+  const name=toFilename(nameParts.length>1?nameParts.slice(-1)[0]:nameParts[0]||'Patient');
+  const fname='Widerspruch_'+name+'_'+isoDate()+'.pdf';
+  html2pdf().set({margin:[25,20,28,25],filename:fname,html2canvas:{scale:2,useCORS:true},jsPDF:{unit:'mm',format:'a4',orientation:'portrait'}})
+    .from(el).toPdf().get('pdf').then(pdf=>{
+      addPageNums(pdf);
+      const blob=pdf.output('blob');
+      const url=URL.createObjectURL(blob);
+      const a=document.createElement('a');a.href=url;a.download=fname;
+      document.body.appendChild(a);a.click();document.body.removeChild(a);
+      setTimeout(()=>URL.revokeObjectURL(url),2000);
+      toast('PDF heruntergeladen: '+fname);
+      const wpid=document.getElementById('wpid')?.value;
+      if(wpid){
+        const b64=pdf.output('datauristring').split(',')[1];
+        api('/api/patienten/'+wpid+'/briefe',{method:'POST',body:JSON.stringify({
+          typ:'widerspruch',notizen:'PDF: '+fname,brief_text:t,pdf_base64:b64,pdf_dateiname:fname
+        })}).then(r=>{if(r.ok)toast('PDF dauerhaft in Patientenakte gespeichert ✓');});
+      }
+    });
+}
+
+// ── Musterbrief ───────────────────────────────────────────
+async function pgMuster(){
+  const pts=await api('/api/patienten');
+  R('<div class="g2">'+
+    '<div class="card"><div class="ch"><span class="ct">Briefdaten</span></div>'+
+    '<div class="fg mb4">'+
+    '<div class="fgrp"><label>Patient wählen</label><select onchange="fillM(this.value)"><option value="">– wählen –</option>'+
+    pts.map(p=>'<option value="'+p.id+'">'+p.vorname+' '+p.nachname+'</option>').join('')+'</select></div>'+
+    '<div class="fg c2"><div class="fgrp"><label>Name</label><input id="mn" oninput="updM()"></div>'+
+    '<div class="fgrp"><label>Straße</label><input id="ms" oninput="updM()"></div></div>'+
+    '<div class="fg c2"><div class="fgrp"><label>PLZ / Ort</label><input id="mpo" oninput="updM()"></div>'+
+    '<div class="fgrp"><label>Telefon</label><input id="mtel" oninput="updM()"></div></div>'+
+    '<div class="fgrp"><label>Krankenkasse (Empfänger)</label><div class="kk-wrap"><input id="mkk_s" placeholder="Krankenkasse suchen…" autocomplete="off"><input type="hidden" id="mkk"></div></div>'+
+    '</div>'+
+    '<div class="slabel mb3">Versicherte Person</div><div class="fg mb4">'+
+    '<div class="fg c2"><div class="fgrp"><label>Name</label><input id="mpn" oninput="updM()"></div>'+
+    '<div class="fgrp"><label>Geburtsdatum</label><input id="mpgeb" type="date" oninput="updM()"></div></div>'+
+    '<div class="fgrp"><label>Versichertennummer</label><input id="mpvnr" oninput="updM()"></div></div>'+
+    '<div class="slabel mb3">Antragstyp</div>'+
+    '<div class="fg mb4"><div class="fgrp"><label>Typ</label><select id="mtyp" onchange="updM()">'+
+    ['erstantrag:Erstantrag Pflegegrad (§ 33 SGB XI)',
+     'hoeherst:Höherstufungsantrag',
+     'eingliederung:Eingliederungshilfe (§ 99 SGB IX)',
+     'grundsicherung:Grundsicherung (§ 41 SGB XII)',
+     'blindenhilfe:Blindenhilfe (§ 72 SGB XII)'].map(x=>{const[v,l]=x.split(':');return'<option value="'+v+'">'+l+'</option>';}).join('')+
+    '</select></div></div>'+
+    '<button class="btn btn-p" style="width:100%" onclick="updM()"><i class="ti ti-refresh"></i>Vorschau</button>'+
+    '</div>'+
+    '<div class="card" style="display:flex;flex-direction:column">'+
+    '<div class="ch"><span class="ct">Briefvorschau</span><div class="fl g8">'+
+    '<button class="btn btn-sm" onclick="cpM()"><i class="ti ti-copy"></i>Kopieren</button>'+
+    '<button class="btn btn-sm btn-p" onclick="dlM()"><i class="ti ti-file-type-pdf"></i>PDF</button>'+
+    '<button class="btn btn-sm" onclick="sendMailModal(\'musterbrief\')"><i class="ti ti-send"></i>E-Mail</button></div></div>'+
+    '<div id="mpreview" class="brief" style="flex:1"></div></div></div>',
+    'Musterbrief');
+  kkSearch('mkk_s','mkk','',()=>updM());
+  updM();
+}
+async function fillM(pid){
+  mPatId=pid||null;
+  if(!pid)return;const d=await api('/api/patienten/'+pid);const p=d.patient;
+  const sv=(id,v)=>{const e=document.getElementById(id);if(e&&v!==undefined)e.value=v;};
+  sv('mn',p.vorname+' '+p.nachname);sv('ms',p.strasse||'');sv('mpo',(p.plz||'')+' '+(p.ort||''));
+  sv('mtel',p.telefon||'');sv('mpn',p.vorname+' '+p.nachname);sv('mpgeb',p.geburtsdatum||'');sv('mpvnr',p.versichertennummer||'');
+  if(p.krankenkasse)selKK('mkk_s','mkk',p.krankenkasse);
+  updM();
+}
+const MBETR={
+  erstantrag:'Antrag auf Leistungen der Pflegeversicherung\ngem. § 33 Abs. 1 SGB XI',
+  hoeherst:'Antrag auf Neubegutachtung / Höherstufung\ngem. § 15 SGB XI',
+  eingliederung:'Antrag auf Eingliederungshilfe\ngem. § 99 SGB IX',
+  grundsicherung:'Antrag auf Grundsicherung im Alter\ngem. § 41 SGB XII',
+  blindenhilfe:'Antrag auf Blindenhilfe\ngem. § 72 SGB XII',
+};
+function updM(){
+  const g=id=>document.getElementById(id)?.value||'[bitte ausfüllen]';
+  const geb=document.getElementById('mpgeb')?.value;
+  const typ=document.getElementById('mtyp')?.value||'erstantrag';
+  const today=new Date().toLocaleDateString('de-DE');
+  const t=g('mn')+'\n'+g('ms')+'\n'+g('mpo')+'\nTel.: '+g('mtel')+'\n\nDatum: '+today+'\n\n'+
+    'An die:\n'+g('mkk')+'\n'+getKKAdr(g('mkk'))+'\n\n\n'+
+    'Betreff: '+MBETR[typ]+'\n\n'+
+    'Sehr geehrte Damen und Herren,\n\n'+
+    'hiermit stelle ich einen Antrag für folgende versicherte Person:\n\n'+
+    '  Name:               '+g('mpn')+'\n'+
+    '  Geburtsdatum:       '+(geb?new Date(geb).toLocaleDateString('de-DE'):'[Geburtsdatum]')+'\n'+
+    '  Versichertennummer: '+g('mpvnr')+'\n\n'+
+    'Ich bitte um schriftliche Eingangsbestätigung sowie um Übersendung\naller erforderlichen Formulare und Unterlagen.\n\n'+
+    'Dieser Antrag wird mit dem heutigen Datum ('+today+') gestellt,\ndamit etwaige Leistungen ab diesem Zeitpunkt berücksichtigt werden.\n\n'+
+    'Mit freundlichen Grüßen,\n\n\n_____________________________\n'+g('mn')+'\n\n'+
+    '─────────────────────────────────────\nHinweis: Per Einschreiben mit Rückschein versenden.\nErstellt mit Pflegepilot Alpha.';
+  const el=document.getElementById('mpreview');if(el)el.textContent=t;
+}
+function cpM(){navigator.clipboard.writeText(document.getElementById('mpreview')?.textContent||'');toast('Kopiert');}
+function dlM(){
+  const t=document.getElementById('mpreview')?.textContent||'';
+  if(!t.trim()){toast('Kein Text zum Exportieren',false);return;}
+  const el=document.createElement('div');
+  el.style.cssText='font-family:"Courier New",Courier,monospace;font-size:10.5pt;line-height:1.9;padding:0;white-space:pre-wrap;color:#111;background:#fff;word-break:break-word;';
+  el.textContent=t;
+  const typMap={erstantrag:'Erstantrag',hoeherst:'Hoeherst',eingliederung:'Eingliederungshilfe',grundsicherung:'Grundsicherung',blindenhilfe:'Blindenhilfe'};
+  const typKey=document.getElementById('mtyp')?.value||'erstantrag';
+  const name=toFilename(document.getElementById('mn')?.value||'Patient');
+  const fname=name+'_'+(typMap[typKey]||'Antrag')+'_'+isoDate()+'.pdf';
+  html2pdf().set({margin:[25,20,28,25],filename:fname,html2canvas:{scale:2,useCORS:true},jsPDF:{unit:'mm',format:'a4',orientation:'portrait'}})
+    .from(el).toPdf().get('pdf').then(pdf=>{
+      addPageNums(pdf);
+      const blob=pdf.output('blob');
+      const url=URL.createObjectURL(blob);
+      const a=document.createElement('a');a.href=url;a.download=fname;
+      document.body.appendChild(a);a.click();document.body.removeChild(a);
+      setTimeout(()=>URL.revokeObjectURL(url),2000);
+      toast('PDF heruntergeladen: '+fname);
+      if(mPatId){
+        const b64=pdf.output('datauristring').split(',')[1];
+        api('/api/patienten/'+mPatId+'/briefe',{method:'POST',body:JSON.stringify({
+          typ:typKey,notizen:'PDF: '+fname,brief_text:t,pdf_base64:b64,pdf_dateiname:fname
+        })}).then(r=>{if(r.ok)toast('PDF dauerhaft in Patientenakte gespeichert ✓');});
+      }
+    });
+}
+
+// ── Krankenkassen-Suchfeld ────────────────────────────────
+async function loadKK(){if(!kkData)kkData=await api('/api/krankenkassen');return kkData;}
+
+function getKKAdr(name){
+  if(!name||name==='[bitte ausfüllen]')return'[Anschrift der Krankenkasse bitte eintragen]';
+  const k=(kkData||[]).find(x=>x.name===name);
+  if(!k)return'[Anschrift bitte ergänzen]';
+  const land=k.land||'DE';
+  const landZ=land!=='DE'?'\n'+land:'';
+  return k.strasse+'\n'+k.plz+' '+k.ort+landZ;
+}
+
+function kkTypBadge(k){
+  const cls={GKV:'b-g',PKV:'b-b',SV:'b-r',KVG:'b-a'}[k.typ]||'b-gr';
+  const land=k.land||'DE';
+  const flag={DE:'🇩🇪',AT:'🇦🇹',CH:'🇨🇭'}[land]||'';
+  return '<span class="badge '+cls+'" style="font-size:10px;flex-shrink:0">'+flag+' '+k.typ+'</span>';
+}
+
+let kkLandFilter={};
+
+function kkSearch(inputId,hiddenId,initVal,onChange){
+  if(onChange)kkCB[inputId]=onChange;
+  kkLandFilter[inputId]=kkLandFilter[inputId]||'DE';
+  loadKK().then(kks=>{
+    const inp=document.getElementById(inputId);
+    const hid=document.getElementById(hiddenId);
+    if(!inp)return;
+    const wrap=inp.parentNode;
+    const old=document.getElementById(inputId+'_dd');if(old)old.remove();
+    const dd=document.createElement('div');
+    dd.className='kk-dd';dd.id=inputId+'_dd';
+    wrap.appendChild(dd);
+    if(initVal){inp.value=initVal;if(hid)hid.value=initVal;}
+
+    function render(items){
+      const tabs='<div class="kk-tabs" onmousedown="event.preventDefault()">'+
+        ['DE','AT','CH','Alle'].map(l=>'<span class="kk-tab'+(kkLandFilter[inputId]===l?' active':'')+
+        '" data-land="'+l+'">'+({DE:'🇩🇪 DE',AT:'🇦🇹 AT',CH:'🇨🇭 CH',Alle:'Alle'}[l])+'</span>').join('')+
+        '</div>';
+      if(!items.length){dd.innerHTML=tabs+'<div class="kk-opt" style="color:var(--muted);cursor:default">Keine Treffer</div>';return;}
+      dd.innerHTML=tabs+items.slice(0,70).map(k=>
+        '<div class="kk-opt" data-kk="'+k.name.replace(/"/g,'&quot;')+'">'+
+        '<span class="kk-opt-name">'+k.name+'</span>'+
+        '<span class="kk-opt-ort">'+k.ort+'</span>'+
+        kkTypBadge(k)+
+        '</div>'
+      ).join('');
+    }
+
+    dd.addEventListener('mousedown',e=>{
+      e.preventDefault();
+      const tab=e.target.closest('[data-land]');
+      if(tab){kkLandFilter[inputId]=tab.dataset.land;open();return;}
+      const opt=e.target.closest('[data-kk]');
+      if(opt)selKK(inputId,hiddenId,opt.dataset.kk);
+    });
+
+    function open(){
+      const q=inp.value.toLowerCase().trim();
+      const lf=kkLandFilter[inputId];
+      let filtered=lf&&lf!=='Alle'?kks.filter(k=>(k.land||'DE')===lf):kks;
+      if(q)filtered=filtered.filter(k=>k.name.toLowerCase().includes(q)||(k.kurzname||'').toLowerCase().includes(q)||k.ort.toLowerCase().includes(q));
+      render(filtered);dd.classList.add('open');
+    }
+    inp.addEventListener('focus',open);
+    inp.addEventListener('input',()=>{if(hid)hid.value='';open();});
+    inp.addEventListener('blur',()=>dd.classList.remove('open'));
+    inp.addEventListener('keydown',e=>{if(e.key==='Escape')dd.classList.remove('open');});
+  });
+}
+function selKK(inputId,hiddenId,name){
+  const inp=document.getElementById(inputId);
+  const hid=document.getElementById(hiddenId);
+  const dd=document.getElementById(inputId+'_dd');
+  if(inp)inp.value=name;if(hid)hid.value=name;if(dd)dd.classList.remove('open');
+  if(kkCB[inputId]&&kkData){const k=kkData.find(x=>x.name===name)||null;kkCB[inputId](k);}
+}
+
+// ── Foto-Upload ───────────────────────────────────────────
+async function uploadFoto(pid,input){
+  const file=input.files[0];if(!file)return;
+  const fd=new FormData();fd.append('foto',file);
+  try{
+    const resp=await fetch('/api/patienten/'+pid+'/foto',{method:'POST',body:fd});
+    const r=await resp.json();
+    if(r.ok){toast('Profilfoto gespeichert ✓');loadPat(pid);}
+    else toast(r.error||'Fehler beim Upload',false);
+  }catch{toast('Upload fehlgeschlagen',false);}
+}
+
+// ── Pflegetagebuch ────────────────────────────────────────
+async function pgTagebuch(pid){
+  if(!pid){
+    const pts=await api('/api/patienten');
+    R('<div class="card"><div class="fgrp"><label>Patient wählen</label>'+
+      '<select onchange="if(this.value)pgTagebuch(parseInt(this.value))"><option value="">– wählen –</option>'+
+      pts.map(p=>'<option value="'+p.id+'">'+p.vorname+' '+p.nachname+'</option>').join('')+'</select></div>'+
+      '<p class="muted sm mt3">Oder öffnen Sie das Tagebuch direkt aus der Patientenakte.</p></div>',
+      'Pflegetagebuch');
+    return;
+  }
+  const [d,entries]=await Promise.all([api('/api/patienten/'+pid),api('/api/patienten/'+pid+'/tagebuch')]);
+  const p=d.patient;
+  R(
+    '<div class="alert a-info mb3"><i class="ti ti-info-circle"></i>'+
+    '<p>Pflegetagebuch für <strong>'+p.vorname+' '+p.nachname+'</strong> gem. <strong>§ 14/15 SGB XI</strong>. '+
+    'Die 6 Begutachtungsmodule (BI) des MDK basieren auf diesen Einträgen. Täglich dokumentieren – v. a. vor dem Gutachter-Termin!</p></div>'+
+
+    '<div class="card mb3"><div class="ch"><span class="ct">Neuer Eintrag</span></div>'+
+    '<div class="fg c2 mb3"><div class="fgrp"><label>Datum *</label>'+
+    '<input type="date" id="tbdat" value="'+isoDate()+'"></div></div>'+
+
+    '<div class="slabel mb3"><i class="ti ti-walk" style="margin-right:5px"></i>Modul 1 – Mobilität · § 14 Abs. 2 Nr. 1 SGB XI</div>'+
+    '<div class="fgrp mb3"><label>Gehen, Aufstehen, Treppensteigen, Fortbewegung außerhalb</label>'+
+    '<textarea id="tbmob" rows="2" placeholder="z. B.: Kann nur mit Rollator gehen. Aufstehen vom Bett nur mit 2 Personen. Treppe nicht mehr möglich."></textarea></div>'+
+
+    '<div class="slabel mb3"><i class="ti ti-brain" style="margin-right:5px"></i>Modul 2 – Kognition &amp; Kommunikation · § 14 Abs. 2 Nr. 2/3 SGB XI</div>'+
+    '<div class="fgrp mb3"><label>Örtliche/zeitliche Orientierung, Gedächtnis, Sprache, Verstehen</label>'+
+    '<textarea id="tbori" rows="2" placeholder="z. B.: Kennt Wochentag nicht. Vergisst Gespräche nach 10 Min. Findet Badezimmer selbstständig."></textarea></div>'+
+
+    '<div class="slabel mb3"><i class="ti ti-shirt" style="margin-right:5px"></i>Modul 4 – Selbstversorgung · § 14 Abs. 2 Nr. 4 SGB XI</div>'+
+    '<div class="fg c2 mb3">'+
+    '<div class="fgrp"><label>Körperpflege (Waschen, Duschen, Zähne, Haare, Rasur)</label>'+
+    '<textarea id="tbkp" rows="2" placeholder="z. B.: Vollständige Übernahme. Kann Waschlappen nicht greifen/halten."></textarea></div>'+
+    '<div class="fgrp"><label>An-/Ausziehen (Kleidung, Schuhe, Knöpfe, Reißverschluss)</label>'+
+    '<textarea id="tbanx" rows="2" placeholder="z. B.: Braucht Hilfe beim Anziehen der Hose und beim Schließen von Knöpfen."></textarea></div>'+
+    '<div class="fgrp" style="grid-column:1/-1"><label>Ernährung (Essen, Trinken, Mahlzeiten richten)</label>'+
+    '<textarea id="tbern" rows="2" placeholder="z. B.: Kann Mahlzeiten nicht selbst richten. Flüssigkeitszufuhr muss überwacht werden."></textarea></div>'+
+    '</div>'+
+
+    '<div class="slabel mb3"><i class="ti ti-pill" style="margin-right:5px"></i>Modul 5 – Medizinische Anforderungen · § 14 Abs. 2 Nr. 5 SGB XI</div>'+
+    '<div class="fgrp mb3"><label>Medikamente, Verbände, Injektionen, Blutzucker, Arztbesuche</label>'+
+    '<textarea id="tbmed" rows="2" placeholder="z. B.: 5 Medikamente morgens + 3 abends – vollständige Übernahme. Blutzucker 2× täglich messen."></textarea></div>'+
+
+    '<div class="slabel mb3"><i class="ti ti-users" style="margin-right:5px"></i>Modul 6 – Sozialleben &amp; Alltagsgestaltung · § 14 Abs. 2 Nr. 6 SGB XI</div>'+
+    '<div class="fgrp mb3"><label>Tagesgestaltung, Kontakte, Beschäftigung, soziale Teilhabe</label>'+
+    '<textarea id="tbsoz" rows="2" placeholder="z. B.: Verlässt Wohnung nicht mehr allein. Kontakt mit Tochter 3× wöchentlich."></textarea></div>'+
+
+    '<div class="fgrp mb4"><label>Allgemeine Beobachtungen &amp; Besonderheiten</label>'+
+    '<textarea id="tball" rows="2" placeholder="z. B.: Sturzereignis heute Nacht. Arztbesuch. Unruhig, schlechter Schlaf."></textarea></div>'+
+    '<div class="fl g8" style="justify-content:flex-end">'+
+    '<button class="btn" onclick="loadPat('+pid+')"><i class="ti ti-arrow-left"></i>Zurück zur Akte</button>'+
+    '<button class="btn btn-p" onclick="saveTB('+pid+')"><i class="ti ti-check"></i>Eintrag speichern</button>'+
+    '</div></div>'+
+
+    (entries.length?
+      '<div class="card"><div class="ch"><span class="ct">Vergangene Einträge ('+entries.length+')</span></div>'+
+      entries.map(e=>'<div class="step">'+
+        '<div class="si s-ok"><i class="ti ti-notebook"></i></div>'+
+        '<div class="sb2" style="flex:1"><div class="t">'+fdate(e.datum)+'</div>'+
+        '<div class="d" style="font-size:11.5px;line-height:1.7;margin-top:3px">'+
+        [e.mobilitaet&&'<strong>Mobilität:</strong> '+e.mobilitaet,
+         e.koerperpflege&&'<strong>Körperpflege:</strong> '+e.koerperpflege,
+         e.anziehen&&'<strong>Anziehen:</strong> '+e.anziehen,
+         e.ernaehrung&&'<strong>Ernährung:</strong> '+e.ernaehrung,
+         e.orientierung&&'<strong>Kognition:</strong> '+e.orientierung,
+         e.medikamente&&'<strong>Medikamente:</strong> '+e.medikamente,
+         e.soziales&&'<strong>Soziales:</strong> '+e.soziales,
+         e.allgemein&&'<strong>Allgemein:</strong> '+e.allgemein
+        ].filter(Boolean).join('<br>')+'</div></div>'+
+        '<button class="btn btn-sm btn-ico" style="color:var(--rdtx);align-self:center" onclick="delTB('+e.id+','+pid+')" title="Löschen"><i class="ti ti-trash"></i></button>'+
+        '</div>').join('')+'</div>':
+      '<div class="card"><p class="muted sm">Noch keine Einträge vorhanden.</p></div>'),
+    'Pflegetagebuch – '+p.vorname+' '+p.nachname
+  );
+}
+async function saveTB(pid){
+  const g=id=>document.getElementById(id)?.value||'';
+  if(!g('tbdat')){toast('Datum eingeben',false);return;}
+  const r=await api('/api/patienten/'+pid+'/tagebuch',{method:'POST',body:JSON.stringify({
+    datum:g('tbdat'),koerperpflege:g('tbkp'),anziehen:g('tbanx'),ernaehrung:g('tbern'),
+    mobilitaet:g('tbmob'),orientierung:g('tbori'),medikamente:g('tbmed'),soziales:g('tbsoz'),allgemein:g('tball')
+  })});
+  if(r.ok){toast('Eintrag gespeichert ✓');pgTagebuch(pid);}
+  else toast('Fehler beim Speichern',false);
+}
+async function delTB(tid,pid){
+  if(!confirm('Eintrag löschen?'))return;
+  await api('/api/tagebuch/'+tid,{method:'DELETE'});
+  toast('Eintrag gelöscht');pgTagebuch(pid);
+}
+
+// ── Aufgaben ──────────────────────────────────────────────
+async function pgAufgaben(){
+  const data=await api('/api/aufgaben');
+  R('<div class="card"><div class="ch"><span class="ct">Offene Aufgaben ('+data.length+')</span>'+
+    '<button class="btn btn-sm" onclick="newAM()"><i class="ti ti-plus"></i>Neue Aufgabe</button></div>'+
+    (data.length===0?'<p class="muted sm">Keine offenen Aufgaben – alles erledigt!</p>':
+    '<div class="tw"><table><thead><tr><th>Aufgabe</th><th>Patient</th><th>Fällig</th><th>Priorität</th><th></th></tr></thead><tbody>'+
+    data.map(a=>'<tr><td><div class="w5">'+a.titel+'</div>'+(a.beschreibung?'<div class="sm muted">'+a.beschreibung+'</div>':'')+
+      '</td><td>'+(a.patient_name?'<span class="tl" onclick="loadPat('+a.patient_id+')">'+a.patient_name+'</span>':'<span class="muted">–</span>')+
+      '</td><td>'+fdate(a.faellig_am)+'</td><td>'+prio(a.prioritaet)+
+      '</td><td><button class="btn btn-sm btn-p" onclick="erlA('+a.id+')"><i class="ti ti-check"></i>Erledigt</button></td></tr>').join('')+
+    '</tbody></table></div>')+
+    '</div>','Offene Aufgaben');
+}
+async function erlA(id){
+  await api('/api/aufgaben/'+id+'/erledigt',{method:'POST'});
+  toast('Aufgabe erledigt ✓');refreshBadge();if(curPage==='aufgaben')pgAufgaben();
+}
+function newAM(){
+  OM('Neue Aufgabe',
+    '<div class="fg"><div class="fgrp"><label>Titel *</label><input id="nat" placeholder="Aufgabentitel"></div>'+
+    '<div class="fgrp"><label>Beschreibung</label><textarea id="nad" rows="2"></textarea></div>'+
+    '<div class="fg c2"><div class="fgrp"><label>Priorität</label>'+
+    '<select id="nap"><option value="normal">Normal</option><option value="mittel">Mittel</option><option value="hoch">Hoch</option></select></div>'+
+    '<div class="fgrp"><label>Fällig am</label><input type="date" id="naf"></div></div></div>'+
+    '<div class="fl g8 mt4" style="justify-content:flex-end">'+
+    '<button class="btn" onclick="CM()">Abbrechen</button>'+
+    '<button class="btn btn-p" onclick="saveAufg()"><i class="ti ti-check"></i>Speichern</button></div>');
+}
+async function saveAufg(){
+  const g=id=>document.getElementById(id)?.value||'';
+  if(!g('nat')){toast('Titel eingeben',false);return;}
+  await api('/api/aufgaben',{method:'POST',body:JSON.stringify({titel:g('nat'),beschreibung:g('nad'),prioritaet:g('nap'),faellig_am:g('naf')})});
+  CM();toast('Aufgabe angelegt');refreshBadge();if(curPage==='aufgaben')pgAufgaben();
+}
+
+initApp().then(()=>{if(curUser){refreshBadge();go('dashboard');}});
+</script>
+</body>
+</html>
diff --git a/pflegepilot_erp.html b/pflegepilot_erp.html
new file mode 100644
index 0000000..8867196
--- /dev/null
+++ b/pflegepilot_erp.html
@@ -0,0 +1,503 @@
+
+<style>
+*{box-sizing:border-box;margin:0;padding:0}
+body{font-family:var(--font-sans);background:var(--color-background-tertiary);color:var(--color-text-primary);font-size:14px}
+.app{display:flex;height:100vh;min-height:600px}
+.sidebar{width:220px;min-width:220px;background:var(--color-background-primary);border-right:0.5px solid var(--color-border-tertiary);display:flex;flex-direction:column;overflow:hidden}
+.logo{padding:18px 16px 14px;border-bottom:0.5px solid var(--color-border-tertiary)}
+.logo-text{font-size:16px;font-weight:500;color:var(--color-text-primary)}
+.logo-sub{font-size:11px;color:var(--color-text-tertiary);margin-top:2px}
+.nav{flex:1;overflow-y:auto;padding:8px 0}
+.nav-section{padding:12px 16px 4px;font-size:11px;font-weight:500;color:var(--color-text-tertiary);text-transform:uppercase;letter-spacing:.05em}
+.nav-item{display:flex;align-items:center;gap:9px;padding:8px 16px;cursor:pointer;border-radius:0;font-size:13.5px;color:var(--color-text-secondary);transition:background .12s}
+.nav-item:hover{background:var(--color-background-secondary);color:var(--color-text-primary)}
+.nav-item.active{background:var(--color-background-secondary);color:var(--color-text-primary);font-weight:500;border-left:2px solid #1D9E75}
+.nav-item i{font-size:16px;width:18px;flex-shrink:0}
+.nav-badge{margin-left:auto;background:var(--color-background-danger);color:var(--color-text-danger);font-size:11px;padding:1px 6px;border-radius:10px}
+.main{flex:1;display:flex;flex-direction:column;overflow:hidden}
+.topbar{background:var(--color-background-primary);border-bottom:0.5px solid var(--color-border-tertiary);padding:0 20px;height:52px;display:flex;align-items:center;gap:12px;flex-shrink:0}
+.page-title{font-size:15px;font-weight:500;flex:1}
+.btn{display:inline-flex;align-items:center;gap:6px;padding:7px 14px;border:0.5px solid var(--color-border-secondary);border-radius:var(--border-radius-md);background:transparent;color:var(--color-text-primary);cursor:pointer;font-size:13px;font-family:var(--font-sans);transition:background .12s}
+.btn:hover{background:var(--color-background-secondary)}
+.btn-primary{background:#1D9E75;border-color:#1D9E75;color:#fff}
+.btn-primary:hover{background:#0F6E56;border-color:#0F6E56;color:#fff}
+.content{flex:1;overflow-y:auto;padding:20px}
+.grid-2{display:grid;grid-template-columns:1fr 1fr;gap:14px}
+.grid-3{display:grid;grid-template-columns:repeat(3,1fr);gap:14px}
+.grid-4{display:grid;grid-template-columns:repeat(4,1fr);gap:14px}
+.card{background:var(--color-background-primary);border:0.5px solid var(--color-border-tertiary);border-radius:var(--border-radius-lg);padding:16px 18px}
+.card-header{display:flex;align-items:center;justify-content:space-between;margin-bottom:14px}
+.card-title{font-size:13px;font-weight:500;color:var(--color-text-secondary)}
+.metric-val{font-size:26px;font-weight:500;margin-top:4px}
+.metric-sub{font-size:12px;color:var(--color-text-tertiary);margin-top:3px}
+.badge{display:inline-flex;align-items:center;padding:2px 9px;border-radius:10px;font-size:12px}
+.badge-green{background:#EAF3DE;color:#3B6D11}
+.badge-amber{background:#FAEEDA;color:#854F0B}
+.badge-blue{background:#E6F1FB;color:#185FA5}
+.badge-red{background:#FCEBEB;color:#A32D2D}
+.badge-gray{background:#F1EFE8;color:#5F5E5A}
+.table{width:100%;border-collapse:collapse}
+.table th{text-align:left;padding:8px 12px;font-size:12px;font-weight:500;color:var(--color-text-secondary);border-bottom:0.5px solid var(--color-border-tertiary)}
+.table td{padding:10px 12px;border-bottom:0.5px solid var(--color-border-tertiary);font-size:13px;vertical-align:middle}
+.table tr:last-child td{border-bottom:none}
+.table tr:hover td{background:var(--color-background-secondary)}
+.table-link{color:var(--color-text-info);cursor:pointer;text-decoration:none}
+.table-link:hover{text-decoration:underline}
+.avatar{width:28px;height:28px;border-radius:50%;display:inline-flex;align-items:center;justify-content:center;font-size:11px;font-weight:500;flex-shrink:0}
+.av-teal{background:#E1F5EE;color:#0F6E56}
+.av-blue{background:#E6F1FB;color:#185FA5}
+.av-amber{background:#FAEEDA;color:#854F0B}
+.av-coral{background:#FAECE7;color:#993C1D}
+.form-row{display:grid;gap:10px;margin-bottom:12px}
+.form-row.cols2{grid-template-columns:1fr 1fr}
+.form-row.cols3{grid-template-columns:1fr 1fr 1fr}
+.form-group{display:flex;flex-direction:column;gap:4px}
+label{font-size:12px;color:var(--color-text-secondary);font-weight:500}
+input,select,textarea{border:0.5px solid var(--color-border-secondary);border-radius:var(--border-radius-md);padding:7px 10px;font-size:13px;font-family:var(--font-sans);background:var(--color-background-primary);color:var(--color-text-primary)}
+input:focus,select:focus,textarea:focus{outline:none;border-color:#1D9E75}
+.progress-bar{height:6px;background:var(--color-background-secondary);border-radius:4px;overflow:hidden;margin-top:6px}
+.progress-fill{height:100%;border-radius:4px;background:#1D9E75;transition:width .4s}
+.step-list{display:flex;flex-direction:column;gap:2px}
+.step{display:flex;align-items:flex-start;gap:10px;padding:8px 0;border-bottom:0.5px solid var(--color-border-tertiary)}
+.step:last-child{border-bottom:none}
+.step-icon{width:24px;height:24px;border-radius:50%;display:flex;align-items:center;justify-content:center;font-size:12px;flex-shrink:0;margin-top:1px}
+.step-done{background:#EAF3DE;color:#3B6D11}
+.step-active{background:#E6F1FB;color:#185FA5}
+.step-pending{background:#F1EFE8;color:#888780}
+.step-text{flex:1}
+.step-title{font-size:13px;font-weight:500}
+.step-desc{font-size:12px;color:var(--color-text-tertiary);margin-top:2px}
+.section-divider{font-size:12px;font-weight:500;color:var(--color-text-tertiary);text-transform:uppercase;letter-spacing:.05em;margin:18px 0 10px;padding-bottom:6px;border-bottom:0.5px solid var(--color-border-tertiary)}
+.tag{display:inline-flex;align-items:center;gap:4px;padding:3px 8px;border-radius:var(--border-radius-md);background:var(--color-background-secondary);font-size:12px;border:0.5px solid var(--color-border-tertiary)}
+.leistung-row{display:flex;align-items:center;justify-content:space-between;padding:9px 0;border-bottom:0.5px solid var(--color-border-tertiary)}
+.leistung-row:last-child{border-bottom:none}
+.leistung-name{font-size:13px}
+.leistung-val{font-size:13px;font-weight:500;color:#0F6E56}
+.alert{display:flex;align-items:flex-start;gap:10px;padding:12px 14px;border-radius:var(--border-radius-md);margin-bottom:12px}
+.alert-info{background:#E6F1FB;border:0.5px solid #B5D4F4}
+.alert-info i{color:#185FA5}
+.alert-text{font-size:13px;color:var(--color-text-primary)}
+.hidden{display:none}
+</style>
+
+<h2 class="sr-only">Pflegepilot – ERP-Verwaltungsoberfläche für Pflegeleistungen und Patientendaten</h2>
+
+<div class="app">
+  <div class="sidebar">
+    <div class="logo">
+      <div class="logo-text"><i class="ti ti-heartbeat" aria-hidden="true" style="color:#1D9E75;margin-right:6px"></i>Pflegepilot</div>
+      <div class="logo-sub">Verwaltungssystem</div>
+    </div>
+    <nav class="nav">
+      <div class="nav-section">Übersicht</div>
+      <div class="nav-item active" onclick="showPage('dashboard')"><i class="ti ti-layout-dashboard" aria-hidden="true"></i>Dashboard</div>
+      <div class="nav-section">Patienten</div>
+      <div class="nav-item" onclick="showPage('patienten')"><i class="ti ti-users" aria-hidden="true"></i>Patientenliste</div>
+      <div class="nav-item" onclick="showPage('neu')"><i class="ti ti-user-plus" aria-hidden="true"></i>Neuer Patient</div>
+      <div class="nav-section">Formulare</div>
+      <div class="nav-item" onclick="showPage('antrag')"><i class="ti ti-file-text" aria-hidden="true"></i>Antrag Pflegegrad</div>
+      <div class="nav-item" onclick="showPage('leistungen')"><i class="ti ti-checklist" aria-hidden="true"></i>Leistungsübersicht</div>
+      <div class="nav-item" onclick="showPage('musterbrief')"><i class="ti ti-mail" aria-hidden="true"></i>Musterbrief</div>
+      <div class="nav-section">Aufgaben</div>
+      <div class="nav-item" onclick="showPage('aufgaben')"><i class="ti ti-bell" aria-hidden="true"></i>Offene Aufgaben<span class="nav-badge">3</span></div>
+    </nav>
+  </div>
+
+  <div class="main">
+    <div class="topbar">
+      <div class="page-title" id="page-title">Dashboard</div>
+      <button class="btn" onclick="showPage('neu')"><i class="ti ti-plus" aria-hidden="true"></i>Neuer Patient</button>
+      <button class="btn btn-primary" onclick="showPage('musterbrief')"><i class="ti ti-file-export" aria-hidden="true"></i>Brief erstellen</button>
+    </div>
+    <div class="content" id="content">
+    </div>
+  </div>
+</div>
+
+<script>
+const pages = {
+  dashboard: {
+    title: 'Dashboard',
+    render: () => `
+      <div class="grid-4" style="margin-bottom:16px">
+        <div class="card">
+          <div class="card-title">Aktive Patienten</div>
+          <div class="metric-val">12</div>
+          <div class="metric-sub"><span class="badge badge-green">+2 diesen Monat</span></div>
+        </div>
+        <div class="card">
+          <div class="card-title">Offene Anträge</div>
+          <div class="metric-val">4</div>
+          <div class="metric-sub"><span class="badge badge-amber">Bearbeitung läuft</span></div>
+        </div>
+        <div class="card">
+          <div class="card-title">Bescheide erwartet</div>
+          <div class="metric-val">3</div>
+          <div class="metric-sub"><span class="badge badge-blue">In Prüfung</span></div>
+        </div>
+        <div class="card">
+          <div class="card-title">Widersprüche</div>
+          <div class="metric-val">1</div>
+          <div class="metric-sub"><span class="badge badge-red">Fristenkontrolle</span></div>
+        </div>
+      </div>
+      <div class="grid-2">
+        <div class="card">
+          <div class="card-header"><span class="card-title">Aktuelle Patienten</span><button class="btn" onclick="showPage('patienten')">Alle anzeigen</button></div>
+          <table class="table">
+            <thead><tr><th>Name</th><th>Pflegegrad</th><th>Status</th></tr></thead>
+            <tbody>
+              <tr><td><div style="display:flex;align-items:center;gap:8px"><div class="avatar av-teal">EH</div><span class="table-link" onclick="showPage('patient_detail')">Erika Huber</span></div></td><td>Grad 3</td><td><span class="badge badge-green">Genehmigt</span></td></tr>
+              <tr><td><div style="display:flex;align-items:center;gap:8px"><div class="avatar av-blue">KM</div><span class="table-link" onclick="showPage('patient_detail')">Klaus Meier</span></div></td><td>Beantragt</td><td><span class="badge badge-amber">In Prüfung</span></td></tr>
+              <tr><td><div style="display:flex;align-items:center;gap:8px"><div class="avatar av-amber">IM</div><span class="table-link" onclick="showPage('patient_detail')">Inge Müller</span></div></td><td>Grad 2</td><td><span class="badge badge-blue">Widerspruch</span></td></tr>
+              <tr><td><div style="display:flex;align-items:center;gap:8px"><div class="avatar av-coral">GS</div><span class="table-link" onclick="showPage('patient_detail')">Georg Schulz</span></div></td><td>Grad 5</td><td><span class="badge badge-green">Genehmigt</span></td></tr>
+            </tbody>
+          </table>
+        </div>
+        <div class="card">
+          <div class="card-header"><span class="card-title">Offene Aufgaben</span><button class="btn" onclick="showPage('aufgaben')">Alle</button></div>
+          <div class="step-list">
+            <div class="step"><div class="step-icon step-active"><i class="ti ti-clock" aria-hidden="true"></i></div><div class="step-text"><div class="step-title">Gutachter-Termin: Klaus Meier</div><div class="step-desc">Termin bestätigen – fällig in 3 Tagen</div></div></div>
+            <div class="step"><div class="step-icon step-active"><i class="ti ti-file-alert" aria-hidden="true"></i></div><div class="step-text"><div class="step-title">Widerspruch: Inge Müller</div><div class="step-desc">Brief muss bis Freitag abgesendet werden</div></div></div>
+            <div class="step"><div class="step-icon step-pending"><i class="ti ti-mail" aria-hidden="true"></i></div><div class="step-text"><div class="step-title">Antrag: Hildegard Braun</div><div class="step-desc">Erstantrag noch nicht abgeschickt</div></div></div>
+          </div>
+        </div>
+      </div>
+    `
+  },
+  patienten: {
+    title: 'Patientenliste',
+    render: () => `
+      <div class="card" style="margin-bottom:14px">
+        <div style="display:flex;gap:10px">
+          <input type="text" placeholder="Patient suchen..." style="flex:1" />
+          <select><option>Alle Pflegegrade</option><option>Grad 1</option><option>Grad 2</option><option>Grad 3</option><option>Grad 4</option><option>Grad 5</option></select>
+          <select><option>Alle Status</option><option>Genehmigt</option><option>In Prüfung</option><option>Abgelehnt</option><option>Widerspruch</option></select>
+        </div>
+      </div>
+      <div class="card">
+        <table class="table">
+          <thead><tr><th>Name</th><th>Geburtsdatum</th><th>Krankenkasse</th><th>Pflegegrad</th><th>Antragsdatum</th><th>Status</th><th>Aktion</th></tr></thead>
+          <tbody>
+            <tr><td><div style="display:flex;align-items:center;gap:8px"><div class="avatar av-teal">EH</div><span class="table-link" onclick="showPage('patient_detail')">Erika Huber</span></div></td><td>12.03.1942</td><td>AOK Bayern</td><td><span class="tag">Grad 3</span></td><td>15.01.2025</td><td><span class="badge badge-green">Genehmigt</span></td><td><button class="btn" onclick="showPage('patient_detail')"><i class="ti ti-eye"></i></button></td></tr>
+            <tr><td><div style="display:flex;align-items:center;gap:8px"><div class="avatar av-blue">KM</div><span class="table-link" onclick="showPage('patient_detail')">Klaus Meier</span></div></td><td>07.11.1938</td><td>TK</td><td><span class="tag">Beantragt</span></td><td>02.04.2025</td><td><span class="badge badge-amber">In Prüfung</span></td><td><button class="btn" onclick="showPage('patient_detail')"><i class="ti ti-eye"></i></button></td></tr>
+            <tr><td><div style="display:flex;align-items:center;gap:8px"><div class="avatar av-amber">IM</div><span class="table-link" onclick="showPage('patient_detail')">Inge Müller</span></div></td><td>23.06.1950</td><td>Barmer</td><td><span class="tag">Grad 2</span></td><td>10.11.2024</td><td><span class="badge badge-blue">Widerspruch</span></td><td><button class="btn" onclick="showPage('patient_detail')"><i class="ti ti-eye"></i></button></td></tr>
+            <tr><td><div style="display:flex;align-items:center;gap:8px"><div class="avatar av-coral">GS</div><span class="table-link" onclick="showPage('patient_detail')">Georg Schulz</span></div></td><td>14.08.1935</td><td>DAK</td><td><span class="tag">Grad 5</span></td><td>05.03.2024</td><td><span class="badge badge-green">Genehmigt</span></td><td><button class="btn" onclick="showPage('patient_detail')"><i class="ti ti-eye"></i></button></td></tr>
+            <tr><td><div style="display:flex;align-items:center;gap:8px"><div class="avatar av-teal">HB</div><span class="table-link" onclick="showPage('patient_detail')">Hildegard Braun</span></div></td><td>30.09.1947</td><td>AOK Bayern</td><td><span class="tag badge-gray">Offen</span></td><td>–</td><td><span class="badge badge-gray">Neu</span></td><td><button class="btn" onclick="showPage('antrag')"><i class="ti ti-file-plus"></i></button></td></tr>
+          </tbody>
+        </table>
+      </div>
+    `
+  },
+  patient_detail: {
+    title: 'Patient: Erika Huber',
+    render: () => `
+      <div class="alert alert-info"><i class="ti ti-shield-lock" style="font-size:18px;margin-top:1px" aria-hidden="true"></i><div class="alert-text"><strong>Datenschutz:</strong> Diese Ansicht enthält personenbezogene Daten. Bitte sicherstellen, dass nur befugtes Personal Zugang hat.</div></div>
+      <div class="grid-2" style="margin-bottom:14px">
+        <div class="card">
+          <div class="card-header"><span class="card-title">Stammdaten</span><button class="btn"><i class="ti ti-edit"></i>Bearbeiten</button></div>
+          <div class="form-row cols2">
+            <div class="form-group"><label>Vorname</label><input value="Erika" /></div>
+            <div class="form-group"><label>Nachname</label><input value="Huber" /></div>
+          </div>
+          <div class="form-row cols2">
+            <div class="form-group"><label>Geburtsdatum</label><input value="12.03.1942" /></div>
+            <div class="form-group"><label>Versichertennummer</label><input value="A123456789" /></div>
+          </div>
+          <div class="form-row">
+            <div class="form-group"><label>Anschrift</label><input value="Musterstraße 12, 82256 Fürstenfeldbruck" /></div>
+          </div>
+          <div class="form-row cols2">
+            <div class="form-group"><label>Telefon</label><input value="08141 / 55432" /></div>
+            <div class="form-group"><label>Krankenkasse</label><input value="AOK Bayern" /></div>
+          </div>
+        </div>
+        <div class="card">
+          <div class="card-header"><span class="card-title">Pflegestatus</span></div>
+          <div class="leistung-row"><span class="leistung-name">Pflegegrad</span><span class="badge badge-green" style="font-size:14px;padding:4px 12px">Grad 3</span></div>
+          <div class="leistung-row"><span class="leistung-name">Antragsdatum</span><span>15.01.2025</span></div>
+          <div class="leistung-row"><span class="leistung-name">Bescheid erhalten</span><span>22.02.2025</span></div>
+          <div class="leistung-row"><span class="leistung-name">Gutachter-Besuch</span><span>08.02.2025</span></div>
+          <div class="leistung-row"><span class="leistung-name">Pflegeperson</span><span>Tochter (privat)</span></div>
+          <div style="margin-top:14px">
+            <div style="font-size:12px;color:var(--color-text-secondary);margin-bottom:4px">Fortschritt: Pflegegrad-Prozess</div>
+            <div class="progress-bar"><div class="progress-fill" style="width:100%"></div></div>
+            <div style="font-size:11px;color:var(--color-text-tertiary);margin-top:4px">Abgeschlossen ✓</div>
+          </div>
+        </div>
+      </div>
+      <div class="card">
+        <div class="card-header"><span class="card-title">Aktive Leistungen</span></div>
+        <div class="grid-3">
+          <div style="padding:10px;background:var(--color-background-secondary);border-radius:var(--border-radius-md)">
+            <div style="font-size:12px;color:var(--color-text-tertiary)">Pflegegeld (mtl.)</div>
+            <div style="font-size:18px;font-weight:500;color:#0F6E56;margin-top:2px">773 €</div>
+          </div>
+          <div style="padding:10px;background:var(--color-background-secondary);border-radius:var(--border-radius-md)">
+            <div style="font-size:12px;color:var(--color-text-tertiary)">Entlastungsbetrag</div>
+            <div style="font-size:18px;font-weight:500;color:#0F6E56;margin-top:2px">131 €</div>
+          </div>
+          <div style="padding:10px;background:var(--color-background-secondary);border-radius:var(--border-radius-md)">
+            <div style="font-size:12px;color:var(--color-text-tertiary)">Hilfsmittel (mtl.)</div>
+            <div style="font-size:18px;font-weight:500;color:#0F6E56;margin-top:2px">42 €</div>
+          </div>
+        </div>
+      </div>
+    `
+  },
+  neu: {
+    title: 'Neuer Patient',
+    render: () => `
+      <div class="card">
+        <div class="section-divider">Persönliche Daten</div>
+        <div class="form-row cols3">
+          <div class="form-group"><label>Vorname *</label><input placeholder="Vorname" /></div>
+          <div class="form-group"><label>Nachname *</label><input placeholder="Nachname" /></div>
+          <div class="form-group"><label>Geburtsdatum *</label><input type="date" /></div>
+        </div>
+        <div class="form-row cols2">
+          <div class="form-group"><label>Straße & Hausnummer</label><input placeholder="Musterstraße 1" /></div>
+          <div class="form-group"><label>PLZ / Ort</label><input placeholder="82256 Fürstenfeldbruck" /></div>
+        </div>
+        <div class="form-row cols2">
+          <div class="form-group"><label>Telefon</label><input placeholder="08141 / ..." /></div>
+          <div class="form-group"><label>E-Mail (optional)</label><input placeholder="email@beispiel.de" /></div>
+        </div>
+        <div class="section-divider">Krankenversicherung</div>
+        <div class="form-row cols3">
+          <div class="form-group"><label>Krankenkasse *</label>
+            <select>
+              <option>– bitte wählen –</option>
+              <option>AOK Bayern</option><option>TK (Techniker Krankenkasse)</option>
+              <option>Barmer</option><option>DAK-Gesundheit</option>
+              <option>IKK classic</option><option>hkk</option>
+              <option>BKK</option><option>Privat versichert (PKV)</option>
+            </select>
+          </div>
+          <div class="form-group"><label>Versichertennummer *</label><input placeholder="A000000000" /></div>
+          <div class="form-group"><label>Versicherungsart</label>
+            <select><option>Gesetzlich (GKV)</option><option>Privat (PKV)</option></select>
+          </div>
+        </div>
+        <div class="section-divider">Pflegesituation</div>
+        <div class="form-row cols3">
+          <div class="form-group"><label>Aktueller Pflegegrad</label>
+            <select><option>Noch kein Antrag</option><option>Grad 1</option><option>Grad 2</option><option>Grad 3</option><option>Grad 4</option><option>Grad 5</option><option>Antrag laufend</option></select>
+          </div>
+          <div class="form-group"><label>Pflegeperson</label>
+            <select><option>Angehörige (privat)</option><option>Pflegedienst (ambulant)</option><option>Pflegeheim (stationär)</option><option>Kombination</option></select>
+          </div>
+          <div class="form-group"><label>Antragsdatum (falls vorhanden)</label><input type="date" /></div>
+        </div>
+        <div class="form-row">
+          <div class="form-group"><label>Notizen / Besonderheiten</label><textarea rows="3" placeholder="z. B. Demenzerkrankung, Mobilitätseinschränkungen ..."></textarea></div>
+        </div>
+        <div style="display:flex;gap:10px;margin-top:6px;justify-content:flex-end">
+          <button class="btn" onclick="showPage('patienten')">Abbrechen</button>
+          <button class="btn btn-primary" onclick="showPage('patienten')"><i class="ti ti-check" aria-hidden="true"></i>Patient anlegen</button>
+        </div>
+      </div>
+    `
+  },
+  antrag: {
+    title: 'Antrag Pflegegrad',
+    render: () => `
+      <div class="grid-2">
+        <div>
+          <div class="card" style="margin-bottom:14px">
+            <div class="card-header"><span class="card-title">Prozess: Pflegegrad beantragen</span></div>
+            <div class="step-list">
+              <div class="step"><div class="step-icon step-done"><i class="ti ti-check" aria-hidden="true"></i></div><div class="step-text"><div class="step-title">Schritt A – Antrag stellen</div><div class="step-desc">Brief / Anruf bei der Krankenkasse – Datum festhalten!</div></div></div>
+              <div class="step"><div class="step-icon step-active"><i class="ti ti-user-check" aria-hidden="true"></i></div><div class="step-text"><div class="step-title">Schritt B – Gutachter-Besuch</div><div class="step-desc">Prüfer kommt nach Hause. Pflegetagebuch vorbereiten.</div></div></div>
+              <div class="step"><div class="step-icon step-pending"><i class="ti ti-mail" aria-hidden="true"></i></div><div class="step-text"><div class="step-title">Schritt C – Bescheid abwarten</div><div class="step-desc">Krankenkasse hat 25 Arbeitstage Zeit. (~5 Wochen)</div></div></div>
+              <div class="step"><div class="step-icon step-pending"><i class="ti ti-file-alert" aria-hidden="true"></i></div><div class="step-text"><div class="step-title">Schritt D – Ggf. Widerspruch</div><div class="step-desc">Bei Ablehnung: Widerspruch innerhalb 1 Monat!</div></div></div>
+            </div>
+          </div>
+          <div class="card">
+            <div class="card-header"><span class="card-title">Patient zuordnen</span></div>
+            <div class="form-group" style="margin-bottom:10px"><label>Patient auswählen</label>
+              <select><option>– Patient wählen –</option><option>Hildegard Braun (neu)</option><option>Klaus Meier</option></select>
+            </div>
+            <div class="form-group" style="margin-bottom:10px"><label>Antragsdatum</label><input type="date" /></div>
+            <div class="form-group" style="margin-bottom:14px"><label>Krankenkasse</label>
+              <select><option>AOK Bayern</option><option>TK</option><option>Barmer</option><option>DAK</option></select>
+            </div>
+            <button class="btn btn-primary" style="width:100%" onclick="showPage('musterbrief')"><i class="ti ti-file-export" aria-hidden="true"></i>Musterbrief für diesen Patienten generieren</button>
+          </div>
+        </div>
+        <div class="card">
+          <div class="card-header"><span class="card-title">Pflegetagebuch-Checkliste</span></div>
+          <div class="alert alert-info"><i class="ti ti-info-circle" style="font-size:18px" aria-hidden="true"></i><div class="alert-text">Diese Punkte sollten <strong>vor dem Gutachter-Besuch</strong> täglich dokumentiert werden.</div></div>
+          <div style="display:flex;flex-direction:column;gap:8px">
+            ${[
+              ['Körperpflege','Waschen, Duschen, Haare kämmen'],
+              ['Anziehen','Hilfe beim Ankleiden'],
+              ['Ernährung','Hilfe beim Essen / Trinken'],
+              ['Mobilität','Treppen, Gehen, Aufstehen'],
+              ['Orientierung','Vergessen, Verwirrtheit, Tag/Nacht'],
+              ['Medikamente','Selbstständige Einnahme möglich?'],
+              ['Soziale Aktivitäten','Kontakte, Hobbys, Selbstständigkeit'],
+            ].map(([t,d]) => `<div style="display:flex;align-items:flex-start;gap:8px"><input type="checkbox" style="margin-top:3px;width:auto;flex-shrink:0"><div><div style="font-size:13px;font-weight:500">${t}</div><div style="font-size:12px;color:var(--color-text-tertiary)">${d}</div></div></div>`).join('')}
+          </div>
+        </div>
+      </div>
+    `
+  },
+  leistungen: {
+    title: 'Leistungsübersicht',
+    render: () => `
+      <div class="grid-2">
+        <div class="card">
+          <div class="card-header"><span class="card-title">Pflegekasse – Geldleistungen (monatlich)</span></div>
+          <div class="leistung-row"><span class="leistung-name">Pflegegeld (Grad 1)</span><span class="leistung-val">0 €</span></div>
+          <div class="leistung-row"><span class="leistung-name">Pflegegeld (Grad 2)</span><span class="leistung-val">332 €</span></div>
+          <div class="leistung-row"><span class="leistung-name">Pflegegeld (Grad 3)</span><span class="leistung-val">573 €</span></div>
+          <div class="leistung-row"><span class="leistung-name">Pflegegeld (Grad 4)</span><span class="leistung-val">765 €</span></div>
+          <div class="leistung-row"><span class="leistung-name">Pflegegeld (Grad 5)</span><span class="leistung-val">947 €</span></div>
+          <div class="leistung-row" style="background:var(--color-background-secondary);border-radius:var(--border-radius-md);padding:9px 8px;border:none;margin-top:8px"><span class="leistung-name" style="font-weight:500">Entlastungsbetrag (alle Grade)</span><span class="leistung-val">131 €</span></div>
+          <div class="leistung-row"><span class="leistung-name">Hilfsmittel (Verbrauch)</span><span class="leistung-val">42 €</span></div>
+        </div>
+        <div class="card">
+          <div class="card-header"><span class="card-title">Pflegekasse – Sachleistungen & Einmalig</span></div>
+          <div class="leistung-row"><span class="leistung-name">Pflegesachleistung Grad 2</span><span class="leistung-val">761 €</span></div>
+          <div class="leistung-row"><span class="leistung-name">Pflegesachleistung Grad 3</span><span class="leistung-val">1.432 €</span></div>
+          <div class="leistung-row"><span class="leistung-name">Pflegesachleistung Grad 4</span><span class="leistung-val">1.778 €</span></div>
+          <div class="leistung-row"><span class="leistung-name">Pflegesachleistung Grad 5</span><span class="leistung-val">2.200 €</span></div>
+          <div class="leistung-row"><span class="leistung-name">Wohnumfeldverbesserung (max.)</span><span class="leistung-val">4.180 €</span></div>
+          <div class="leistung-row"><span class="leistung-name">Gemeinsamer Jahresbetrag (ab 07/2025)</span><span class="leistung-val">3.539 €</span></div>
+          <div class="leistung-row"><span class="leistung-name">Wohngruppen-Zuschlag</span><span class="leistung-val">214 €</span></div>
+        </div>
+        <div class="card">
+          <div class="card-header"><span class="card-title">Krankenkasse – Hilfsmittel (Auswahl)</span></div>
+          <div class="leistung-row"><span class="leistung-name">Rollstuhl / Rollator</span><span class="badge badge-green">Kassenleistung</span></div>
+          <div class="leistung-row"><span class="leistung-name">Hörgerät</span><span class="badge badge-green">Zuschuss</span></div>
+          <div class="leistung-row"><span class="leistung-name">Kompressionsstrümpfe</span><span class="badge badge-green">Kassenleistung</span></div>
+          <div class="leistung-row"><span class="leistung-name">Pflegebett (technisch)</span><span class="badge badge-blue">Leihe / Zuschuss</span></div>
+          <div class="leistung-row"><span class="leistung-name">DiPA (Pflege-Apps)</span><span class="leistung-val">bis 50 €</span></div>
+          <div class="leistung-row"><span class="leistung-name">Hausnotruf</span><span class="badge badge-blue">Pflegekasse</span></div>
+        </div>
+        <div class="card">
+          <div class="card-header"><span class="card-title">Therapie (Krankenkasse, auf Rezept)</span></div>
+          <div class="leistung-row"><span class="leistung-name">Physiotherapie</span><span class="badge badge-green">Kassenleistung</span></div>
+          <div class="leistung-row"><span class="leistung-name">Ergotherapie</span><span class="badge badge-green">Kassenleistung</span></div>
+          <div class="leistung-row"><span class="leistung-name">Logopädie</span><span class="badge badge-green">Kassenleistung</span></div>
+          <div class="leistung-row"><span class="leistung-name">Podologie (bes. Diabetes)</span><span class="badge badge-green">Kassenleistung</span></div>
+          <div class="leistung-row"><span class="leistung-name">Häusliche Krankenpflege</span><span class="badge badge-blue">Mit Rezept</span></div>
+          <div class="leistung-row"><span class="leistung-name">DiGA (Digitale Therapie-Apps)</span><span class="badge badge-blue">Auf Rezept</span></div>
+        </div>
+      </div>
+    `
+  },
+  musterbrief: {
+    title: 'Musterbrief erstellen',
+    render: () => `
+      <div class="grid-2">
+        <div class="card">
+          <div class="card-header"><span class="card-title">Briefdaten eingeben</span></div>
+          <div class="section-divider">Absender (Antragsteller)</div>
+          <div class="form-row cols2">
+            <div class="form-group"><label>Vorname</label><input id="v_vor" placeholder="Maria" /></div>
+            <div class="form-group"><label>Nachname</label><input id="v_nach" placeholder="Mustermann" /></div>
+          </div>
+          <div class="form-row"><div class="form-group"><label>Straße & Hausnummer</label><input id="v_str" placeholder="Musterstraße 1" /></div></div>
+          <div class="form-row cols2">
+            <div class="form-group"><label>PLZ</label><input id="v_plz" placeholder="82256" /></div>
+            <div class="form-group"><label>Ort</label><input id="v_ort" placeholder="Fürstenfeldbruck" /></div>
+          </div>
+          <div class="form-row"><div class="form-group"><label>Telefon</label><input id="v_tel" placeholder="08141 / 12345" /></div></div>
+          <div class="section-divider">Empfänger (Krankenkasse)</div>
+          <div class="form-row"><div class="form-group"><label>Krankenkasse</label>
+            <select id="kk"><option>AOK Bayern</option><option>TK – Techniker Krankenkasse</option><option>Barmer</option><option>DAK-Gesundheit</option><option>IKK classic</option></select>
+          </div></div>
+          <div class="section-divider">Versicherte Person</div>
+          <div class="form-row cols2">
+            <div class="form-group"><label>Vorname</label><input id="p_vor" placeholder="Vorname" /></div>
+            <div class="form-group"><label>Nachname</label><input id="p_nach" placeholder="Nachname" /></div>
+          </div>
+          <div class="form-row cols2">
+            <div class="form-group"><label>Geburtsdatum</label><input id="p_geb" type="date" /></div>
+            <div class="form-group"><label>Versichertennummer</label><input id="p_vnr" placeholder="A000000000" /></div>
+          </div>
+          <button class="btn btn-primary" style="width:100%;margin-top:8px" onclick="generateLetter()"><i class="ti ti-refresh" aria-hidden="true"></i>Brief aktualisieren</button>
+        </div>
+        <div class="card" id="letter-preview" style="font-family:var(--font-sans);line-height:1.7;font-size:13.5px">
+          <div style="color:var(--color-text-secondary);font-size:12px;margin-bottom:14px;display:flex;align-items:center;gap:6px"><i class="ti ti-eye" aria-hidden="true"></i>Vorschau – wird live aktualisiert</div>
+          <div id="letter-body" style="white-space:pre-wrap;color:var(--color-text-primary)">← Formular links ausfüllen, um den Brief zu generieren.</div>
+          <div style="margin-top:16px;display:flex;gap:8px">
+            <button class="btn" onclick="copyLetter()"><i class="ti ti-copy" aria-hidden="true"></i>Text kopieren</button>
+          </div>
+        </div>
+      </div>
+    `
+  },
+  aufgaben: {
+    title: 'Offene Aufgaben',
+    render: () => `
+      <div class="card">
+        <table class="table">
+          <thead><tr><th>Aufgabe</th><th>Patient</th><th>Fällig</th><th>Priorität</th><th>Status</th></tr></thead>
+          <tbody>
+            <tr><td>Gutachter-Termin bestätigen</td><td><span class="table-link" onclick="showPage('patient_detail')">Klaus Meier</span></td><td>13.05.2025</td><td><span class="badge badge-red">Hoch</span></td><td><button class="btn" style="font-size:12px;padding:4px 10px">Erledigt</button></td></tr>
+            <tr><td>Widerspruch-Brief absenden</td><td><span class="table-link" onclick="showPage('patient_detail')">Inge Müller</span></td><td>16.05.2025</td><td><span class="badge badge-red">Hoch</span></td><td><button class="btn" style="font-size:12px;padding:4px 10px">Erledigt</button></td></tr>
+            <tr><td>Erstantrag ausfüllen & absenden</td><td><span class="table-link" onclick="showPage('patient_detail')">Hildegard Braun</span></td><td>20.05.2025</td><td><span class="badge badge-amber">Mittel</span></td><td><button class="btn" style="font-size:12px;padding:4px 10px">Erledigt</button></td></tr>
+            <tr><td>Entlastungsbetrag prüfen (Mai)</td><td><span class="table-link" onclick="showPage('patient_detail')">Erika Huber</span></td><td>31.05.2025</td><td><span class="badge badge-gray">Normal</span></td><td><button class="btn" style="font-size:12px;padding:4px 10px">Erledigt</button></td></tr>
+          </tbody>
+        </table>
+      </div>
+    `
+  }
+};
+
+function showPage(id) {
+  const page = pages[id];
+  if (!page) return;
+  document.getElementById('page-title').textContent = page.title;
+  document.getElementById('content').innerHTML = page.render();
+  document.querySelectorAll('.nav-item').forEach(el => el.classList.remove('active'));
+  document.querySelectorAll('.nav-item').forEach(el => {
+    if(el.getAttribute('onclick') && el.getAttribute('onclick').includes(id)) el.classList.add('active');
+  });
+  if(id === 'musterbrief') setTimeout(generateLetter, 100);
+}
+
+function generateLetter() {
+  const g = id => (document.getElementById(id) || {}).value || '';
+  const date = new Date().toLocaleDateString('de-DE');
+  const brief = `${g('v_vor')||'[Vorname]'} ${g('v_nach')||'[Nachname]'}
+${g('v_str')||'[Straße Nr.]'}
+${g('v_plz')||'[PLZ]'} ${g('v_ort')||'[Ort]'}
+Tel: ${g('v_tel')||'[Telefon]'}
+
+Datum: ${date}
+
+An die:
+${document.getElementById('kk')?.value||'[Krankenkasse]'}
+
+
+Betreff: Antrag auf Leistungen der Pflegekasse
+
+Sehr geehrte Damen und Herren,
+
+hiermit stelle ich einen Antrag auf Leistungen der Pflegeversicherung für:
+
+Name: ${g('p_vor')||'[Vorname]'} ${g('p_nach')||'[Nachname]'}
+Geburtsdatum: ${g('p_geb') ? new Date(g('p_geb')).toLocaleDateString('de-DE') : '[Geburtsdatum]'}
+Versichertennummer: ${g('p_vnr')||'[Versichertennummer]'}
+
+Bitte bestätigen Sie mir kurz, dass dieser Brief bei Ihnen angekommen ist. Senden Sie mir danach bitte alle weiteren Formulare zu.
+
+Mit freundlichen Grüßen,
+
+_______________________
+${g('v_vor')||'[Vorname]'} ${g('v_nach')||'[Nachname]'}`;
+  const el = document.getElementById('letter-body');
+  if(el) el.textContent = brief;
+}
+
+function copyLetter() {
+  const text = document.getElementById('letter-body')?.textContent;
+  if(text) navigator.clipboard.writeText(text).catch(()=>{});
+}
+
+showPage('dashboard');
+</script>
diff --git a/refactoring.md b/refactoring.md
new file mode 100644
index 0000000..479ffb4
--- /dev/null
+++ b/refactoring.md
@@ -0,0 +1,28 @@
+Wir müssen umbauen, 
+
+
+
+aktuell läuft das System als Zentraler Dienst für mehrere Patienten. 
+
+Nach Rücksprache habe ich erfahren, das Projekt soll wie folgt erstellt sein. 
+
+
+
+
+
+Webseite für Informationen über die App -> Login in die App -> Innerhalb der App kann man nur seine eigenen Patienten sehen im Regelfall 1-3 Patienten als das nahe Familien Umfeld das man verwaltet. Keine Möglichkeit andere Patienten irgendwie zu finden oder zu lokalisieren. 
+
+
+
+Für das Anlegen eines Patienten, um es den Angehörigen so leicht wie möglich zu gestalten, wäre ein Interview als reine Web-Application ohne KI Anbietung von Vorteil. 
+
+
+
+Für mich als Administrator fehlt eine Dashboard/Admin-Seite um Konten zu sperren oder zu löschen, alternativ um auf Anwaltliche Anordnung Archivierte Inhalte zu exportieren, beachte hierbei die DSGVO das muss Rechtlich komplett abgesichert sein für mich als Betreiber und für die alle Verwalter sowie Patienten. 
+
+
+
+Bezüglich des Refactoring - Stelle mir fragen über die Achritektur, Strukuturen, Serverstruktur und den Aufbau. 
+
+
+