diff --git a/.gitignore b/.gitignore
index ec99bcc..9b901ee 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,3 +5,4 @@ sessions/*.db-shm
 
 # macOS-Artefakte
 .DS_Store
+sessions/*.txt
diff --git a/26-4047 KfW SiKo_PlanKo_04_16.09.2026.pdf b/26-4047 KfW SiKo_PlanKo_04_16.09.2026.pdf
deleted file mode 100644
index 7aeb3e1..0000000
Binary files a/26-4047 KfW SiKo_PlanKo_04_16.09.2026.pdf and /dev/null differ
diff --git a/CLAUDE.md b/CLAUDE.md
index 7248dbd..f9d81c2 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -9,13 +9,56 @@ Single-page app for tracking engineering projects across weekly sessions
 step, no bundler, no tests. Data is persisted in a SQLite database
 (`node:sqlite`, needs Node >= 22.13) at `sessions/projektuebersicht.db`.
 
-Two HTML entrypoints, both served statically by Express:
-- `Test.html` — the main app (tabs: Projektboard, Auslastung, Projekte,
-  Projektbeteiligte). Served at `/`.
-- `project-plan.html` — per-project Gantt/TODO planning view, opened in a new
-  tab via `openProjectPlan()` in `js/gantt.js`. Loads the shared helper modules
-  (`globals`, `utils`, `ui`, `date-picker`, `server`, `gantt`) plus the
-  plan modules under `js/plan/` — NOT the full main module set.
+**ONE** HTML entrypoint, served statically by Express:
+- `App.html` — the whole app (sidebar nav items, in order: Meine Aufgaben,
+  **Projekte**, Wochenbericht, Auslastung, Projektbeteiligte, then
+  **Einstellungen** and — for admins only — **Admin**). Served at `/`. It
+  also contains the **Projektbereich** — the area of ONE project — as the
+  tab `plan` (`<div id="plan">`), with its own sub-navigation (`.plan-nav`)
+  over six sections: **Dashboard**, **Terminplan** (Gantt), **Aufgaben**
+  (task/milestone list), **Leistung** (erbrachter Leistungswert, see below),
+  **Dateien**, **Einstellungen** (project master data incl. honorar and the
+  beauftragte Leistungsphasen). Opened via `openProjectPlan()` in
+  `js/gantt.js`, which is now just `setPlanTarget()` + `showTab('plan')` —
+  the same kind of switch as Dashboard → Projekte, sidebar and topbar
+  stay put.
+  **There used to be a separate `Projekte` tab next to the Projektboard.** It
+  listed the very same projects a second time and offered a second editing
+  mask for the very same fields. Both are now ONE list — the tab `board`,
+  labelled **Projekte** (see "Eine Projektliste" below). The URL still reads `/Projektplan/<Name>?weekLabel=…&projNr=…`
+  and the selected section still lives in the URL fragment (`…#aufgaben`),
+  so both stay linkable. See "Projektbereich" below.
+**`admin-users.html` no longer exists either.** It was a standalone
+admin-only page with a hand-built header instead of the sidebar and its own
+`checkAuthAndInit()` + role check. Its markup moved into `App.html` as the
+`benutzer` section of the Admin area, its `<style>` block into `styles.css`,
+and `js/admin-users.js` now exports `renderAdminUsers()` instead of running
+its own page entry. `GET /admin-users.html` 301-redirects to `/Admin#benutzer`.
+The role check inside it is gone: the Admin area is unreachable for members
+anyway (`showTab()` redirects them), and the endpoints are server-enforced.
+
+**`project-plan.html` no longer exists.** It used to be a separate document
+with a reduced imitation of the sidebar (plain `<a href>` links, no
+Einstellungen/Admin sections) and its own `/load-all` fetch. Its markup moved
+into `App.html` (`#plan` plus the plan dialogs), its `<style>` block moved to
+`public/plan-styles.css`, and its modules under `js/plan/` are now loaded by
+`App.html`. `GET /project-plan.html` 301-redirects to the new route.
+
+The whole app requires login (see "Auth / security quirk" below):
+`App.html` shows a blocking login overlay (`checkAuthAndInit()` in
+`js/auth.js`) until `GET /whoami` confirms a session.
+
+`App.html`'s navigation is a single persistent **left sidebar**
+(`#headerMenu`/`.side-menu`) — it replaced the former top tab bar, a
+separate `<header>`, and a separate off-canvas tool drawer, which have all
+been merged into this one element (see "Frontend architecture" below).
+After login the app lands on the **Dashboard ("Meine Aufgaben")**, not the
+project list (`DEFAULT_TAB` in `js/globals.js`); the list remains
+fully available as a sidebar nav item. The former "Projektbeteiligte" tab
+(per-department `people`/`person_roles`/`person_absences` CRUD) has been
+fully replaced by the global `users` table: it is now a read-only view of
+that department's active users, and only admins manage team members, via
+`admin-users.html` (see "Projektbeteiligte" below).
 
 All UI strings/comments are German. Preserve German in
 user-facing text.
@@ -25,46 +68,137 @@ user-facing text.
 ```
 .
 ├── server.js                 # Express server + SQLite API
-├── package.json             # deps: express, cors only
+├── package.json             # deps: express, cors, plus pdfjs-dist/mammoth
+│                            # (added for Protokoll-Import, see "### Protokolle")
+├── .npmrc                   # omit=optional — hält pdfjs-dist's rein optionales
+│                            # @napi-rs/canvas (nur für Seiten-Rendering, hier
+│                            # ungenutzt) aus node_modules heraus
 ├── docker-compose.yml       # at repo ROOT; build context ., dockerfile Docker/Dockerfile
 ├── Docker/Dockerfile        # node:22-alpine (nötig für node:sqlite)
 ├── .dockerignore
 ├── public/
-│   ├── Test.html            # main app (served at /)
+│   ├── App.html            # main app (served at /)
+│   ├── admin-users.html     # standalone admin-only user management page
 │   ├── js/                  # shared modules (classic scripts, global fns)
-│   │   ├── globals.js       # Konstanten (LPHS, ROLES, LPH-Farben, DEPARTMENTS) + db/currentDepartment
-│   │   ├── utils.js         # esc, uid, Datum-/Differenz-Helfer, personIdForName, peopleByRole, assignKey, weekSortKey
+│   │   ├── globals.js       # Konstanten (LPHS, ROLES, LPH-Farben, DEPARTMENTS, TAB_SLUGS) + db/currentDepartment
+│   │   ├── utils.js         # esc, uid, Datum-/Differenz-Helfer, personIdForName,
+│   │   │                    # peopleByRole, assignKey, weekSortKey +
+│   │   │                    # renderProjektVerlauf() (die EINE Verlaufs-
+│   │   │                    # Darstellung, von allen drei Stellen genutzt)
 │   │   ├── ui.js            # LocalStorage-UI-State, Header-Collapse, Theme
 │   │   ├── date-picker.js   # Datums-/Bereichspicker-Overlays
-│   │   ├── server.js        # baseUrl, sendWeekToServer, sendPeopleToServer, blobToDataUrl
+│   │   ├── server.js        # baseUrl, sendWeekToServer, deleteWeekFromServer, blobToDataUrl (global people list has no client write path anymore, see Persistence)
+│   │   ├── auth.js          # currentUser, checkAuthAndInit (Login-Overlay), logout, renderUserBar
 │   │   ├── store.js         # save/syncAllToServer, switchDepartment, load, seed
-│   │   ├── weeks.js         # Wochen-Auswahl, -Erzeugung, -Klonen, Auto-Lock, -Löschung
+│   │   ├── weeks.js         # Wochen-Auswahl, Auto-Lock, -Löschung, unlockCurrentWeek (POST /unlock-week) —
+│   │   │                    # Erzeugung/Klonen entfallen, siehe "Automatischer Sitzungswechsel"
 │   │   ├── gantt.js         # GANTT-Diagramm (buildGanttHtml, openProjectPlan), geshared
-│   │   ├── showmode.js      # Show-Mode (Präsentationsmodus)
-│   │   ├── tabs-auth.js     # showTab, confirmPassword (SHA256-Passwortschutz)
-│   │   ├── pdf.js           # PDF-Export (pdfmake, A3 quer)
-│   │   ├── csv.js           # exportCSV (lädt ZIP von GET /export-csv)
+│   │   ├── tabs-auth.js     # showTab (5 Tabs; kein Passwortschutz mehr, siehe Auth-Abschnitt)
+│   │   ├── pdf.js           # drei PDF-Exporte (pdfmake): exportWochenberichtPDF()
+│   │   │                    # ist die Tagesordnung als Bericht je Gewerk — Übersicht
+│   │   │                    # + eine Akte je Projekt (A4 hochkant), exportSandboxPlanPDF()
+│   │   │                    # der Balkenplan eines Planung-Terminplans (A3 quer),
+│   │   │                    # exportProtokollPDF() das Besprechungsprotokoll eines
+│   │   │                    # Projekts (A4 hochkant, Punkte gruppiert, neue gelb)
+│   │   ├── projekt-wizard.js # Assistent "Neues Projekt" (sechs Schritte,
+│   │   │                    # Gewerke, gefiltertes Team, Terminplan aus Honorar)
+│   │   ├── auftrag.js       # Auftragsstatus (Anfrage→Angebot→beauftragt→
+│   │   │                    # abgeschlossen), Chip/Auswahlfeld und der
+│   │   │                    # Beauftragungs-Dialog
 │   │   ├── backup.js        # downloadBackup (lädt SQLite-Snapshot von GET /backup)
-│   │   ├── import.js        # importDb (Backup-Wiederherstellung über POST /import, passwortgeschützt)
-│   │   └── init.js          # renderAll/initUiState + Seiteneinstieg (nur Test.html)
-│   │   ├── board/           # tab-specific: Projektboard
-│   │   │   └── board.js     # Projektboard-Rendering, Status-Editor, Anwesenheit, Zuordnung
+│   │   ├── import.js        # importDb (Backup-Wiederherstellung über POST /import, admin-only)
+│   │   └── init.js          # renderAll/initUiState + Seiteneinstieg hinter checkAuthAndInit() (nur App.html)
+│   │   ├── board/           # tab-specific: die Projektliste ("Projekte")
+│   │   │   └── board.js     # Projektlisten-Rendering (Anzeige, BOARD_OPTS
+│   │   │                    # .nurAnsicht), Reihenfolge/Löschen und der
+│   │   │                    # Kommentar-Editor (Textfeld mit Verfasser/Zeitstempel,
+│   │   │                    # ausdrücklichem Speichern und scrollbarem Verlauf der
+│   │   │                    # früheren Sitzungen; auch vom Wochenbericht genutzt —
+│   │   │                    # Bedienelemente adressieren ihr Feld über closest(),
+│   │   │                    # nicht über IDs, da beide Tabs dieselben Projekte
+│   │   │                    # rendern). Kürzel-Legende und Anwesenheit sind hier
+│   │   │                    # entfallen (Anwesenheit siehe wochenbericht/)
+│   │   ├── wochenbericht/   # tab-specific: Wochenbericht (Tagesordnung des
+│   │   │                    # wöchentlichen Teammeetings — dort wird JEDES
+│   │   │                    # Projekt angesehen, Vollständigkeit vor Filterung)
+│   │   │   └── wochenbericht.js # Gruppierung "Neu kommentiert"/"Fortschritt"/
+│   │   │                    # "Unverändert" per project_uid-Vergleich zur Vorwoche
+│   │   │                    # (nutzt renderBoardDrawer/renderBoardRow aus board.js;
+│   │   │                    # die Karten tragen ein farbiges Kopfband je
+│   │   │                    # Änderungsart — .report-card-neu/-fortschritt,
+│   │   │                    # Farben in --band-neu/--band-fortschritt — und
+│   │   │                    # stellen die Schubladen-Blöcke dreispaltig; zeigen
+│   │   │                    # über BERICHT_OPTS nur die beauftragten
+│   │   │                    # Leistungsphasen, Rückfall auf alle wenn leer)
+│   │   │                    # + renderProjectTimeline(): der aufklappbare
+│   │   │                    # "Verlauf" je Projekt — die Kacheln der früheren
+│   │   │                    # Sitzungen waagerecht und scrollbar, mit
+│   │   │                    # Kommentar, LPH-Ständen, Terminen aus dem Plan
+│   │   │                    # und Beteiligten JENER Woche; gegenüber der
+│   │   │                    # Kachel davor geänderte Werte hervorgehoben
+│   │   │                    # + Anwesenheitserfassung am Seitenfuß
+│   │   │                    # (renderAttendance/toggleAttendance/setAllAttendance,
+│   │   │                    # binär an/abwesend über currentWeek().people mit Zähler)
 │   │   ├── people/          # tab-specific: Projektbeteiligte
-│   │   │   └── people.js    # Personen-Tab-Rendering + Drag-and-Drop + Abwesenheiten
-│   │   ├── projects/        # tab-specific: Projekte
-│   │   │   └── projects.js  # Projekte-Tab-Rendering + Drag-and-Drop
+│   │   │   └── people.js    # read-only Personen-Liste (aus db.globalPeople, kein CRUD/Drag-
+│   │   │                    # and-Drop mehr) + abteilungsübergreifende Besetzung (admin-only)
+│   │   ├── projects/        # Ablage-Logik der Projektliste (der eigene
+│   │   │   └── projects.js  # Projekte-Tab ist entfallen): Drag-and-Drop,
+│   │   │                    # reorderProjects(), delProjectFromList();
+│   │   │                    # renderProjects() rendert nur noch, wenn
+│   │   │                    # #projectsList existiert
 │   │   ├── load/            # tab-specific: Auslastung
-│   │   │   └── load.js      # Auslastungs-Tab, LP-Modal, Neues-Projekt-Modal
-│   ├── project-plan.html    # Gantt/TODO planning view
-│   ├── js/plan/             # planning modules (nur von project-plan.html geladen)
+│   │   │   └── load.js      # Auslastungs-Tab als LASTBAND (Zeile je Person
+│   │   │                    # und Rolle, Balken nach Projekten aufgeteilt),
+│   │   │                    # LP-Modal, Neues-Projekt-Modal
+│   │   │                    # (inkl. Auswahl der beauftragten Leistungsphasen,
+│   │   │                    # p.beauftragteLP — dieselbe Liste wie im
+│   │   │                    # Honorar-Dialog der Projektplan-Seite)
+│   │   ├── dashboard/        # tab-specific: Meine Aufgaben
+│   │   │   └── dashboard.js  # renderDashboard (GET /my-dashboard: offene TODOs + ausstehende Freigaben)
+│   │   ├── wand/              # tab-specific: Wandtafel (Touch-Dashboard, ersetzt Show Mode)
+│   │   │   └── wand.js        # renderWandboard — rein client-seitige Kacheln aus db (kein eigener Endpunkt)
+│   │   ├── settings/         # tab-specific: Einstellungen
+│   │   │   └── settings.js   # NUR "Mein Konto": Stammdaten + Passwortwechsel
+│   │   ├── admin/            # tab-specific: Admin (nur Administratoren)
+│   │   │   └── admin.js      # Abschnitte Honorar, Auslastung (Schwellen/Skala/
+│   │   │                     # Aufwandsvorlage), Termine & Sitzungen, Feiertage,
+│   │   │                     # Aufgaben-Vorlagen, Betrieb & Sicherheit,
+│   │   │                     # Datenbank & Sitzungen (Backup/Import/Löschen)
+│   │   └── admin-users.js   # Abschnitt "Benutzerverwaltung" des Bereichs #admin
+│   │                        # (renderAdminUsers, CRUD via /admin/users*)
+│   ├── plan-styles.css      # Stile des Projektbereichs (früher <style> in project-plan.html)
+│   ├── js/plan/             # Module des Projektbereichs (#plan in App.html)
 │   │   ├── plan-state.js    # PlanApp-Zustand, Datenladepath, savePlan, Toasts
+│   │   ├── plan-sections.js # Bereichs-Navigation (showPlanSection, URL-Fragment)
+│   │   │                    # + Dashboard-Karten (renderPlanDashboard)
+│   │   ├── plan-info.js     # Status/Kommentar, Gruppe, amtierende LPH, LPH-%,
+│   │   │                    # Beteiligten-Matrix (verteilt auf Dashboard+Einstellungen)
+│   │   ├── plan-settings.js # Bereich "Einstellungen": Projektangaben, Honorar,
+│   │   │                    # beauftragte Leistungsphasen (renderPlanSettings)
+│   │   ├── plan-tasks.js    # Bereich "Aufgaben": Aufgaben-/Meilensteinliste
+│   │   │                    # (renderPlanTasks; öffnet dieselben Dialoge wie das GANTT)
+│   │   ├── plan-history.js  # Kommentar-Verlauf über alle Sitzungen (+ Vorwochen-Helfer)
+│   │   ├── plan-templates.js # Aufgaben aus LPH-Vorlagen (lph_templates)
+│   │   ├── plan-honorar.js  # Terminplan aus Honorar + beauftragten LPH errechnen
 │   │   ├── plan-build-gantt.js # buildGanttHtml-Erweiterung (TODO- und Meilensteinzeilen)
 │   │   ├── plan-gantt.js    # renderPlanGantt, Abhängigkeitslinien, Zoom, Ressourcen-Load
 │   │   ├── plan-drag.js     # GANTT-Balken-Drag/Resize + TODO-/Meilenstein-Zeilen-Drag
-│   │   ├── plan-modals.js   # TODO-, Meilenstein- und Abwesenheits-Modals
+│   │   ├── plan-modals.js   # TODO-, Meilenstein- und Abwesenheits-Modals; der
+│   │   │                    # TODO-Dialog vereint "Erledigt"+Fortschritt in einem
+│   │   │                    # Status-Segment (offen/arbeit/fertig -> done+progress),
+│   │   │                    # Zuständige als Personen-Chips, Vorgänger eingeklappt
+│   │   │                    # mit Suche und gesperrten Zirkelbezügen; Esc/Strg+Enter
+│   │   │                    # und Hintergrund-Klick zentral für alle drei Dialoge
+│   │   ├── plan-leistung.js # Bereich "Leistung": erbrachter Leistungswert
+│   │   │                    # (Honorar × HOAI-Anteil × Fortschritt je Phase)
+│   │   ├── plan-files.js    # Datei-Upload/-Liste/-Freigabe/-Kommentare (project-files-Endpunkte)
+│   │   ├── plan-protokoll.js # Bereich "Protokolle": Besprechungsprotokolle
+│   │   │                    # je Projekt, mit Fortschreiben offener Punkte
+│   │   │                    # und gelber Neu-Markierung (project-protokolle-Endpunkte)
 │   │   └── plan-schedule.js # Kritischer Pfad, Auto-Schedule, Mail-Link
 │   ├── styles.css
-│   └── dein_bild.ico
+│   └── logo.ico
 └── sessions/                # SQLite-DB; bind-mounted into Docker container
     └── projektuebersicht.db # node:sqlite database (WAL mode)
 ```
@@ -83,27 +217,239 @@ docker compose up --build # Docker variant (compose file is at repo root)
   via `file://` (then only seed/demo data loads).
 - Check `/health` returns `{ok:true}` after starting.
 
+## Departments were retired (read this before trusting "department" elsewhere)
+
+This file historically described `ELT`/`HLS`/`ARCH` as three fully separate
+partitions — each with its OWN `weeks`, `projects`, and people list, switched
+via a sidebar "Abteilung" selector and `switchDepartment()`. **That is no
+longer true.** `migrateRemoveDepartmentPartition()` (`server.js`, runs
+idempotently at every startup, guarded on `weeks` still having a `department`
+column) merged all per-department weeks sharing the same label into one
+global week (and merged same-`nr` projects across the former departments into
+one project, tagging every former department as a `project_tags` entry —
+confirmed deterministically, ELT→HLS→ARCH precedence, nothing silently
+dropped). There is now **one shared week/project/people list**, full stop:
+`GET /load-all` and `POST /save-week` take no `department` param,
+`weeks`/`projects`/`week_people`/`attendance` have no `department` column,
+`switchDepartment()` and the `.dept-tab` sidebar no longer exist client-side,
+and `currentDepartment` is gone.
+
+`VALID_DEPARTMENTS`/`DEPARTMENTS` (`ELT|HLS|ARCH`) still exist, but now mean
+two different, narrower things:
+- **A user's own discipline** — `users.department`, maintained in
+  `admin-users.html`, used for staffing/team pickers.
+- **A project's discipline(s)** — `project_gewerke` (one or more per
+  project), see "Wochenbericht — Gewerke-Trennung" below.
+
+**Known documentation debt:** many mentions of "department"/"Abteilung"
+further down in this file — `db.globalPeople[currentDepartment]`,
+`openProjectPlan()` building `/HLS/Projektplan/…`, `switchDepartment()`
+behavior, the "Eine Projektliste"/"Projektbeteiligte" sections, etc. — still
+describe the pre-migration, per-department architecture and were not swept
+in the same pass that added this note. Treat any such mention as unverified
+until checked against the actual code; do not assume it still applies.
+
+## Automatischer Sitzungswechsel (read this before trusting "newWeek"/"cloneWeek" elsewhere)
+
+Sessions ("Sitzungen", `weeks.label` = "KW XX / YYYY") are still the backbone
+of the whole app — Wochenbericht, Board and Auslastung all key off the
+current one, and the Wochenbericht's own week-over-week comparison/Verlauf
+features (`renderProjektVerlauf()`, `classifyProjectChange()`, "Vergleich mit
+KW…") depend on there being a fresh session every week. What changed: **a new
+session is no longer a user action.** It used to be `newWeek()`/`cloneWeek()`
+(`public/js/weeks.js`), triggered by two buttons in the Werkzeuge sidebar
+group. Both are gone — on Erik's explicit call: "eine Sitzung stellt eine
+Woche dar… kommt eine neue Woche kommt auch eine neue Sitzung unabhängig von
+den Wochenberichten" (a session should follow the calendar, not whether
+anyone happens to open the Wochenbericht that week), and the transition
+should be **completely silent** — no toast, no confirmation.
+
+**`ensureCurrentWeekRollover()` (`server.js`) replaces both functions,
+server-side.** It runs once right after the HTTP server starts listening
+(catches a rollover that should have happened while the server was down) and
+then every hour via `setInterval` — deliberately NOT tied to any route or
+tab, so a session change happens even if nobody ever opens the app that
+week. (This is the first recurring background job in this codebase; there
+was no prior pattern to mirror.) On each run: compute today's ISO
+calendar-week/year (`getIsoWeekInfo()`, a straight port of `getWeekNumber()`
+from `public/js/utils.js`, extended to also return the ISO week-*year*, which
+can differ from the calendar year right at year boundaries); build the label
+via `formatWeekLabel()` ("KW 05 / 2026" — the exact shape both the old
+`validateWeekLabel()`'s regex and `weekSortKey()`/`weekSortKeyServer()`'s
+parsing expect); compare against the chronologically latest **real** (i.e.
+non-`SANDBOX_WEEK_LABEL`) session via the already-existing
+`weekSortKeyServer()` (previously only used by `/my-dashboard`'s fallback).
+If the calendar hasn't moved into a new week since then, it's a no-op — the
+function is safe to call as often as the interval likes, and safe to run
+again on every server restart without ever creating a duplicate.
+
+**When a new week IS due, the reset is a deliberate, exact port of what
+`cloneWeek()` used to do client-side** — same fields, same rationale, just
+executed server-side against a plain JS object built from `loadWeeks()`
+(itself already callable with no HTTP context) and written via
+`saveWeekRelational()`/`serializeWeek()` (also already pure DB-writing
+functions with zero dependency on `req`/`req.user` — confirmed by reading
+both top to bottom before relying on it): deep-clone the latest real week,
+give it a fresh `id` (`crypto.randomUUID()`, matching the ID scheme already
+used elsewhere in server.js) and the new label/`date`
+(`heuteIsoLokal()`), reset `attendance={}`, `locked=false`, drop `updatedAt`
+(a carried-over revision would make `/save-week`'s conflict check reject the
+brand-new label — moot here since this bypasses that route entirely, but the
+field is dropped anyway for cleanliness); per project, a fresh
+`id` (`crypto.randomUUID()`) and cleared `status`/`statusAuthor`/`statusAt`/
+`besprochen`/`statusState`. Everything else — Beteiligte, `lph`, `assign`,
+the whole `plan` (todos/milestones keep THEIR OWN ids unchanged, only the
+owning project's id changes), `project_uid`, `honorar`, `beauftragteLP`,
+`gewerke`, tags — carries over untouched, exactly as `cloneWeek()` always
+left it.
+
+**Locking**: there was, and is, no server-side equivalent of
+`applyAutoLock()` (still client-side-only, still exactly as before). The
+rollover replicates its invariant itself instead of relying on some client
+being open to do it: once the new week is saved, if
+`app_settings.autoLockAktiv` is on (read via the already-existing
+`readAppSettings()`), every other real week gets `locked=1` in one `UPDATE`.
+Turning `autoLockAktiv` off does not stop new sessions from being created —
+only stops them from locking everything else, same distinction the setting
+already made for `applyAutoLock()`.
+
+**Fresh-install edge case**: if there is no real week at all yet (nothing to
+clone), the rollover falls back to building an empty one — global people
+list, no projects — mirroring what `newWeek()` used to produce, so a brand
+new deployment still ends up with a session without needing a button to
+press.
+
+**Verified live** against a scratch copy of the production DB before ever
+touching the real one (the real database's latest session, KW 33/2026,
+predated "today" by seven ISO weeks — restarting the server for real was
+always going to trigger a real jump to KW 40/2026, so correctness was
+checked against a copy first): all 29 real projects carried over with fresh
+project ids, comments/`besprochen` cleared, LPH values and `plan_todos`
+(with their original todo ids) preserved byte-for-byte, older sessions
+correctly locked, a second server start produced no duplicate, and disabling
+`autoLockAktiv` left the previous latest week unlocked as expected.
+
+`newWeek()`, `cloneWeek()`, and `validateWeekLabel()` are gone from
+`public/js/weeks.js` (confirmed unreferenced anywhere else before removal).
+**Known documentation debt**, same caveat as the department note above: this
+file still has scattered comments elsewhere (in `board.js`, `utils.js`,
+`wochenbericht.js`, `plan-state.js`, `plan-history.js`,
+`plan-build-gantt.js`, and a few spots in this very file) that name
+`cloneWeek()`/`newWeek()` as the live mechanism for "project ids change every
+week"/"a new session starts with an empty comment" and similar — the
+underlying *facts* they describe are still true, only the mechanism producing
+them moved to `ensureCurrentWeekRollover()`. Treat a `cloneWeek()`/`newWeek()`
+mention elsewhere as describing that historical mechanism, not code that
+still exists, until it's been swept.
+
 ## Server API (`server.js`)
 
-- `GET /` → `Test.html`; `GET /health`.
-- Deep links per department + tab: `GET /<Dept>/<Tab>` → `Test.html`, e.g.
-  `/HLS/Auslastung` or `/ELT/Projektübersicht`. Tab slugs (`TAB_SLUGS` in
-  `js/globals.js`) are `Projektübersicht|Auslastung|Projekte|Projektbeteiligte`;
+Auth levels (see "Auth / security quirk" below for the mechanism): **Public**
+(no session needed) / **Auth** (any valid session) / **Admin** (`role='admin'`,
+via `requireRole('admin')`). HTML shell routes stay Public — they only ever
+serve static markup, never data; the actual security boundary is the 401/403
+on the JSON endpoints.
+
+- `GET /` → `App.html`; `GET /health`. Public.
+- Deep links per department + tab: `GET /<Dept>/<Tab>` → `App.html`, e.g.
+  `/HLS/Auslastung` or `/ELT/Projektübersicht`. Public. Tab slugs
+  (`TAB_SLUGS` in `js/globals.js`, `VALID_TAB_SLUGS` in `server.js`) are
+  `Projektübersicht|Wochenbericht|Auslastung|Projekte|Projektbeteiligte|MeineAufgaben|Einstellungen|Admin`;
   anything else returns 404. Exception: `GET /<Dept>/Projektplan(/<ProjName>)?`
-  (`PLAN_SLUG`) serves `project-plan.html`, the GANTT view, with
+  (`PLAN_SLUG`) serves `App.html` as well (the Projektbereich is a tab of it
+  now, selected client-side by `applyUrlRoute()`), with
   `weekLabel|projNr` as query params (the project name is a readable path
   segment only; identification happens via weekLabel + projNr). The frontend
   reads/writes these routes via `applyUrlRoute()`/`updateRouteUrl()` in
   `js/ui.js` and all static assets in the HTML use **absolute** paths
-  (`/js/...`, `/styles.css`) so they resolve on nested routes.
-- `GET /load-all?department=` → `{weeks:[weekObj], people:[personObj]}` with the
-  global people list in `people`; weeks are full JSON week objects (id, label,
+  (`/js/...`, `/styles.css`) so they resolve on nested routes. `admin-users.html`
+  itself is just a static file under `public/` (no dedicated server route/slug).
+- `POST /login {username,password}` → Public. Verifies against `users` (scrypt,
+  see Auth section), creates a `user_sessions` row and sets the session cookie.
+  Same generic error for wrong username, wrong password, or inactive account
+  (no user enumeration).
+- `POST /logout` → Auth. Deletes the current session row, clears the cookie.
+- `GET /whoami` → Public. Returns `{ok:true, user: req.user || null}` — the
+  basis for the client-side login overlay (`checkAuthAndInit()`).
+- `POST /change-password {currentPassword, newPassword}` → Auth. Requires the
+  current password even when `must_change_password` is set; new password ≥ 8
+  chars. Its UI is `#passwordModal` (`js/auth.js`) — reachable from
+  Einstellungen → Mein Konto, and shown non-dismissibly right after login when
+  the account carries `must_change_password`. Until that dialog existed the
+  endpoint had **no** caller at all: every new and every reset account got the
+  flag, `admin-users.html` displayed "Passwortwechsel erforderlich", and
+  nobody could act on it.
+- `POST /change-email {email}` → Auth. Scoped to `req.user.id` (like
+  `/change-password`, not a body-supplied user id), no admin role needed.
+  Rejects an empty value with 400; no format validation beyond trimming
+  (same permissiveness as the admin path below). Its UI is the inline
+  E-Mail field in Einstellungen → Mein Konto (`js/settings/settings.js`,
+  `submitEmailChange()`) — until this route existed the address was
+  view-only there and only an admin could set it via `PATCH
+  /admin/users/:id`; an admin can still set/correct it there, e.g. for a
+  colleague who hasn't logged in yet.
+- `GET /admin/users` → Admin. Lists all users (incl. inactive) with their
+  `roles` (discipline roles from `user_roles`, see below), without password
+  fields or absences (those are loaded separately, see next bullet).
+- `GET /admin/users/:id/absences` → Admin. Lists one user's absences
+  (`id, start, end, type, note`, sorted by `start`) from `user_absences` —
+  loaded on demand by the admin-users.js edit modal, not embedded in
+  `GET /admin/users` (would bloat the list response).
+- `POST /admin/users {username, displayName, email?, role?, personId?, department, initials?, roles?, password?, generatePassword?}`
+  → Admin. Creates a user with `must_change_password=1`; `department` is
+  **required** (must be a `VALID_DEPARTMENTS` value, 400 otherwise — empty is
+  only tolerated for the pre-existing bootstrap admin, not for new accounts);
+  `initials` is the short board-column label, stored as given (empty is
+  allowed — `loadGlobalPeople()` falls back to `username` at read time, see
+  Persistence); `roles` is an array validated against
+  `VALID_DISCIPLINE_ROLES = new Set(['Planung','Projektleitung','Bauüberwachung'])`
+  (400 on an unknown role) and written to `user_roles`. Password either given
+  explicitly (≥ 8 chars) or auto-generated (`generatePassword:true`, returned
+  once as `generatedPassword`).
+- `PATCH /admin/users/:id {displayName?, email?, role?, active?, personId?, department?, initials?, roles?}` →
+  Admin. Partial update; same `department`/`roles` validation as `POST`
+  (only when the field is present); `roles` is a replace-all (delete then
+  re-insert `user_roles`, same pattern as the old `serializeGlobalPeople`).
+  An admin can't deactivate or demote their own account. Deactivating a user
+  immediately deletes all their sessions. A `person_id` collision (now
+  globally unique, see Persistence) is caught and returned as 409.
+- `POST /admin/users/:id/reset-password` → Admin. Sets a new random password,
+  forces `must_change_password=1`, deletes all sessions of that user (forces
+  re-login), returns the plaintext once as `generatedPassword`.
+- `DELETE /admin/users/:id[?hard=1]` → Admin. Default is a soft-delete
+  (`active=0` + delete sessions); `?hard=1` permanently deletes the row, but
+  only if the user is referenced nowhere in `project_files.uploaded_by_user_id`
+  / `project_file_reviewers.user_id` / `project_file_comments.user_id` (else
+  409). An admin can never delete their own account (soft or hard).
+- `GET /users` → Auth (not admin-only). Lists active users
+  (`id, username, displayName, email, personId, department, initials, roles`)
+  — used both by the reviewer-picker in the file upload UI and by the
+  cross-department staffing picker in the (now read-only) Projektbeteiligte
+  tab (`js/people/people.js`) — deliberately separate from `/admin/users`,
+  which is admin-only and exposes more fields/inactive accounts.
+- `POST /users/:id/absences {start, end, type, note?}` → Auth (not
+  admin-only — matches the previous permission level: any logged-in user
+  maintains absences in the Projektbeteiligte tab / on the Gantt page).
+  Requires `start`/`end` (400 otherwise); server generates the absence `id`
+  (`crypto.randomUUID()`).
+- `DELETE /users/:id/absences/:absenceId` → Auth. Idempotent (no error if the
+  absence is already gone).
+- `GET /load-all` → Auth. `{weeks:[weekObj], people:[personObj], sandboxPlans:[projectObj], sandboxUpdatedAt}` — **no
+  `department` param**: `migrateRemoveDepartmentPartition()` (see "Departments
+  were retired" below) dissolved the former per-department partitioning, so
+  this returns the one shared set of weeks and the one shared people list
+  (`loadGlobalPeople()`, see Persistence — still filtered to `active=1`, just
+  not to a department anymore); weeks are full JSON week objects (id, label,
   date, locked, updatedAt, people, attendance, projects), sorted by label.
-- `POST /save-week {department, week, baseUpdatedAt}` → upserts one week (JSON
-  object, keyed by department + label). Used by `sendWeekToServer()`. The client
-  sends its local revision in `baseUpdatedAt` (the `updatedAt` value from
-  `load-all`); the server compares it to `weeks.updated_at` before writing and
-  answers `409 {ok:false, conflict:true, error, updatedAt}` if someone else
+  `sandboxPlans`/`sandboxUpdatedAt` are the reserved Planung-Sandbox "week"
+  (`SANDBOX_WEEK_LABEL`) split OUT of `weeks[]` — see "Planung —
+  projektunabhängige Terminplan-Sandbox" below — so it can never leak into
+  any code that iterates `weeks`.
+- `POST /save-week {week, baseUpdatedAt}` → Auth. Upserts one week (JSON
+  object, keyed by label only). Used by `sendWeekToServer()`. The
+  client sends its local revision in `baseUpdatedAt` (the `updatedAt` value
+  from `load-all`); the server compares it to `weeks.updated_at` before writing
+  and answers `409 {ok:false, conflict:true, error, updatedAt}` if someone else
   saved the week in the meantime. A save with a **non-empty** base for a week
   the server no longer knows is also rejected with 409 ("wurde gelöscht") so a
   deleted week can't silently resurrect; only new weeks (empty/missing base)
@@ -111,34 +457,169 @@ docker compose up --build # Docker variant (compose file is at repo root)
   the client stores as the new sync base. Clients WITHOUT `baseUpdatedAt` (old
   versions) always pass. The check runs synchronously in-process before the
   write transaction (no race between check and write).
-- `POST /save-people {department, people}` → replaces the department's global
-  people list (JSON array).
-- `POST /delete-week {department, label}` → deletes the week; missing label
-  yields 400, missing week tolerates with `deleted:false`.
-- `GET /export-csv?department=` → ZIP with one readable CSV per logical entity
-  (wochen, personen, sitzungsteilnehmer, projekte, zuordnungen,
-  leistungsphasen, aktuelle-leistungsphasen, aufwand-je-leistungsphase,
-  projektplaene, todos, meilensteine) for that department. CSV: UTF-8 with BOM,
-  CRLF, `;` separator by default (overridable via `?sep=`; German Excel opens
-  it directly). ZIP is built in pure Node (`zlib.deflateRawSync`, manual CRC32,
-  no external library). Used by `exportCSV()` in `js/csv.js`.
-- `GET /backup` → consistent SQLite snapshot (`VACUUM INTO`, WAL-safe) as a
-  `.db` file download (temp file in `os.tmpdir()`, deleted after send). Used by
-  `downloadBackup()` in `js/backup.js`. Additionally, on server startup the
+- `POST /delete-week {department, label}` → Admin. Deletes the week; missing
+  label yields 400, missing week tolerates with `deleted:false`.
+- `POST /unlock-week {department, label}` → Admin. Unlocks a locked week
+  (`locked=0`, new `updated_at` revision, same convention as `/save-week`) —
+  replaces the formerly client-only unlock logic
+  (`unlockCurrentWeek()`/`js/weeks.js`); 404 if the week doesn't exist.
+- `GET /my-dashboard` → Auth. Liefert `tasks` (persönlich zugewiesene offene
+  Aufgaben), **`projectDates`** (Aufgaben und Meilensteine der Projekte, denen
+  der Aufrufer zugeordnet ist — siehe „Dashboard" unten), `pendingReviews` und
+  `colleagueAbsences`. Aggregates, per department (`ELT`/`HLS`/`ARCH`),
+  the currently unlocked week's open (`done=0`) `plan_todos` assigned to the
+  caller's `person_id` (sorted by due date, empty dates last), plus
+  `pendingReviews` — files where the caller is a `pending` reviewer
+  (`project_file_reviewers` joined with `project_files`/`users`). Normally
+  exactly one unlocked week exists per department (`applyAutoLock()`
+  invariant); if that invariant is violated (0 or >1 unlocked weeks),
+  `weekSortKeyServer()` picks the most recent week as a fallback. A user
+  without a matching `person_id` gets an empty task list per department (no
+  error).
+- `POST /project-files?department=&projectNr=&projectName=&filename=&reviewers=id1,id2`
+  → Auth. Raw binary body like `/import` (`express.raw({type:'*/*', limit:'200mb'})`).
+  Rejects an invalid/missing `department` (stricter than `departmentKey()`'s
+  ELT-fallback — an upload must never land in the wrong department silently)
+  and an empty `projectNr` (400). Reviewer IDs are parsed from the
+  comma-separated query param, deduplicated, filtered to active users, and the
+  uploader is removed (no self-review); at least one reviewer must remain
+  (400 otherwise). See "File uploads" below for storage/path details.
+- `GET /project-files?department=&projectNr=` → Auth. Lists a project's files
+  incl. uploader name, per-reviewer decision, and comment count.
+- `GET /project-files/:id/download` → Auth. `res.download()` from
+  `sessions/uploads/<department>/<stored_name>`, with `original_filename` only
+  used as the download's `Content-Disposition` filename.
+- `POST /project-files/:id/review {decision:'approved'|'rejected', note?}` →
+  Auth. Only for a caller who is an eligible `pending` reviewer of that file;
+  409 if the file's overall status is already terminal
+  (`approved`/`rejected`). Recomputes the overall status: any `rejected`
+  decision → `rejected` immediately; all reviewers `approved` → `approved`;
+  otherwise stays `pending`.
+- `GET /project-files/:id/comments` → Auth. Chronological comment list.
+- `POST /project-files/:id/comments {body}` → Auth. Any logged-in user may
+  comment, not just the assigned reviewers.
+- `DELETE /project-files/:id` → Auth (not admin-only, but scoped): allowed for
+  the uploader while the file is still `pending`, or for an admin at any time
+  (403 otherwise). Deletes the DB row (and its reviewer/comment rows, deleted
+  explicitly rather than via FK cascade — see Persistence section) before
+  best-effort deleting the physical file.
+- `GET /project-protokolle?projectNr=` → Auth. Summary list of a project's
+  Protokolle (counts of open/erledigt points, Teilnehmer count), sorted by
+  `nummer` descending — see "### Protokolle" below.
+- `GET /project-protokolle/:id` → Auth. One full Protokoll incl. all
+  `teilnehmer`/`punkte`.
+- `POST /project-protokolle?projectNr=&projectName=&weekLabel=
+  {datum, betreff, ort, teilnehmer}` → Auth. Creates a new Protokoll;
+  `nummer` is server-assigned (`MAX(nummer)+1` for that `project_nr`), and
+  every still-open (`erledigt=0`) point of that project's most recently
+  created Protokoll is copied into it (the "Fortschreiben" — see "###
+  Protokolle").
+- `PUT /project-protokolle/:id {datum, betreff, ort, teilnehmer, punkte}` →
+  Auth. Replaces the Protokoll's Teilnehmer/Punkte wholesale (delete +
+  re-insert, one transaction) — the same "whole object" pattern
+  `saveWeekRelational()` uses for a week, not a REST route per field. A point
+  with a known `id` keeps its server-tracked `stamm_id`/`neu`; a point
+  without one is treated as newly added (`neu=1`).
+- `DELETE /project-protokolle/:id` → Auth (not admin-only — same permission
+  level as deleting a todo/milestone). Idempotent.
+- `POST /project-protokolle/import?projectNr=&projectName=&weekLabel=&datum=
+  &betreff=&ort=&filename=&erkennung=` → Auth. Raw-binary body like `POST
+  /project-files` (`express.raw`, 50 MB limit; the route is listed in
+  `RAW_BODY_ROUTES` so the global `express.json()` parser never touches it —
+  see "JSON-Dateien lassen sich hochladen" below, same reasoning). Extracts
+  text from an uploaded `.pdf`/`.docx` (400 on any other extension). `erkennung`
+  (`'chatgpt'|'claude'`, optional) tries KI-gestützte Erkennung first,
+  falling back to the `erkennePunkteAusText()` heuristic on any failure —
+  anything else in that param skips straight to the heuristic; creates the
+  Protokoll through the same `legeProtokollAn()` path as the plain `POST`
+  above — see "### Protokolle" below for both recognition paths and the
+  PDF-library history. Response includes `erkennungsart`/`erkennungshinweis`.
+- `GET /project-protokolle/:id/quelldatei` → Auth. Downloads the original
+  uploaded file of an imported Protokoll (404 if it wasn't imported) — the
+  Protokoll equivalent of `GET /project-files/:id/download`.
+- `GET /my-ai-settings` → Auth (not admin-only — scoped to `req.user.id`,
+  same pattern as `/change-email`). Returns, per provider, only whether an
+  API key is stored (`configured: bool`) plus the — non-secret — `apiUrl`
+  to pre-fill an edit form; never the key itself. `PUT /my-ai-settings
+  {chatgpt?: {apiKey?, apiUrl?}, claude?: {apiKey?, apiUrl?}}` → Auth, same
+  scoping. A given `apiKey` replaces it (empty string clears it); a given
+  `apiUrl` is validated via `istGueltigeAiUrl()` — `https://` always passes,
+  `http://` only on the loopback (`localhost`/`127.0.0.1`/`::1`), anything
+  else is 400 — or clears an override back to the default endpoint; an
+  omitted sub-field is left untouched. See "### Protokolle" below for why
+  each account keeps its own key rather than one firmenweit, and for why
+  plain `http` is allowed on the loopback.
+- `POST /my-ai-settings/test {provider}` → Auth, same scoping. "Neu
+  verbinden": actually exercises the caller's saved key/URL for that
+  provider via `erkennePunkteMitKI()` (a short dummy text, the same code
+  path an import uses). Responds `{ok:true}` or, on any failure,
+  `{ok:false, error}` with HTTP 200 — a failed test is an expected outcome,
+  not a server error. See "### Protokolle" below.
+- `GET /app-settings` → **Auth** (not admin-only — the frontend *computes*
+  with these: Auslastung, ampel, Honorar schedule). `PUT /app-settings` →
+  **Admin**, partial update. `APP_SETTING_DEFS` in `server.js` is the single
+  place a key is defined (default, parser, label); `readAppSettings()` always
+  returns a complete object, falling back to the default for a missing or
+  unusable row. Unknown keys and invalid values are rejected with 400 *before*
+  anything is written, and gelb > rot is refused outright. Keys:
+  `stundensatz`, `arbeitsstundenProTag`, `vollzeitStundenProWoche`,
+  `auslastungSchwelleGelb`, `auslastungSchwelleRot`, `referenzHonorar`,
+  `verteilzeitraumWochen`,
+  `aufwandVorlage` (JSON, validated against `VALID_LPHS`/
+  `VALID_DISCIPLINE_ROLES`, values 0–1), `autoLockAktiv`,
+  `feiertagBundesland`, `maxBackups`, `sessionTage`, `loginMaxVersuche`,
+  `loginSperreMinuten`.
+- `GET /holidays` → Auth; `POST /holidays {date,name}` / `DELETE /holidays/:date`
+  → Admin. `date` is the primary key, so posting an existing date just renames
+  it. `GET /holidays` also returns `states` (the 16 German states), since the
+  server is the single place that list lives and the maintenance mask needs it
+  right away.
+- `GET /holidays/suggest?year=&state=` → Auth; `POST /holidays/import {year,state}`
+  → Admin. German public holidays are **computed**, not fetched from a web
+  service: `holidaysForYear()` in `server.js` combines fixed dates with
+  everything hanging off Easter (`easterSunday()`, the Gaussian/Meeus formula;
+  `bussUndBettag()` for Saxony). No external dependency, no internet access on
+  the server — which a shop network does not necessarily have — and the result
+  is deterministic and works offline. The suggestion route marks days already
+  stored (`vorhanden`); the import uses `INSERT OR IGNORE`, so a hand-edited
+  name on an existing date survives. Nothing is written automatically: a
+  holiday shifts every computed schedule, so an admin confirms it. The state
+  is remembered in `app_settings.feiertagBundesland` (default `NW`).
+  Municipality-level cases (Fronleichnam in parts of SN/TH, Mariä Himmelfahrt
+  in Bavarian catholic municipalities) are deliberately left out — they cannot
+  be derived from the state and can be added by hand.
+- `GET /backup` → **Admin**. Consistent SQLite snapshot (`VACUUM INTO`, WAL-safe) as
+  a `.db` file download (temp file in `os.tmpdir()`, deleted after send). Used
+  by `downloadBackup()` in `js/backup.js`. Additionally, on server startup the
   server writes a timestamped copy to `sessions/backups/` (also via
   `VACUUM INTO`) and keeps only the `MAX_BACKUPS` newest ones (default 10).
-- `POST /import` → restores the whole database from a `.db` backup file sent as
-  a raw binary body (`express.raw`, limit 100 MB). Validates the schema
+- `POST /import` → Admin. Restores the whole database from a `.db` backup file
+  sent as a raw binary body (`express.raw`, limit 100 MB). Validates the schema
   (`pragma_table_info` on every table, exact column match vs. live DB), then
   swaps all data via `ATTACH DATABASE …` + DELETE/INSERT-SELECT inside one
   transaction (rollback on error). Immediately BEFORE the restore the server
   saves a fresh auto-backup of the current state via `runAutoBackup()` (so a
   restore can be undone), then performs the swap. Used by `importDb()` in
-  `js/import.js`, which is password-gated (`requestedAction` type `'importDb'`
-  in `js/tabs-auth.js`) like week deletion.
-- Valid departments hard-coded as `ELT|HLS|ARCH` in `server.js`
-  (`VALID_DEPARTMENTS`); anything else silently falls back to `ELT`. Same set in
-  `DEPARTMENTS` in `js/globals.js`.
+  `js/import.js` (the "DB Import" button is only shown to admins,
+  `renderUserBar()` in `js/auth.js`, and the route itself is admin-only
+  regardless of UI). Note: `IMPORT_TABLES` in `server.js` lists the 16
+  original per-week/session relational tables (`weeks` … `plan_milestone_deps`)
+  plus `project_protokolle`/`protokoll_teilnehmer`/`protokoll_punkte` (added
+  with the Protokolle feature — unlike `project_files`, a Protokoll has no
+  on-disk component, so it's safe to include in a restore, see "###
+  Protokolle"), i.e. the 7 auth/user/file tables (`users`, `user_sessions`,
+  `user_roles`, `user_absences`, `project_files`, `project_file_reviewers`,
+  `project_file_comments`) are **not** touched by import/export — a DB restore
+  never overwrites accounts, roles, absences, sessions, or file-review state.
+  (`people`/`person_roles`/`person_absences` were removed from `IMPORT_TABLES`
+  along with the tables themselves, see Persistence.)
+- `ELT|HLS|ARCH` (`VALID_DEPARTMENTS` in `server.js`, `DEPARTMENTS` in
+  `js/globals.js`) are **no longer a partitioning of weeks/projects/people** —
+  see "Departments were retired" below. They still identify a **user's own**
+  discipline (`users.department`) and, since the Wochenbericht-Gewerke feature,
+  a **project's** discipline(s) (`project_gewerke` — see "Wochenbericht —
+  Gewerke-Trennung" below); `VALID_DEPARTMENTS` is the shared value set for
+  both.
 - Static assets get `Cache-Control: no-store`.
 - JSON body limit is 2 MB.
 
@@ -147,36 +628,164 @@ docker compose up --build # Docker variant (compose file is at repo root)
 - Data lives in `sessions/projektuebersicht.db` (`node:sqlite` `DatabaseSync`,
   WAL mode, `PRAGMA foreign_keys = ON`, `PRAGMA busy_timeout = 5000` to avoid
   `SQLITE_BUSY` under concurrent writers), created automatically. The schema is
-  **fully relational** (19 tables) instead of one big JSON document per week:
+  **fully relational** (26 tables, in the unconditional `CREATE TABLE`
+  block at the top of `server.js`) instead of one big JSON document per week:
   - `weeks` (department, label, week_id, date, locked, updated_at; PK
     `(department,label)`) — `updated_at` is the revision timestamp for the
     single-user conflict handling (see `/save-week` above)
   - `week_people` / `week_people_roles` — person copies per week (`array_order`
     keeps the list order, `role_order` the role array order)
   - `attendance` — présence per week/person
-  - `projects` (`array_order` = position in the JSON array, `order_value` = the
-    `p.order` field, which is only unique *within a group*, not globally!)
+  - `projects` — u. a. `groesse` (REAL 0–1, Ersatz für ein fehlendes Honorar
+    in der Auslastungsrechnung, siehe "Auslastung — Wochenstunden statt
+    Faktoren"); (`array_order` = position in the JSON array, `order_value` = the
+    `p.order` field, which is only unique *within a group*, not globally!;
+    `besprochen` = ticked off in the team meeting — it belongs to the
+    SESSION, not the project, so `cloneWeek()` resets it: a new session
+    starts with an empty agenda)
+  - `project_gewerke` (week_label, project_id, gewerk; PK über alle drei) —
+    die Fachbereiche, die das Projekt bearbeiten (`ELT`/`HLS`/`ARCH`, dieselben
+    Werte wie `users.department`); steuert die Auswahl der Beteiligten im
+    Assistenten
   - `project_lph`, `project_assign` (person_id|role keys split into columns),
     `project_aufwand` (LP effort per role), `project_aktuelle_lp`
   - `project_plan`, `plan_people`, `plan_todos` / `plan_todo_assignees` /
     `plan_todo_deps`, `plan_milestones` (`position` column!) /
     `plan_milestone_deps`
-  - `people` / `person_roles` / `person_absences` — global people per department
-- The HTTP API stays JSON-shaped: `serializeWeek()` /
-  `serializeGlobalPeople()` split incoming week/people objects across the
-  tables inside a transaction, `loadWeeks()` / `loadGlobalPeople()`
-  (re)assemble them on read. `saveWeekRelational()` deletes the week's rows
-  first (`deleteWeekData()`, note `weeks` uses `label`, all child tables
-  `week_label`) and returns the new `updated_at` revision written by
-  `serializeWeek()`.
-- Migration on every start (idempotent):
-  `migrateLegacySchema()` converts a DB from the old single-JSON-document format
-  (detected via a `data` column in `weeks`): it reads the documents, drops all
-  tables, recreates the relational schema and inserts everything in one
-  transaction. Afterwards `migrateWeeksUpdatedAt()` adds the `updated_at`
-  column to `weeks` (idempotent, `ALTER TABLE … ADD COLUMN`).
-  Note: legacy rows keep `updated_at = ''`, so the first client save with an
-  empty `baseUpdatedAt` matches and only then a real revision is written.
+  - `users` (id, username UNIQUE, display_name, email, password_hash,
+    password_salt, role `'admin'|'member'`, person_id, active,
+    must_change_password, created_at, updated_at, **department, initials**) +
+    index on `person_id` **and** `CREATE UNIQUE INDEX … ON users(person_id)
+    WHERE person_id != ''` (see `ensureUserPersonIdUniqueIndex()` below) —
+    `capacity_hours` (contractual hours per week, added by
+    `migrateUsersDepartment()`; `0` = not maintained and counts as a full
+    position),
+    `person_id = personIdForName(display_name)`, the bridge to the existing
+    `person_id`-based assignment scheme (e.g. `plan_todo_assignees`) so
+    dashboard aggregation needs no schema change there; `department` is a
+    `VALID_DEPARTMENTS` value (empty only tolerated for the pre-existing
+    bootstrap admin), `initials` is the short board-column label
+  - `user_roles` (user_id, role, role_order; PK `(user_id,role)`, FK →
+    `users(id) ON DELETE CASCADE`) — discipline roles
+    (`Planung`/`Projektleitung`/`Bauüberwachung`, `VALID_DISCIPLINE_ROLES`)
+  - `user_absences` (user_id, id, start, end, type, note; PK `(user_id,id)`,
+    FK → `users(id) ON DELETE CASCADE`)
+  - `user_ai_keys` (user_id, provider, api_key, api_url; PK
+    `(user_id,provider)`, FK → `users(id) ON DELETE CASCADE`) — each
+    account's own OpenAI/Claude API key + optional API-URL override for the
+    Protokoll-Import's KI-gestützte Erkennung, see "### Protokolle"
+  - `user_sessions` (token PK, user_id, created_at, last_seen_at, expires_at)
+  - `holidays` (date PK `YYYY-MM-DD`, name) — firmenweite arbeitsfreie Tage.
+    A table rather than a JSON value in `app_settings` because it is a list
+    that grows and is maintained entry by entry. It feeds `HOLIDAYS`
+    (`js/globals.js`) and thus `isWorkday()`/`workdaysBetween()`/
+    `addWorkdays()` in `public/js/utils.js` — i.e. the Honorar schedule and
+    the Projektbereich's resource load. Dependency-based scheduling
+    (Auto-Schedule) still counts calendar days, as it always did.
+  - `project_files` (id PK, department, project_nr, project_name,
+    original_filename, stored_name, content_type, size_bytes,
+    uploaded_by_user_id, status `'pending'|'approved'|'rejected'`, created_at,
+    updated_at) + index on `(department, project_nr)`
+  - `project_file_reviewers` (file_id, user_id, decision `'pending'|'approved'|'rejected'`,
+    decided_at, note; PK `(file_id, user_id)`) + index on `(user_id, decision)`
+  - `project_file_comments` (id PK, file_id, user_id, body, created_at)
+  - `project_protokolle` (id PK, project_nr, project_name, nummer, datum,
+    betreff, ort, verfasser_user_id, week_label, created_at, updated_at) +
+    index on `project_nr` — scoped like `project_files`, see "### Protokolle"
+  - `protokoll_teilnehmer` (id PK, protokoll_id, name, firma, anwesend,
+    array_order) + index on `protokoll_id`
+  - `protokoll_punkte` (id PK, protokoll_id, stamm_id, nummer, gruppe, neu,
+    thema, text, zustaendig, termin, erledigt, erstellt_am, array_order) +
+    index on `protokoll_id` — `stamm_id` links copies of "the same" point
+    across Protokolle (the "Fortschreiben"), `nummer`/`gruppe` are free text.
+    `erstellt_am` (added on Erik's follow-up request, migration
+    `migrateAddProtokollPunktErstelltAm()`, existing rows stay empty — their
+    real origin date can't be reconstructed) is set exactly once, the moment
+    a point is first saved — either the owning Protokoll's own `datum` (a
+    point added by hand or newly recognized on import) — and, like
+    `stamm_id`, carried forward UNCHANGED by the Fortschreiben-copy in
+    `legeProtokollAn()` and by `PUT /project-protokolle/:id` (which looks up
+    the existing row by `id` and keeps its stored value rather than trusting
+    whatever the client sends): a Fortschreiben copy or an ordinary edit of
+    an existing point is not a new creation, so its original date must not
+    move just because it now also appears in a later Protokoll. Only a point
+    with no matching existing `id` gets a *fresh* `erstellt_am`, from the
+    `datum` being saved in that very request — the same rule `neu`/`stamm_id`
+    already follow for telling "genuinely new" apart from "carried over".
+
+  `people` / `person_roles` / `person_absences` (the former per-department
+  global-people schema) are **gone** from the live schema — they are only
+  ever created transiently by `migrateLegacySchema()` when converting a very
+  old single-JSON-document DB, and then immediately retired by
+  `migrateRetirePeopleTablesIntoUsers()` (see Migration below) in the same
+  startup. `loadGlobalPeople(department)` now reads exclusively from
+  `users`/`user_roles`/`user_absences` (`WHERE department = ? AND active = 1`)
+  and returns the unchanged shape `{id, name, fullName, email, role:[],
+  absences:[{id,start,end,type,note}]}` (`id`/`name`/`fullName` map to
+  `person_id`/`initials||username`/`display_name`), so `GET /load-all`,
+  `board.js`, `load.js`, `gantt.js`, `plan-modals.js` needed no changes.
+
+  **FK constraint note:** although `PRAGMA foreign_keys = ON` is set, only
+  `user_sessions.user_id`, `user_roles.user_id`, `user_absences.user_id` and
+  `user_ai_keys.user_id` have a declared `FOREIGN KEY … REFERENCES
+  users(id) ON DELETE CASCADE` (deleting a user auto-deletes their
+  sessions/roles/absences/AI keys). Every other
+  table — the 16 original per-week/session tables, the 4 file-related ones
+  (`users`, `project_files`, `project_file_reviewers`,
+  `project_file_comments`) and the 3 Protokolle tables (`project_protokolle`,
+  `protokoll_teilnehmer`, `protokoll_punkte`) — has **no** declared FK
+  constraints; this is a deliberate continuation of the pre-existing
+  convention (referential
+  integrity is enforced in application code, e.g. `deleteWeekData()`), not an
+  oversight. `DELETE /project-files/:id` therefore deletes
+  `project_file_comments` and `project_file_reviewers` rows explicitly before
+  the `project_files` row.
+- The HTTP API stays JSON-shaped: `serializeWeek()` splits an incoming week
+  object across the tables inside a transaction, `loadWeeks()` /
+  `loadGlobalPeople()` (re)assemble week/people data on read.
+  `saveWeekRelational()` deletes the week's rows first (`deleteWeekData()`,
+  note `weeks` uses `label`, all child tables `week_label`) and returns the
+  new `updated_at` revision written by `serializeWeek()`. There is no
+  `serializeGlobalPeople()` anymore — the global people list has no write
+  path of its own; it is a read-only projection of `users`/`user_roles`/
+  `user_absences`, which are written only through `/admin/users*` and
+  `/users/:id/absences*`.
+- Migration on every start (idempotent, run in this order after schema
+  creation):
+  1. `migrateLegacySchema()` converts a DB from the old single-JSON-document
+     format (detected via a `data` column in `weeks`): it reads the
+     documents, drops all tables, recreates the (then-current, including the
+     now-retired `people`/`person_roles`/`person_absences`) relational schema
+     and inserts everything in one transaction.
+  2. `migrateWeeksUpdatedAt()` adds the `updated_at` column to `weeks`
+     (idempotent, `ALTER TABLE … ADD COLUMN`). Legacy rows keep
+     `updated_at = ''`, so the first client save with an empty
+     `baseUpdatedAt` matches and only then a real revision is written.
+  3. `migrateUsersDepartment()` adds the `department`/`initials` columns to
+     `users` if missing (idempotent `ALTER TABLE … ADD COLUMN`, same pattern
+     as step 2).
+  4. `ensureUserPersonIdUniqueIndex()` first calls `dedupeUserPersonIds()` —
+     `person_id` used to only need to be unique *per department* (the old
+     `people` table); now that it globally identifies a user, any existing
+     duplicates are resolved by appending `_<user id>` to every row but the
+     first (logged with `console.warn`) — then creates
+     `idx_users_person_id_unique` (a partial unique index skipping empty
+     `person_id`).
+  5. `migrateRetirePeopleTablesIntoUsers()` runs only while a `people` table
+     still exists (no-op/idempotent otherwise): for every legacy `people` row
+     it looks up a `users` row by `(department, person_id)`; on a match it
+     copies that person's `person_roles` into `user_roles`
+     (`INSERT OR IGNORE`); on no match the row is only logged to the console
+     as unmatched — **no placeholder user is created** for it (would pollute
+     the user list with non-loginable dead entries). Historical `person_absences`
+     rows are **not** migrated (`serializeGlobalPeople()`'s old code wrote
+     `String(absenceObject)`, i.e. literally `"[object Object]"`, into that
+     column, so there was nothing meaningful to carry over). It then drops
+     `people`, `person_roles`, and `person_absences`. Historical weeks are
+     unaffected either way: `week_people`/`week_people_roles` already freeze
+     each week's person name/roles at save time, independent of the global
+     people table.
+  6. `bootstrapInitialAdmin()` (see Auth section).
 - The DB file sits in `sessions/`, so the existing Docker bind-mount
   `./sessions:/app/sessions` keeps it persistent. The path is overridable via
   the `DB_PATH` environment variable (used for tests), production default is
@@ -187,16 +796,38 @@ docker compose up --build # Docker variant (compose file is at repo root)
 ## Frontend architecture
 
 - The frontend is split into small classic non-module `<script>` files under
-  `public/js/`; **all functions are globals on `window`**. Two HTML files include
-  them via `<script src>` tags; load order in the HTML defines dependencies,
-  since there is no bundler:
-  - `Test.html` loads `globals → utils → ui → date-picker → server →
+  `public/js/`; **all functions are globals on `window`**. Three HTML files
+  include them via `<script src>` tags; load order in the HTML defines
+  dependencies, since there is no bundler:
+  - `App.html` loads `globals → utils → ui → date-picker → server → auth →
     store → weeks` (shared modules), then the tab-specific folders `board →
-    people → projects → load`, finally `gantt → showmode → tabs-auth → pdf →
-    init`. See the exact list in `Test.html`.
-  - `project-plan.html` loads only `globals → utils → ui → date-picker →
-    server → gantt` plus the `js/plan/*` modules. It must NOT load modules that
-    touch main-only page elements (`store`, `weeks`, `board`, …, `init`).
+    people → projects → load → dashboard → wand`, finally `gantt →
+    tabs-auth → pdf → backup → import → init`. See the exact list in
+    `App.html`. `auth.js` sits right after `server.js` because
+    `checkAuthAndInit()` needs `baseUrl()`, and before `store.js`/`weeks.js`
+    since nothing may talk to the data endpoints before a session exists.
+    The `js/plan/*` modules of the Projektbereich sit right after `gantt.js`
+    (`plan-state → plan-sections → plan-info → plan-history →
+    plan-build-gantt → plan-gantt → plan-drag → plan-modals → plan-tasks →
+    plan-files → plan-templates → plan-honorar → plan-settings →
+    plan-schedule`): they must come after `gantt.js`, whose `buildGanttHtml()`
+    `plan-build-gantt.js` wraps, and `plan-history` must stay before
+    `plan-build-gantt`, which uses its previous-week helpers. None of them
+    collides with a main-module global — every one runs in an IIFE over
+    `window.PlanApp` and exports through `window.*`.
+  - `admin-users.html` is the second, fully independent page (the only one
+    outside the tab system): it loads only `globals →
+    utils → ui → server → auth → admin-users.js` (no `date-picker`, no
+    `gantt`, no `plan/*` — it only talks to `/admin/users*`).
+- `currentUser`/`checkAuthAndInit()` (`js/auth.js`) are the shared client-side
+  auth concept across all three pages: `checkAuthAndInit(onAuthenticated)`
+  calls `GET /whoami`; with a session it sets `currentUser`, hides the login
+  overlay and runs `onAuthenticated()` (the page's normal entry point, e.g.
+  `initUiState()` + `switchDepartment()` in `js/init.js`); without one it shows
+  the blocking `#loginOverlay`/`#loginForm` and only proceeds after a
+  successful `POST /login`. `renderUserBar()` shows the current user's
+  name/role and toggles admin-only UI (the "DB Import" button, the
+  `#adminUsersLink` to `admin-users.html`) based on `currentUser.role`.
 - Shared state object `window.PlanApp` (`js/plan/plan-state.js`) holds all
   project-plan page state (week, project, zoom level, drag/`modal`-state),
   `db`/`currentDepartment` live in `js/globals.js`.
@@ -209,63 +840,2374 @@ docker compose up --build # Docker variant (compose file is at repo root)
   `findProjectForPlan` resolves them. Person IDs follow
   `personIdForName(name)` → `p_<lowercased alnum>`.
 - `save()` debounces 500 ms then `syncAllToServer()` writes **only dirty weeks**
-  (`dirtyWeeks` – track `markWeekDirty()`) via `sendWeekToServer()`, plus the
-  people list `markPeopleDirty()` via `sendPeopleToServer()` if marked dirty.
-  An in-flight guard (`syncInFlight`/`syncQueued`) prevents overlapping syncs
-  from double-POSTing the same week with the same revision (which would look
-  like a spurious 409). On success the server-provided `updatedAt` revision is
-  adopted as the new sync base; weeks whose save failed (network errors) stay
-  dirty and are retried. A `409` conflict response drops the local changes for
-  that week and `handleWeekConflict()` reloads **only that week** from the
-  server (`reloadWeekFromServer()`), leaving all other dirty weeks and the
-  people list untouched. Exception: `js/plan/plan-state.js` `savePlan()`
-  bypasses `save()` and writes only the current week directly via
-  `sendWeekToServer()` (with the same in-flight/trailing-save guard), adopting
-  the returned `updatedAt` and showing a toast on conflict. `switchWeek()` (in
+  (`dirtyWeeks` – track `markWeekDirty()`) via `sendWeekToServer()`. There is
+  no separate people-list dirty-tracking/sync path anymore (no
+  `dirtyPeople`/`markPeopleDirty()`/`sendPeopleToServer()`) — since
+  Projektbeteiligte is a read-only projection of `users`/`user_roles`/
+  `user_absences`, the only way the client ever changes "people" data is
+  either (a) admin CRUD on `admin-users.html` (writes straight to
+  `/admin/users*`/`/users/:id/absences*`, no debounce/dirty-tracking
+  involved), or (b) the cross-department roster addition
+  (`addUserToCurrentWeekRoster()` in `js/people/people.js`), which just
+  pushes into `currentWeek().people` and goes through the normal week-`save()`
+  path. An in-flight guard (`syncInFlight`/`syncQueued`) prevents overlapping
+  syncs from double-POSTing the same week with the same revision (which would
+  look like a spurious 409). On success the server-provided `updatedAt`
+  revision is adopted as the new sync base; weeks whose save failed (network
+  errors) stay dirty and are retried. A `409` conflict response drops the
+  local changes for that week and `handleWeekConflict()` reloads **only that
+  week** from the server (`reloadWeekFromServer()`), leaving all other dirty
+  weeks untouched. Exception: `js/plan/plan-state.js` `savePlan()` bypasses
+  `save()` and writes only the current week directly via `sendWeekToServer()`
+  (with the same in-flight/trailing-save guard), adopting the returned
+  `updatedAt` and showing a toast on conflict. `switchWeek()` (in
   `js/weeks.js`) does NOT trigger a save – only actual edits do.
 - `switchDepartment()` cancels a pending save debounce before switching, and
   `load()` discards stale `/load-all` responses after a department switch
   (frozen `requestedDepartment`), so late responses can never render or persist
   data under the wrong department.
-- Person drag-and-drop in the people tab: drag handle (`.drag-handle`) binds
-  `ondragstart`/`ondragend`, the `.people-sortable` container binds
-  `ondragover`/`ondrop`; insertion is computed by `getDragAfterElement(container,
-  y, selector)` (`js/projects/projects.js`, used with `.person-card` here and
-  `.person-list-item` in the projects tab). `reorderPeople()` updates both
-  `db.globalPeople` and the current week's person copy, then `save()`. No drag
-  handles are rendered on locked weeks.
+- The people tab no longer has drag-and-drop, a form, or delete/reorder
+  actions (`renderPeople()` in `js/people/people.js` is read-only rendering
+  of `db.globalPeople[currentDepartment]` plus any cross-department roster
+  additions on the current week). `getDragAfterElement()`/drag-and-drop
+  (`js/projects/projects.js`) serves the project list's `.board-row` rows
+  and, via `js/people/people.js`, the `.person-list-item` rows — the people tab's former
+  `.person-card`/`.people-sortable`/`reorderPeople()` drag machinery was
+  removed along with the CRUD UI. No drag handles are rendered on locked
+  weeks in the Projekte tab either way.
 - Weeks are sorted by calendar week extracted from the label (`KW XX / YYYY`)
   via `weekSortKey()`, not alphabetically/by filename.
 - `applyAutoLock()` locks every week except the chronologically last one after
   load/clone/new-week; `localStorage` UI state is not restored for locked tabs.
 - `localStorage` keys: `projuebersicht_v1` (department only — tab is never
   restored from storage; at startup the tab comes from the deep-link URL if
-  present, otherwise `board`), `projuebersicht-theme`, header-collapse key. Do
-  **not** store data in `localStorage`; it is UI state only.
+  present, otherwise `DEFAULT_TAB` = `'dashboard'`, i.e. "Meine Aufgaben"),
+  `projuebersicht-theme`, header-collapse key. Do **not** store data in
+  `localStorage`; it is UI state only.
 - Deep-link URLs (`/<Dept>/<Tab>`) are shared via the address bar:
   `updateRouteUrl()` rewrites the path via `history.replaceState` on tab and
-  department switches; protected tabs keep the URL but open the password modal.
+  department switches. Since the whole app requires login, an unauthenticated
+  visitor to any deep link (including `/Projektplan/…`) simply sees the
+  login overlay first; the URL itself is never gated per-tab anymore (there is
+  no more admin/member split at the tab level — see Auth section).
+- **Sidebar navigation (`App.html` only):** the former top tab bar, a
+  separate `<header>`, and a separate off-canvas tool drawer have been merged
+  into one persistent left sidebar, `#headerMenu`/`.side-menu` (the element
+  keeps its old id/class and `toggleHeader()`/`setHeaderCollapsed()` mechanics
+  from `js/ui.js`, now repurposed to hold the entire navigation). Structure
+  top to bottom: brand (logo/title), a "Navigation" section with the
+  `.nav-item.tab`/`data-tab` buttons (`showTab()`) in the order Meine
+  Aufgaben → Projekte → Wochenbericht → Auslastung (plus `#planNavItem`, see
+  below) — **no "Abteilung" section** (removed along with department
+  partitioning, see "Departments were retired"; `.dept-tab`/`switchDepartment()`
+  no longer exist) — then — below the divider — the **Einstellungen** nav item (the tab
+  `settings`), the **Werkzeuge** accordion and the **Admin** accordion (its
+  sub-items are the sections of the `admin` tab, see below), and a
+  `.side-menu-footer` with `#userBarInfo`/`#adminUsersLink`/logout
+  (`renderUserBar()`, unchanged). At `min-width: 769px` the sidebar is
+  `position: sticky` and permanently visible (no hamburger, `styles.css`);
+  below that width, a narrow `.mobile-topbar` (logo + hamburger) replaces the
+  old `<header>` and the sidebar reverts to its pre-existing off-canvas
+  slide-in behavior. `admin-users.html` deliberately does **not** get this
+  sidebar — it stays a focused standalone page outside the tab system, with
+  its own back-link and user bar. The Projektbereich needs no special case
+  at all any more: being the tab `plan` of `App.html`, it simply IS under
+  the same sidebar, with every section (Sitzung, Einstellungen, Admin, user
+  footer) working as everywhere else. The only sidebar addition is
+  `#planNavItem` — a nav item that stays hidden until a project has been
+  opened and then carries that project's name (`syncPlanNavItem()` in
+  `js/tabs-auth.js`), so the sidebar still highlights where you are while in
+  the Projektbereich. `showTab()` additionally hides `.container` for
+  `t === 'plan'`, because `#plan` deliberately sits OUTSIDE it (it brings its
+  own header and padding) and the empty container's padding would otherwise
+  show as a blank strip.
 
 ## Auth / security quirk
 
-- The `projects` and `people` tabs, week deletion, and week unlock are gated by
-  a password modal comparing `CryptoJS.SHA256(input)` to
-  `PROTECTED_PASSWORD_HASH` (`js/globals.js`, modal in `js/tabs-auth.js`).
-  Client-side only — not real security. CryptoJS and pdfmake (PDF export) are
-  loaded from `cdnjs.cloudflare.com` in `Test.html`, so those features need
-  internet access and won't work offline. `project-plan.html` loads neither.
+- Real server-side authentication (this replaced the old client-only
+  password modal — `PROTECTED_PASSWORD_HASH`, `isAuthenticated`,
+  `requestedAction`, `confirmPassword()`, `#passwordModal`, and the CryptoJS
+  CDN `<script>` tag are all gone; `js/tabs-auth.js` now only holds `showTab()`).
+  Login is required for the **entire app**, not just for mutations/admin
+  actions — every JSON endpoint except `/login`/`/whoami` requires at least a
+  valid session (see the Auth-level markers in "Server API" above).
+- **Sessions:** a session is a row in `user_sessions` (`token` PK, 30-day
+  `expires_at`), identified via the `puebersicht_session` cookie
+  (`HttpOnly; SameSite=Lax`, `Secure` added automatically when the request is
+  HTTPS). Cookie parsing/setting is hand-rolled (`parseCookies()`,
+  `setSessionCookie()`/`clearSessionCookie()` in `server.js`) — no
+  `cookie-parser` dependency, keeping the project's express+cors-only
+  convention. `attachUser` middleware (registered via `app.use(attachUser)`
+  right after `express.json()` and before `express.static`, so it runs for
+  every request including static assets) reads the cookie, loads the joined
+  session+user row, and sets `req.user` (or `null`); it also refreshes
+  `last_seen_at` on every authenticated request. `requireAuth` (401 if
+  `req.user` is null) and `requireRole('admin')` (401 if not logged in, else
+  403 if `role !== 'admin'`) are the two middleware factories used on routes.
+- **Passwords:** hashed with Node's built-in `crypto.scryptSync` (salt +
+  64-byte hash, `hashPassword()`/`verifyPassword()` in `server.js`);
+  `verifyPassword()` uses `crypto.timingSafeEqual()`. No bcrypt/argon2
+  dependency — stays within the express+cors-only convention.
+  `/login` returns the same generic error for wrong username, wrong password,
+  or an inactive account (no username-enumeration signal).
+- **Roles:** `admin`, `member`, and `kiosk` (`users.role`, `VALID_ROLES` in
+  `server.js` — do not confuse with the discipline `roles` array on a user,
+  `Planung`/`Projektleitung`/`Bauüberwachung` in `user_roles`, which is
+  unrelated to permissions). `kiosk` is the one role that IS fully
+  server-enforced rather than a UI gate (see "Wandtafel" below for why it
+  exists): `requireAuth` rejects it outright everywhere except the handful
+  of read-only routes the Wandtafel needs (`requireAuthOderKiosk`), and a
+  `kiosk` account can never carry a discipline role (enforced on both
+  `POST`/`PATCH /admin/users*`, in both directions — setting `role: 'kiosk'`
+  on an account with existing discipline roles is rejected exactly like
+  adding a discipline role to an existing `kiosk` account). Otherwise, only
+  the genuinely destructive/administrative actions are **server-enforced**
+  admin-only: week deletion (`/delete-week`), week unlock (`/unlock-week`),
+  DB import (`/import`), and the `/admin/users*` CRUD. `/users/:id/absences*`
+  stays open to any logged-in user (unchanged permission level from before).
+  The `Projekte` tab and the (now read-only) `Projektbeteiligte` tab only
+  require being logged in — any role; actually adding/editing/removing team
+  members happens exclusively via `admin-users.html` (admin-only). The
+  cross-department roster-add/remove UI in the Projektbeteiligte tab
+  (`js/people/people.js`) is only **rendered** for `currentUser.role ===
+  'admin'` — like the old client-only password modal, this is a UI-level
+  gate, not a server-enforced one: it writes into `currentWeek().people`
+  through the ordinary `save()` → `POST /save-week`, which only requires
+  `requireAuth` (any role), so it does not add a new hard permission
+  boundary.
+- **First-admin bootstrap:** `bootstrapInitialAdmin()` runs once at every
+  server start, guarded by `SELECT COUNT(*) FROM users` — if `users` is empty
+  (fresh install), it generates a random password
+  (`crypto.randomBytes(15).toString('base64url')`), creates an `admin` account
+  (username `admin`, `must_change_password=1`), and prints the plaintext
+  password to the console **and** writes it to
+  `sessions/INITIAL_ADMIN_PASSWORD.txt` (outside `public/`, so
+  `express.static` never serves it). There is no hardcoded password anywhere
+  in the code.
+- **`users.person_id`** is the bridge between login accounts and the
+  pre-existing, department-independent `personIdForName()`-based assignment
+  scheme (e.g. `plan_todo_assignees.person_id`) — set explicitly by an admin
+  (not auto-derived server-side), so an account and a project-roster entry can
+  exist independently of each other. A user with no matching `person_id` sees
+  an empty dashboard with a hint instead of an error (`renderDashboard()` in
+  `js/dashboard/dashboard.js`).
+- CryptoJS is gone; pdfmake (PDF export) is still loaded from
+  `cdnjs.cloudflare.com` in `App.html`, so PDF export needs internet access
+  and won't work offline. `admin-users.html` loads no CDN script.
 - User-provided status HTML is sanitized on render via a small whitelist
   (`sanitizeStatusHtml` in `js/board/board.js`) to mitigate XSS.
 
+### Ein Ort je Angabe
+
+Every piece of project data now has exactly ONE place where it is entered.
+Before, six of nine fields were editable in three different masks
+(Projektboard, Wochenbericht, Projektbereich) — nobody knew which one was
+authoritative, and two people could change the same field in different places.
+The split follows what kind of data it is:
+
+- **Laufende Erfassung → Wochenbericht only.** The session comment
+  (`p.status`), the progress per Leistungsphase (`p.lph`) and the assignment of
+  people (`p.assign`) are produced in the weekly meeting. They are editable
+  **only** in the Wochenbericht.
+- **Stammdaten → Projektbereich only.** Projektnummer, Bezeichnung,
+  Schlagwörter, Gruppe, amtierende Leistungsphase, Auftragsstatus, Honorar, the
+  beauftragte Leistungsphasen and the Aufwands-Gewichtung live in the
+  Projektbereich (`einstellungen` section, `js/plan/plan-settings.js` plus
+  `js/plan/plan-info.js` for Gruppe/amtierende LPH).
+- **Everywhere else: display plus a way there.** `renderBoardDrawer()` takes
+  `opts.nurAnsicht` (set by `BOARD_OPTS` in `js/board/board.js`): same card,
+  same values, same order — but no input fields, no clickable avatars, and a
+  `.drawer-verweis` underneath with the button "Im Wochenbericht bearbeiten →".
+  The Projektbereich does the same via `setzeBerichtVerweis()`
+  (`js/plan/plan-info.js`), filling `#planStatusVerweis`, `#planLphVerweis`
+  and `#planAssignVerweis`.
+- **The link is a real jump**, not a hint: `springZumWochenbericht(uid)`
+  (`js/plan/plan-info.js`, also used by `renderBerichtVerweis()` in
+  `board.js`) sets `berichtAuswahl` **before** `showTab('wochenbericht')` and
+  therefore lands on that very project. Without it the user would have to find
+  it again in a list of thirty. (`berichtAuswahl` is a global `let` binding
+  from `js/wochenbericht/wochenbericht.js` — classic scripts, no modules, so
+  assigning it from another file works.)
+- **Consequence:** `planStatusBlur()`, `setPlanLph()` and `setPlanAssign()` in
+  `js/plan/plan-info.js` are **gone** — they had no caller left. The status
+  editor's formatting toolbar (`formatStatus()` buttons) went with them in the
+  Projektbereich; the Wochenbericht keeps the full editor. `editLph()`,
+  `cycleAssign()` and `saveBoardComment()` in `js/board/board.js` are
+  untouched — the Wochenbericht's editing hangs off them.
+- **Honorar and beauftragte Leistungsphasen stay editable in TWO places** on
+  purpose (Projekteinstellungen and the "Terminplan aus Honorar" dialog, so the
+  dialog remains usable on its own); both write through the same functions in
+  `js/plan/plan-honorar.js` and re-render each other, so they cannot drift.
+- Changing the **Projektnummer** asks for confirmation (`setPlanProjNr()`):
+  uploaded files hang off `(department, project_nr)`, so a renumbered project
+  would lose them. Changing the **Bezeichnung** updates the plan header
+  (`#planTitle`), the sidebar entry (`syncPlanNavItem()`), the URL
+  (`updateRouteUrl('plan')`) and the list — `renderPlanPage()` would do all of
+  it, but it is module-local in `plan-state.js` and unreachable from
+  `plan-settings.js`.
+
+### Eine Projektliste (tab `board`, labelled "Projekte")
+
+The former `Projekte` tab is gone; `renderBoard()` is the single project list.
+It kept everything that concerns the LIST and gave up everything that concerns
+a single project's data:
+
+- Each group is a drop zone: `<div class="board-list projects-sortable"
+  data-group="…" ondragover ondrop>`, each row `draggable` with a
+  `.drag-handle`. The handlers stay in `js/projects/projects.js`
+  (`handleDragStart`/`handleDrop`/`handleDragEnd`/`reorderProjects`) — they
+  hold the ordering logic and are also used by `js/people/people.js`. Only
+  `handleDrop()` had to learn which selector to use: it picks
+  `.board-row:not([style*="opacity"])` when the drop zone contains board rows,
+  `.person-list-item` otherwise. Without that, every drop landed at the end of
+  the group.
+- All four groups from `GROUP_ORDER` are pre-seeded even when empty, so a group
+  emptied by dragging stays a drop target (a bug already fixed once in the old
+  Projekte tab).
+- `.board-row-actions` at the end of each row: "Öffnen" (Projektbereich) and
+  "Löschen" (`delProjectFromList()`), hidden until hover/focus so the list
+  stays calm. "+ Projekt" sits in the list's title row now (it was only in the
+  sidebar before); the sidebar entry stays and opens the same mask.
+- `js/projects/projects.js` no longer renders anything by default:
+  `renderProjects()` returns immediately unless `#projectsList` exists. Every
+  caller (`renderAll()`, `editProjectField()`, `auftrag.js`, `load.js`) can
+  stay as it is.
+- `TAB_SLUGS` (`js/globals.js`) lost `projects`, but `TAB_BY_SLUG['Projekte']`
+  is set to `'board'` and `VALID_TAB_SLUGS` (`server.js`) still accepts
+  `Projekte`, so forwarded links keep working instead of 404ing.
+
+### Assistent "Neues Projekt" (`js/projekt-wizard.js`)
+
+Sechs Schritte statt eines Formulars mit allen Feldern auf einmal. Der frühere
+Dialog `#newProjModal` ist entfallen, ebenso `openNewProjModal()`,
+`closeNewProjModal()`, `newProjStatusGewechselt()` und `saveNewProj()` in
+`js/load/load.js`.
+
+1. **Projekt** — Nummer, Bezeichnung, **Gewerke**, Gruppe, Schlagwörter
+2. **Auftrag** — Auftragsstatus, Honorar **oder** Projektgröße, beauftragte
+   Leistungsphasen
+3. **Stand** — amtierende Leistungsphase
+4. **Team** — Beteiligte je Rolle, auf die Gewerke des Projekts eingeschränkt
+5. **Terminplan** — aus dem Honorar errechnet
+6. **Prüfen** — Zusammenfassung, dann Anlegen
+
+**Warum überhaupt:** Honorar, Team und Schlagwörter mussten zuvor NACH dem
+Anlegen an drei weiteren Stellen nachgetragen werden — und wurden es meist
+nicht. Genau daher rühren die Projekte, die in der Auslastung als „nicht
+bewertbar" erscheinen. Umgekehrt ist die 27-Felder-Aufwandsmatrix aus dem
+Anlegen verschwunden: Die firmenweite Vorlage genügt, die Feinjustierung
+gehört in den Projektbereich (`openLpModal()` lebt dort weiter).
+
+**Jeder Schritt ist Pflicht.** `wizardFehlt(key)` liefert die fehlenden
+Angaben als Klartext; solange etwas fehlt, bleibt „Weiter" gesperrt und
+daneben steht, *was* fehlt — ein gesperrter Knopf ohne Begründung ist eine
+Sackgasse. Ein Assistent, der unvollständige Projekte durchlässt, löst das
+Problem nicht, das er lösen soll.
+
+**Gewerke** (`project_gewerke`, Tabelle nach dem Muster von
+`project_beauftragte_lph`; Werte wie `VALID_DEPARTMENTS`): Ein Projekt gehört
+zu einem oder mehreren Fachbereichen. Im Schritt „Team" stehen nur die
+Mitarbeiter daraus zur Auswahl — ein reines Elektro-Projekt soll nicht die
+ganze Belegschaft anbieten. Wer jemanden aus einem anderen Gewerk braucht,
+holt ihn über das Auswahlfeld „Mitarbeiter aus anderen Gewerken" ausdrücklich
+dazu; solche Personen tragen in der Auswahl einen gestrichelten Rand. Wird ein
+Gewerk wieder abgewählt, fallen seine Beteiligten aus dem Team — sonst stünde
+im Projekt jemand, der nach der eigenen Regel gar nicht auswählbar wäre.
+
+Das **Gewerk einer Person** kommt aus `users.department`; `loadGlobalPeople()`
+liefert es als Feld `gewerk` mit. Gewählt wird aber aus `week.people` und
+nicht aus `db.globalPeople`: Die Zuordnung landet in `project.assign` und wird
+vom Board über `currentWeek().people` aufgelöst — wer dort fehlt, erschiene
+nirgends.
+
+**Honorar oder Projektgröße, nie beides.** Das jeweils andere Feld wird
+gesperrt statt nur ignoriert (ein Feld, das man ausfüllen kann, ohne dass es
+wirkt, ist eine Falle) und beim Umschalten geleert. Die Projektgröße ist ein
+**Zahlenfeld**, kein Regler: Ein Schieber legt eine Feinabstufung nahe, die
+eine grobe Schätzung nicht hat. Neben ihr steht **kein Eurobetrag** — intern
+rechnet `projektBasisHonorar()` zwar über `referenzHonorar`, aber die Summe
+auszuweisen gäbe der Schätzung eine Genauigkeit, die sie nicht hat
+(`groesseText()` gibt deshalb nur noch die Zahl zurück).
+
+**Terminplan** (`wizardPlanZeilen()`): derselbe Rechenweg wie
+`berechneHonorarPlan()` — Phasenhonorar ÷ Stundensatz = Stunden, ÷
+(Arbeitsstunden pro Tag × Personen) = Dauer, Phasen hintereinander über
+`addWorkdays()` (kennt die gepflegten Feiertage). Erzeugt je beauftragter
+Phase eine Aufgabe in `project.plan.todos`.
+- **Aus der Projektgröße wird KEIN Terminplan gerechnet.** Sie ist eine
+  Schätzung, kein vereinbarter Betrag; daraus abgeleitete Termine sähen im
+  Gantt so verbindlich aus wie errechnete. Der Schritt zeigt das als
+  erklärten Hinweis, nicht als kommentarlos gesperrtes Feld.
+- Das **Team steht vor dem Terminplan**, weil die Dauer davon abhängt, wie
+  viele daran arbeiten. Die Teamgröße ist die Vorgabe für „gleichzeitig
+  daran" und überschreibbar. Ohne diesen Schritt ergab eine Phase über
+  180.000 € rechnerisch 172 Arbeitstage für eine Person, und der Plan lief
+  über Jahre.
+
+### Auftragsstatus — von der Anfrage zum Projekt
+
+`projects.auftragsstatus` (`anfrage|angebot|beauftragt|abgeschlossen`, default
+`beauftragt`, column added by `migrateAddProjectAuftragsstatus()`) makes the
+step into a project explicit. Everything lives in `public/js/auftrag.js`:
+
+- `auftragsstatusChip(p)` returns an **empty string** for `beauftragt` — the
+  normal case must not add noise to thirty rows. Shown in the project list
+  (`renderBoardRow()`), in the Wochenbericht agenda row and in its detail head.
+- `auftragsstatusSelectHtml(p)` is the mask, used by the Projekteinstellungen
+  (`#settingsAuftragsstatus`) and the "Neues Projekt" dialog.
+- Switching TO `beauftragt` does not write directly: `setAuftragsstatus()`
+  opens `#beauftragungModal`, because honorar and the beauftragte
+  Leistungsphasen belong to the commissioning. The dialog requires at least one
+  Leistungsphase, asks back when honorar is missing, offers to move the project
+  out of "In Anbahnung" (that group deliberately does not count towards
+  Auslastung) and can jump straight to the Terminplan.
+- In the "Neues Projekt" dialog the group follows the status
+  (`newProjStatusGewechselt()` in `js/load/load.js`): Anfrage/Angebot proposes
+  "In Anbahnung", back to Beauftragt proposes "Aktive Projekte". It is a
+  visible proposal in the select, so it can be overridden.
+- `POST /save-week` rejects an unknown status with 400 before writing anything;
+  `auftragsstatus` is in `IMPORT_OPTIONAL_COLS` so older backups still import,
+  and `projekte.csv` carries the column.
+
+### Projektbereich (tab `plan` in `App.html`)
+
+- Each project has its OWN area, not just a Gantt view. The area is split into
+  six sections switched by the `.plan-nav` bar (`showPlanSection()` in
+  `js/plan/plan-sections.js`); all six live in the DOM at once and are only
+  toggled via `.is-active`, so every render function keeps filling its elements
+  regardless of visibility (that is why the split needed no changes in
+  `plan-info.js`, `plan-gantt.js`, `plan-files.js`). The current section is
+  written to the URL fragment with `history.replaceState` (`…#aufgaben`) and
+  restored from it on load (`app.initPlanSections()`, called at the end of
+  `renderPlanPage()`); a `hashchange` listener follows external changes.
+  - **Dashboard** — KPI tiles (`renderPlanKpis()`), the session comment and the
+    LPH progress list (`renderPlanInfo()`), "Nächste Termine" and "Team"
+    (`renderPlanDashboard()`), plus three compact cards that jump to the
+    Ressourcen/Dateien section or open the Verlauf modal.
+  - **Terminplan** — the Gantt with its toolbar and, below it, the resource
+    load (`#resourceLoadContainer`, formerly a modal).
+  - **Aufgaben** — the same todos/milestones as a list (`renderPlanTasks()`,
+    `js/plan/plan-tasks.js`). No own data and no own dialogs: a row opens the
+    very same `openTodoModal()`/`openMilestoneModal()` as the Gantt, and the
+    indices match because the list keeps `plan.todos`/`plan.milestones` order.
+    The create buttons (`+ Aufgabe`, `+ Meilenstein`, `+ Vorlage`,
+    `+ Terminplan`) exist twice — in the Gantt toolbar and above the list, the
+    latter with an `…BtnList` id suffix; `renderPlanPage()` hides both sets on
+    locked weeks.
+    **A todo is only a Gantt row when it has BOTH a start and an end date.**
+    `plan.todos` is the one shared list either way — every todo always shows
+    up here in Aufgaben, with its assignees (`t.assignees`, "Zuständige"
+    chips in `openTodoModal()`, unrelated to whether it has a schedule) — but
+    `plan-build-gantt.js` (the `buildGanttHtml()` extension that inserts
+    TODO/milestone rows under the project row) only inserts a row for a todo
+    with `todo.start && todo.end`; a title-only todo (created via `+ Aufgabe`
+    or `+ TODO` with the date range left empty — nothing in `saveTodoEdit()`
+    requires dates, only the title) stays a pure checklist item that appears
+    solely here, never in the Gantt/Terminplan. The Aufgaben row for such a
+    todo shows "ohne Termin" in place of a date range
+    (`.plan-task-no-schedule`). Giving it a start/end later (editing the same
+    todo through either view) makes a Gantt row for it appear on the next
+    render — same object, no separate "convert to scheduled" action needed.
+    `reorderPlanRows()` (`js/plan/plan-drag.js`) accounts for this: its
+    DOM-row-count safety check and the reordering itself only ever touch
+    todos that have `start && end` (`scheduledIds`) — a title-only todo has
+    no drag handle in the Gantt to begin with and keeps its exact position in
+    `plan.todos` untouched by any Gantt row drag.
+  - **Leistung** — Leistungsstand & Abrechnung (`renderPlanLeistung()`,
+    `js/plan/plan-leistung.js`): the value actually earned, per beauftragte
+    Leistungsphase, as **Honorar × HOAI-Anteil der Phase × Fortschritt der
+    Phase**. The shares come from `GET /honorar-config` and are normalised
+    across the beauftragte phases only (same as `berechneHonorarPlan()`), so a
+    project commissioned for three phases still adds up to 100 %. Nothing is
+    entered here: honorar and the beauftragte phases come from
+    "Einstellungen", the progress from the Wochenbericht — this section only
+    computes. Three cases deliberately show a hint instead of a number: no
+    honorar, no beauftragte phase, no shares stored. **This was the missing
+    link** — the app knew the honorar and it knew the progress per phase, but
+    never put the two together, so nobody could see what a project had earned.
+    It is its own section rather than a Dashboard card because the breakdown
+    has one row per phase with five columns; as a card it would either be
+    cramped or appear twice.
+  - **Dateien** — upload/review/comments (`js/plan/plan-files.js`), formerly a
+    modal.
+  - **Protokolle** — Besprechungsprotokolle (`js/plan/plan-protokoll.js`), see
+    "### Protokolle" below for the data model and the "Fortschreiben"
+    mechanism.
+  - **Einstellungen** — project number/name (display only — the page is
+    addressed by them), Gruppe, amtierende Leistungsphase, Beteiligten-Matrix
+    (all still rendered by `plan-info.js`), plus Honorar and the **beauftragte
+    Leistungsphasen** (`renderPlanSettings()`, `js/plan/plan-settings.js`).
+- `p.honorar`/`p.beauftragteLP` can now be edited in TWO places: here and in
+  the "Terminplan aus Honorar" dialog (which keeps them so it stays usable on
+  its own). Both write through `setHonorarBetrag()`/`toggleBeauftragteLp()` in
+  `js/plan/plan-honorar.js` and re-render the other mask afterwards, so they
+  cannot drift apart. Persistence is the ordinary `savePlan()` → `POST
+  /save-week` path (columns `projects.honorar` / table
+  `project_beauftragte_lph`) — no dedicated endpoint.
+- `renderPlanGantt()` is the central refresh hook: it ends by calling
+  `renderPlanTasks()` and `renderPlanDashboard()`, so every existing mutation
+  path (drag, modals, auto-schedule, templates, honorar plan) updates all three
+  views without touching those modules.
+- The four former modals (`#planInfoModal`, `#planResourceModal`,
+  `#planFilesModal`) are gone; only `#planHistoryModal` (Verlauf) remains.
+  `openResourceModal()`/`openFilesPanel()` kept their names but now just switch
+  sections. On a load error (missing params, unknown week/project, network)
+  `app.hidePlanNav()` hides the section bar, since every section would be empty.
+  Because the area now shows one project after another within the same
+  document, `app.showPlanNav()` exists as its counterpart (a fresh page load
+  used to reset it for free).
+- **Entry point (two steps, deliberately split).** `setPlanTarget(weekLabel,
+  projNr, projName)` only *stores* the target; `openPlanView()` resolves it
+  against the already-loaded `db.weeks` and renders. `showTab('plan')` does
+  the second step itself, AFTER the area is visible — the Gantt measures its
+  container width, which is 0 in a hidden element. `openProjectPlan()` and
+  the deep-link path in `initUiState()` therefore only call `setPlanTarget()`.
+  Addressing is by week label + project nr/name (never `project.id`, which
+  `cloneWeek()` re-assigns). On the very first deep-link render `db.weeks` is
+  still empty; that is not an error but a "wird geladen…" state, and `load()`
+  calls `showTab(currentTab)` again once the data is there.
+- **There is no separate data load and no separate save path any more.** The
+  old page fetched `/load-all` itself and wrote with its own
+  `sendWeekToServer()`, because `store.js` wasn't loaded there. In one
+  document that would be two writers on the same week sending the same
+  revision base — the slower one getting a bogus 409. `savePlan()` is now
+  just `markWeekDirty(app.week.label)` + `scheduleSessionSync()`, i.e. the
+  ordinary debounced path with its in-flight guard, retry banner, conflict
+  handling and 401 login overlay. It passes the label explicitly rather than
+  calling `save()`, since `save()` marks the *currently selected* week and a
+  deep link may have pointed the Projektbereich at a different one.
+- `updateRouteUrl('plan')` (`js/ui.js`) is the one tab whose URL is not a
+  fixed slug: it builds `/Projektplan/<Name>?weekLabel=…&projNr=…` from
+  `window.PlanApp` and **keeps `window.location.hash`**, so a link to a
+  specific section survives the switch. `applyUrlRoute()` parses the same
+  shape back into `{tab:'plan', weekLabel, projNr, projName}`.
+- The `hashchange` listener in `plan-sections.js` and the `resize` listener in
+  `plan-gantt.js` both bail out unless `currentTab === 'plan'` — they now run
+  while completely different tabs are on screen.
+
+### File uploads (`project_files` / review / comments)
+
+- Files are linked to a project via **`(department, project_nr)`**, NOT
+  `(department, week_label, project_id)` — `project_id` (`p.id`) is
+  regenerated on every `cloneWeek()` (`public/js/weeks.js`), while `p.nr`
+  stays stable across the project's whole lifecycle. A project without a
+  `nr` cannot receive files: the upload button is disabled client-side
+  (`openFilesModal()` in `js/plan/plan-files.js`) and the server rejects with
+  400 regardless.
+- **Storage:** `sessions/uploads/<department>/<uuid>.<ext>`
+  (`uploadDirFor()`/`extractFileExtension()` in `server.js`). The on-disk
+  filename is always a fresh `crypto.randomUUID()` plus an extension taken
+  from a whitelist regex (`/\.([a-zA-Z0-9]{1,8})$/`) applied to the
+  client-supplied filename — no client-controlled string (`original_filename`,
+  `project_nr`, `project_name`, `filename` query param) is ever interpolated
+  into a filesystem path. `original_filename` is stored purely for display and
+  is only ever used as the second argument to `res.download()` (the
+  `Content-Disposition` filename), never as a path segment.
+- **Multi-reviewer workflow:** an upload lists one or more reviewer user IDs
+  (query param `reviewers=id1,id2`, deduplicated, filtered to active users,
+  uploader removed — no self-review, at least one must remain or the upload is
+  rejected with 400). Each reviewer gets a `project_file_reviewers` row with
+  `decision='pending'`. `POST /project-files/:id/review` recomputes the
+  file's overall `status` after every decision: **any single `rejected` decision
+  blocks the file immediately** (terminal); only once **all** reviewers have
+  `approved` does the file become `approved` (also terminal). Once terminal, no
+  further review decisions are accepted (409).
+- Deletion (`DELETE /project-files/:id`) is allowed for the uploader while
+  `status='pending'`, or for an admin at any time; it deletes the
+  `project_file_comments` and `project_file_reviewers` rows explicitly (no FK
+  cascade — see Persistence section) before the `project_files` row, then
+  best-effort removes the physical file.
+- `import` never touches these tables (see `/import` note above) — a DB
+  restore neither includes nor overwrites uploaded files or their
+  review/comment state.
+
+### Protokolle (`project_protokolle` / `protokoll_teilnehmer` / `protokoll_punkte`)
+
+Besprechungsprotokolle je Projekt (classic Baubesprechungsprotokoll: Bauherr,
+ausführende Firmen and the office's own team meet, discuss numbered points,
+and unresolved points carry over meeting to meeting) — the seventh section of
+the Projektbereich (`js/plan/plan-protokoll.js`), a persisted document type
+that did not exist before this feature. The "Protokoll" inside the
+Wochenbericht (`openBerichtProtokoll()`) is unrelated: that one is a
+throwaway, client-only text export of what changed in a session, never
+stored and not tied to a single project — this is a genuinely different,
+stored, per-project document.
+
+**Scoped by `project_nr`, exactly like `project_files`, NOT by
+`week_label`/`project_id`.** `project_id` is regenerated on every automatic
+session rollover (`ensureCurrentWeekRollover()`, see above), but a Protokoll
+must survive across sessions. `week_label` is still stored on
+`project_protokolle` — purely informational (which session was current when
+the Protokoll was created), never used to look one up. A project without a
+`nr` (a Planung-Sandbox plan) can't have Protokolle — the section is hidden
+there, same reasoning and same mechanism as Dateien (see "Planung —
+projektunabhängige Terminplan-Sandbox" above).
+
+**Save pattern: one PUT replaces the whole editable content**, not a REST
+route per field. `PUT /project-protokolle/:id` deletes and re-inserts every
+`protokoll_teilnehmer`/`protokoll_punkte` row of that Protokoll in one
+transaction (same "delete then re-insert" shape as
+`deleteWeekData()`/`serializeWeek()` for a whole week) — closer in spirit to
+how `plan.todos` is saved as one object via `savePlan()` than to
+`project_files`' many small endpoints, because Teilnehmer and Punkte are
+authored together in one sitting. The detail view in
+`js/plan/plan-protokoll.js` is accordingly **inline in the Protokolle
+section, not a modal** — too much content for a dialog — with an explicit
+"Speichern" button (no autosave) and simple text/checkbox fields mutating an
+in-memory copy directly (no re-render per keystroke, to avoid losing input
+focus); only structural changes (add/remove a row, change a point's group)
+re-render.
+
+**"Fortschreiben" — the core mechanism, entirely server-side
+(`POST /project-protokolle`, `server.js`):** creating a new Protokoll for a
+project **copies** every `erledigt=0` point of that project's most recently
+created Protokoll into the new one — fresh `id`, same `stamm_id` and
+`nummer`, `neu=0`. `stamm_id` is what makes a point "the same point" across
+Protokolle; it is never exposed to or trusted from the client. A point newly
+added within a Protokoll (no existing `id` in the client's `PUT` payload)
+gets a fresh `stamm_id` and `neu=1` — which drives the yellow highlight
+(`.protokoll-punkt.is-neu`, own CSS tokens `--protokoll-neu-bg`/
+`--protokoll-neu-border` in `styles.css`, deliberately NOT `--band-neu`,
+which already means something else — "neu kommentiertes Projekt", blue — in
+the Wochenbericht). Marking a point `erledigt` in one Protokoll does not
+retroactively change it in earlier, already-created Protokolle (each
+Protokoll's own copy is an immutable snapshot, like a distributed paper
+protocol); it simply isn't copied into the *next* one. The very first
+Protokoll of a project has nothing to copy from, so every one of its points
+is `neu=1` by definition.
+
+**`nummer` is computed, never edited — entirely decoupled from the
+Fortschreiben/`neu` logic.** First built as a free-text field the user typed
+by hand; changed on Erik's follow-up request to be fully automatic —
+`berechneProtokollNummern(punkte)` (`js/plan/plan-protokoll.js`, exposed on
+`window` so `exportProtokollPDF()` in `js/pdf.js` can call the identical
+function — same cross-file pattern as `classifyProjectChange()` in
+`wochenbericht.js`, which `pdf.js` also calls directly) derives every point's
+displayed number purely from its **current** `gruppe` and position: a group
+gets a top-level number in the order it first appears among the points, and
+each point inside it gets "`<Gruppennummer>.<Position>`" (e.g. "1.1", "1.2",
+"1.3" for the first group's three points, "2.1" for the second group's
+first); a point with no group is just a plain top-level number on its own
+("1", "2", "3" …). **Groups and ungrouped points share ONE counter for that
+top-level number**, not two separate ones — on Erik's explicit follow-up
+("keine Nummer doppelt… wenn die 1 schon in Ohne Gruppe gibt darf sie nicht
+nochmal in ELT oder HLS auftauchen"): whichever comes first in the points'
+order — an ungrouped point, or the first point of a not-yet-seen group —
+claims the next number, so a plain "1" (an ungrouped point) and a group
+numbered "1" (whose points would read "1.1", "1.2"…) can never coexist in
+the same Protokoll; every top-level number is unique across the whole
+document, standalone points and group prefixes alike. **Never trusts the stored
+`protokoll_punkte.nummer` column** — recomputed fresh on every render (and
+again by `exportProtokollPDF()` from its own freshly-fetched copy), so
+screen and PDF can never disagree and a point's number always reflects
+reality even if it moved groups or another point was added/removed/reordered
+around it. The column still exists and the client fills it with the current
+computed value right before every `PUT` purely for the sake of anyone
+reading the row directly (e.g. via the API) — it is never read back as a
+source of truth. Renumbering therefore never affects whether a point is "the
+same point" across Protokolle (that's `stamm_id`) or whether it counts as
+new (`neu`, set once, only at creation) — moving a point to a different
+group, or another point being deleted and shifting everyone's numbers, has
+zero effect on Fortschreiben/`neu`. `gruppe` itself is a genuinely free-text
+field with no backing table and no fixed list — unlike
+`project_gewerke`/`VALID_DEPARTMENTS`, which are a closed enumeration, a
+Protokoll group is created simply by typing it on a point; a `<datalist>`
+suggests names already used within the currently open Protokoll to curb
+accidental near-duplicates ("ELT" vs "Elt"), fed from already-loaded data —
+no extra server round-trip. Points are displayed **clustered into sections
+by `gruppe`**, in the same first-appearance order that drives the
+Gruppennummer, with an "Ohne Gruppe" section always first when any ungrouped
+points exist. Changing a point's group moves it to the matching section (and
+recomputes every affected number) on the next render (`onchange`, not
+`oninput`, so re-clustering doesn't fire mid-keystroke and steal focus from
+other fields).
+
+**Reordering after the fact** (Erik's follow-up request) is two separate,
+matching controls, both plain ↑/↓ buttons re-rendering just the Punkte-Block
+— no drag-and-drop, since a point's *visual* section is already fixed by its
+`gruppe` (dragging it across group sections wouldn't make sense without also
+changing that field, which the Gruppe input already does): `verschiebePunkt(
+idx, richtung)` swaps a point with its neighbour **within the same group**
+(or within "Ohne Gruppe") only — disabled at the top/bottom of that group's
+own list; `verschiebeGruppe(gruppe, richtung)` moves an entire group's points
+as one block relative to the other groups (rebuilds `currentProtokoll.punkte`
+as "Ohne Gruppe" points first, unchanged, then each group's points
+concatenated in the new group order) — this is what actually changes which
+group gets Gruppennummer "1" vs. "2". "Ohne Gruppe" itself is not
+reorderable relative to the groups (it stays the fixed first section, same
+reasoning as its render order above); both buttons are simply absent/disabled
+at a list's boundary rather than wrapping around.
+
+**Teilnehmer are free text** (`protokoll_teilnehmer`: name + optional
+Firma/Rolle, binary `anwesend` — deliberately the same "no third state" rule
+as `week.attendance`), independent of user accounts entirely — construction
+meetings routinely include externals (Bauherr, ausführende Firmen) who have
+no login here and never should. Two separate, non-overlapping paths fill it:
+creating a new Protokoll by hand (`neuesProtokoll()` in `plan-protokoll.js`)
+pre-fills the Teilnehmer list from the names of the project's *most recently
+created* Protokoll (with `anwesend` reset to `true` — presence must be
+reconfirmed every meeting, never assumed), falling back to
+`projectAssignees(app.project, app.week)` (internal team only, no Firma) if
+no earlier Protokoll exists, or an empty list otherwise — this prefill is
+pure client-side convenience before the `POST`. Importing a document
+(`POST /project-protokolle/import`) instead sources Teilnehmer from the
+document itself via the KI-gestützte Erkennung (see below) — the two paths
+are never combined/merged: an import shows only what the uploaded document
+actually contains, never the previous Protokoll's roster, so the user is
+never left guessing which source a listed name came from. Either way, the
+server only ever persists whatever Teilnehmer array `legeProtokollAn()` is
+given — it does no inference of its own.
+
+**No lock/finalize concept in this first version** — unlike a real paper
+Protokoll (which is fixed once distributed), every Protokoll here stays
+editable indefinitely by any logged-in user, the same permission level as
+editing a todo or milestone (`DELETE /project-protokolle/:id` is likewise
+`requireAuth`, not admin-only — deleting a Protokoll is ordinary project
+content, not an administrative action). A future "abgeschlossen" status
+would be a natural, small follow-up, not part of this feature.
+
+**PDF export** (`exportProtokollPDF(protokollId)`, `js/pdf.js`) is the third
+PDF export the app has (alongside `exportWochenberichtPDF()`/
+`exportSandboxPlanPDF()`) — A4 portrait like the Wochenbericht (same
+`PDF_WB_PAGE_W`/`PDF_WB_MARGIN_X`/`pdfWbGridLayout()`), reusing `PDF_STYLES`/
+`loadLogoPng()`/`PDF_ASSIGN_MAIN`. It deliberately re-fetches the Protokoll
+fresh from the server rather than reading `plan-protokoll.js`'s private
+in-memory state, so the exported PDF always reflects the last **saved**
+state, never unsaved edits sitting in an open form. Like the screen, the
+Punktetabelle is split into sections by `gruppe`, and `neu=1` rows get a
+pale-yellow `fillColor` — a literal hex value, not the CSS custom property,
+since a PDF does not react to the viewer's light/dark theme.
+
+`project_protokolle`/`protokoll_teilnehmer`/`protokoll_punkte` are part of
+`IMPORT_TABLES` (`server.js`) — a Protokoll created by hand has no on-disk
+component and lives entirely in the database (same reasoning as
+`plan_todos`); an **imported** one additionally references a file on disk
+(see next paragraph), which — like `project_files` — a DB restore neither
+includes nor overwrites.
+
+**Import: turning an external protocol into one of these** (`POST
+/project-protokolle/import`, `server.js`) — a second way to create a
+Protokoll, alongside the "+ Neues Protokoll" button, for the common case
+where the Bauherr or an ausführende Firma writes and circulates their own
+protocol instead of the office's own. Rather than just filing the document,
+the route extracts its text and turns it into ordinary Protokoll-Punkte, so
+the result is immediately usable through every feature described above
+(Fortschreiben, Gruppen, Verschieben, PDF-Export) instead of being a second,
+parallel kind of content.
+
+- **Two new dependencies**, the first this project has ever needed beyond
+  express/cors: `pdfjs-dist` (PDF → text, via its `legacy/build/pdf.mjs`
+  Node-compatible entry point, loaded with a dynamic `import()` from
+  `server.js`'s otherwise-CommonJS code) and `mammoth` (`.docx` → text). Both
+  run entirely locally — no network call, no API key, no per-use cost.
+  (A third, `undici`, followed later — not for text extraction but to fix a
+  local-server timeout bug in the KI recognition itself; see
+  `LOKAL_DISPATCHER` further below.)
+  `extrahierePdfText(buf)` (`server.js`) opens the document and walks every
+  page's `getTextContent()` items, inserting a newline whenever an item's Y
+  coordinate (`item.transform[5]`) changes — the same reconstruction a naive
+  `.join(' ')` would lose, and `erkennePunkteAusText()` needs real line
+  breaks, since a Punkt-Marker must sit at a line's start.
+  **`@napi-rs/canvas`** (only for page-to-image rendering, never used here)
+  is merely an `optionalDependency` of `pdfjs-dist`, not a hard one — the
+  project's `.npmrc` (`omit=optional`) keeps `npm install` from ever
+  fetching it, so no native addon ships regardless of platform.
+  **First choice was `pdf-parse@1.x`, abandoned after it failed under
+  real testing**: pinned initially to dodge `pdf-parse@2.x`'s hard
+  dependency on `pdfjs-dist` + `@napi-rs/canvas`, but `pdf-parse@1.1.4`
+  bundles a `pdfjs` build frozen at 2017 (`v1.10.100`) that throws
+  `UnknownErrorException: bad XRef entry` on **any** PDF, valid or not, the
+  moment Node's own `http` module has been loaded anywhere in the process —
+  reproducible with nothing more than `require('http')` before the parse
+  call, confirmed unrelated to the PDF's bytes (identical MD5 in and out) or
+  their transmission (curl vs. direct Node `http.request` vs. a plain local
+  `fs.readFileSync` in the same process — only the last one, with `http`
+  never loaded, succeeded). Since `express` itself transitively loads
+  `http`, this made `pdf-parse` fail on *every* request through the actual
+  server while appearing to work fine in an isolated throwaway script —
+  exactly the gap a smoke test that only calls the parser directly would
+  miss. Switching to `pdfjs-dist` directly (current, actively maintained,
+  zero hard dependencies) was unaffected by the same `require('http')`
+  repro. Found and fixed before this reached Erik, by testing the actual
+  route end-to-end (script → curl → server) rather than trusting a
+  standalone unit-style check of the parsing function alone.
+- **`erkennePunkteAusText(text)`** (`server.js`) is the heuristic, plain
+  regex/string-processing, no AI: it looks for line-starting numbering
+  markers ("1.1", "TOP 3", "Punkt 2" …, `PROTOKOLL_PUNKT_MARKER`), and for
+  each match treats the rest of the line as `thema` and everything up to the
+  next match as `text`; within that text, labeled fields ("Zuständig:",
+  "Termin:" …, `PROTOKOLL_LABEL_MUSTER`) are pulled out if present, and the
+  words "erledigt"/"geschlossen" set `erledigt=true`. **`gruppe` is
+  deliberately never guessed** — external documents group too
+  inconsistently (by Gewerk, by chapter, not at all) to infer reliably, so
+  every recognized point lands in "Ohne Gruppe" for the user to sort by
+  hand. If no numbering pattern matches anywhere in the whole document, a
+  fallback kicks in: every non-empty paragraph becomes its own point with no
+  further parsing. The function is pure (no I/O), independent of whether the
+  text came from a PDF or a Word file.
+- **KI-gestützte Erkennung (ChatGPT/Claude) as the primary path, with
+  `erkennePunkteAusText()` above as the automatic fallback** — on Erik's
+  explicit follow-up request, after the heuristic-only version above had
+  already shipped. The import dialog offers a `<select>` ("ChatGPT"/
+  "Claude", `#protokollImportErkennung` in `App.html`, built at dialog-open
+  time from `GET /my-ai-settings` so an option can carry a live "(kein
+  Schlüssel hinterlegt)" hint); the chosen provider is sent as
+  `?erkennung=chatgpt|claude` to `POST /project-protokolle/import`.
+  Deliberately **not** a third "Textmuster" menu entry — that path is a
+  safety net, never a conscious choice, exactly mirroring how a
+  missing/failing key behaves. `erkennePunkteMitKI(text, userId, provider)`
+  (`server.js`, right next to `erkennePunkteAusText()`) reads that ACCOUNT's
+  own key via `readUserAiKey(userId, provider)`; on **any** failure — no key
+  stored, network error, non-2xx response, a timeout (`AbortController`,
+  `KI_TIMEOUT_MS_CLOUD`/`KI_TIMEOUT_MS_LOKAL`), or a response that doesn't
+  match the expected shape —
+  the route catches it and calls `erkennePunkteAusText(text)` instead, so
+  the import always succeeds, even with no internet access at all. The
+  response carries `erkennungsart` (`'chatgpt'|'claude'|'textmuster'`) and,
+  only on a fallback, `erkennungshinweis` (the failure reason); the client
+  surfaces that via the existing `app.showToast()` (`plan-state.js`) rather
+  than silently pretending the AI path was used. **Unlike the heuristic,
+  the KI path can also attempt `gruppe` and Teilnehmer recognition** (added
+  on Erik's follow-up request, after both had shipped empty/absent from
+  every import) — a language model can use context the heuristic's plain
+  regex cannot: it recognises an actual section heading ("Elektro:", "TOP
+  HLS") and a genuine Teilnehmer-/Anwesenheitsliste (usually at the
+  document's start/end), things `erkennePunkteAusText()` deliberately never
+  attempts (previous bullet).
+  **`KI_SYSTEM_PROMPT` stayed deliberately short after it turned out to be
+  extremely sensitive to added instructions** — found when Erik reported
+  that a real import ("kopiert die Texte nicht mit, erstellt nur die
+  Überschriften") produced almost no usable point text at all, diagnosed
+  against his actual, real-world sample document (a professional
+  PromanX/Phenix "Besprechungsbericht" export) rather than a synthetic
+  toy text. That document turned out to be multi-level numbered — a
+  top-level chapter ("01"), a sub-chapter ("01.0"), and only the deepest
+  level ("01.0 01.03") carrying real descriptive text — and repeated,
+  dated revision paragraphs under the same point across several past
+  meetings. Direct, repeatable testing against Erik's local LM Studio
+  (`temperature:0`, so not sampling noise) showed the SAME request, with
+  only small prompt wording changes, swinging between 0, 1, 10, and 11
+  recognised points, and between fully-populated and completely EMPTY
+  `text` fields for every point — a longer, more explicit prompt (covering
+  the multi-level numbering, an anti-hallucination rule for `gruppe`, an
+  explicit Teilnehmer section, a rule for merging dated revision
+  paragraphs) reliably performed WORSE than a much shorter one covering
+  only the essentials, and even appending one extra, individually
+  reasonable sentence to an already-working prompt was enough to regress
+  it back to near-total failure. The worst single cause found: a leading,
+  general "erfinde nichts, lass im Zweifel leer" instruction appeared to
+  make the model default to leaving `text` itself empty out of the same
+  caution — the opposite of Erik's actual complaint. `KI_SYSTEM_PROMPT`'s
+  final, shipped wording is therefore intentionally minimal (no explicit
+  Teilnehmer instructions, no revision-merging rule) and was kept VERBATIM
+  from the one specific phrasing that was empirically confirmed to work
+  (same token counts/results across repeated runs at `temperature:0`) —
+  not polished for house style, since even small rewordings had already
+  proven capable of silently breaking it again. At the time this was a
+  real, but partial, fix: it recovered most point text where the previous
+  prompt recovered almost none, but did not reliably suppress a bare
+  chapter/sub-chapter heading from occasionally still becoming its own
+  empty point, and revision continuations of an earlier point could still
+  surface as separate, oddly-numbered entries.
+  **A follow-up round (Erik: multiple distinct points under one heading
+  should each come through as their own point, AND the existing paragraphs
+  under a point should be carried over) added exactly ONE further sentence**
+  and, against the same real-document stability test, did NOT regress —
+  "Stehen unter einer Überschrift mehrere eigene Punkte, gib jeden einzeln
+  aus. Folgen auf einen Punkt weitere Absätze ohne neue eigene Nummer,
+  gehören sie zu diesem Punkt dazu." Confirmed against the document's own
+  worst case (`01.0 01.06`, three dated revision paragraphs spanning three
+  past meetings): previously these surfaced as orphaned, theme-less
+  fragments; with the new sentence they came back as ONE point carrying all
+  three paragraphs concatenated (2144 characters), and the earlier
+  multi-point case (`01.0 01.01`/`01.0 01.03`/`01.0 01.04` all under the
+  same `01.0 Organisation` heading) stayed correctly split into separate
+  points. So the earlier "not something further prompt tuning could fix"
+  conclusion was an overstatement from stopping after ONE failed attempt,
+  not a hard ceiling — the real lesson is that EVERY wording change here
+  must be tested against the real document at `temperature:0` individually
+  before shipping, since nothing about this model's reaction to a given
+  sentence can be predicted from how reasonable the sentence reads.
+  **A second, independent failure mode turned up while testing the above**:
+  against a test excerpt that was artificially cut to exclude the
+  document's own real Teilnehmer-/Verteiler table, the model — still obliged
+  by the schema to produce a `teilnehmer` array, with nothing genuine to put
+  in it — span into a token-repetition loop (the same short name fragment
+  repeated well over a thousand times) until `max_tokens` cut the response
+  off mid-string, yielding invalid, unparseable JSON that discarded the
+  otherwise-correct `punkte` result too. Re-run with the document's actual
+  opening Teilnehmer table included, the loop did not recur, and the request
+  finished in a tenth of the time (73s vs. 700+s) — strong evidence the
+  trigger was the absence of real participant data for that one field, not
+  the new point-splitting instruction, and not something every real import
+  will hit (a real Besprechungsbericht always carries its own participant
+  table). `frequency_penalty`/`presence_penalty` (`erkennePunkteMitChatGPT()`
+  only — Anthropic's Messages API has no equivalent parameter) were added
+  as a defensive measure regardless, since a repetition loop is a known,
+  generic small-model failure mode worth guarding against independent of
+  this one trigger being understood.
+  **A third round (Erik: the KI should also judge whether a point is open,
+  done, or purely informational) replaced the point's boolean `erledigt`
+  output with a tri-state `status` — matching the app's own `offen`/
+  `erledigt`/`info` status already added for manual editing (see the
+  `protokoll_punkte.status` bullet above) — and taught the model to prefer a
+  literal in-document marker over its own judgement: the real sample
+  document, it turns out, prints the word "Info" directly under several
+  points as their own status field, which `erkennePunkteMitChatGPT()`'s new
+  instruction now explicitly looks for first. Confirmed against the same
+  real document: status came back correctly split across all three values —
+  several points correctly `info` (matching their literal "Info" marker),
+  others correctly `offen` or `erledigt` from the narrative content when no
+  literal marker applied. Normalisation lives in `normalisierePunktAusKi()`
+  (validates against `VALID_PROTOKOLL_PUNKT_STATUS`, falls back to `offen`)
+  and in `legeProtokollAn()`'s `zusatzPunkte` loop, which accepts EITHER a
+  valid `status` string (the KI path) OR falls back to deriving one from the
+  older boolean `erledigt` (the Textmuster heuristic, `erkennePunkteAusText()`,
+  was deliberately left alone — it has no way to judge "informational vs.
+  actionable", only regex pattern matches for "erledigt"/"geschlossen").
+  **This change cost back some of the previous round's paragraph-merging
+  quality** — the same real-document test that previously returned a point
+  like `01.0 01.06` fully merged (2144 characters, three dated revisions in
+  one `text`) now split it again into two or three same-themed entries once
+  `status` entered the picture, even after adding one more connecting
+  sentence ("bleibt es EIN Punkt mit dem Status des letzten Absatzes") that
+  measurably helped (11 fragments down to 9) without fully fixing it. This
+  is accepted rather than chased further: unlike the earlier regressions,
+  nothing here comes back empty, orphaned, or theme-less any more — every
+  fragment still carries its own real thema, text, and now-correct status,
+  it is simply split one topic too finely in places. The status-rule and the
+  merge-rule competing for the same limited headroom is, like the two
+  previous rounds, a model-capability ceiling rather than a wording problem
+  left unsolved — the same point about
+  a stronger model having more room applies here too.
+  A more capable model — the real Cloud `gpt-4o-mini`, or a
+  larger local model — has more room for further instructions than this
+  one could handle; that remains a model-capability question, not a prompt one.
+  `temperature:0` was added to both providers' requests for the same
+  reason the instability was diagnosable in the first place: without it,
+  identical requests returned different results from run to run, making
+  it impossible to tell a prompt regression from ordinary sampling noise.
+  `max_tokens` was also added to both (16000 for ChatGPT, 8192 for
+  Claude — previously unset for ChatGPT, too low at 4096 for Claude):
+  a long Besprechungsbericht with many points needs more completion budget
+  than either default/prior value guaranteed, and a response cut short by
+  a token limit would look identical to one where the model simply decided
+  to stop — a second, independent way the old behaviour could under-report
+  points regardless of prompt wording.
+  - **Both providers run over Node's built-in global `fetch()`** — no new
+    npm dependency, unlike the PDF/Word text extraction above, which
+    genuinely needed libraries. `erkennePunkteMitChatGPT(text, apiKey,
+    apiUrl)` uses the Chat Completions API (`gpt-4o-mini`) with Structured
+    Outputs (`response_format: json_schema`, strict mode) to force the exact
+    point shape; `erkennePunkteMitClaude(text, apiKey, apiUrl)` uses the
+    Messages API (`claude-haiku-4-5-20251001`) with forced tool-use
+    (`tool_choice: {type:'tool', …}`) as the equivalent structured-output
+    mechanism — Claude has no separate JSON-schema response mode. Both
+    normalise each point through the same `normalisierePunktAusKi()` into the
+    same `{nummer, gruppe, thema, text, zustaendig, termin, erledigt}` shape
+    `erkennePunkteAusText()` already produces (here `gruppe` is a real
+    pass-through, not hardcoded empty — see above), so `legeProtokollAn()`
+    and everything downstream needs no branching on where a point came from.
+    Each recognizer additionally returns a sibling `teilnehmer` array
+    (normalised through `normalisiereTeilnehmerAusKi()` into
+    `{name, firma, anwesend}`) — both functions' return value changed from a
+    plain points array to `{punkte, teilnehmer}` for this; `erkennePunkteMitKI()`
+    passes that object straight through, and the `/project-protokolle/import`
+    route destructures it into its own `zusatzPunkte`/`teilnehmerAusDokument`
+    locals, passing the latter to `legeProtokollAn()` instead of the
+    hardcoded `[]` it started with. On the Textmuster-Fallback path
+    `teilnehmerAusDokument` stays `[]`, same as before — the heuristic still
+    never attempts Teilnehmer recognition.
+    Text sent to either API is capped at `KI_MAX_TEXT_LAENGE` (40,000
+    characters) — bounds cost/latency on a pathologically large upload,
+    comfortably more than any real Besprechungsprotokoll needs. An `apiUrl`
+    argument overrides `KI_DEFAULT_URL[provider]` when the account has one
+    configured (see next bullet) — e.g. a locally running, OpenAI-compatible
+    server (LM Studio, Ollama) instead of the public cloud API, so the
+    feature can be tried with a free local model, or a company proxy/
+    self-hosted gateway.
+  - **Every account holds its OWN key (and optional URL) — not a firmenweit
+    setting.** First built admin-managed/firmenweit, changed on Erik's
+    explicit follow-up ("jeder user soll für sich seinen schlüssel
+    hinterlegen können und die url angeben können"): a new, small
+    **`user_ai_keys`** table (`user_id, provider` primary key, `api_key`,
+    `api_url`, `FOREIGN KEY … ON DELETE CASCADE` — same User-Kind-Tabelle
+    pattern as `user_roles`/`user_absences`) replaces the two rows that used
+    to live in the firmenweit `app_settings` singleton store.
+    `readUserAiKey(userId, provider)`/`writeUserAiKey(userId, provider,
+    patch)` (`server.js`) are the read/write path. `GET`/`PUT
+    /my-ai-settings` (scoped to `req.user.id`, never a client-supplied id —
+    same pattern as `POST /change-email`) manage them: `GET` returns, per
+    provider, only `{configured, apiUrl}` — **never the key itself**, the
+    same "write-only, never read back" shape as a password, while `apiUrl`
+    is not secret and comes back so the form can be pre-filled; `PUT` sets
+    or (given an explicit empty string) clears a key, and separately
+    validates/sets or clears an `apiUrl` via `istGueltigeAiUrl()` (400 if
+    invalid), leaving an omitted sub-field untouched. The UI lives
+    under **Einstellungen → Mein Konto** (`settings.js`, card
+    `#settingsAiCard`) — not in Admin, since it is now personal account
+    data like the e-mail address and password right above it in the same
+    card list, not an administrative setting. No admin role is required or
+    checked anywhere in this path.
+  - **The card shows a "Cloud"/"Eigener Server" toggle (`.ai-mode-toggle`,
+    `setAiMode()` in `settings.js`) instead of the collapsed "API-URL" link
+    the first design used.** Redesigned after real use: connecting a local
+    server (LM Studio) turned out to be the first thing Erik tried, not an
+    edge case, so hiding the URL field behind a small disclosure undersold
+    it — the toggle makes "Cloud" vs. "Eigener Server" a visible choice,
+    and the URL field's placeholder names a concrete example
+    (`http://localhost:1234 für LM Studio`) instead of an abstract
+    explanation. `renderSettingsAiKeys()` opens "Eigener Server"
+    automatically whenever a saved `apiUrl` is non-empty, so a configured
+    override is never hidden on page load.
+  - **`POST /my-ai-settings/test` ("Neu verbinden") actually exercises the
+    saved connection** — the card previously only showed whether a key was
+    *stored* (`configured`), never whether it *worked*; diagnosing Erik's
+    LM Studio setup this week (wrong path, too-short timeout, a reasoning
+    model burning almost all its tokens on invisible "thinking") had to
+    happen entirely through real import attempts because nothing surfaced
+    a connection problem on its own. The route reuses
+    `erkennePunkteMitKI()` unchanged, scoped to `req.user.id`, with a short
+    dummy text — the exact same code path an import uses, so a successful
+    test means an import would succeed too (timeout choice, the local
+    `reasoning_effort` handling, and URL normalisation all apply
+    identically). Returns `{ok:false, error}` with **HTTP 200** on a failed
+    test — a failed connection attempt is an expected, valid outcome to
+    report, not a server error, so the client branches on `ok` rather than
+    on HTTP status. `testMyAiConnection()` (`settings.js`) drives the
+    `.ai-reconnect-btn` next to the status pill (spins via
+    `.is-testing` while in flight, disabled whenever the provider isn't
+    configured — same disabled-state pattern as the "Entfernen" button) and
+    writes a failure into `.ai-test-error`, a plain line under the key row
+    that **stays visible** until the next test result replaces or clears
+    it — deliberately not a fading toast: a toast firing at the same moment
+    the surrounding view changes is exactly how the Protokoll-Import's own
+    KI-fallback banner was first missed (see below), the identical lesson
+    applied here before it could repeat. A successful test instead uses the
+    existing transient `showSettingsNote()` — good news is allowed to fade.
+  - **`istGueltigeAiUrl()` allows plain `http://` on the loopback
+    (`localhost`/`127.0.0.1`/`::1`) — everywhere else `https://` is
+    required.** First shipped as `https://`-only, which broke the single
+    most obvious reason to set a custom URL at all: Erik tried pointing it
+    at a locally running LM Studio, whose OpenAI-compatible server is
+    plain `http://localhost:1234/…` (a local dev server essentially never
+    carries a TLS certificate for `localhost`). The `PUT` silently rejected
+    that URL with 400, so the account's `api_url` stayed empty and every
+    import kept hitting the real, public OpenAI endpoint with an
+    OpenAI-shaped key that was never meant for it — confirmed from the
+    live server log, which showed OpenAI's own `Incorrect API key
+    provided…` message, i.e. the request really did leave the building
+    instead of staying on `localhost` as intended. `http` stays disallowed
+    for every non-loopback host — the key would otherwise cross a real
+    network in plaintext — but on the loopback the request never leaves the
+    machine, so there is nothing to protect against. Only meaningful when
+    the server itself runs on the same machine as the local LLM server
+    (true for a normal `npm start`); inside the Docker container (see
+    "Docker" below), `localhost` means the container, not the host, so
+    reaching a host-side LM Studio/Ollama instance needs
+    `host.docker.internal` (Docker Desktop) or the host's LAN address
+    instead.
+  - **`normalisiereAiUrl(apiUrl, defaultUrl)` fills in the provider's
+    default path when a custom `apiUrl` has none.** LM Studio and Ollama
+    are both conventionally addressed by their bare origin
+    (`http://localhost:1234`, `http://localhost:11434`) — that's the
+    address either tool's own UI shows, not the full
+    `…/v1/chat/completions` request path a raw `fetch()` needs. Saving just
+    the origin therefore isn't a user mistake to reject, it's the expected
+    input; without normalising it, the request landed on `/` at the local
+    server. Reproduced directly against Erik's own running LM Studio (this
+    Bash tool executes on the same machine the app runs on, so `curl
+    127.0.0.1:1234` reached his real instance, not a stand-in): its log
+    read `Received request: POST to /` / `Unexpected endpoint or method …
+    Returning 200 anyway` for the bare origin, and correctly hit
+    `/v1/chat/completions` once the path was appended. Only a *missing or
+    empty* path (`new URL(apiUrl).pathname` is `''`/`'/'`) gets the
+    default appended — an explicit, different path (e.g. a company proxy
+    with its own route) is always left exactly as entered.
+  - **`KI_TIMEOUT_MS_LOKAL` (30 min — raised twice from an initial 5 min:
+    first to 15 min after Erik reported it still aborted often once the
+    prompt fix below made the model generate real text for every point
+    instead of staying mostly empty — see that bullet — then to 30 min
+    after even 15 min still aborted while LM Studio itself finished cleanly
+    at roughly 12,000 generated tokens on his hardware) applies whenever the
+    resolved URL is on the loopback; every
+    other host keeps the original `KI_TIMEOUT_MS_CLOUD` (45 s).** A single
+    45 s timeout across the board silently aborted every
+    request to a local model before it could finish — confirmed against
+    Erik's own LM Studio, which remained correctly computing well past that
+    point ("läuft aber durch") while the app had already given up and
+    reported `This operation was aborted`. Cloud APIs keep the short
+    timeout: a hung request there really does mean something is wrong and
+    should fail fast, whereas CPU/modest-GPU local inference routinely
+    takes minutes for a single structured-output completion — nothing to
+    time out early for. `fetchMitTimeout()` decides via the same
+    `istLoopbackHost()` the URL validation above uses, so both paths share
+    one definition of "runs on this machine". On its own this raised
+    timeout still wasn't enough for Erik's setup — see the next bullet for
+    why, and for the fix that actually resolved it.
+  - **`erkennePunkteMitChatGPT()` sends `reasoning_effort: 'none'` to local
+    targets — the real fix for "This operation was aborted" even at a 5
+    minute timeout.** Diagnosed by querying Erik's actual, running LM
+    Studio directly (this Bash tool runs on the same machine as `server.js`
+    itself, so `curl 127.0.0.1:1234` reaches it for real, not a stand-in):
+    the loaded model, `qwen/qwen3.5-9b`, is a **reasoning model** that
+    emits a hidden "thinking" transcript (its own `reasoning_content`
+    field, separate from `content`) before every answer. For the trivial
+    prompt "Sag nur das Wort: Test", it spent 260 of 264 completion tokens
+    — 98.5% — on thinking alone, taking 15 seconds for a one-word answer;
+    scaled up to the real task (an 11-page Besprechungsprotokoll, 100+
+    points, strict JSON schema), that invisible phase alone plausibly runs
+    to thousands of tokens, comfortably past any timeout regardless of how
+    generous, even though the model reliably finishes if simply given
+    enough time ("läuft aber durch" — Erik's own description). Two
+    documented Qwen3 conventions for suppressing it were tried against this
+    server and neither worked (`enable_thinking: false`, both top-level and
+    nested under `chat_template_kwargs`; the `/no_think` prompt suffix) —
+    only `reasoning_effort: 'none'` (the OpenAI o-series parameter, which
+    LM Studio's compatibility layer honors) did: `reasoning_tokens` dropped
+    to 0 and the same trivial prompt returned in 0.4s. Re-verified with the
+    actual `KI_SYSTEM_PROMPT` and `KI_PUNKT_SCHEMA` against a real sample
+    protocol text: correct, fully valid points (including correctly
+    inferring `erledigt: true` from a point's text) in 11s with zero
+    reasoning tokens, and end-to-end through the real import route in
+    9.5s (`erkennungsart: 'chatgpt'`, no fallback needed) — the existing
+    prompt and schema design needed no changes at all once the reasoning
+    phase was out of the way. Sent **only** when `istLoopbackHost()` is
+    true for the resolved URL — never to the real OpenAI endpoint, where
+    `gpt-4o-mini` (not a reasoning model) doesn't support the parameter and
+    an unrecognized field could be rejected outright. Claude is unaffected
+    by any of this: Anthropic's Messages API only enables thinking via an
+    explicit, opt-in `thinking` parameter that this code never sends, so
+    there's no equivalent default-reasoning trap to guard against there.
+  - **`LOKAL_DISPATCHER` (`server.js`, a dedicated `undici.Agent`) — the fix
+    for a second, independent abort Erik hit once `KI_TIMEOUT_MS_LOKAL` was
+    first raised past 5 minutes: `fetch failed` / `Headers Timeout Error`,
+    even though LM Studio itself kept computing.** Node's global `fetch()`
+    runs on an internal undici client whose OWN default `Agent` closes a
+    connection after `headersTimeout`/`bodyTimeout` = 5 minutes each,
+    entirely independent of the app's own `AbortController` — invisible as
+    long as `KI_TIMEOUT_MS_LOKAL` itself was also ~5 minutes (both fired at
+    about the same time, so only the app's own clean "This operation was
+    aborted" was ever seen), but once the app's own timeout was raised,
+    undici's shorter built-in one fired first instead, surfacing as the
+    generic, lower-level `fetch failed`. Reproduced directly: a throwaway
+    local HTTP server that delays its response, fetched with a
+    deliberately short custom dispatcher, failed with the exact same
+    `fetch failed` / `Headers Timeout Error` pair Erik saw; the same setup
+    with a long dispatcher let the delayed response through. `fetch()`
+    itself has no option for this — only the non-standard (but
+    Node-honored) `dispatcher` field in its request options can override
+    it, which needs an actual `Agent` instance, hence the one new
+    dependency: **`undici`** (a second dependency beyond pdfjs-dist/
+    mammoth, and the only one of the three NOT used for its own `fetch` —
+    only for its `Agent` class, passed into Node's own global `fetch()` via
+    `dispatcher`). `fetchMitTimeout()` attaches `LOKAL_DISPATCHER` only for
+    loopback targets, with `headersTimeout`/`bodyTimeout` kept 10s above
+    `KI_TIMEOUT_MS_LOKAL` so the app's own, friendlier abort message always
+    wins the race against undici's lower-level one. Cloud targets are
+    unaffected (`KI_TIMEOUT_MS_CLOUD` at 45s is far under undici's 5-minute
+    default, so the problem never applied there).
+  - **Stored in plaintext**, the same trust boundary as every other column
+    in the same database file (e.g. `user_sessions.token`) — not a new or
+    weaker guarantee than the rest of the schema.
+  - **Breaks, for this one feature only, the server's previous "no internet
+    access needed" property** — `holidaysForYear()` was deliberately built
+    without a network dependency so the whole app keeps working on an
+    office network without internet (see its own comment in `server.js`).
+    KI-gestützte Erkennung inherently needs outbound internet access from
+    the server; the automatic fallback to `erkennePunkteAusText()` means the
+    app as a whole is unaffected — only this one recognition path silently
+    degrades to the offline heuristic when there's no connectivity (or when
+    the calling account simply hasn't configured a key).
+- **The result is explicitly a draft, not a finished record** — recognition
+  from an arbitrarily formatted foreign document, with or without AI, cannot
+  be perfectly reliable (table columns routinely collapse in a plain-text
+  extract, and even a capable model can misread a badly scanned source), so
+  the design leans toward leaving a field empty rather than guessing wrong:
+  an empty field is obviously incomplete when reviewed, a wrongly filled one
+  is not. Every imported Protokoll shows a banner in the detail view
+  (`.protokoll-import-banner` in `plan-styles.css`, reusing the same
+  `--protokoll-neu-bg`/`--protokoll-neu-border` tokens as the `.is-neu`
+  point highlight) prompting a check before saving, plus a "Quelldatei
+  herunterladen" link (`GET /project-protokolle/:id/quelldatei`, the
+  Protokoll equivalent of `GET /project-files/:id/download`) so recognized
+  text can always be checked against the original. Both are driven purely by
+  whether `quelleDateiname` is set on the loaded Protokoll — no separate
+  "was this imported" flag or client-side state.
+- **Shares the ordinary creation path, not a separate one**: the pre-existing
+  inline logic of `POST /project-protokolle` was extracted into
+  `legeProtokollAn(opts)`, called by both routes, so an imported Protokoll
+  gets the exact same `nummer` assignment and Fortschreiben-copy of the
+  previous Protokoll's open points as a manually created one — the import
+  only adds the recognized points on top (`neu=1`, fresh `stamm_id`, appended
+  after the copied-forward points). Nothing about numbering, grouping, or
+  reordering (described above) needed to change for this feature — imported
+  points are ordinary points from the moment they exist.
+- **Two new nullable columns on `project_protokolle`**,
+  `quelle_dateiname`/`quelle_stored_name` (migration
+  `migrateAddProtokollQuelle()`, same idempotent `ALTER TABLE` pattern as
+  `migrateAddProjectGroesse()`), empty for every hand-created Protokoll. The
+  uploaded file itself is stored the same way as `project_files` —
+  `sessions/uploads/<uuid>.<ext>` (`uploadDirFor()`/`extractFileExtension()`,
+  both reused unchanged) — but **not** in the `project_files` table itself:
+  that table's reviewer/approval workflow doesn't apply here (nobody
+  "approves" someone else's protocol), so `quelle_stored_name` is the only
+  pointer to the file, and `quelle_stored_name` (unlike `quelle_dateiname`)
+  is never sent to the client — only used server-side to resolve the
+  download route.
+
+### Auslastung — Wochenstunden statt Faktoren
+
+Die Auslastung wird in **Wochenstunden** gerechnet und erst zum Schluss auf die
+Kapazität der Person bezogen. Vorher war sie eine Summe dimensionsloser
+Gewichte: Ein Projekt in LPH 5 zählte für die Planung 1,0 — ob es 20.000 € oder
+2 Mio. € umfasste. Zwei kleine Projekte wogen damit schwerer als ein großes,
+und die Zahl sagte nichts darüber, wie viel Arbeit anliegt.
+
+**Der Weg von einem Projekt zu den Wochenstunden einer Person**
+(`berechneAuslastung()` in `js/load/load.js`, sechs Schritte):
+
+1. **Basis** — `projektBasisHonorar()`: das Honorar des Projekts. Fehlt es,
+   tritt `projects.groesse` (0–1) mal `APP_SETTINGS.referenzHonorar` an seine
+   Stelle. Fehlt beides, ist das Projekt **nicht bewertbar** — es wird als
+   Lücke ausgewiesen, nicht als Null gezählt.
+2. **Phase** — `arbeitsPhase()` bestimmt, womit gerechnet wird: die amtierende
+   Leistungsphase, und wenn die bereits zu 100 % erledigt ist, die nächste
+   beauftragte, die noch offen ist. Ohne diesen Schritt fiel ein Projekt aus
+   der Auslastung, sobald jemand seine Phase auf 100 % setzte, ohne
+   weiterzuschalten — im Bestand der Normalfall. Sind alle beauftragten Phasen
+   fertig, ist das Projekt fertig und bindet zu Recht keine Kapazität mehr.
+   `phasenAnteilProzent()` liefert den Anteil dieser Phase am Honorar
+   (`HONORAR_ANTEILE`, auf die **beauftragten** Phasen normiert — dieselbe
+   Rechnung wie im Leistungsstand), abzüglich des Fortschritts. Übrig bleibt
+   der offene Wert.
+3. **Stunden** — offener Wert geteilt durch `APP_SETTINGS.stundensatz`.
+4. **Rolle** — `rollenGewicht()` (Projektmatrix, sonst firmenweite Vorlage,
+   unverändert), hier aber als **Anteil**: Gewicht der Rolle durch die Summe
+   aller Rollengewichte dieser Phase.
+5. **Köpfe** — Aufteilung auf die Personen, die dieser Rolle im Projekt
+   zugeordnet sind (`zuordnungsGewicht()`: Hauptverantwortung 1,
+   Unterstützung 0,5). Ohne diesen Schritt zählte jeder von drei Planern die
+   vollen Phasenstunden — der Aufwand verdreifacht sich nicht dadurch, dass
+   mehr Leute daran arbeiten. Dafür bekommt `berechneAuslastung()` das
+   `assign`-Objekt des Projekts als letzten Parameter.
+6. **Zeit** — `projektVerteilWochen()`: die Wochen bis zum spätesten Datum im
+   Terminplan; ohne Terminplan (oder bei bereits verstrichenem Ende) gilt
+   `APP_SETTINGS.verteilzeitraumWochen`. Ohne Horizont wäre die Wochenlast
+   nicht bestimmt — dieselben Reststunden bedeuten über vier Wochen etwas
+   anderes als über vierzig.
+
+`HONORAR_ANTEILE` (`js/globals.js`) wird von `loadAppSettings()` (`js/store.js`)
+zusammen mit den übrigen Vorgaben aus `GET /honorar-config` geladen, also
+**vor** `/load-all` und damit vor dem ersten `renderAll()`. Der Projektbereich
+holt sie sich für den Leistungsstand weiterhin selbst (`plan-leistung.js`),
+weil er sie auch nach einer Änderung im laufenden Betrieb neu braucht.
+
+**Was die Seite sonst noch anders macht als zuvor:**
+
+- **Eine Summenzeile je MENSCH** über alle Rollen steht vor den Rollenblöcken.
+  Bisher fehlte sie: Wer in drei Rollen arbeitet, hat trotzdem nur eine
+  Arbeitswoche, und jede einzelne Rollenzeile blieb unter der Schwelle. Erik
+  Dunin kam mit 0,80 Planung und 0,40 Projektleitung auf 1,20 — rot war keine
+  der drei Zeilen.
+- **Die Kopfzeile sagt, was die Zahlen abdecken** („1 von 25 Projekten
+  bewertet"), und ein Aufklapper listet die nicht bewertbaren Projekte mit
+  Grund. Vier Gründe kommen vor: ohne amtierende Leistungsphase, ohne Honorar
+  und ohne Projektgröße, ohne Honorar-Anteil für diese Phase, und **niemand
+  für \<Rolle\> zugeordnet** — ein Projekt kann bewertbar sein und trotzdem
+  bei niemandem ankommen, etwa wenn es in LPH 8 steht (die die Bauüberwachung
+  trägt), aber nur ein Planer zugeordnet ist. Eine fehlende Angabe ist keine
+  fehlende Arbeit; vorher war beides eine Null.
+- **Das volle Band ist die Wochenkapazität.** Die frühere Skala
+  `auslastungBalkenMax` (Vorgabe 8) ist ersatzlos entfallen — samt
+  `loadBarMax()`, dem Admin-Feld und dem Eintrag in `APP_SETTING_DEFS`: Sie
+  stand im Widerspruch zur Ampel, die ab 1,0 rot wird, sodass ein roter Balken
+  nur zu einem Achtel gefüllt war.
+- **`js/pdf.js` rechnet dieselbe Rechnung** (Spalten „h / Woche" und „Anteil
+  der Kapazität"), sonst wiesen Bildschirm und Druck verschiedene Zahlen aus.
+
+**Die Projektgröße** (`projects.groesse`, REAL 0–1, Migration
+`migrateAddProjectGroesse()`) wird als Regler im Bereich „Einstellungen" des
+Projekts und im Dialog „Neues Projekt" gepflegt; `groesseText()` zeigt neben
+dem Regler den Eurobetrag, weil eine nackte Zahl zwischen 0 und 1 niemandem
+etwas sagt. Unter dem Regler steht, ob er gerade überhaupt zählt — eine Zahl,
+die wirkungslos ist, ohne dass man es sieht, wäre schlimmer als keine.
+Bestandszeilen starten mit 0 (= keine Angabe), absichtlich ohne Vorgabewert
+wie 0,5: Eine erfundene Größe erzeugte Zahlen, die nach Messung aussehen.
+`normalizeGroesse()` (`server.js`) kappt auf 0…1.
+
+### Auslastung — das Lastband
+
+`renderLoad()` (`js/load/load.js`) zeigt eine **Zeile je Person und Rolle**,
+und der Balken ist nach Projekten aufgeteilt: ein Segment je Projekt, seine
+Breite der Beitrag zur Last. Vorher stand jede Person in einer eigenen
+`.load-card` mit ihrer Projektliste klein darunter — man sah die Zahl, aber
+nicht, woraus sie besteht. Auf eine Auslastung von 1,80 folgt aber immer
+dieselbe Frage: aus einem großen Projekt oder aus fünf kleinen, und was davon
+lässt sich abgeben? Genau das beantwortet das Band.
+
+- **Gerechnet wird nichts Zusätzliches.** `stats[key].projects` hält
+  `{anzahl, stunden, nr, quelle}` statt nur einer Zählung — derselbe Wert, der
+  ohnehin aufaddiert wird, wurde bisher nur verworfen. Die Segmentbreiten sind
+  Anteile der Wochenkapazität, sodass ein volles Band eine volle Woche ist.
+  Segmente aus einer geschätzten Projektgröße tragen in der Legende ein `≈`.
+- **`projektFarbe(name)`** hasht den Projektnamen in `PROJEKT_FARBEN`, statt
+  nach Position zu vergeben: Die Auswertung läuft auch über alle Sitzungen, in
+  denen ein Projekt an wechselnder Stelle steht — eine Farbe, die je Sitzung
+  springt, wäre schlimmer als keine. Die Palette ist bewusst gedämpft und vom
+  Ampelspektrum getrennt (ein Segment sagt, WELCHES Projekt, nicht ob es gut
+  steht) und trägt weiße Schrift mit mindestens 4,5:1.
+- **Beschriftung erst ab 7 % der Bandbreite**, sonst bliebe von "21-4001" ein
+  angeschnittenes "21-40" stehen. Schmale Segmente behalten Farbe, Tooltip und
+  ihren Eintrag in der `.load-legende`, die nur die tatsächlich vorkommenden
+  Projekte auflistet.
+- **Eine Null bekommt KEINE Ampelfarbe** (`--text-subtle` statt Grün): Grün
+  hieße "gut ausgelastet", die Null heißt aber "nichts zugeordnet". In einer
+  Sitzung mit ungepflegten Zuordnungen stünden sonst dreizehn grüne Nullen
+  untereinander und meldeten Entwarnung, wo nur Daten fehlen — im Bestand
+  genau der Fall.
+- **`loadAmpelColor()` liefert Design-Tokens** (`var(--red)` …) statt der
+  früheren Festwerte. Die Ampel färbt jetzt die große Zahl am Zeilenende, und
+  `#c53030` kam auf schwarzem Grund nur auf 3,6:1; mit dem Token sind es 6,2:1.
+  `pdfLoadAmpelColor()` behält seine druckfreundlichen Festwerte — ein PDF hat
+  kein Thema.
+- Innerhalb einer Rolle wird **absteigend nach Auslastung** sortiert: Wer zu
+  viel hat, steht oben, und die Zeilen ohne Zuordnung sammeln sich unten,
+  statt die Liste zu durchsetzen.
+- **`.load-card`/`.load-row`/`.load-num`/`.load-detail` bleiben bestehen** —
+  das Dashboard (`js/dashboard/dashboard.js`) und die Ressourcenansicht des
+  Projektbereichs (`js/plan/plan-gantt.js`) bauen darauf auf. Der Show Mode
+  kopiert das gerenderte HTML und zeigt das Band deshalb ohne Änderung; die
+  drei `.show-mode-content .load-*`-Regeln wurden auf die Zeilenform
+  umgestellt.
+
+### Projektbeteiligte (global users, cross-department staffing)
+
+**Removed from the sidebar navigation** (on Erik's request): once departments
+stopped partitioning weeks/projects/people, this tab's original job —
+pulling a Beteiligter from an ELT/HLS/ARCH-specific roster into a
+department-scoped session — no longer applied to a single shared roster, and
+what remained (a read-only list) duplicated the role/avatar chips already
+visible in Wochenbericht/Board/Auslastung. The `.nav-item.tab[data-tab="people"]`
+button in `App.html` is gone; the tab panel (`#people`), its module
+(`js/people/people.js`) and its deep-link slug (`Projektbeteiligte` in
+`VALID_TAB_SLUGS`) are all still there and still reachable by URL — only the
+sidebar entry point was removed, not the feature itself. The bullets below
+describe that still-live feature; where they mention department-scoped
+rosters, treat that as unverified against current reality (see "Departments
+were retired").
+
+- The per-department "Projektbeteiligte" concept — its own `people`/
+  `person_roles`/`person_absences` rows with client-side CRUD/drag-reorder —
+  has been fully replaced by the global `users` table (see Persistence for
+  the migration). `db.globalPeople[department]` is now populated purely by
+  the server: `loadGlobalPeople(department)` (`server.js`) reads
+  `users`/`user_roles`/`user_absences` filtered to `department` and
+  `active=1`, so the Projektbeteiligte tab (`js/people/people.js`,
+  `renderPeople()`) is **read-only** — no add/edit/delete/reorder form, no
+  drag handles. Only admins maintain team members, exclusively through
+  `admin-users.html` (`department` is a required field there, `initials` is
+  the board-column label, `roles` are the discipline roles).
+- **Cross-department staffing:** a project's team is not restricted to its
+  department's own users. In the Projektbeteiligte tab, an admin (UI-gated
+  only, see Auth section) on an unlocked week sees a "+ Person aus anderer
+  Abteilung zur aktuellen Sitzung hinzufügen" picker (`loadCrossDeptUserOptions()`/
+  `addSelectedUserToCurrentWeekRoster()` in `js/people/people.js`), sourced
+  from `GET /users` filtered to `department !== currentDepartment`, a set
+  `personId`, and not already in `currentWeek().people`.
+  `addUserToCurrentWeekRoster(user)` pushes a normal person object
+  (`{id, name, fullName, email, role, absences:[]}`, built from the chosen
+  user) directly into `currentWeek().people` and calls the ordinary `save()`
+  — no new endpoint needed, since `week.people` is already part of the whole
+  week JSON that `/save-week` writes. Because `board.js`'s `renderBoard()`/
+  `peopleByRole()`/`cycleAssign()` and `load.js` iterate exclusively over
+  `currentWeek().people` (never `db.globalPeople[dept]` directly), the added
+  person immediately shows up as its own assignable board column — no
+  changes were needed in `board.js`/`load.js`. `renderPeople()` shows such
+  entries with an "(andere Abteilung)" hint and a "✕ Aus dieser Sitzung
+  entfernen" button (`removeForeignUserFromCurrentWeekRoster()`), which
+  refuses to remove a person still assigned to a project in that week (same
+  guard the old `delPerson()` had). `cloneWeek()` carries these
+  cross-department additions into the next week automatically (it copies
+  `week.people` verbatim); `newWeek()` (a fresh start) does not — the roster
+  resets to the department's own home users, which is intentional (with an
+  explanatory hint in the UI).
+
+### Planung — projektunabhängige Terminplan-Sandbox (tab `planung`, `js/planung/planung.js`)
+
+Ein zweiter, eigener Abschnitt der Seitenleiste (nicht Teil von
+"Navigation", zwischen Auslastung und Einstellungen) — eine **Sandbox**, in
+der sich Terminpläne **unabhängig von einem echten Kundenprojekt** anlegen
+lassen: entweder aus einem Honorar errechnet (derselbe Rechner wie bei einem
+echten Projekt) oder frei von Hand begonnen. Jeder angemeldete Nutzer darf
+das, keine Admin-Sperre. Mit voller Terminplan-Funktionalität — Drag&Drop,
+Abhängigkeiten, kritischer Pfad, Auto-Schedule, Zoom — weil ein Sandbox-Plan
+technisch ein ganz normales Projekt ist, nur an einer besonderen Stelle.
+
+**Architektur: eine reservierte Sitzung statt eines Flags.** Ein erster
+Ansatz (ein Flag auf einem Projekt der jeweils aktuellen Sitzung) wurde
+verworfen: `cloneWeek()` (`public/js/weeks.js`) vergibt beim Duplizieren
+einer Sitzung jedem Projekt eine neue `id` — ein Sandbox-Plan verlöre bei
+jeder neuen Sitzung seine Identität. `newWeek()` startet dagegen mit
+`projects:[]` — ein Sandbox-Plan in der "aktuellen Woche" verschwände beim
+nächsten `newWeek()` einfach. Und `applyAutoLock()` sperrt jede Woche außer
+der zeitlich letzten — ein Sandbox-Plan würde unvermittelt schreibgeschützt.
+Stattdessen: **eine einzige, dauerhaft reservierte "Sitzung"**,
+`SANDBOX_WEEK_LABEL = '__sandbox__'` (identisch in `server.js` und
+`js/globals.js` — kein gemeinsames Modulsystem zwischen Server und Client).
+`ensureSandboxWeek()` (`server.js`, läuft bei jedem Start wie die übrigen
+Migrationen) legt die `weeks`-Zeile per `INSERT OR IGNORE` einmalig an.
+Jeder Sandbox-Terminplan ist eine ganz normale Zeile in
+`projects`/`project_plan`/`plan_todos`/`plan_milestones`/… mit diesem
+`week_label` — **keine neue Spalte, keine Migration an `projects`** (bis auf
+`updated_at`, siehe unten), `loadWeeks()`/`serializeWeek()` bleiben
+unverändert.
+
+**Der entscheidende Vorteil: strukturelle statt gemerkter Isolation.**
+`GET /load-all` (`server.js`) spaltet `loadWeeks()`s Ergebnis auf — die
+Sandbox-Woche wird NICHT als Teil von `weeks[]` ausgeliefert, sondern separat
+als `sandboxPlans` (nur ihre `.projects`) plus `sandboxUpdatedAt`. Der Client
+baut daraus in `load()` (`js/store.js`) ein eigenes, synthetisches Objekt
+`db.sandboxWeek` — niemals Teil von `db.weeks`. Weil `renderBoard()`
+(board.js), `berichtProjekte()` (wochenbericht.js), `berechneAuslastung()`
+(load.js), `exportWochenberichtPDF()` (pdf.js),
+`renderAdminSitzungen()` (admin.js) und jeder künftige Code, der `db.weeks`
+durchläuft, die Sandbox-Daten also **strukturell nie sehen können**, gibt es
+keinen Filter, den man in sechs Dateien hätte vergessen können — anders als
+bei einem Flag-Ansatz. Nur an den wenigen Stellen, die `db.weeks` selbst
+zusammensetzen oder adressieren, gibt es einen expliziten, kleinen Zweig:
+
+**Achtung, echte Ausnahme dieser Garantie:** Sie gilt nur für den Weg über
+`GET /load-all` (also für `db.weeks` clientseitig). Jeder serverseitige Code,
+der `loadWeeks()` selbst ein zweites Mal aufruft, statt sich auf `db.weeks`
+zu verlassen, braucht denselben `.filter(w => w.label !== SANDBOX_WEEK_LABEL)`
+direkt nach dem Aufruf erneut — sonst bekäme die reservierte Sandbox-Woche
+dort eine eigene Zeile, als wäre sie eine echte Sitzung. Vor jeder neuen
+serverseitigen Route, die `loadWeeks()` aufruft, lohnt sich deshalb ein
+kurzer Blick auf diesen Abschnitt.
+- `syncAllToServer()` (store.js): `label === SANDBOX_WEEK_LABEL` löst zu
+  `db.sandboxWeek` statt zu `db.weeks.find(...)` auf — ohne diesen Zweig
+  würden Sandbox-Änderungen lautlos verworfen (`dirtyWeeks.delete()`, ohne je
+  zu speichern), weil `db.weeks.find()` die Sandbox nie findet.
+- `openPlanView()` (`js/plan/plan-state.js`): eigener Zweig für
+  `app.weekLabel === SANDBOX_WEEK_LABEL`, der `app.week = db.sandboxWeek`
+  setzt und das Projekt über die stabile **`id`** sucht statt über `nr`/`name`
+  wie bei einem echten Projekt (`openSandboxPlan(planId)`,
+  `app.sandboxPlanId`) — Sandbox-Projekte werden nie geklont, ihre `id` ist
+  also im Unterschied zu einem echten Projekt dauerhaft stabil, und sie haben
+  kein `nr`, also auch keine sinnvolle `nr`/`name`-Adressierung.
+- `applyAutoLock()` (weeks.js): filtert `SANDBOX_WEEK_LABEL` heraus, bevor
+  "welche Woche ist die späteste" berechnet wird — ein reines Sicherheitsnetz,
+  da die Sandbox-Woche strukturell ohnehin nie in `db.weeks` ankommt.
+- `validateWeekLabel()` (weeks.js) lehnt den reservierten Namen als von Hand
+  eingegebene Sitzungsbezeichnung ab; `/delete-week`/`/unlock-week`
+  (server.js) lehnen ihn mit 400 ab — die reservierte Woche ist über die
+  normale Sitzungsverwaltung weder löschbar noch entsperrbar.
+- `updateRouteUrl()`/`applyUrlRoute()` (`js/ui.js`) und `initUiState()`
+  (`js/init.js`): die Deep-Link-Adresse eines Sandbox-Plans trägt `planId`
+  statt `projNr` (`/Projektplan/<Name>?weekLabel=__sandbox__&planId=…`), weil
+  ein Sandbox-Plan kein `nr` hat.
+
+**`projects.updated_at`** (neue, idempotente Migration
+`migrateAddProjectUpdatedAt()`, gleiches Muster wie
+`migrateAddProjectGroesse()`) ist die einzige neue Spalte — nötig, weil
+mehrere, voneinander unabhängige Sandbox-Pläne in EINER Woche liegen und sich
+"zuletzt bearbeitet" bis dahin nur je WOCHE unterscheiden ließ
+(`weeks.updated_at`). Für echte Projekte harmlos mitgeführt, aber ungenutzt.
+Befüllt in `serializeWeek()`s bestehendem `insProject.run(...)`.
+
+**Welche Projektfelder ein Sandbox-Plan nutzt:** `name` (einzige Identität,
+Pflichtfeld, keine Duplikate — geprüft in `erstellePlanungTerminplan()`),
+`honorar` + `beauftragteLP` (treiben den vorhandenen "Terminplan aus
+Honorar"-Rechner, `plan-honorar.js`, unverändert), der komplette
+`plan`-Baum (Todos/Meilensteine/Abhängigkeiten/Beteiligte). NICHT genutzt:
+`nr`, `group`, `auftragsstatus`, `groesse`, `project_gewerke` — jeweils an
+echte Geschäftslogik gebunden, die für eine Sandbox keinen Sinn ergibt.
+
+**Wiederverwendeter Projektbereich, mit ausgeblendeten Abschnitten.**
+`openSandboxPlan(planId)` führt in denselben Projektbereich (`#plan`), der
+auch für echte Projekte dient — keine zweite Gantt-Implementierung. Ein
+zentraler Merker `app.isSandboxPlan()` (`plan-state.js`, neben dem
+bestehenden `app.isLocked()`) blendet aus: die Bereiche **Dateien** (kein
+`nr`, kein sinnvoller Prüf-Workflow), **Leistung** (echte
+Abrechnung/Auftragsstatus-abhängig) und **Protokolle** (hängt wie Dateien an
+`project.nr`) ganz (`plan-nav`-Knöpfe versteckt, `initPlanSections()` in
+plan-sections.js fängt zusätzlich einen direkten
+`#dateien`/`#leistung`/`#protokolle`-Link ab und fällt auf Dashboard zurück); in
+**Einstellungen** (`plan-settings.js`) die Felder Projektnummer,
+Auftragsstatus, Gewerke, Projektgröße — **Honorar, beauftragte
+Leistungsphasen und die Beteiligten-Matrix bleiben sichtbar**. Die
+Kompakt-Karte "Verlauf" (`renderPlanHistory()`, plan-history.js) zeigt einen
+eigenen Hinweistext statt der (für eine nie geklonte Sitzung bedeutungslosen)
+Versions-Historie. Die Kopfzeile zeigt bewusst NICHT das rohe
+`week.label` ("__sandbox__", ein interner Marker) als Untertitel, sondern
+"Planung — unabhängig von einem laufenden Projekt".
+
+**Anlegen** — bewusst kein mehrstufiger Assistent wie "Neues Projekt" (der
+verlangt Gewerke/Team/Auftragsstatus, die hier nicht zutreffen), sondern ein
+schlanker Dialog (`#neuerTerminplanModal`, `erstellePlanungTerminplan()`):
+Name + Wahl zwischen "Aus Honorar berechnen" (landet in Einstellungen mit
+fokussiertem Honorar-Feld; der Nutzer nutzt danach den bereits vorhandenen
+"Terminplan aus Honorar"-Knopf dort — kein eigener Rechen-Code) und "Leer
+beginnen" (landet direkt im leeren Terminplan).
+
+**Bekannte, unveränderte Alteigenheit:** `saveWeekRelational()` löscht und
+schreibt beim Speichern die komplette Woche neu — bearbeiten zwei Personen
+gleichzeitig zwei verschiedene Sandbox-Pläne, kann es zu einem 409-Konflikt
+kommen, obwohl sich die Änderungen inhaltlich nicht überschneiden. Keine neue
+Schwäche dieses Features, sondern dieselbe Begrenzung, die heute schon gilt,
+wenn zwei Personen zwei verschiedene echte Projekte derselben Woche
+gleichzeitig bearbeiten.
+
+### Einstellungen (tab `settings`, `js/settings/settings.js`)
+
+- This area belongs to the signed-in account itself and holds **"Mein
+  Konto"** plus, in a second card, its own **"KI-Zugangsdaten"** — the
+  account's personal OpenAI/Claude API key (+ optional API-URL override) for
+  the Protokoll-Import's KI-gestützte Erkennung, see "### Protokolle" for
+  the full `user_ai_keys`/`GET`+`PUT /my-ai-settings` mechanism. "Mein
+  Konto" itself holds master data for display, the account's own e-mail
+  address, and the password change. Display name, role and `personId` stay an admin's
+  job via `PATCH /admin/users/:id`; the area calls out a missing `personId`
+  explicitly, since that silently empties "Meine Aufgaben"
+  (`GET /my-dashboard` matches on `plan_todo_assignees.person_id`).
+  **E-mail is the one field the account edits itself** (inline input next to
+  the value, `submitEmailChange()` → `POST /change-email`, see Server API) —
+  it used to be admin-only like the rest of that group, but unlike display
+  name or role it is purely contact information the account owner is best
+  placed to keep current, and making someone wait on an admin just to enter
+  their own address was needless friction. An admin can still set/correct it
+  via the Benutzerverwaltung, e.g. for a colleague who hasn't logged in yet.
+- Everything company-wide used to sit here next to it. That mixed two
+  different things in one list — your own account details, which concern
+  everyone, and defaults that shift *everyone's* numbers and belong to admins
+  alone. The latter moved to the Admin area below.
+- Until this area existed the app had **no settings page at all**. The sidebar
+  group labelled "Einstellungen" contained only *actions* (Neue Sitzung,
+  Sitzung duplizieren, PDF-Export, Show Mode, CSV-Export) and is therefore now
+  labelled **"Werkzeuge"** (accordion key `tools`, ids `toolsAccordionToggle`/
+  `toolsSubnav`).
+- **CSV-Export removed entirely** (route, `js/csv.js`, the "CSV Export"
+  button) — on Erik's explicit call: with a real SQLite database behind the
+  app now, a standing CSV export of the same data no longer earns its place;
+  `GET /backup` already covers taking the data out wholesale. Unlike the
+  Projektbeteiligte nav removal, this was a full removal, not just an
+  unlinking — no route, no deep link, nothing left to find by URL.
+  `buildExportCsvs()`/`buildZip()`/`csvFile()`/`csvCell()`/`CSV_SEP` (all
+  server.js) went with it.
+- **"Neue Sitzung"/"Sitzung duplizieren" removed as well**, for an unrelated
+  reason: see "Automatischer Sitzungswechsel" below — creating a session is
+  no longer a user action at all.
+- **"PDF Export" (`exportPDF()`) removed too** — on Erik's call, PDF export
+  should live only in the Wochenbericht and in Planung-Terminpläne, not as a
+  standalone whole-session export. Along with the button and the function
+  itself, `pdf.js` lost every helper exclusive to it (`pdfRoleBg()`,
+  `pdfTableLayout()`, `pdfHeaderRows()`, `pdfProjectRow()`,
+  `pdfGroupTitleRow()`, `pdfColumnWidths()`, `pdfCheckWidth()`,
+  `pdfAttendanceBlock()`, `pdfLoadSection()`, and the color constants
+  `PDF_ROLE_BG`/`PDF_ALT_ROW_BG`/`PDF_PAD_X`/`PDF_LINE_W`) — everything the
+  remaining two exports (`exportWochenberichtPDF()`/`exportSandboxPlanPDF()`)
+  still share (`PDF_STYLES`, `PDF_NEUTRAL_BG`, page geometry,
+  `pdfStatusText()`, `pdfNormalizeColor()`, `loadLogoPng()`) stayed. This was
+  the one export that showed every project across every Gewerk in a single
+  file — that capability is gone with it; the per-Gewerk Wochenbericht PDFs
+  are now the only filed record. Werkzeuge is down to two items:
+  `+ Neues Projekt`, `Wandtafel` (the former `Show Mode` entry — see
+  "Wandtafel" below).
+
+### Admin (tab `admin`, `js/admin/admin.js`)
+
+- Everything only admins may do, in one place. Split into **sections, one
+  visible at a time**, switched from the sidebar: "Admin" is an accordion
+  (`#adminAccordionToggle`/`#adminSubnav`) whose sub-items call
+  `showAdminSection()`. `ADMIN_SECTIONS` is the single place a section is
+  defined (key, heading); the binding to the markup runs through the
+  `data-admin-section` attribute on both the card in `App.html` and the
+  sidebar item. The chosen section lives in the URL fragment
+  (`/Admin#auslastung`) — same pattern as `.plan-nav` in the Projektbereich —
+  which is why `updateRouteUrl()` keeps `location.hash` for `admin`.
+- Two deviations from the "Werkzeuge" accordion, both deliberate: its head
+  entry also *navigates* (the sub-items are in-page navigation, not actions,
+  so a head that shows nothing would mislead) — from elsewhere a click always
+  enters the area and expands, only from inside does it toggle; and its
+  sub-items carry a persistent `.is-active` highlight.
+  `syncAdminNavState()` in `js/tabs-auth.js` marks the head active while the
+  area is open, because it is no longer a `.tab` button and the generic
+  highlight does not reach it.
+- `showTab('admin')` redirects non-admins to `DEFAULT_TAB`: without it a
+  forwarded `/Admin` link showed a member an empty page, since
+  `renderAdminArea()` renders nothing for them.
+- Sections:
+  - **Benutzerverwaltung** — accounts, roles, weekly hours, absences
+    (`js/admin-users.js`, `renderAdminUsers()`); reloaded from the server
+    every time the section is entered, since the list changes outside this
+    browser and the other masks compute with it (weekly hours → Auslastung).
+    Marked `wide: true` in `ADMIN_SECTIONS`, which lifts the grid's width cap
+    — the table has ten columns.
+  - **Honorar** — `stundensatz` + the per-LPH shares (`PUT /honorar-config`).
+    A running sum turns amber unless the shares add up to 100 %.
+  - **Auslastung** — `vollzeitStundenProWoche`, the ampel thresholds,
+    `referenzHonorar`, `verteilzeitraumWochen`, and `aufwandVorlage` (the per-LPH/role weighting that applies to
+    every project without its own matrix — i.e. most of them, which is why it
+    quietly determined a large part of the Auslastung while it was a code
+    constant).
+  - **Termine & Sitzungen** — `arbeitsstundenProTag` and `autoLockAktiv`.
+    Switching auto-lock off does **not** retroactively unlock: already-locked
+    weeks stay locked, unlocking remains a deliberate admin action
+    (`POST /unlock-week`).
+    **Also holds the "Sitzungen" list** (`renderAdminSitzungen()`,
+    `js/admin/admin.js`) — every week with its lock state and, for anything
+    that isn't the one open week, an action to reach it. This replaced the
+    week `<select>` that used to sit in the topbar (`#appTopbarWeek`,
+    removed): sessions are storage and history now, not something the whole
+    UI asks you to pick from. In normal operation there's exactly one row
+    without an action (the open week, `db.currentWeek`, always the
+    chronologically latest under `applyAutoLock()`); everything else is
+    **Gesperrt** (`Entsperren` → `unlockWeek()`) or **Entsperrt**
+    (`Öffnen` → `switchWeek()` + jump to Board — the one place left that can
+    put a week other than the latest into `db.currentWeek`). Deleting a
+    session also moved here (`Löschen` → `deleteWeekById()`) from its old
+    home in *Datenbank & Sitzungen*, which depended on "the week chosen in
+    the topbar" and had no other way to name a target once that selector was
+    gone.
+    **The unlock window is shorter than it looks**: `unlockWeek()` only
+    flips that one week's flag, but `applyAutoLock()` re-locks every week
+    except the latest, and runs again on `deleteWeekById()` — not just on
+    page reload. Deleting an unrelated session while a correction is in
+    progress silently re-locks it before the fix is saved. Since the
+    automatic Sitzungswechsel (see "Automatischer Sitzungswechsel" above),
+    there is a second, independent trigger for the same outcome:
+    `ensureCurrentWeekRollover()` re-locks every other real week itself,
+    server-side, the moment the calendar rolls into a new ISO week — so an
+    in-progress correction on an older week can now also get silently
+    re-locked purely by time passing, with nobody clicking anything at all.
+    Both respect `app_settings.autoLockAktiv`. Surfacing "Entsperrt" as its
+    own row state only made this pre-existing risk visible, not new.
+  - **Feiertage** — the `holidays` table, plus a "gesetzliche Feiertage
+    übernehmen" mask that computes a year's public holidays for a chosen state
+    and lets the admin take them over (see `/holidays/suggest` above). It
+    flags when the current or next year has no day stored at all — otherwise
+    missing holidays only surface via a wrongly computed schedule.
+  - **Aufgaben-Vorlagen** — create/delete steps per LPH
+    (`POST`/`DELETE /lph-templates`).
+  - **Betrieb & Sicherheit** — `maxBackups`, `sessionTage`,
+    `loginMaxVersuche`, `loginSperreMinuten`. The session lifetime applies to
+    *new* logins; existing sessions keep their stored `expires_at`.
+  - **Datenbank & Sitzungen** — DB Backup, DB Import, Sitzung löschen. These
+    three used to be bare sidebar menu entries where a mis-click was enough;
+    they now sit behind an explanation of what each one does.
+- **Honorar and Aufgaben-Vorlagen were moved out of project dialogs.** They
+  used to sit inside `#honorarPlanModal` (`js/plan/plan-honorar.js`) and
+  `#lphTemplateModal` (`js/plan/plan-templates.js`) — findable only by someone
+  who happened to be computing a schedule. Those dialogs now only *use* the
+  values and show admins a link here (`renderHonorarHint()`/
+  `renderTemplateHint()`). Since `plan-honorar.js` caches the config for the
+  whole page lifetime, `saveHonorarConfig()` calls
+  `invalidateHonorarConfig()` afterwards — otherwise a dialog opened later in
+  the same session would keep computing with the old rate.
+- **Honorar, Auslastung, Termine and Betrieb used to be constants in the
+  source** — partly in the frontend (`LP_AUFWAND_VORLAGE`,
+  `THRESHOLD_RATIO_*`, `LOAD_BAR_MAX`, `STUNDEN_PRO_TAG`), partly in the
+  server (`MAX_BACKUPS`, `SESSION_MAX_AGE_MS`, `LOGIN_MAX_ATTEMPTS`,
+  `LOGIN_BLOCK_MS`). They moved here not because they change often but because
+  they shift the numbers *everyone* sees, which makes maintaining them an
+  administration task rather than a source edit. All of those identifiers are
+  gone; the client reads the values from `APP_SETTINGS` (`js/globals.js`),
+  filled by `loadAppSettings()` in `js/store.js` **before** `/load-all`, since
+  `renderAll()` already computes with them. If that fetch fails the defaults
+  in `js/globals.js` stand — deliberately identical to `APP_SETTING_DEFS`, so
+  the app keeps computing as it did instead of showing wrong numbers.
+- **Part-time capacity.** `users.capacity_hours` (maintained per account in
+  `admin-users.html`) is what the Auslastung now measures a person against:
+  `kapazitaetsFaktor()` in `js/load/load.js` divides the raw weekly load by
+  `capacity_hours / vollzeitStundenProWoche`, so a half position counts as
+  fully loaded at half the work. `0` = not maintained = full position, so
+  existing accounts keep their previous picture. **`kapazitaetsFaktor()`
+  takes the person OBJECT, not just its id**: a week's participants are
+  frozen copies (`week_people`) whose id dates from when they were created —
+  legacy data has `p_ap` where the account now carries `p_alexander_plum`, so
+  the id alone would never find them and the full name is the second bridge.
+  `js/pdf.js` applies the same factor, otherwise screen and PDF would report
+  different numbers for the same part-timer.
+- **"+ Neues Projekt" is no longer an admin entry** — it moved to
+  "Werkzeuge". Creating a project goes through the ordinary week save
+  (`POST /save-week`, `requireAuth`); the server never required the admin
+  role for it, so the gate was purely cosmetic and merely kept members from
+  ordinary work.
+- The area being hidden for non-admins is a **UI gate only**, like everywhere
+  else in this app; the real barrier is `requireRole('admin')` on
+  `PUT /app-settings`, `PUT /honorar-config`, `POST`/`DELETE /lph-templates`,
+  `POST`/`DELETE /holidays`, `GET /backup`, `POST /import` and
+  `POST /delete-week` (verified: a member account gets 403 on each and the
+  stored values stay unchanged).
+
+### Wochenbericht — die Tagesordnung
+
+- The Wochenbericht is laid out as the **agenda of the weekly team meeting**:
+  the full project list on the left, the selected project full-size on the
+  right. It replaced a stack of 29 open cards that ran to 18 screens (11.6
+  after the cards were compressed) — **now 1.1**. The list stays put, so you
+  always see where you are and what is still to come.
+- **Ordered by project group** (`GROUP_ORDER`, like the project list), no
+  longer by kind of change: every project gets discussed whether it changed or
+  not, and sorting by change would force jumping between sections. What
+  changed is still computed (`classifyProjectChange()`) and shown — as a dot
+  in the list and a label in the detail, not as a sort key.
+- `berichtAuswahl` holds the **`project_uid`**, not an index: saving a comment
+  re-renders the list, and an index would point at a different project if the
+  order changed.
+- `renderBerichtListe()` is separate from `renderWochenbericht()` because the
+  jump field redraws only the list — the detail, and above all a comment being
+  typed, must survive.
+- The eight functions, all built in:
+  - **Besprochen-Haken** + "12 von 29 besprochen" (`projects.besprochen`,
+    saved through the ordinary `save()` path).
+  - **Besprochen & weiter** — ticks off and jumps to the next open item,
+    searching behind the current position first, then from the top.
+  - **Keyboard**: ↓/↑ switch project, Ctrl+↵ saves the comment and moves on.
+    Bound at document level but gated on `currentTab === 'wochenbericht'`.
+  - **Vorwochen-Zeile** — last session's comment above the input field, the
+    answer to "what did we agree last week?" without opening the Verlauf.
+  - **Aufgabe aus Kommentar** — turns a decision into a real `plan_todo`
+    (title suggested from the *unsaved* field content, since in a meeting you
+    type the decision and create the task before saving).
+  - **Protokoll** — what changed versus the previous session plus the tasks
+    created today, as text to copy or mail. The mailto route refuses overlong
+    bodies rather than opening a truncated draft. **Not** the same thing as
+    the PDF below: the Protokoll is a delta (what changed + what's new), meant
+    to be pasted somewhere else; the PDF is the full agenda as a standalone
+    file.
+  - **„Als PDF ablegen"** (`exportWochenberichtPDF()`, `js/pdf.js`) — one of
+    the two remaining PDF exports (the other is `exportSandboxPlanPDF()` for
+    Planung-Terminpläne; the third, the board's own gewerkeübergreifende A3
+    session-overview `exportPDF()`, was removed — see "Werkzeuge" above). The
+    Wochenbericht is itself two-part, A4 portrait: **page 1** is a lined overview
+    table per group (change dot, Nr., Name, Änderungsgrund, amtierende LPH +
+    Fortschritt, Besprochen-Haken — `pdfWbUebersichtBlock()`) followed by the
+    **Anwesenheit der Sitzung** as its own gridded table
+    (`pdfWbAnwesenheitBlock()`, reading `w.attendance`/`w.people` exactly like
+    the on-screen `renderAttendance()`: a missing entry counts as not present,
+    same as an explicit `false` — there is no third "not yet recorded"
+    state, so the count is literal even when nobody has been marked yet).
+    **Page 2 onward** ("Vollständiger Bericht") is one bordered Akte per
+    project with a left spine colored by `classifyProjectChange()`'s bucket
+    (`PDF_WB_CHANGE_COLORS`: new/status/progress/unchanged), two columns
+    inside — comment on the left via `pdfStatusText()` (same bold/color
+    fidelity as the screen), a gridded Leistungsphasen-table and
+    Beteiligte-table on the right (`pdfWbLphMiniTable()`/
+    `pdfWbBeteiligteTable()`, falling back to all `LPHS` when none are
+    beauftragt — same rule as `renderBoardDrawer()`), plus who's assigned but
+    marked absent (`abwesendeBeteiligte()`). The amtierende-LPH value is
+    computed once (`pdfWbAktuelleLphInfo()`, same `lpActiveList()` the
+    Auslastung uses) and read by both the overview row and, indirectly, the
+    Akte — so the two pages can never show conflicting figures for the same
+    project. Reuses `PDF_STYLES`/`pdfStatusText()`/`loadLogoPng()` from the
+    existing module. `pdfHslToHex()` is the one color helper: it lets the
+    browser itself convert `getProgressColor()`'s `hsl()` output (pdfmake
+    doesn't understand `hsl()`) into the hex `pdfNormalizeColor()` already
+    handles, so the bar in the PDF is the exact same color as on screen
+    instead of a second, invented scale. The overview/attendance/mini-tables
+    all share one grid layout (`pdfWbGridLayout()`) so the whole document
+    reads as tables throughout rather than mixing ruled and unruled blocks.
+  - **Sprung-Feld** — filters the list only while something is typed; the
+    agenda must stay complete.
+  - **Abwesenheits-Hinweis** — marks projects whose assignees are absent, read
+    from `week.attendance`. Stays silent while nobody is marked present at
+    all, since "everyone is missing" would be a false alarm.
+- Two bugs worth remembering, both found by measuring, not by looking:
+  - The dense-card rules were scoped to `.report-card`, a container this
+    rewrite removed — the card silently fell back to the Board layout
+    (Leistungsphasen missing, people stacked). They now hang off
+    `.board-drawer-dicht` itself.
+  - The state class was literally `status`, which matched the unrelated
+    `.status { min-width: 240px }` — the 7 px dot became 240 px wide and
+    squeezed the project name to zero. State classes carry an `is-` prefix now.
+- The dense card is **two columns again** (comment | phases + people). It had
+  three while 29 cards stood stacked and height mattered; in the agenda only
+  one project is ever open, so height is free while width is scarce — beside
+  the list, three columns left the people 137 px.
+
+### Wochenbericht — Gewerke-Trennung
+
+Since departments stopped partitioning the data (see "Departments were
+retired" above), every project from every discipline sat in the same, single
+Tagesordnung — but ELT, HLS and ARCH hold their weekly team meeting
+separately, at different times, and each meeting only needs its own trade's
+projects, not the other two's. Completeness ("every project gets discussed")
+now applies **within the chosen Gewerk**, not across all three at once; the
+one place that still shows every project regardless of Gewerk is the
+unfiltered "Projekte" board (`renderBoard()`) — untouched by this feature.
+
+- **`wochenberichtGewerk`** (`js/wochenbericht/wochenbericht.js`) is a
+  module-level `let`, `null` until resolved. Deliberately **not** persisted to
+  `localStorage` — it resets on every page load/login, so a stale choice from
+  a different meeting can never carry over silently.
+- **Defaults from the account's own Gewerk, no dialog needed for the normal
+  case**: `wochenberichtGewerkVoreinstellen()` runs at the top of
+  `renderWochenbericht()` and, once per page load, sets
+  `wochenberichtGewerk` to `currentUser.department` (added to `req.user` in
+  `attachUser()`, `server.js`, specifically for this) if that's a valid
+  Gewerk — most people only ever need their own trade's meeting, so this
+  alone gets them straight to a filtered Tagesordnung with no extra step.
+  Only an account without a maintained `department` (e.g. the bootstrap admin)
+  falls through with `wochenberichtGewerk` still `null`.
+- **Changing it is a plain `<select>`, not a full-screen step**
+  (`renderGewerkDropdown()`, rendered both in the normal header via
+  `renderBerichtKopf()` and, as a bare prompt, when no default could be
+  resolved) — switching trades mid-session is a quick correction, not its own
+  workflow, so it deliberately does NOT interrupt the page the way the first
+  version of this feature (a blocking `#gewerkWizardModal`) did; that modal
+  and `oeffneGewerkWizard()` are gone. Picking an option calls
+  `waehleWochenberichtGewerk(g)` directly (`onchange`), which re-renders.
+- **The filter lives in ONE place**, `berichtProjekte(w)` itself: when
+  `wochenberichtGewerk` is set, it returns only projects whose `p.gewerke`
+  (from `project_gewerke`, populated by the "Neues Projekt" wizard's Gewerke
+  step, `js/projekt-wizard.js`) includes it. Because `renderWochenbericht()`,
+  `renderBerichtListe()`, `aktuellesBerichtProjekt()`, `openBerichtProtokoll()`
+  (the Protokoll text export) AND `exportWochenberichtPDF()` (`js/pdf.js`)
+  all call this same function, the filter applies everywhere at once with no
+  separate plumbing — screen, Protokoll and PDF can never disagree about
+  which projects belong to the current Gewerke-Besprechung. The PDF's header,
+  footer and filename additionally spell out the Gewerk
+  (`Wochenbericht_ELT_KW_33___2026.pdf`); `exportWochenberichtPDF()` refuses
+  with a message if called with no Gewerk chosen (only reachable for an
+  account with no maintained `department`, since everyone else gets one from
+  `wochenberichtGewerkVoreinstellen()` — the guard costs nothing either way).
+- **Attendance is unaffected** — `w.attendance`/`w.people` are session-wide,
+  not per-Gewerk, so `pdfWbAnwesenheitBlock()`/`renderAttendance()` keep
+  showing everyone regardless of the chosen Gewerk.
+- **Backfill for pre-existing projects**
+  (`migrateBackfillProjectGewerkeAusTags()`, `server.js`, runs at every
+  startup): every project that predates the Gewerke step — i.e. has zero
+  `project_gewerke` rows — gets its Gewerk copied from whichever
+  `ELT`/`HLS`/`ARCH` entry already sits in its `project_tags` (the marker
+  `migrateRemoveDepartmentPartition()` left behind when it merged the former
+  per-department copies). Without this, every pre-existing project would
+  silently vanish from every Gewerke-filtered Tagesordnung the first time
+  this feature shipped. Idempotent and non-destructive: it only ever inserts
+  for a project with **zero** `project_gewerke` rows, so a manual correction
+  in Projekteinstellungen (see next bullet) is never overwritten by a later
+  server restart.
+- **Gewerke are now correctable outside the wizard**: Projekteinstellungen
+  (`renderPlanSettings()`, `js/plan/plan-settings.js`) gained a "Gewerke"
+  checkbox row next to Schlagwörter, saved through `togglePlanGewerk()` —
+  the exact same mutate-`p.field`-then-`savePlan()` pattern as
+  `toggleBeauftragteLp()` (`js/plan/plan-honorar.js`). Before this, a
+  project's Gewerke could only ever be set once, during creation.
+
+### Wochenbericht — Verlauf der Vorwochen
+
+- The Wochenbericht is the **agenda of a weekly team meeting in which every
+  project is looked at**, changed or not. Completeness beats filtering here:
+  proposals that hide unchanged projects or reorder the list by kind of change
+  work against that routine — they force jumping between sections instead of
+  working down one list.
+- What is wanted instead is **being able to trace what changed from week to
+  week**, as a history available on demand next to the current state. That is
+  what `renderProjektVerlauf()` provides: an expandable "Verlauf" under each
+  project card showing one tile per earlier session, horizontally scrollable,
+  newest first. The current session is the card itself.
+- **It lives in `js/utils.js`, not in one tab**, because all three places that
+  show a history use it: the Wochenbericht under the project card, the project
+  list, and the Verlauf dialog of the Projektbereich (`openHistoryModal()`,
+  `js/plan/plan-history.js`). Each of them used to have its own version with
+  its own filter — the dialog showed comment texts only, and only for sessions
+  where the text actually changed — so the same project's history looked
+  different depending on where you opened it and could contradict itself. The
+  former "Frühere Sitzungen" expander under the comment field (a fourth, even
+  narrower selection) is gone with it.
+- Two things depend on `weekLabel`: with one, that session is left out (it is
+  the card above) and each tile offers "übernehmen" to copy an old comment into
+  the current one; **without** one — the dialog, which has no "current"
+  version — all sessions are shown and no "übernehmen" button appears, since
+  there would be no field to copy into.
+- **No new data storage.** Every session already holds a full copy of every
+  project — one tile per week — and `projectVersionsForUid()` (`js/utils.js`)
+  returns them chronologically. The timeline only makes visible what was
+  always there.
+- A tile carries the session's comment, the LPH values, the plan's dates
+  (latest date = project end, plus the next milestone) and the people assigned
+  **in that week** — read from that session's `week.people`, not today's, so an
+  old tile never shows people who weren't there yet.
+- Values that differ from the tile *before* it are highlighted: the tiles sit
+  side by side, but with ten Leistungsphasen the one changed number is
+  otherwise impossible to spot.
+- Rendered by `renderBoardDrawer()` (`js/board/board.js`) in **both** of its
+  variants; the former `BERICHT_OPTS.timeline` flag is gone, since the history
+  now hangs off every card rather than only the Wochenbericht's.
+
+### Dashboard ("Meine Aufgaben", now the default landing tab)
+
+**Aufbau: Kopf — Band — zwei Zonen.** Die Anordnung folgt der Frage, die beim
+Blick aufs Dashboard zuerst ansteht: „Was muss ich heute anpacken?"
+
+1. **Kopf** (`renderDashboardKopf()`) — Begrüßung und Datum links, Sitzung und
+   Uhr klein rechts. Die Uhrzeit war zuvor die größte Zahl auf dem Bildschirm;
+   sie ist die Angabe, nach der man am wenigsten handelt.
+2. **Band** (`renderDashboardBand()`) — der Befund des Tages als **Satz**
+   („8 Termine sind überfällig, 1 wird heute fällig"), daneben vier
+   Kennzahlen. Zuvor standen hier vier gleich große Kacheln, von denen meist
+   drei eine Null zeigten — die eine Zahl, auf die es ankommt, bekam dadurch
+   kein Gewicht. Ist nichts überfällig und nichts heute fällig, wird das Band
+   farblos (`.ist-ruhig`): Eine Null in Alarmfarbe behauptet ein Problem, das
+   es nicht gibt. Die Zahl im Satz ist `1.15em` groß — ab 19 px fett gilt für
+   den Kontrast die Schwelle für große Schrift, die Ampelfarbe erreicht auf
+   der abgesetzten Bandfläche sonst nur 4,1:1 im dunklen Thema.
+3. **Linke Zone** — der eigene Arbeitsstrom: „Meine Aufgaben" und „Termine
+   meiner Projekte", beide in derselben `.dash-karte`.
+4. **Rechte Zone** (300 px) — was man wissen muss, ohne selbst tätig zu
+   werden: ausstehende Freigaben und Abwesenheiten, beide in derselben
+   schmalen Zeilenform (`.dash-rand-zeile`). Zuvor stand der Urlaub eines
+   Kollegen gleichrangig unter den eigenen offenen Aufgaben. Unter 1080 px
+   fällt das Raster auf eine Spalte zurück.
+
+**Aufgaben sind Zeilen, keine Karten** (`renderDashboardAufgabe()`): Eine Karte
+belegte eine halbe Bildschirmbreite für vier Zeilen Inhalt. Dieselben Angaben —
+Titel, Projekt, Fortschritt, Fälligkeit, Schlagwörter — stehen jetzt in einer
+Zeile. Entfallen sind damit `renderStatTile()`, `renderDashboardTaskCard()`,
+`renderDashboardReviewCard()`, `renderDashboardGreeting()` und die CSS-Klassen
+`.dashboard-greeting`/`.dashboard-clock`/`.dashboard-absence-*`/
+`.absence-chip-live`.
+
+**Zwei Listen, die nicht dasselbe sind** — das ist der Kern dieses Bereichs:
+
+- **Meine Aufgaben** (`tasks`): die Aufgaben, die der Person PERSÖNLICH
+  zugewiesen sind (`plan_todo_assignees.person_id`), auch in Projekten, mit
+  denen sie sonst nichts zu tun hat. Als Karten.
+- **Termine meiner Projekte** (`projectDates`): die Aufgaben UND Meilensteine
+  der PROJEKTE, denen die Person zugeordnet ist (`project_assign`, state 1
+  oder 2) — unabhängig davon, wer die einzelne Aufgabe erledigt. Eine
+  Projektleitung muss wissen, wann im eigenen Projekt etwas fällig wird, auch
+  wenn ein anderer es abarbeitet. Als Liste, nach Dringlichkeit gegliedert
+  (Überfällig / Diese Woche / Danach).
+
+Beides zusammen beantwortet die Frage, die sonst nur durch Öffnen von dreißig
+Terminplänen zu beantworten war. Details:
+
+- **Keine Doppelung:** Was bereits unter `tasks` steht, wird aus
+  `projectDates` herausgefiltert (`selbst`-Kennzeichen, serverseitig).
+- **Zeitfenster 21 Tage** nach vorn; überfällige Termine bleiben dagegen ohne
+  Altersgrenze stehen — eine Frist verfällt nicht dadurch, dass sie lange
+  gerissen ist. Ohne die Grenze nach vorn stünden Termine aus einem Jahr in
+  der Liste und die dringenden gingen darin unter.
+- **Meilensteine haben kein Erledigt-Kennzeichen** (`plan_milestones` hat
+  keine `done`-Spalte), deshalb zählt bei ihnen allein das Datum; bei Aufgaben
+  gilt zusätzlich `done = 0` und ein gesetztes Enddatum.
+- **Die Namen der Zuständigen kommen aus `week_people`**, nicht aus
+  `loadGlobalPeople()`: Die globale Liste enthält nur Personen mit
+  Benutzerkonto, die Teilnehmerliste einer Sitzung dagegen jede Person, die
+  dort mitarbeitet. Ohne diesen Weg stand in der Liste `p_ap` statt
+  „Alexander Plum".
+- **Die Kachel „Überfällig"** zählt beide Listen zusammen; damit die Summe
+  nachvollziehbar bleibt, kennzeichnet auch die Aufgabenkarte ein überfälliges
+  Fälligkeitsdatum (`b.ist-ueberfaellig`). Eine Null bleibt neutral statt rot —
+  „0 überfällig" ist eine gute Nachricht.
+- Eine Zeile führt in den Terminplan des Projekts (`…#aufgaben`) — dorthin,
+  wo sich der Termin ändern lässt.
+- **Datumsvergleiche laufen über `heuteIso()`/`isoPlusTage()` (js/utils.js)
+  bzw. `heuteIsoLokal()`/`isoPlusTageLokal()` (server.js), nicht über
+  `new Date().toISOString().slice(0,10)`.** Letzteres rechnet nach UTC um: In
+  deutscher Sommerzeit (UTC+2) ist damit zwischen 00:00 und 02:00 Ortszeit
+  noch der Vortag gemeint — Termine von heute galten in diesem Fenster als
+  überfällig, und eine heute beginnende Abwesenheit fiel aus der Liste. Die
+  Feiertagsberechnung (`holidaysForYear()`) rechnet dagegen bewusst
+  durchgehend in UTC (`Date.UTC`, `isoFromDate()`) und ist davon nicht
+  betroffen. Serverseitig setzt die Korrektur voraus, dass der Server auf die
+  Zeitzone des Büros gestellt ist — im Docker-Container also
+  `TZ=Europe/Berlin`.
+
+
+- `GET /my-dashboard` (Auth) is the sole data source for this tab
+  (`js/dashboard/dashboard.js`, slug `MeineAufgaben`, first item in the
+  sidebar nav and `DEFAULT_TAB` in `js/globals.js` — the app lands here right
+  after login, not on the Projektboard). It aggregates, per
+  department (`ELT`/`HLS`/`ARCH`), the caller's open TODOs from that
+  department's currently unlocked week — normally there's exactly one
+  (`applyAutoLock()` invariant); if that's ever violated (0 or >1 unlocked
+  weeks) the server falls back to the most recent week via
+  `weekSortKeyServer()`, a server-side port of `weekSortKey()`
+  (`public/js/utils.js`). Tasks are matched by `plan_todo_assignees.person_id
+  = req.user.personId` and sorted by due date (empty dates last). The
+  response also includes `pendingReviews` (files awaiting the caller's
+  review decision), populated by the file-upload feature described above.
+
+### Wandtafel (tab `wand`, `js/wand/wand.js`)
+
+A tile dashboard meant for a dedicated, permanently-running touch monitor in
+the office — gewerke- and user-wide, the opposite scope of the Dashboard
+above (which is deliberately personal, "Meine Aufgaben"). **Replaces Show
+Mode outright** (`js/showmode.js`, the whole `.show-mode-*` CSS block, and
+the sidebar's old "Show Mode" entry are gone, not just unlinked). Show Mode
+only ever cloned whatever the ONE logged-in session's `#board`/`#load` tab
+happened to be rendering at the time (`copyCurrentViewToShowMode()` did a
+literal `innerHTML` copy, no independent data path) — it pre-dates both the
+department-retirement and the Dashboard, and never aggregated anything
+across Gewerke or users. Erik's own words: "macht so keinen Sinn mehr."
+
+- **No new server endpoint.** Every tile is a client-side projection of the
+  same `db` state every other tab already has after `GET /load-all` —
+  deliberately, to avoid holding `berechneAuslastung()`'s business logic in
+  two places (server SQL and client JS) for the sake of one dashboard. The
+  background refresh (`wandRefreshTick()`, every 60 s) checks `GET /whoami`
+  first, then calls the ordinary `load(true)` — the `true` is a new, optional
+  `silent` parameter on `load()` (`js/store.js`): on failure it only
+  `console.error()`s and leaves the last-known-good data on screen, instead
+  of `load()`'s normal blocking `alert()` + data-wipe, which would otherwise
+  stack unusable alert dialogs on an unattended touch screen every minute.
+- **Dedicated `kiosk` role** (`users.role`, alongside `admin`/`member` —
+  `VALID_ROLES` in `server.js` is now the one place that set is defined).
+  First built on a plain `member` account, changed on Erik's explicit
+  follow-up request for a real, separate role rather than relying on an
+  ordinary account's full write access. A `kiosk` account logs into the
+  kiosk browser once and is pointed at `/Wandtafel` directly (OS-level kiosk
+  browser config, e.g. a `--kiosk` flag — outside this codebase); its
+  session lives the normal, app-wide `sessionTage` (default 30 days,
+  unchanged) like any other account — no separate session-lifetime
+  mechanism was added. If the session expires, `wandRefreshTick()` calls the
+  existing `showLoginOverlay()` (`js/auth.js`) in place — the login form was
+  already wired once at page load by `checkAuthAndInit()`, so re-entering
+  the password resumes the Wandtafel via the same `afterAuthenticated()` →
+  `initUiState()` → `load()` path every normal page load already uses,
+  without a full reload (`initUiState()` re-derives `currentTab` from the
+  still-unchanged `/Wandtafel` URL).
+  - **Enforced server-side, not just a UI gate** (unlike most role
+    distinctions in this app, which are only hidden in the UI while the
+    server accepts any logged-in account — see "Auth / security quirk"):
+    `requireAuth` (`server.js`) now rejects `role === 'kiosk'` with 403
+    outright, on every route that used to accept any authenticated account.
+    A new, narrower `requireAuthOderKiosk` replaces plain `requireAuth` on
+    exactly the four read-only routes the Wandtafel's own `load()` call
+    needs — `GET /load-all`, `/app-settings`, `/holidays`,
+    `/honorar-config` — plus `POST /logout` (a kiosk account can still end
+    its own session, even though the UI has no reachable button for it once
+    the topbar is hidden). Every write route, `GET /users`, `GET
+    /my-dashboard`, and everything admin-only stays on plain `requireAuth`/
+    `requireRole('admin')` and therefore 403s a kiosk account exactly like
+    an anonymous visitor would get 401'd.
+  - **No Fachrolle, enforced in both directions.** `POST /admin/users` and
+    `PATCH /admin/users/:id` reject a `kiosk` role combined with a non-empty
+    discipline-`roles` array (400, "Ein Kiosk-Konto kann keine Fachrolle
+    haben.") — checked against the EFFECTIVE role and roles a request would
+    produce, not just the fields present in that one request body: setting
+    `role: 'kiosk'` on an account that already carries discipline roles in
+    the database is rejected exactly like sending `roles` alongside `role:
+    'kiosk'` in the same request, by reading the existing `user_roles` rows
+    when `roles` itself is absent from the PATCH body. The reverse direction
+    needed its own fix: the pre-existing self-demotion guard only checked
+    `role === 'admin' && newRole === 'member'`, so an admin could otherwise
+    have stepped themselves down to `kiosk` (a stricter demotion than to
+    `member`) through a gap the original check never anticipated — it now
+    checks `newRole !== 'admin'` generically. Client-side,
+    `saveNewUser()`'s existing "at least one Fachrolle required" check
+    (`admin-users.js`) is skipped when the selected role is `kiosk` (the
+    whole reason that check exists — `peopleByRole()` makes a roleless
+    account invisible everywhere — is exactly the outcome wanted here), and
+    selecting "Kiosk" in either user form disables and unchecks the
+    Fachrolle boxes live (`onUserRoleChange()`), so the 400 is never
+    actually hit in normal use — it exists as the real enforcement, the
+    client behavior is just not making the user discover it the hard way.
+  - **`GET /users` excludes `role = 'kiosk'`** — this endpoint (reviewer
+    picker, cross-department staffing) isn't Fachrolle-scoped the way
+    `peopleByRole()` is, so a kiosk account without discipline roles would
+    otherwise still turn up there as a selectable reviewer or team member,
+    where it could never actually act (every write route it would need
+    already 403s it) — just a dead end for whoever picked it, closed before
+    it could confuse anyone.
+- **Seitenleiste und Kopfzeile blenden sich aus** while on this tab
+  (`body.wandtafel-aktiv`, toggled in `showTab()`, hides `.app-topbar`/
+  `.side-menu`/`.side-menu-backdrop`). Written before the dedicated `kiosk`
+  role existed, when the account behind the display was an ordinary
+  `member` with real write access everywhere else — the hiding was a
+  security measure then, not just tidiness. The `kiosk` role closed that
+  hole server-side, but the hiding stayed: every other tab would now just
+  403 on its own data fetch for a kiosk account, and a sidebar full of
+  buttons that each lead to a broken-looking error view is a worse
+  experience than no sidebar at all. A small, deliberately unobtrusive
+  "← Zur Übersicht" link inside the panel (`App.html`) is the only way
+  back — meant for a staff member previewing the tab via their own,
+  non-kiosk account, not for the kiosk account itself, which has no reason
+  to ever leave it (and would just hit 403s on whatever tab it landed on).
+- **Two columns, version 2 (Erik's choice from the layout comparison),
+  replacing an earlier six-tile 3×2 grid.** The grid version left visibly
+  uneven whitespace: a tile with a single number (e.g. "Abwesend heute")
+  shared a row with a tile holding three meters, and — since every tile in a
+  row shares that row's height — the thin tile stretched to match without
+  having the content to fill it. Erik's own words: "ich finde es blöd das
+  Leere bereiche da sind." The fix is structural, not cosmetic: fewer,
+  heavier-weighted components (three left tiles, one feed) rather than many
+  thin ones, each stretched via `.wand-kachel-body { justify-content:
+  space-evenly }` so its own content distributes across its own full height
+  instead of clumping at the top. `body.wandtafel-aktiv` additionally makes
+  `.app-main`/`.container`/`#wand` behave like a fixed `100vh` viewport with
+  `overflow: hidden` instead of a normally-scrolling page — an unattended
+  display should never need scrolling, and the two columns size themselves
+  to exactly fill it rather than growing with content.
+  - **Left column — three tiles, never tappable as a whole.** An earlier
+    version let the whole tile expand/collapse (`wandKachelKlick()`,
+    `wandOffenKachel`, a chevron in the title). Erik's explicit follow-up
+    request removed that outright: "Das ein- und ausklappen der
+    Informationen in der Heute-Kachel kann entfallen. Die einzelnen dort
+    dargestellten Elemente sollen anklickbar sein, nicht die Kachel selber.
+    Das soll auch bei allen anderen Kacheln so sein." Every tile now always
+    renders its one, compact view — `wandKachel()` lost its interactive
+    wrapper entirely — and instead each individual element INSIDE a tile is
+    its own click target (`.ist-klickbar` on the specific row/stat/avatar,
+    never on `.wand-kachel`), each jumping straight to the matching detail
+    rather than toggling anything in place. Tapping one opens a full-screen
+    **Übersicht** (overview), the same drill-down mechanism the überfällige-
+    Aufgaben list introduced, now generalized to every clickable element via
+    one piece of module state: `wandUebersicht` (`null`, or
+    `{typ, gewerk?}` — `gewerk` only for the two per-Gewerk types) set by
+    `wandZeigeUebersicht(typ, gewerk)` and cleared by
+    `wandSchliesseUebersicht()`; `wandUebersichtHtml(w)` dispatches on `typ`
+    to the matching builder. `wandUebersicht` resets to `null` inside
+    `startWandboard()`'s guarded (once-per-real-entry) branch, so leaving
+    and returning to the Wandtafel always starts back at the normal
+    two-column view rather than wherever it was left.
+    - **Auslastung je Gewerk** — each of the three Gewerk meter rows is its
+      own click target (`wandZeigeUebersicht('auslastung', g)`).
+      `wandAuslastungJeGewerk()` collects, alongside the existing per-Gewerk
+      totals, a `projekte:[{id,name,nr,stunden}]` list — reusing the exact
+      same `berechneAuslastung()` call `renderLoad()` already makes, just
+      also keeping the per-project number instead of only summing it. The
+      deliberate multi-Gewerke double-count (a project tagged with several
+      Gewerke counts its full contribution at each) is unchanged. The
+      opened overview (`wandUebersichtAuslastung()`) lists every
+      contributing project of that Gewerk, highest hours first; a row jumps
+      into the project's **Leistung** section (`wandSpringeZuProjekt(pid,
+      'leistung')`) — the section that already computes honorar × Phase ×
+      Fortschritt, the most directly relevant place for an Auslastung
+      question to land.
+    - **Wochenbericht besprochen** — each of the three Gewerk meter rows
+      (only rendered clickable when that Gewerk actually has relevant
+      projects) opens `wandZeigeUebersicht('besprochen', g)`.
+      `wandBesprochenDaten()` now keeps `offeneProjekte:[{id,uid,name,nr}]`
+      per Gewerk (replacing the plain-string `offeneNamen` the first
+      version had) so each row in the opened overview
+      (`wandUebersichtBesprochen()`) can carry its `project_uid`. Clicking a
+      row does **not** open the Projektbereich — it calls
+      `springZumWochenbericht(uid)` (`js/plan/plan-info.js`), landing
+      directly on that project in the Wochenbericht. This follows "Ein Ort
+      je Angabe" (CLAUDE.md): the `besprochen`-Haken and the session
+      comment are editable *only* in the Wochenbericht, never in the
+      Projektbereich, so a jump into the Projektbereich would only land on
+      its own read-only verweis back to the Wochenbericht — one hop that
+      the Wandtafel now skips entirely.
+    - **Heute** — the two stat numbers (offene Aufgaben/überfällig) and the
+      avatar row are each independently clickable, no merged
+      expand/collapse state any more:
+      - **"offene Aufgaben"** → `wandZeigeUebersicht('offen')` — EVERY open
+        task across every project (not just overdue), nearest due date
+        first, empty dates last (`wandHeuteDaten()`'s new `offeneListe`,
+        the same sort convention "Meine Aufgaben" uses on the Dashboard).
+      - **"überfällig"** → `wandZeigeUebersicht('ueberfaellig')` — unchanged
+        from the previous version, now reached directly instead of as a
+        tap-target nested inside an otherwise expand/collapse-only tile.
+      - **the avatar row** → `wandZeigeUebersicht('abwesend')` — previously
+        only visible as an expanded detail list, now its own overview
+        reachable straight from the avatars; a row shows name/type/bis with
+        no click-through (an absence belongs to no project to jump to).
+      All three overviews share one row renderer
+      (`wandUebersichtZeile(links, mitte, rechts, onclick, rechtsKlasse)`)
+      and one frame (`wandUebersichtRahmen()`) — the per-type builders only
+      supply the three columns' content and (where it applies) the
+      `onclick`. A clicked task row calls `wandSpringeZuProjekt(pid,
+      'aufgaben')`, which sets `location.hash = 'aufgaben'` *before*
+      `openProjectPlan(pid)` (`js/gantt.js`) — the same "set the hash
+      first, `showTab('plan')`'s own `updateRouteUrl()` preserves it"
+      mechanism the Dashboard's own task links rely on
+      (`js/dashboard/dashboard.js`). This is a deliberate, explicit exit
+      from the Wandtafel: `showTab('plan')` clears `body.wandtafel-aktiv`
+      (sidebar/topbar return) exactly like navigating to any other tab
+      would, and a kiosk account landing on the Projektbereich can view it
+      (todos render from already-loaded `db` data, no fetch needed) but not
+      edit anything there (every write route still 403s) — a few of the
+      Projektbereich's OTHER sections do prefetch their own data
+      unconditionally on load (Dateien, Protokolle, the Benutzerliste for
+      the reviewer-picker), and those specific fetches 403 and log a
+      caught, non-fatal error for a kiosk account; the Aufgaben/Terminplan
+      sections themselves are unaffected. Every overview's list is the one
+      deliberate exception to the Wandtafel's "never scrolls" rule
+      (`.wand-uebersicht-liste { overflow-y: auto }`) — a genuinely long
+      list belongs to an intentional drill-down, not the passive ambient
+      view.
+  - **Right column — "Aktuell diese Woche"** replacing the old standalone
+    Projektportfolio tile outright (portfolio composition by
+    Gruppe/Auftragsstatus is not currently shown anywhere on the Wandtafel —
+    a deliberate scope cut in this version, not an oversight, left for a
+    future addition if wanted). `wandAktuelleEreignisse()` collects three
+    event kinds pulled from every project in the session:
+    - **Neu** — a project whose `classifyProjectChange()` bucket (reused
+      directly from `js/wochenbericht/wochenbericht.js`, same function the
+      Wochenbericht tab itself uses to diff against `findPreviousWeek()`) is
+      `'status'` or `'new'`, with a plain-text comment preview via
+      `statusPreviewText()` (`js/board/board.js`, HTML stripped, 70 chars).
+    - **Überfällig** — any open `plan_todos` entry whose `end` date has
+      already passed, across every project (not scoped to a person, unlike
+      `GET /my-dashboard`).
+    - **Termin** — any upcoming `plan_milestones` entry, across every
+      project.
+    Within each kind, entries are sorted by **closeness to today regardless
+    of direction** (`Math.abs(tageBis(datum))` ascending, `tageBis()` reused
+    from `js/dashboard/dashboard.js`) rather than by date — an event from
+    yesterday and one from tomorrow are both "relevant right now" in a way a
+    plain chronological sort wouldn't group together.
+    **On Erik's follow-up ("ein anderes Design für die Kachel Aktuell diese
+    Woche"), `wandFeedHtml()` groups these events into THREE SIDE-BY-SIDE
+    COLUMNS by kind (`WAND_FEED_SPALTEN`: Neu/Überfällig/Termine,
+    `.wand-feed-gruppen`/`.wand-feed-gruppe`) instead of one chronologically
+    mixed list** — a design choice ("Variante C") picked from a 3-way visual
+    comparison (alongside a connecting timeline and larger accent-bordered
+    cards). Trades away the previous single-list "what matters most right
+    now regardless of kind" ordering for an at-a-glance read of HOW MANY
+    events of each kind are pending — each column header shows the kind's
+    TRUE total count (`.wand-feed-gruppe-anzahl`) even though only
+    `WAND_FEED_MAX` (5, now a PER-COLUMN cap rather than a global one)
+    entries are actually listed underneath; an empty column shows "keine"
+    rather than being hidden, since the column's presence itself is part of
+    the at-a-glance count. Each row's timestamp (`relativerTag()`, also from
+    `dashboard.js`) is the same relative-day phrasing ("heute"/"morgen"/"seit
+    3 Tagen") used throughout the rest of the app.
+    **Every entry is its own click target** (`.wand-feed-eintrag`, part of
+    the same per-element interaction model as the left column). Each event
+    object carries `pid` and an `abschnitt` matched to its kind (`aufgaben`
+    for an überfällig entry, `terminplan` for a termin entry, `dashboard`
+    for a neu entry), and a click calls the shared `wandSpringeZuProjekt(pid,
+    abschnitt)` — an entry is already a single, concrete event, so unlike
+    the left column's meter rows it jumps straight into the project with no
+    intermediate overview.
+  - **Stand** — unchanged: a plain "Stand: HH:MM Uhr" timestamp under the
+    feed, the cheapest possible signal that the kiosk hasn't silently frozen
+    over the days/weeks it runs unattended.
+- **Below the fold: the complete project list, reachable by scrolling — the
+  one deliberate exception to "this display never scrolls".** Erik's
+  follow-up, after being told the ambient view couldn't fit a full project
+  list without breaking the fixed-viewport design: the Wandtafel's monitor is
+  a real touch screen, so he can walk up and scroll it by hand ("ich habe
+  einen Touch Monitor... ich kann mich vor die Tafel stellen und scrollen").
+  `renderWandboard()` now renders the two-column area wrapped in a new
+  `.wand-ambient` box (still exactly one screen tall, `min-height: 100%`)
+  followed by `wandProjektlisteHtml(w)` — every project, grouped and ordered
+  exactly like the Projekte list (`GROUP_ORDER`/`sortGroups()`, unlike the
+  Auslastung/Besprochen tiles this one deliberately INCLUDES "In Anbahnung",
+  since the point here is completeness, not bewertbare Arbeitslast).
+  **On Erik's explicit follow-up ("Die Projektliste soll so aussehen wie die
+  Originale"), each row is NOT a bespoke Wandtafel row** — it is built with
+  the exact same `renderBoardRow()` + `BOARD_OPTS` call `renderBoard()`
+  itself uses for the real Projekte tab (`js/board/board.js`): same Nr.,
+  name, Auftragsstatus-Kennzeichen, comment preview, avatar stack and
+  Phasen-Badge, and the row expands to the identical `renderBoardDrawer()`
+  detail panel. `locked` is passed as a hardcoded `true` regardless of the
+  session's actual lock state — the Wandtafel never writes (see file-header
+  comment), so this always hides the drag handle and the "Löschen" button
+  and always renders the comment as `.comment-readonly`, independent of
+  whether the real session happens to be unlocked; a kiosk account's write
+  attempt would 403 server-side anyway, so there is nothing to protect by
+  mirroring the real lock state here — only an unconditional, hardcoded
+  read-only rendering makes the guarantee independent of that state.
+  `toggleBoardRow()` (`board.js`) now also calls `renderWandboard()` after
+  flipping a row's expanded state, exactly as it already did for
+  `renderBoard()`/`renderWochenbericht()`, so expanding/collapsing a row in
+  the Wandtafel's own list takes effect immediately instead of only on the
+  next full re-render. Only `#wandContent` itself scrolls (class
+  `.wand-scrollable`, toggled by `renderWandboard()` — present
+  for the normal ambient view, absent while an Übersicht is open, which stays
+  exactly one screen tall with its own existing internal list scroll) —
+  `.app-main`/`.container` above it are untouched, still `overflow: hidden`.
+  **An unattended touch display can't be left in whatever state the last
+  passer-by scrolled it to**, so `WAND_IDLE_MS` (60 s) drives an inactivity
+  timer: `wandAktivitaetErkannt()` is registered once, globally, on
+  `pointerdown`/`touchstart`/`wheel`/`keydown`/`scroll` (the `scroll`
+  listener needs the **capturing** phase specifically — a scroll event on an
+  element, unlike on `window`/`document`, does not bubble, but a capturing
+  listener on an ancestor still sees it on the way down regardless of
+  bubbling) and is a no-op unless `body.wandtafel-aktiv` is set, so it costs
+  nothing on every other tab. Each call resets the timer; after `WAND_IDLE_MS`
+  without any of those events, `wandBeiUntaetigkeitZuruecksetzen()` clears
+  `wandUebersicht` and calls `renderWandboard({resetScroll:true})`,
+  unconditionally — even if nobody opened an Übersicht and only scrolled the
+  project list, that scroll position must still snap back. The same
+  `resetScroll` flag is also why an ordinary 60-second background data
+  refresh (`wandRefreshTick()` → `load(true)` → `renderWandboard()`, no
+  `opts`) does **not** reset anyone's scroll position — `renderWandboard()`
+  reads and restores `container.scrollTop` across every re-render unless
+  `resetScroll` is explicitly passed, so a person actively scrolling the
+  project list is never yanked back to the top by the routine data refresh,
+  only by genuine inactivity. **`#wandIdleCountdown`** (a `<span>` next to
+  "← Zur Übersicht" in `App.html`'s `.wand-kopfzeile`, deliberately OUTSIDE
+  `#wandContent` so it survives every data/content re-render untouched) —
+  Erik's follow-up wanting to see the countdown, not just experience the
+  jump. `wandAktivitaetErkannt()` additionally stores the absolute fire time
+  in `wandIdleDeadline`; a separate 1-second `setInterval`
+  (`wandCountdownTimer`, started/stopped alongside the others in
+  `startWandboard()`/`stopWandboard()`) runs `wandCountdownTick()`, which
+  writes "Rücksprung in N s" from `wandIdleDeadline - Date.now()`.
+  `wandBeiUntaetigkeitZuruecksetzen()` calls `wandAktivitaetErkannt()` again
+  at its own end, so the countdown keeps cycling continuously for as long as
+  the Wandtafel is open, rather than running once and going silent after the
+  first automatic reset.
+- **The same auto-return also applies AFTER leaving the Wandtafel through one
+  of its own clickable areas** — Erik's follow-up: "auch wenn ich eine der
+  Flächen/Projekte auf der Tafel anklicke soll nach 1 min das Bild wieder
+  zurückspringen". A tap on a project (the project list, a feed row, an
+  Übersicht row) or a Gewerk meter deliberately navigates away into the
+  Projektbereich or the Wochenbericht — without this, the display would be
+  left there indefinitely once nobody is around to notice. `wandUnterwegs`
+  (a module-level flag) tracks "away because of such a click"; while true,
+  `wandAktivitaetErkannt()` drives a *second* timer, `wandRueckkehrTimer`
+  (same `WAND_IDLE_MS`), instead of the on-Wandtafel idle timer, and
+  `wandKehreZurueck()` calls `showTab('wand')` once it fires — same
+  `WAND_IDLE_MS` constant, same "any touch resets it" semantics as the
+  on-Wandtafel case, just pointed the opposite direction.
+  **`wandUnterwegs` is set by one generic, capturing `click` listener on
+  `document` that checks `#wandContent.contains(event.target)`** — not by
+  wrapping every individual navigation call. The project list's rows render
+  through the real `renderBoardRow()` (see above), whose own `.board-name`
+  handler calls `openProjectPlan()` **directly** and calls
+  `event.stopPropagation()` first; a normal bubbling listener on
+  `#wandContent` would never see that click at all. A *capturing* listener
+  does, because capturing runs on the way down to the target regardless of
+  any `stopPropagation()` called later during bubbling. The listener only
+  ever sets the flag — arming `wandRueckkehrTimer` itself happens at the end
+  of `stopWandboard()` (`if(wandUnterwegs) wandAktivitaetErkannt();`), which
+  runs synchronously, in the same click, right after `body.wandtafel-aktiv`
+  has already been removed by `showTab()` — so by the time it checks,
+  `wandAktivitaetErkannt()` reliably takes the "away" branch rather than the
+  on-Wandtafel one. The Besprochen-Übersicht's jump into the Wochenbericht
+  (`springZumWochenbericht()`, shared with `board.js`/`plan-info.js`) needed
+  no wrapper or special-casing either, for the same reason — the click still
+  originates inside `#wandContent`. **The explicit "← Zur Übersicht" exit is
+  the one deliberate exception**: that button sits in `.wand-kopfzeile`,
+  OUTSIDE `#wandContent`, so the listener never sees it and `wandUnterwegs`
+  stays `false` — a staff member's deliberate preview exit is not
+  interrupted after a minute, only an accidental or exploratory tap on the
+  Wandtafel's own content is. `startWandboard()` resets `wandUnterwegs` to
+  `false` and clears `wandRueckkehrTimer` on every fresh arrival at the
+  Wandtafel (whether via `wandKehreZurueck()` or an ordinary manual
+  navigation back to it), so a completed round trip never leaves a stale
+  timer armed.
+- `TAB_SLUGS`/`VALID_TAB_SLUGS` gained `wand: 'Wandtafel'`
+  (`js/globals.js`/`server.js`) — the deep-link `/Wandtafel` works through
+  the same `applyUrlRoute()`/`updateRouteUrl()` mechanism as every other tab,
+  no special-casing needed. A redirect `GET /Test.html`-style old link isn't
+  needed here since nothing ever pointed at this tab before it existed.
+
 ## Docker
 
 - `docker compose up --build` from the repo root. Compose maps `3003:3003`,
-  bind-mounts `./sessions:/app/sessions`, `restart: unless-stopped`.
+  bind-mounts `./sessions:/app/sessions`, `restart: unless-stopped` and sets
+  **`TZ: Europe/Berlin`** — ohne das liefe der Container auf UTC, und die
+  Datumsvergleiche des Servers (`heuteIsoLokal()`) lägen zwischen Mitternacht
+  und 2 Uhr Ortszeit einen Tag zurück.
 - Dockerfile: `node:22-alpine` (nötig für node:sqlite), `npm ci --production`,
   runs as non-root `node`, HEALTHCHECK on `/health`. `.dockerignore` excludes
   `Docker/*` (except `Docker/Dockerfile`), `node_modules/`, `.git`,
   `npm-debug.log`.
 
+## Behobene Fehler (Prüfung 09/2026)
+
+Aus einer systematischen Durchsicht (Bericht mit 58 Funden) wurden folgende
+Verhaltensweisen geändert — wer den alten Zustand im Kopf hat, findet hier die
+Abweichungen:
+
+- **`GET /backup` ist admin-only** (`requireRole('admin')`). Der Snapshot
+  enthält die komplette Datenbank samt `user_sessions.token` im Klartext; mit
+  einem fremden Token ließ sich jede Admin-Grenze umgehen. Die Schaltfläche
+  "DB Backup" steht deshalb jetzt im Admin-Bereich der Seitenleiste.
+- **Die Sperre gesperrter Sitzungen wird serverseitig durchgesetzt**:
+  `/save-week` weist `locked: true → false` für Nicht-Admins mit 403 ab. Das
+  Sperren (false → true) bleibt jedem erlaubt, weil `applyAutoLock()` es beim
+  normalen Speichern mitschreibt.
+- **Anmeldung gebremst**: 10 Fehlversuche je Konto und Absender-Adresse sperren
+  für 10 Minuten (429). Der Schlüssel enthält den Benutzernamen, damit nicht
+  ein Tippfehler alle hinter derselben Büro-Adresse aussperrt. Bei unbekanntem
+  Benutzernamen wird trotzdem einmal gehasht (sonst verriete die Antwortzeit
+  gültige Konten). Abgelaufene Sitzungen werden beim Start gelöscht.
+- **`loadGlobalPeople()` liefert nur Konten mit gesetzter `person_id`.** Zwei
+  Konten ohne Kennung hätten sonst denselben leeren Primärschlüssel im
+  Teilnehmerkreis einer Sitzung belegt und jedes Speichern mit 500 abgebrochen;
+  `serializeWeek()` filtert doppelte Kennungen zusätzlich heraus.
+- **`loadWeeks()` hängt Teilnehmer an, statt sie per `array_order` zu
+  indizieren** — kollidierende Ordnungszahlen hätten Personen still
+  überschrieben.
+- **JSON-Dateien lassen sich hochladen**: Der globale `express.json()`-Parser
+  läuft nicht mehr über die in `RAW_BODY_ROUTES` gelisteten Routen (`/import`,
+  `POST /project-files`, `POST /project-protokolle/import` — die nehmen rohe
+  Binärdaten entgegen); das Limit für Sitzungsdaten liegt bei 8 MB.
+- **Der Teilnehmerkreis einer laufenden Sitzung ist wieder pflegbar**:
+  `addPersonToCurrentWeek()`/`removePersonFromCurrentWeek()` in
+  `js/people/people.js`. Vorher entstand `week.people` nur bei `newWeek()`, ein
+  später angelegter Benutzer war in keiner laufenden Sitzung zuordenbar. Das
+  Entfernen verweigert sich, solange die Person noch einem Projekt der Sitzung
+  zugeordnet ist.
+- **Speichern meldet sich**: `store.js` zählt Änderungen je Woche mit
+  (`weekChangeCounter`), damit eine Bearbeitung WÄHREND eines laufenden
+  Speichervorgangs ihre Dirty-Markierung behält; Fehler erscheinen als Band
+  unten rechts (`.sync-problem-bar`), werden nach 20 Sekunden erneut versucht,
+  und ein 401 öffnet wieder das Anmeldefenster. Nach einem fehlgeschlagenen
+  `load()` werden **keine** Beispieldaten mehr erzeugt (`seed()` lief früher
+  auch im Fehlerfall und überschrieb per `save()` die echte "KW 30 / 2026").
+- **`sanitizeStatusHtml()`** packte unerlaubte Elemente mit einem falschen
+  Referenzknoten aus (`insertBefore(child.firstChild, node)`) und warf dabei
+  `NotFoundError` — ein eingefügter Link genügte, um das Board-Rendering
+  abzubrechen. Zusätzlich werden ausgepackte Kinder jetzt erneut geprüft
+  (sonst blieben `<li>`/`<tbody>` stehen) und `<script>`/`<style>` samt Inhalt
+  verworfen. `esc()` maskiert nun auch `'`, weil mehrere Inline-Handler den
+  Wert in einfach gequotete JS-Strings setzen.
+- **Sitzungsbezeichnungen werden geprüft** (`validateWeekLabel()` in
+  `js/weeks.js`): keine Dubletten (der Server schlüsselt allein über das Label)
+  und Rückfrage bei fehlendem `KW …`-Muster (sonst sortiert die Sitzung hinter
+  alle echten und `applyAutoLock()` sperrt den Rest).
+- **Auslastung**: Die Ampel bezieht sich auf die Kapazität (gelb ab 0,75, rot
+  ab 1,0) statt auf das Skalenmaximum `LOAD_BAR_MAX`; der Mittelwert teilt nur
+  durch die Sitzungen, in denen die Person im Teilnehmerkreis stand.
+- **Projektbereich**: Auto-Schedule terminiert Meilensteine vor ihren
+  Nachfolgern, der Meilenstein-Dialog sperrt Zirkelbezüge, die Vorgängerliste
+  zeigt auch die einzige vorhandene Aufgabe (`>= 1` statt `> 1`), Enter im
+  Vorgänger-Suchfeld speichert nicht mehr, und das Verschieben einer
+  Abwesenheit legt erst neu an, wenn das Löschen bestätigt ist.
+- **Modals liegen über der Navigation** (`.modal-bg` `z-index: 300`); gesperrte
+  Bedienelemente sind an `:disabled`-Regeln erkennbar.
+
+### Nachtrag: die zunächst offen gebliebenen Punkte
+
+- **Aufwands-Gewichtung ohne Eintrag** (`berechneAuslastung()`, `js/load/load.js`):
+  Fehlt am Projekt ein Matrixwert, gilt jetzt der Wert aus der firmenweiten
+  Vorlage `LP_AUFWAND_VORLAGE` für diese Phase und Rolle — vorher pauschal 1,0.
+  Damit zählen zwei gleich gelagerte Projekte gleich, unabhängig davon, ob die
+  Aufwandsmaske schon einmal gespeichert wurde (LPH 9 steht in der Vorlage
+  bewusst auf 0). Nur wenn die Vorlage die Phase gar nicht kennt, bleibt es bei
+  1,0. Das Eingabefeld zeigt den jeweiligen Vorgabewert als Platzhalter.
+- **Abwesenheiten fremder Konten**: Eintragen bleibt für jedes angemeldete
+  Konto erlaubt (die Projektleitung pflegt Urlaube ihres Teams mit), aber
+  `user_absences.created_by` hält fest, wer den Eintrag angelegt hat.
+  `DELETE /users/:id/absences/:absenceId` erlaubt das Löschen nur der
+  betroffenen Person, dem Ersteller oder einem Administrator (sonst 403).
+  Die Spalte wird beim Start idempotent nachgerüstet; Altbestand hat
+  `created_by = 0` und ist damit nur von der betroffenen Person oder von
+  Administratoren löschbar.
+- **Fokus beim Speichern per Fokuswechsel** (`js/board/board.js`): Ein
+  `mousedown`-Lauscher in der Capture-Phase merkt sich, in welches
+  Kommentarfeld geklickt wird; nach dem Neu-Rendern stellt
+  `restorePendingCommentFocus()` den Fokus dort wieder her (Cursor ans
+  Textende). Die Schaltflächen "Speichern" und der Verlaufs-Aufklapper
+  unterdrücken zusätzlich den Fokusverlust (`onmousedown`/`preventDefault`,
+  wie zuvor schon "Verwerfen" und "übernehmen").
+- **Tote Reste entfernt**: `renderGantt()`/`fitGanttRange()` in `js/gantt.js`
+  (griffen auf Elemente zu, die es in keiner Seite mehr gibt), `statusBlur()`
+  und `delProj()` in `js/board/board.js` (seit dem Textfeld-Editor bzw. der
+  neuen Zeilendarstellung ohne Aufrufer), 16 CSS-Regelblöcke der früheren
+  TODO-Liste (damals in `project-plan.html`), die wirkungslose Klasse
+  `plan-main-content-full` und der gegenstandslose 900px-Umbruch.
+  **`buildGanttHtml()` bleibt in `js/gantt.js`** — `js/plan/plan-build-gantt.js`
+  umhüllt sie (`originalBuildGanttHtml`), sie ist also die Grundlage des
+  gesamten GANTT. Der Link "Zurück zur Übersicht" in `admin-users.html` nutzt
+  jetzt die neue Regel `a.secondary` statt Inline-Stilen.
+- **`esc()` verträgt Nicht-Strings**: Leistungsphasen-Prozentwerte kommen je
+  nach Herkunft als Zahl an; `(100).replace` ist keine Funktion und riss das
+  Rendern des Wochenberichts mit. `esc()` wandelt jetzt über `String()` um
+  (nur `null`/`undefined` werden zu `''`).
+
 ## Conventions & verification
 
 - Git repo; commits are German (e.g. "PDF Export von A4 auf A3 …"). Remote:
diff --git a/README.md b/README.md
index 8197947..1111a3a 100644
--- a/README.md
+++ b/README.md
@@ -1,145 +1,129 @@
-# Projektübersicht — README
+# Projektübersicht
 
-## Übersicht
-Dieses Projekt ist eine lokale Weboberfläche zur Verwaltung von TGA-Projekten (Elektro, HLS, Architektur) über wöchentliche Sitzungen. Die Anwendung besteht aus:
+Werkzeug für ein Ingenieurbüro der technischen Gebäudeausrüstung (TGA), um
+Projekte über wöchentliche Sitzungen hinweg zu verfolgen: Leistungsphasen nach
+HOAI, Termine, Personaleinsatz, die wöchentliche Teambesprechung und die
+Dokumentenfreigabe. Single-Page-App ohne Build-Schritt: Vanilla JS/HTML/CSS
+im Frontend, Node.js/Express im Backend, Daten in SQLite.
 
-- einem Frontend aus zwei HTML-Einstiegen (`Test.html` für die Hauptansicht mit Tabs, `project-plan.html` für die Projektplanung/GANTT-Ansicht) plus `styles.css` und den JS-Modulen unter `public/js/`
-- einem einfachen Node.js-/Express-Server in `server.js`
-- einem Datenspeicher in einer SQLite-Datenbank (`node:sqlite`, benötigt Node ≥ 22.13) unter `sessions/projektuebersicht.db`
-- einem Docker-Setup (`Docker/Dockerfile` + `docker-compose.yml` im Projektstamm)
+## Technologie
 
-## Datei- und Komponentenübersicht
+- **Frontend**: klassische, unmodulare `<script>`-Dateien unter `public/js/`
+  — alle Funktionen liegen global auf `window`, kein Bundler, kein Framework.
+  **Eine** HTML-Datei, `public/App.html`, bildet die gesamte Oberfläche ab
+  (Seitenleiste + alle Bereiche inklusive des Projektbereichs eines einzelnen
+  Projekts).
+- **Backend**: Node.js (≥ 22.13, wegen `node:sqlite`) + Express, alles in
+  einer einzigen `server.js`.
+- **Datenbank**: SQLite über das eingebaute `node:sqlite`-Modul (WAL-Modus,
+  vollständig relational, keine Einzeldatei je Woche), Datei unter
+  `sessions/projektuebersicht.db`.
+- Kein Linter, kein Formatter, keine Testsuite. Verifikation läuft manuell:
+  Server starten, Bereich im Browser ausprobieren, SQLite-Datei prüfen.
 
-### Wichtige Laufzeit-Dateien
-- `server.js`
-  - Node.js/Express-Server
-  - dient als API für das Frontend
-  - stellt statische Dateien (`Test.html`, `project-plan.html`, die Module unter `js/`, `styles.css`, etc.) bereit; statische Assets werden mit `Cache-Control: no-store` ausgeliefert
-  - implementiert Endpunkte:
-    - `GET /` → liefert `Test.html`
-    - `GET /load-all?department=…` → lädt alle Sitzungen plus globale Personenliste einer Abteilung
-    - `POST /save-week {department, week, baseUpdatedAt}` → speichert/aktualisiert eine Sitzung; mit `baseUpdatedAt` (die vom Client gehaltene Revision = `updatedAt` aus `load-all`) erkennt der Server veraltete Speicherungen und antwortet dann mit HTTP 409 `{ok:false, conflict:true, …}`; auch gelöschte Sitzungen werden mit nicht-leerer Basis nicht wiederbelebt (409). Erfolgreiche Saves antworten `{ok:true, updatedAt}` (neue Revision)
-    - `POST /save-people {department, people}` → ersetzt die globale Personenliste einer Abteilung
-    - `POST /delete-week {department, label}` → löscht eine Sitzung
-    - `GET /health` → Gesundheitscheck (`{ok:true}`)
-    - Deep Links je Abteilung + Tab, z. B. `GET /HLS/Auslastung` oder `GET /ELT/Projektübersicht` → liefert `Test.html`; gültige Tab-Slugs sind `Projektübersicht | Auslastung | Projekte | Projektbeteiligte`, alles andere ergibt 404
-    - `GET /<Dept>/Projektplan(/<ProjName>)?` → liefert `project-plan.html` (GANTT-Ansicht); die Identifikation erfolgt über die Query-Parameter `weekLabel` und `projNr`, der Projektname ist nur ein lesbares Pfad-Segment
-  - validiert Abteilungen gegen `ELT | HLS | ARCH` (unbekannte fallen stillschweigend auf `ELT` zurück)
-  - legt das `sessions`-Verzeichnis beim Start an, falls es nicht existiert
-  - JSON-Body-Limit von 2 MB
-  - beendet sich mit aussagekräftiger Fehlermeldung, wenn der Port belegt ist
+## Starten
 
-- `package.json`
-  - definiert den Node.js-Startbefehl `npm start`
-  - enthält Produktionsabhängigkeiten `express` und `cors`
-
-- `package-lock.json`
-  - wird für reproduzierbare Docker-Builds verwendet (`npm ci`)
-
-- `public/js/` (Module)
-  - Die Client-Logik ist in kleine klassische Script-Dateien aufgeteilt (alle Funktionen global auf `window`, kein Bundler):
-    - gemeinsame Helfer: `globals.js`, `utils.js`, `ui.js`, `date-picker.js`, `server.js`, `store.js`, `weeks.js`, `gantt.js`, `showmode.js`, `tabs-auth.js`, `pdf.js`, `init.js`
-    - tab-spezifisch in eigenen Ordnern: `board/board.js` (Projektboard), `people/people.js` (Projektbeteiligte), `projects/projects.js` (Projekte), `load/load.js` (Auslastung)
-    - Planungs-Module unter `js/plan/` (`plan-state`, `plan-build-gantt`, `plan-gantt`, `plan-drag`, `plan-modals`, `plan-schedule`)
-  - rendert das Projektboard, die Projekt- und Personenverwaltung sowie die Auslastungsansicht
-  - lädt Daten über den Server und speichert Änderungen als JSON-Objekte in die SQLite-Datenbank zurück
-  - verwendet `currentDepartment` zur Trennung von Abteilungen (`ELT`, `HLS`, `ARCH`)
-  - speichert:
-    - alle Sitzungen und die globale Personenliste pro Abteilung in `sessions/projektuebersicht.db`
-  - sortiert Sitzungen nach Kalenderwoche, nicht alphabetisch
-  - sperrt historische Sitzungen automatisch (bis auf die chronologisch letzte)
-  - Personen sind global pro Abteilung verwaltet; historische Sitzungen behalten ihre lokalen Personenkopien
-  - speichert keine Daten in `localStorage` (dort liegt nur UI-Zustand wie Abteilung, Theme und Header-Collapse)
-
-- `Test.html`
-  - die Haupt-Benutzeroberfläche der Anwendung (Tabs: Projektboard, Auslastung, Projekte, Projektbeteiligte)
-  - lädt `styles.css` und die JS-Module aus `js/` in fester Reihenfolge (siehe `AGENTS.md`)
-  - enthält die Abteilungsauswahl, Sitzungsnavigation, Tab-Navigation, das Passwort-Modal sowie PDF-Export
-  - lädt CryptoJS (Passwortprüfung) und pdfmake (PDF-Export) von `cdnjs.cloudflare.com` — diese Funktionen benötigen daher Internetzugang
-
-- `project-plan.html`
-  - die Planungsansicht (GANTT/TODOs/Meilensteine) pro Projekt
-  - öffnet sich in einem neuen Tab über `openProjectPlan()` (`js/gantt.js`)
-  - lädt nur die gemeinsamen Helfermodule plus `js/plan/*` und window-übergreifend abgestimmte Pfade
-
-- `styles.css`
-  - Layout und Styling der Oberfläche
-
-### Docker-bezogene Dateien
-- `Docker/Dockerfile`
-  - Basis-Image: `node:22-alpine` (nötig, da `node:sqlite` erst ab Node 22.13 ohne Flag stabil verfügbar ist)
-  - kopiert `package.json` und `package-lock.json`, installiert Produktionsabhängigkeiten mit `npm ci`
-  - kopiert `server.js` und `public/` nach `/app`
-  - legt sicherheitshalber `/app/sessions` an
-  - läuft als nicht-root-User `node`
-  - enthält einen `HEALTHCHECK` auf `/health`
-  - startet `node server.js`
-
-- `docker-compose.yml` (im Projektstamm)
-  - definiert den Service `projektuebersicht`
-  - baut das Image mit Build-Kontext `.` und `Docker/Dockerfile`
-  - mappt Port `3003:3003`
-  - bindet das Host-Verzeichnis `./sessions` in den Container nach `/app/sessions`
-  - setzt `restart: unless-stopped`
-  - definiert einen `healthcheck`
-
-- `.dockerignore`
-  - schließt unnötige Dateien aus dem Docker-Build aus: `node_modules/`, `npm-debug.log`, `.git`, `.gitignore`, `Docker/*` (außer `Docker/Dockerfile`)
-
-### Sonstige Dateien
-- `dein_bild.ico`
-  - optionales Icon, wird vom Server statisch ausgeliefert, wenn angefragt
-
-- `AGENTS.md`
-  - Projektnotizen / Dokumentation, aber nicht Teil des Anwendungslaufs
-
-## Persistenz und Datenfluss
-
-### Speicherung
-- Alle persistierten Daten werden in einer SQLite-Datenbank (`node:sqlite`, `DatabaseSync`, WAL-Modus, `PRAGMA foreign_keys = ON`) unter `sessions/projektuebersicht.db` gespeichert.
-- Das Schema ist vollständig relational (19 Tabellen): `weeks`, `week_people` (+ `week_people_roles`), `attendance`, `projects`, `project_lph`, `project_assign`, `project_aufwand`, `project_aktuelle_lp`, `project_plan`, `plan_people`, `plan_todos` (+ `plan_todo_assignees`, `plan_todo_deps`), `plan_milestones` (+ `plan_milestone_deps`), `people` (+ `person_roles`, `person_absences`). Projekt-/Personen-IDs bleiben dadurch über Neustarts stabil.
-- Der Datenbankpfad ist über die Umgebungsvariable `DB_PATH` übersteuerbar (für Tests/Backups), Standard ist `sessions/projektuebersicht.db`.
-
-### Server-API
-- Der Server wird in `server.js` erstellt und startet auf Port `3003` oder dem Wert von `process.env.PORT`.
-- Das Frontend ruft den Server über `window.location.origin` an (Fallback `http://localhost:3003` bei `file://`-Öffnung).
-
-### Wo werden die Daten gespeichert?
-- Das Frontend schreibt über den Server in die SQLite-Datenbank.
-- In `js/store.js` speichert die Anwendung nur **geänderte** Sitzungen (Dirty-Tracking über `markWeekDirty()`/`markPeopleDirty()`) via `/save-week` (Sitzungen) bzw. `/save-people` (globale Personen); ein In-Flight-Guard verhindert Doppel-Speicherungen. Jede Sitzung führt einen Revisions-Zeitstempel (`updated_at`, übertragen als `updatedAt`); speichert ein Client mit veralteter Revision (`baseUpdatedAt`), antwortet der Server mit HTTP 409 und der Client lädt nur diese eine Sitzung neu (andere ungespeicherte Änderungen bleiben erhalten).
-- Der Server zerlegt die JSON-Objekte in die relationalen Tabellen (`serializeWeek()`/`loadWeeks()`) in einer Transaktion pro Sitzung. Beim Start migriert `migrateLegacySchema()` idempotent ein altes Single-JSON-Dokument-Schema in das relationale Schema; anschließend ergänzt `migrateWeeksUpdatedAt()` die `updated_at`-Spalte der `weeks`-Tabelle (idempotent). `PRAGMA busy_timeout = 5000` verhindert Fehler bei parallelen Schreibzugriffen.
-
-## Betrieb
-
-### Lokal mit Node.js (Node ≥ 22.13)
+### Lokal (Node.js ≥ 22.13)
 ```bash
 npm install
 npm start
 ```
-Danach ist die Anwendung erreichbar unter `http://localhost:3003`.
-
-Falls der Port belegt ist:
+Erreichbar unter `http://localhost:3003`. Anderer Port:
 ```bash
 PORT=3004 npm start
 ```
 
 ### Mit Docker
-Im Projektstamm ausführen:
-
 ```bash
 docker compose up --build
 ```
+`docker-compose.yml` liegt im Projektstamm, baut aus `Docker/Dockerfile`
+(`node:22-alpine`), mappt Port `3003` und bindet `./sessions` in den
+Container nach `/app/sessions` — die Datenbank und alle Uploads bleiben damit
+auf dem Host erhalten. `TZ=Europe/Berlin` ist gesetzt, weil mehrere
+Datumsvergleiche im Server von der lokalen Zeitzone abhängen.
 
-Danach ist die Anwendung erreichbar unter:
+### Erste Anmeldung
+Die gesamte Anwendung verlangt eine Anmeldung. Ist die `users`-Tabelle beim
+ersten Start leer, legt der Server automatisch ein Admin-Konto
+(`admin`) mit einem zufälligen Passwort an, gibt es einmalig auf der Konsole
+aus und schreibt es zusätzlich nach `sessions/INITIAL_ADMIN_PASSWORD.txt`
+(liegt außerhalb von `public/`, wird also nie ausgeliefert). Das Konto muss
+sein Passwort beim ersten Login ändern.
 
-```
-http://localhost:3003
-```
+## Bereiche der Anwendung
 
-## Wichtige Hinweise
-- Der Server benötigt Lese-/Schreibzugriff auf `sessions/` (für die SQLite-Datenbank und das Docker-Bind-Mount).
-- Die Docker-Compose-Konfiguration liegt im Projektstamm und mountet `./sessions` in den Container. Achte darauf, dass der relative Pfad im Kontext korrekt ist, wenn du `docker compose` aus einem anderen Verzeichnis startest.
-- `js/store.js` und `js/server.js` arbeiten mit Abteilungsparametern und speichern Daten abteilungsweise getrennt.
-- Die Passwortfunktion (Tabs „Projekte“/„Projektbeteiligte“, Sitzungslöschung, Entsperren) ist nur ein einfacher Client-Mechanismus im Frontend (SHA256-Vergleich) und kein echter Sicherheitsmechanismus.
-- Globale Personen werden pro Abteilung in der Datenbank verwaltet. Wird eine Person global gelöscht, bleibt sie in bereits existierenden Sitzungen sichtbar (Wochen-Personenkopien).
-- CryptoJS und pdfmake werden von `cdnjs.cloudflare.com` geladen — PDF-Export und Passwortprüfung funktionieren ohne Internet nicht.
\ No newline at end of file
+Seitenleiste, in dieser Reihenfolge:
+
+- **Meine Aufgaben** — Dashboard und Startansicht nach dem Login: offene
+  persönliche Aufgaben, Termine der eigenen Projekte, ausstehende
+  Datei-Freigaben, Abwesenheiten von Kollegen.
+- **Projekte** — die eine Projektliste (Board), gruppiert, per Drag-and-Drop
+  sortierbar.
+- **Wochenbericht** — die Tagesordnung der wöchentlichen Teambesprechung, je
+  Gewerk (ELT/HLS/ARCH) gefiltert: jedes Projekt dieses Gewerks wird
+  angesehen, mit Vergleich zur Vorwoche, Anwesenheitserfassung und PDF-Export.
+- **Auslastung** — Personalauslastung in tatsächlichen Wochenstunden,
+  aufgeteilt nach Projekten (Lastband).
+- **Projektbeteiligte** — schreibgeschützte Übersicht der aktiven
+  Benutzerkonten; Teammitglieder pflegt ausschließlich ein Administrator
+  (Admin → Benutzerverwaltung).
+- **Planung** — ein von einem konkreten Projekt unabhängiger
+  Terminplan-Sandkasten, z. B. um einen Zeitplan vorab durchzurechnen.
+- **Einstellungen** — das eigene Konto: Stammdaten, E-Mail, Passwort, eigene
+  KI-Zugangsdaten für die Protokoll-Erkennung (siehe unten).
+- **Admin** *(nur Administratoren)* — Benutzerverwaltung, Honorar-Vorgaben,
+  Auslastungs-Schwellen, Sitzungsverwaltung, Feiertage, Aufgaben-Vorlagen,
+  Betrieb & Sicherheit, Datenbank-Backup/-Import.
+
+### Projektbereich
+
+Aus der Projektliste heraus öffnet sich zu einem Projekt ein eigener Bereich
+mit sieben Abschnitten: Dashboard, Terminplan (GANTT mit Aufgaben und
+Meilensteinen), Aufgaben, Leistung (erbrachter Leistungswert je Phase),
+Dateien, Protokolle (Besprechungsprotokolle) und Einstellungen
+(Projektstammdaten, Honorar, beauftragte Leistungsphasen).
+
+## Datenhaltung
+
+- Vollständig relationales SQLite-Schema statt eines JSON-Dokuments je Woche;
+  Projekt- und Personen-IDs bleiben über Neustarts stabil.
+- Eine Sitzung ("KW XX / YYYY") entspricht einer Kalenderwoche. Der Wechsel
+  in eine neue Sitzung läuft automatisch im Hintergrund (stündliche Prüfung)
+  — es gibt keine "Neue Sitzung"-Schaltfläche mehr.
+- Der Server legt bei jedem Start automatisch einen Zeitstempel-Snapshot
+  unter `sessions/backups/` an und behält nur die neuesten (Anzahl einstellbar
+  unter Admin → Betrieb & Sicherheit). Ein Admin kann zusätzlich jederzeit
+  ein Backup herunterladen oder eine Sicherung zurückspielen.
+- Hochgeladene Dateien (Freigabe-Workflow, importierte Protokolle) liegen
+  unter `sessions/uploads/<uuid>.<endung>`, referenziert über die Datenbank.
+
+## Authentifizierung & Rollen
+
+Echte serverseitige Sitzungen (Cookie, `scrypt`-gehashte Passwörter) — kein
+clientseitiger Passwortschutz. Zwei Rollen: `admin` und `member`; nur
+wirklich destruktive bzw. administrative Aktionen (Benutzerverwaltung,
+Sitzung löschen/entsperren, DB-Import/-Backup) sind serverseitig auf Admins
+beschränkt. Zu viele Fehlversuche sperren ein Konto vorübergehend.
+
+## Besonderheiten
+
+- **Keine Abteilungstrennung mehr**: Alle Sitzungen, Projekte und Personen
+  liegen in einer gemeinsamen Liste. `ELT`/`HLS`/`ARCH` bezeichnen heute nur
+  noch die Fachrichtung eines Benutzerkontos bzw. die Gewerke eines Projekts.
+- **Protokoll-Import** kann ein hochgeladenes PDF/Word-Dokument
+  KI-gestützt (eigener OpenAI- oder Claude-Schlüssel je Konto, auch ein
+  lokal laufendes Modell möglich) in Besprechungspunkte umwandeln und fällt
+  ohne Schlüssel oder bei einem Fehler automatisch auf eine
+  Text-Heuristik zurück.
+- Der PDF-Export lädt `pdfmake` von `cdnjs.cloudflare.com` — benötigt
+  Internetzugang.
+- Feiertage werden serverseitig berechnet (keine externe Abhängigkeit), die
+  KI-gestützte Protokoll-Erkennung braucht dagegen Internetzugang bzw. ein
+  erreichbares lokales Modell.
+
+## Weiterführende Dokumentation
+
+`CLAUDE.md` im Projektstamm enthält die ausführliche technische
+Dokumentation: Server-API, vollständiges Datenmodell, Architekturentscheidungen
+und ihre Begründung. Ausgangspunkt für tiefere Änderungen am Code.
diff --git a/package-lock.json b/package-lock.json
index 4ed389d..8efe9b3 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -11,7 +11,8 @@
         "cors": "^2.8.5",
         "express": "^4.18.2",
         "mammoth": "^1.13.0",
-        "pdfjs-dist": "^6.3.289"
+        "pdfjs-dist": "^6.3.289",
+        "undici": "^8.11.2"
       }
     },
     "node_modules/@napi-rs/canvas": {
@@ -1304,6 +1305,15 @@
       "integrity": "sha512-DXtD3ZtEQzc7M8m4cXotyHR+FAS18C64asBYY5vqZexfYryNNnDc02W4hKg3rdQuqOYas1jkseX0+nZXjTXnvQ==",
       "license": "MIT"
     },
+    "node_modules/undici": {
+      "version": "8.11.2",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-8.11.2.tgz",
+      "integrity": "sha512-u4UB2/IrKdU6lFxumHmmo1a3fCQO5tzQllRorfoRS63txhrB7xTpSn1PftwC4qEHkOaqP95fCWW4lJzwErwzhQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=22.19.0"
+      }
+    },
     "node_modules/unpipe": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
diff --git a/package.json b/package.json
index e5b58e8..f82e2b9 100644
--- a/package.json
+++ b/package.json
@@ -10,6 +10,7 @@
     "cors": "^2.8.5",
     "express": "^4.18.2",
     "mammoth": "^1.13.0",
-    "pdfjs-dist": "^6.3.289"
+    "pdfjs-dist": "^6.3.289",
+    "undici": "^8.11.2"
   }
 }
diff --git a/public/App.html b/public/App.html
new file mode 100644
index 0000000..4e519c9
--- /dev/null
+++ b/public/App.html
@@ -0,0 +1,1673 @@
+<!DOCTYPE html>
+<!--
+  HAUPTSEITE der Projektübersicht (wird vom Express-Server unter "/" ausgeliefert).
+  Sie verwaltet eine einzige, firmenweit globale wöchentliche Sitzung (Sitzungswahl,
+  -anlage, -duplikat und -löschung im seitlichen Menü) und enthält ALLE Bereiche der
+  Anwendung. Die Seitenleiste links schaltet über showTab() (js/tabs-auth.js)
+  zwischen ihnen um: Dashboard, Projektboard, Wochenbericht, Auslastung, Projekte,
+  Projektbeteiligte, Wandtafel — und dem PROJEKTBEREICH eines einzelnen Projekts (#plan).
+
+  Der Projektbereich war bis zum Umbau ein eigenes Dokument (public/project-plan.html),
+  das openProjectPlan() als neue Seite öffnete; die Seitenleiste dort war nur eine
+  abgespeckte Nachbildung. Jetzt ist er ein Bereich wie jeder andere: dieselbe
+  Seitenleiste, derselbe Wechsel-Weg wie vom Dashboard ins Projektboard, kein
+  Neuladen. Adressierbar bleibt er über "/Projektplan/<Projektname>?weekLabel=…
+  &projNr=…" (applyUrlRoute()/updateRouteUrl() in js/ui.js); seine fünf
+  Unterbereiche stehen im URL-Fragment (…#aufgaben).
+
+  Geladen werden das gemeinsame Stylesheet styles.css und plan-styles.css (die
+  Stile des Projektbereichs, früher ein <style>-Block in project-plan.html) sowie
+  der Reihe nach die Module js/globals.js, js/utils.js, js/icons.js, js/ui.js,
+  js/date-picker.js, js/server.js, js/auth.js, js/store.js, js/weeks.js, danach die
+  bereichsspezifischen Module js/board/board.js, js/wochenbericht/wochenbericht.js,
+  js/people/people.js, js/projects/projects.js, js/load/load.js,
+  js/dashboard/dashboard.js, js/wand/wand.js (Wandtafel, braucht load.js/
+  auftrag.js/dashboard.js), dann js/gantt.js mit den darauf aufbauenden
+  js/plan/*-Modulen des Projektbereichs und zuletzt js/tabs-auth.js,
+  js/pdf.js, js/backup.js, js/import.js und
+  js/init.js; pdfmake kommt von einem CDN. Der Zugriff auf die gesamte Seite ist
+  über eine echte serverseitige Session abgesichert (js/auth.js,
+  checkAuthAndInit(): Login-Overlay bis /whoami eine gültige Session meldet).
+-->
+<html lang="de">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Projektübersicht</title>
+<link rel="stylesheet" href="/styles.css?v=62">
+<link rel="stylesheet" href="/plan-styles.css?v=19">
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/pdfmake/0.2.10/pdfmake.min.js"></script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/pdfmake/0.2.10/vfs_fonts.js"></script>
+ </head>
+<body>
+<div class="app-shell">
+  <header class="app-topbar">
+    <button class="mobile-nav-toggle menu-corner-btn" onclick="toggleHeader()" title="Menü öffnen/schließen" aria-expanded="false" aria-controls="headerMenu">
+      <span class="icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"><line x1="4" y1="7" x2="20" y2="7"/><line x1="4" y1="12" x2="20" y2="12"/><line x1="4" y1="17" x2="20" y2="17"/></svg></span>
+    </button>
+
+    <div class="topbar-brand">
+      <img src="/logo.ico" alt="Logo" class="topbar-logo">
+      <h1 id="pageTitle" class="topbar-title">Projektübersicht</h1>
+    </div>
+
+    <!-- Die Sitzungsauswahl stand hier früher als Dropdown. Sitzungen sind
+         reine Speicherung + Verlauf; die Oberfläche zeigt immer nur die
+         eine offene Sitzung, ohne das im Menüband zu betonen. Eine
+         gesperrte Sitzung lässt sich weiterhin ansehen und für eine
+         Korrektur entsperren — dafür jetzt Admin → Termine & Sitzungen
+         (renderAdminSitzungen(), js/admin/admin.js). -->
+
+    <div class="app-topbar-actions">
+      <button class="theme-toggle-circle" id="themeToggle" onclick="toggleTheme()" title="Hell/Dunkel umschalten">
+        <span id="themeIcon"><span class="icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M20.5 14.5A8.5 8.5 0 1 1 9.5 3.5a7 7 0 0 0 11 11Z"/></svg></span></span>
+      </button>
+
+      <div class="topbar-user">
+        <button class="theme-toggle-circle avatar-btn" id="userMenuToggle" onclick="toggleUserMenu()" title="Konto" aria-expanded="false" aria-controls="userMenuDropdown">
+          <span class="icon" id="userAvatarIcon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="8.5" r="3.5"/><path d="M4.5 20c0-4 3.5-6.5 7.5-6.5s7.5 2.5 7.5 6.5"/></svg></span>
+        </button>
+        <div class="user-menu-dropdown" id="userMenuDropdown">
+          <div class="user-menu-info" id="userBarInfo"></div>
+          <button class="menu-item" onclick="logout()">
+            <span class="icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M9 21H5.5A1.5 1.5 0 0 1 4 19.5v-15A1.5 1.5 0 0 1 5.5 3H9"/><path d="M16 17l5-5-5-5"/><line x1="21" y1="12" x2="9" y2="12"/></svg></span>
+            Abmelden
+          </button>
+        </div>
+      </div>
+    </div>
+  </header>
+
+  <div class="app-body">
+  <div id="headerMenu" class="side-menu" aria-hidden="true">
+    <div class="side-menu-mobile-header">
+      <button class="header-toggle secondary" onclick="toggleHeader()" title="Menü schließen">
+        <span class="icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"><line x1="6" y1="6" x2="18" y2="18"/><line x1="18" y1="6" x2="6" y2="18"/></svg></span>
+      </button>
+    </div>
+
+    <nav class="sidebar-nav">
+      <button class="nav-item tab active" data-tab="dashboard" onclick="showTab('dashboard')" title="Dashboard">
+        <span class="nav-icon"><span class="icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="4" width="7" height="7" rx="1.5"/><path d="m4.5 7.5 1.3 1.3L8.5 6"/><line x1="13" y1="6" x2="21" y2="6"/><rect x="3" y="14" width="7" height="7" rx="1.5"/><path d="m4.5 17.5 1.3 1.3 2.7-2.8"/><line x1="13" y1="16" x2="21" y2="16"/></svg></span></span><span class="nav-label">Dashboard</span>
+      </button>
+
+      <hr class="sidebar-nav-divider">
+
+      <div class="sidebar-section-label">Navigation</div>
+      <!-- Die eine Projektliste. Der frühere zweite Eintrag "Projekte" —
+           dieselben Projekte, dieselben Angaben, eine zweite Bearbeitungs-
+           maske — ist hier aufgegangen: Reihenfolge, Gruppenwechsel und
+           Löschen stehen in dieser Liste, die Projektangaben im
+           Projektbereich, die wöchentliche Erfassung im Wochenbericht. -->
+      <button class="nav-item tab" data-tab="board" onclick="showTab('board')" title="Projekte">
+        <span class="nav-icon"><span class="icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="3" width="18" height="18" rx="2.5"/><line x1="9" y1="3" x2="9" y2="21"/><line x1="15" y1="3" x2="15" y2="21"/></svg></span></span><span class="nav-label">Projekte</span>
+      </button>
+      <button class="nav-item tab" data-tab="wochenbericht" onclick="showTab('wochenbericht')" title="Wochenbericht">
+        <span class="nav-icon"><span class="icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M8 3.5h8a1.5 1.5 0 0 1 1.5 1.5v14a1.5 1.5 0 0 1-1.5 1.5H8A1.5 1.5 0 0 1 6.5 19V5A1.5 1.5 0 0 1 8 3.5Z"/><path d="M9.5 3.5h5v2.2a.8.8 0 0 1-.8.8h-3.4a.8.8 0 0 1-.8-.8V3.5Z"/><path d="m9.3 12.2 1.5 1.5 3.4-3.4"/><line x1="9.3" y1="16.3" x2="14.7" y2="16.3"/></svg></span></span><span class="nav-label">Wochenbericht</span>
+      </button>
+      <button class="nav-item tab" data-tab="load" onclick="showTab('load')" title="Auslastung">
+        <span class="nav-icon"><span class="icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><line x1="5" y1="21" x2="5" y2="10"/><line x1="12" y1="21" x2="12" y2="5"/><line x1="19" y1="21" x2="19" y2="14"/><line x1="3" y1="21" x2="21" y2="21"/></svg></span></span><span class="nav-label">Auslastung</span>
+      </button>
+      <!-- "Projektbeteiligte" stand hier bis zur Entfernung der Abteilungs-
+           trennung (migrateRemoveDepartmentPartition(), CLAUDE.md
+           "Departments were retired"): eine rein lesende Liste, deren
+           eigentlicher Zweck — Beteiligte gezielt aus einer ANDEREN Abteilung
+           in die eigene Sitzung zu holen — mit der Zusammenlegung zu EINEM
+           gemeinsamen Personenkreis entfiel. Übrig blieb eine Dopplung der
+           Rollen-/Avatar-Chips, die in Wochenbericht/Board/Auslastung ohnehin
+           schon sichtbar sind. Auf Eriks Wunsch aus der Seitenleiste entfernt;
+           der Tab selbst (`#people`, `js/people/people.js`) und sein Slug
+           `Projektbeteiligte` in VALID_TAB_SLUGS bestehen unverändert fort —
+           ein alter Link/Deep-Link funktioniert also weiterhin, nur der
+           direkte Weg über die Navigation fehlt. -->
+
+      <!-- Projektbereich: der einzige Navigationspunkt, der nicht immer da
+           ist. Er erscheint, sobald ein Projekt geöffnet wurde, und trägt
+           dessen Bezeichnung (syncPlanNavItem() in js/tabs-auth.js). Ohne
+           ihn wäre im Projektbereich gar kein Punkt hervorgehoben und die
+           Seitenleiste zeigte nicht mehr, wo man gerade ist. -->
+      <button class="nav-item tab" data-tab="plan" id="planNavItem" style="display:none" onclick="showTab('plan')" title="Projektbereich">
+        <span class="nav-icon"><span class="icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><rect x="3.5" y="5" width="17" height="14" rx="2"/><line x1="3.5" y1="9.5" x2="20.5" y2="9.5"/><line x1="7" y1="13" x2="13" y2="13"/><line x1="7" y1="16" x2="16" y2="16"/></svg></span></span><span class="nav-label" id="planNavItemLabel">Projektbereich</span>
+      </button>
+
+      <!-- Planung: eigener, zweiter Abschnitt (nicht Teil von "Navigation"),
+           wie gewünscht — eine Sandbox für Terminpläne unabhängig von einem
+           echten Projekt (aus Honorar errechnet oder frei angelegt), siehe
+           CLAUDE.md "Planung — projektunabhängige Terminplan-Sandbox". -->
+      <div class="sidebar-section-label">Planung</div>
+      <button class="nav-item tab" data-tab="planung" onclick="showTab('planung')" title="Planung">
+        <span class="nav-icon"><span class="icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><rect x="3.5" y="4" width="17" height="17" rx="2.5"/><line x1="3.5" y1="9.5" x2="20.5" y2="9.5"/><line x1="8" y1="2.5" x2="8" y2="6.5"/><line x1="16" y1="2.5" x2="16" y2="6.5"/><line x1="7" y1="14" x2="12" y2="14"/><line x1="7" y1="17.5" x2="15" y2="17.5"/></svg></span></span><span class="nav-label">Planung</span>
+      </button>
+
+      <hr class="sidebar-nav-divider">
+
+      <!-- Einstellungen: seit die firmenweiten Masken in den Admin-Bereich
+           gewandert sind, steht hier nur noch das eigene Konto — ein
+           Aufklapp-Menue fuer einen einzigen Punkt waere Ballast. -->
+      <button class="nav-item tab" data-tab="settings" onclick="showTab('settings')" title="Einstellungen">
+        <span class="nav-icon"><span class="icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="3.2"/><path d="M12 3.5v2.4M12 18.1v2.4M20.5 12h-2.4M5.9 12H3.5M17.7 6.3l-1.7 1.7M8 15.7l-1.7 1.7M17.7 17.7 16 16M8 8 6.3 6.3"/></svg></span></span><span class="nav-label">Einstellungen</span>
+      </button>
+
+      <button class="nav-item nav-group-toggle" id="toolsAccordionToggle" onclick="toggleSidebarAccordion('tools')" title="Werkzeuge" aria-expanded="false" aria-controls="toolsSubnav">
+        <span class="nav-icon"><span class="icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M14.5 6.2a3.6 3.6 0 0 1 4.8 4.4l-8.1 8.1a2 2 0 0 1-2.8-2.8l8.1-8.1"/><path d="M6.5 3.5 9 6l-3 3-2.5-2.5a3.5 3.5 0 0 1 3-3Z"/></svg></span></span><span class="nav-label">Werkzeuge</span>
+        <span class="nav-chevron"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><polyline points="6 9 12 15 18 9"/></svg></span>
+      </button>
+      <div class="sidebar-subnav" id="toolsSubnav">
+        <!-- "+ Neues Projekt" stand bis zum Aufraeumen unter "Admin". Ein
+             Projekt anzulegen ist aber alltaegliche Arbeit: Es geht ueber den
+             normalen Wochen-Speicherweg (POST /save-week, requireAuth), der
+             Server verlangt dafuer keine Administratorrolle. Die Sperre war
+             rein optisch und hielt Mitglieder von gewoehnlicher Arbeit ab,
+             ohne irgendetwas zu schuetzen. -->
+        <!-- "Neue Sitzung"/"Sitzung duplizieren" standen hier bis zum
+             automatischen Sitzungswechsel (ensureCurrentWeekRollover(),
+             server.js): eine neue Sitzung entsteht jetzt serverseitig von
+             selbst, sobald der Kalender in eine neue ISO-Woche wechselt —
+             unabhängig davon, ob der Wochenbericht überhaupt geöffnet wird,
+             siehe CLAUDE.md. -->
+        <!-- "PDF Export" (die gewerkeübergreifende A3-Sitzungsübersicht,
+             exportPDF()) stand hier bis auf Eriks Wunsch: PDF-Export soll
+             nur noch im Wochenbericht (exportWochenberichtPDF()) und in den
+             Terminplanungen (exportSandboxPlanPDF()) stehen — beide siehe
+             js/pdf.js. Damit fällt die einzige gewerkeübergreifende
+             Sitzungsübersicht als PDF weg; die einzelnen Gewerke-Berichte
+             im Wochenbericht bleiben die Ablage. -->
+        <button class="menu-item sidebar-subitem" onclick="openNewProjWizard()">+ Neues Projekt</button>
+        <button class="menu-item sidebar-subitem" onclick="showTab('wand')">Wandtafel</button>
+      </div>
+
+      <!-- Admin: aufklappbare Gruppe ueber die Abschnitte von #admin. Wie
+           bei "Einstellungen" zuvor ist das KEINE Aktionsliste, sondern
+           Navigation innerhalb eines Bereichs — deshalb fuehrt schon der
+           Kopf-Eintrag dorthin (toggleAdminNav()) und die Unterpunkte
+           schalten nur den sichtbaren Abschnitt um (showAdminSection() in
+           js/admin/admin.js). Die gesamte Gruppe blendet renderUserBar()
+           (js/auth.js) fuer Nicht-Administratoren aus; die eigentliche
+           Sperre sitzt serverseitig auf den Routen. -->
+      <div id="navAdminSection" style="display:none">
+        <button class="nav-item nav-group-toggle" id="adminAccordionToggle" onclick="toggleAdminNav()" title="Admin" aria-expanded="false" aria-controls="adminSubnav">
+          <span class="nav-icon"><span class="icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M12 3.5 5.5 6v5.3c0 4.4 2.9 7.4 6.5 8.7 3.6-1.3 6.5-4.3 6.5-8.7V6Z"/><path d="m9 12 2.1 2.1L15.5 9.5"/></svg></span></span><span class="nav-label">Admin</span>
+          <span class="nav-chevron"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><polyline points="6 9 12 15 18 9"/></svg></span>
+        </button>
+        <div class="sidebar-subnav" id="adminSubnav">
+          <button class="menu-item sidebar-subitem" data-admin-section="benutzer" onclick="showAdminSection('benutzer')">Benutzerverwaltung</button>
+          <button class="menu-item sidebar-subitem" data-admin-section="honorar" onclick="showAdminSection('honorar')">Honorar</button>
+          <button class="menu-item sidebar-subitem" data-admin-section="auslastung" onclick="showAdminSection('auslastung')">Auslastung</button>
+          <button class="menu-item sidebar-subitem" data-admin-section="termine" onclick="showAdminSection('termine')">Termine &amp; Sitzungen</button>
+          <button class="menu-item sidebar-subitem" data-admin-section="feiertage" onclick="showAdminSection('feiertage')">Feiertage</button>
+          <button class="menu-item sidebar-subitem" data-admin-section="vorlagen" onclick="showAdminSection('vorlagen')">Aufgaben-Vorlagen</button>
+          <button class="menu-item sidebar-subitem" data-admin-section="betrieb" onclick="showAdminSection('betrieb')">Betrieb &amp; Sicherheit</button>
+          <button class="menu-item sidebar-subitem" data-admin-section="datenbank" onclick="showAdminSection('datenbank')">Datenbank &amp; Sitzungen</button>
+        </div>
+      </div>
+    </nav>
+
+    <button class="sidebar-collapse-bar" id="sidebarCollapseToggle" onclick="toggleSidebarCollapse()" title="Seitenleiste ein-/ausklappen" aria-pressed="false">
+      <span id="sidebarCollapseIcon" class="icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><polyline points="15 5 8 12 15 19"/></svg></span>
+    </button>
+  </div>
+
+  <div id="sideMenuBackdrop" class="side-menu-backdrop" onclick="toggleHeader()"></div>
+
+  <div class="app-main">
+    <div class="container">
+  <!-- BOARD -->
+  <!-- display:none wie bei allen anderen Panels: showTab() blendet den
+       richtigen Bereich erst nach der Anmeldeprüfung ein. Ohne das stand
+       hinter dem Login-Fenster das Projektboard, während in der Navigation
+       "Dashboard" hervorgehoben war. -->
+  <div id="board" style="display:none">
+    <!-- Titelzeile mit "+ Projekt": Der Knopf stand bisher nur in der
+         Seitenleiste unter "Sitzung". Anlegen gehört dorthin, wo die Projekte
+         stehen — in dieser Liste, die seit der Zusammenlegung auch Reihenfolge,
+         Gruppe und Löschen verantwortet. In der Seitenleiste bleibt er
+         zusätzlich stehen, weil er dort dieselbe Maske öffnet. -->
+    <div class="bericht-titelzeile">
+      <div class="section-title" style="margin:0">Projekte</div>
+      <button type="button" class="secondary small" onclick="openNewProjWizard()">+ Projekt</button>
+    </div>
+    <!-- Die Farbe der Kreise richtet sich nach der ROLLE (siehe
+         .board-avatar.role-* in styles.css), die Füllung nach der Art der
+         Zuordnung. Die frühere Legende erklärte nur Grün und behauptete damit
+         implizit, Projektleitung (rot) und Bauüberwachung (blau) gäbe es nicht. -->
+    <div class="legend">
+      <span><span class="swatch" style="background:var(--green)"></span> Planung</span>
+      <span><span class="swatch" style="background:var(--red)"></span> Projektleitung</span>
+      <span><span class="swatch" style="background:var(--accent)"></span> Bauüberwachung</span>
+      <span class="legend-sep">·</span>
+      <span><span class="swatch" style="background:var(--text-subtle)"></span> gefüllt = hauptverantwortlich</span>
+      <span><span class="swatch" style="background:transparent;box-shadow:inset 0 0 0 2px var(--text-subtle)"></span> umrandet = unterstützend</span>
+      </div>
+    <div id="boardTable"></div>
+  </div>
+
+  <!-- WOCHENBERICHT -->
+  <div id="wochenbericht" style="display:none">
+    <div class="bericht-titelzeile">
+      <div class="section-title" style="margin:0">Wochenbericht</div>
+      <button type="button" class="secondary small" onclick="openBerichtProtokoll()">Protokoll…</button>
+      <!-- Anderer Export als "Protokoll": Das Protokoll ist eine Kurzfassung
+           (was hat sich geändert + neue Aufgaben) zum Kopieren/Mailen. Dieser
+           Knopf legt die ganze Tagesordnung als PDF ab — eine Karte je
+           Projekt mit vollständigem Kommentar, Fortschritt und Beteiligten,
+           siehe exportWochenberichtPDF() in js/pdf.js. -->
+      <button type="button" class="secondary small" onclick="exportWochenberichtPDF()">Als PDF ablegen</button>
+    </div>
+    <div id="wochenberichtContent"></div>
+    <div id="weekAttendance"></div>
+  </div>
+
+  <!-- LOAD -->
+  <div id="load" style="display:none">
+    <div class="section-title">Auslastung der Projektbeteiligten</div>
+    <div class="load-grid" id="loadGrid"></div>
+  </div>
+
+  <!-- PEOPLE -->
+  <div id="people" style="display:none">
+    <div class="section-title">Projektbeteiligte</div>
+    <div id="peopleList"></div>
+  </div>
+
+  <!-- PLANUNG (js/planung/planung.js) — Terminplan-Sandbox, unabhängig von
+       einem echten Projekt. Bearbeitet wird ein einzelner Plan im ganz
+       normalen Projektbereich (#plan) — siehe openSandboxPlan(),
+       js/plan/plan-state.js. -->
+  <div id="planung" style="display:none">
+    <div class="bericht-titelzeile">
+      <div class="section-title" style="margin:0">Planung</div>
+      <button type="button" class="secondary small" onclick="oeffneNeuerTerminplanDialog()">+ Neuer Terminplan</button>
+    </div>
+    <p class="hint" style="margin:0 0 16px">Terminpläne unabhängig von einem laufenden Projekt — zum Ausprobieren, für Angebote, um Kapazität grob abzuschätzen.</p>
+    <div id="planungList"></div>
+  </div>
+
+  <!-- DASHBOARD (Begrüßung/Uhr, Meine Aufgaben, Freigaben, Kollegen-Abwesenheiten) -->
+  <div id="dashboard" style="display:none">
+    <div id="dashboardContent"></div>
+  </div>
+
+  <!-- WANDTAFEL (js/wand/wand.js) — gewerke- und nutzerübergreifendes
+       Kachel-Dashboard für ein dauerhaft laufendes Touch-Display. Ersetzt
+       den früheren Show Mode, der nur die gerade angemeldete Sitzung
+       großflächig klonte und keine echte Zusammenfassung über Gewerke/
+       Nutzer hinweg bot. showTab() blendet beim Betreten zusätzlich
+       Seitenleiste und Kopfzeile aus (body.wandtafel-aktiv, styles.css) —
+       das Kiosk-Konto hat echte Schreibrechte, eine zufällige Berührung der
+       Navigation soll dort nicht versehentlich in einen bearbeitbaren
+       Bereich führen. Der kleine Rücksprung-Link dient einer Vorschau durch
+       reguläres Personal; das Kiosk-Konto selbst braucht ihn nie. -->
+  <div id="wand" style="display:none">
+    <div class="wand-kopfzeile">
+      <button type="button" class="wand-zurueck" onclick="showTab((typeof previousTab==='string' && previousTab && previousTab!=='wand') ? previousTab : DEFAULT_TAB)">← Zur Übersicht</button>
+      <span id="wandIdleCountdown" class="wand-idle-countdown"></span>
+    </div>
+    <div id="wandContent" class="wand-grid-wrap"></div>
+  </div>
+
+  <!-- EINSTELLUNGEN (js/settings/settings.js)
+       Nur noch das eigene Konto: Stammdaten zur Ansicht und der
+       Passwortwechsel. Die firmenweiten Masken standen hier zunaechst
+       daneben, gehoeren aber zum Bereich "Admin" weiter unten — sie
+       verschieben die Zahlen ALLER Nutzer und stehen nur Administratoren zu,
+       waehrend dieser Bereich jedem angemeldeten Konto gehoert. -->
+  <div id="settings" style="display:none">
+    <div class="section-title">Einstellungen</div>
+
+    <div class="settings-grid">
+      <section class="settings-card" id="settingsAccountCard" data-settings-section="konto">
+        <h3 class="settings-card-title">Mein Konto</h3>
+        <div id="settingsAccountInfo" class="settings-kv"></div>
+        <p class="hint">Anzeigename, Rolle und Personen-Zuordnung pflegt ein
+           Administrator in der Benutzerverwaltung. Die E-Mail-Adresse und das
+           Passwort gehören dem Konto selbst.</p>
+        <div class="toolbar">
+          <button class="secondary" onclick="openPasswordModal(false)">Passwort ändern</button>
+        </div>
+      </section>
+
+      <!-- KI-Zugangsdaten: persönlich je Konto, nicht firmenweit — jeder
+           Nutzer hinterlegt seinen eigenen Schlüssel (+ optional eine
+           abweichende API-URL für einen lokalen Server wie LM Studio/
+           Ollama oder einen Firmen-Proxy) für die KI-gestützte
+           Punkt-Erkennung beim Protokoll-Import. Die Schlüssel werden
+           geschrieben, aber nie zurückgelesen (wie ein Passwort), siehe
+           readUserAiKey()/writeUserAiKey() in server.js und CLAUDE.md
+           "### Protokolle". Je Anbieter ein eigener, umrandeter Block mit
+           Cloud/Eigener-Server-Umschalter statt eines eingeklappten
+           "API-URL"-Links — die eigene Anbindung (z. B. LM Studio) ist ein
+           Kernfall, kein Nebendetail, siehe CLAUDE.md. Dazu ein
+           "Neu verbinden"-Knopf (echter Testaufruf über
+           POST /my-ai-settings/test, nicht nur Anzeige von "configured")
+           mit Fehlertext, der bis zum nächsten Testergebnis stehen bleibt
+           (Design-Entwürfe mit Erik abgestimmt: Artifacts d7ab2945,
+           01fe1346). -->
+      <section class="settings-card" id="settingsAiCard">
+        <h3 class="settings-card-title">KI-Zugangsdaten</h3>
+        <p class="hint">Für die automatische Punkt-Erkennung beim Protokoll-Import
+          (Projektbereich → Protokolle → „Protokoll importieren"). Ohne
+          hinterlegten Schlüssel wird automatisch die Textmuster-Erkennung
+          verwendet — ein Schlüssel ist also optional, nicht Voraussetzung.</p>
+
+        <div class="ai-provider" id="aiProviderChatgpt">
+          <div class="ai-provider-head">
+            <div class="ai-provider-mark chatgpt">Ai</div>
+            <div class="ai-provider-info">
+              <div class="ai-provider-name">ChatGPT</div>
+              <div class="ai-provider-sub">OpenAI</div>
+            </div>
+            <span class="ai-status-chip" id="aiOpenaiStatus"><span class="dot"></span>–</span>
+            <button class="ai-reconnect-btn" id="aiOpenaiReconnectBtn" onclick="testMyAiConnection('chatgpt')" title="Neu verbinden">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><polyline points="23 4 23 10 17 10"/><polyline points="1 20 1 14 7 14"/><path d="M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15"/></svg>
+            </button>
+          </div>
+          <div class="ai-provider-row">
+            <input type="password" id="setAiOpenaiKey" placeholder="API-Schlüssel einfügen…" autocomplete="off">
+            <button class="ai-icon-btn" onclick="saveMyAiKey('chatgpt')" title="Speichern">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><polyline points="5 13 10 18 19 7"/></svg>
+            </button>
+            <button class="ai-text-btn" id="aiOpenaiClearBtn" onclick="clearMyAiKey('chatgpt')" title="Schlüssel entfernen">Entfernen</button>
+          </div>
+          <div class="ai-test-error" id="aiOpenaiTestError"></div>
+          <div class="ai-mode-toggle" id="aiOpenaiModeToggle">
+            <button type="button" class="is-active" onclick="setAiMode('chatgpt','cloud')">Cloud</button>
+            <button type="button" onclick="setAiMode('chatgpt','lokal')">Eigener Server</button>
+          </div>
+          <div class="ai-url-panel" id="aiOpenaiUrlPanel">
+            <label>Adresse des eigenen Servers</label>
+            <div class="ai-provider-row">
+              <input type="text" id="setAiOpenaiUrl" placeholder="z. B. http://localhost:1234 für LM Studio">
+              <button class="ai-icon-btn" onclick="saveMyAiUrl('chatgpt')" title="URL speichern">
+                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><polyline points="5 13 10 18 19 7"/></svg>
+              </button>
+            </div>
+          </div>
+        </div>
+
+        <div class="ai-provider" id="aiProviderClaude">
+          <div class="ai-provider-head">
+            <div class="ai-provider-mark claude">Cl</div>
+            <div class="ai-provider-info">
+              <div class="ai-provider-name">Claude</div>
+              <div class="ai-provider-sub">Anthropic</div>
+            </div>
+            <span class="ai-status-chip" id="aiClaudeStatus"><span class="dot"></span>–</span>
+            <button class="ai-reconnect-btn" id="aiClaudeReconnectBtn" onclick="testMyAiConnection('claude')" title="Neu verbinden">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><polyline points="23 4 23 10 17 10"/><polyline points="1 20 1 14 7 14"/><path d="M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15"/></svg>
+            </button>
+          </div>
+          <div class="ai-provider-row">
+            <input type="password" id="setAiClaudeKey" placeholder="API-Schlüssel einfügen…" autocomplete="off">
+            <button class="ai-icon-btn" onclick="saveMyAiKey('claude')" title="Speichern">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><polyline points="5 13 10 18 19 7"/></svg>
+            </button>
+            <button class="ai-text-btn" id="aiClaudeClearBtn" onclick="clearMyAiKey('claude')" title="Schlüssel entfernen">Entfernen</button>
+          </div>
+          <div class="ai-test-error" id="aiClaudeTestError"></div>
+          <div class="ai-mode-toggle" id="aiClaudeModeToggle">
+            <button type="button" class="is-active" onclick="setAiMode('claude','cloud')">Cloud</button>
+            <button type="button" onclick="setAiMode('claude','lokal')">Eigener Server</button>
+          </div>
+          <div class="ai-url-panel" id="aiClaudeUrlPanel">
+            <label>Adresse des eigenen Servers</label>
+            <div class="ai-provider-row">
+              <input type="text" id="setAiClaudeUrl" placeholder="z. B. http://localhost:11434 für Ollama">
+              <button class="ai-icon-btn" onclick="saveMyAiUrl('claude')" title="URL speichern">
+                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><polyline points="5 13 10 18 19 7"/></svg>
+              </button>
+            </div>
+          </div>
+        </div>
+
+        <span class="field-error" id="settingsAiError" hidden></span>
+      </section>
+    </div>
+
+    <div id="settingsNote" class="settings-note"></div>
+  </div>
+
+  <!-- ===================== ADMIN (js/admin/admin.js) =====================
+       Alles, was nur Administratoren zusteht, an einer Stelle. Die
+       firmenweiten Masken standen zuvor im Bereich „Einstellungen" neben
+       „Mein Konto" — das vermischte die eigenen Kontoangaben mit Vorgaben,
+       die die Zahlen ALLER verschieben. Die drei Datenbank-/Sitzungs-
+       Aktionen waren nackte Menüpunkte in der Seitenleiste, wo ein
+       Fehlklick genügte; sie stehen jetzt im Abschnitt „Datenbank &
+       Sitzungen" mit dem Hinweis, was sie anrichten.
+       Sichtbar ist immer genau ein Abschnitt (showAdminSection()); der
+       gewählte steht im URL-Fragment (…/Admin#auslastung). -->
+  <div id="admin" style="display:none">
+    <div class="section-title" id="adminSectionTitle">Admin</div>
+
+    <div class="settings-grid">
+      <section class="settings-card" id="adminHonorarCard" data-admin-section="honorar" style="display:none">
+        <h3 class="settings-card-title">Honorar <span class="settings-scope">firmenweit · nur Administratoren</span></h3>
+        <p class="hint">Grundlage der Terminplan-Berechnung aus dem Honorar („+ Terminplan" im
+           Projektbereich): Honorar × Anteil der Leistungsphase ÷ Stundensatz = Stunden.</p>
+        <div id="honorarAdminFields" class="honorar-anteil-grid"></div>
+        <div class="honorar-admin-foot">
+          <div id="honorarAdminSum"></div>
+          <label class="honorar-satz-field">
+            <span>Stundensatz</span>
+            <input type="number" id="honorarStundensatz" min="1" step="1" value="135"> €
+          </label>
+          <button class="secondary small" onclick="saveHonorarConfig()">Speichern</button>
+        </div>
+      </section>
+
+      <section class="settings-card" id="adminAuslastungCard" data-admin-section="auslastung" style="display:none">
+        <h3 class="settings-card-title">Auslastung <span class="settings-scope">firmenweit · nur Administratoren</span></h3>
+        <p class="hint">Die Auslastung wird in <strong>Wochenstunden</strong> gerechnet: offener
+           Honorarwert der amtierenden Leistungsphase geteilt durch den Stundensatz, verteilt auf
+           die Rollen, die zugeordneten Personen und die verbleibenden Wochen. Die Ampel misst
+           jede Person an IHRER Stelle — 1,0 heißt voll ausgelastet; die vertraglichen
+           Wochenstunden stehen am Konto (Benutzerverwaltung).</p>
+        <div class="settings-field-grid">
+          <label class="settings-field"><span>Wochenstunden einer vollen Stelle</span>
+            <input type="number" id="setVollzeitStunden" min="1" max="80" step="0.5"></label>
+          <label class="settings-field"><span>Ampel gelb ab</span>
+            <input type="number" id="setSchwelleGelb" min="0.05" max="5" step="0.05"></label>
+          <label class="settings-field"><span>Ampel rot ab</span>
+            <input type="number" id="setSchwelleRot" min="0.05" max="5" step="0.05"></label>
+          <label class="settings-field"><span>Referenzhonorar für die Projektgröße (€)</span>
+            <input type="number" id="setReferenzHonorar" min="1000" max="100000000" step="1000"></label>
+          <label class="settings-field"><span>Verteilzeitraum ohne Terminplan (Wochen)</span>
+            <input type="number" id="setVerteilWochen" min="1" max="260" step="1"></label>
+        </div>
+        <p class="hint">Projekte ohne hinterlegtes Honorar tragen statt dessen eine
+           <strong>Projektgröße von 0 bis 1</strong> (Bereich „Einstellungen" des Projekts);
+           1,0 entspricht dem Referenzhonorar. Der Verteilzeitraum gilt, solange ein Projekt
+           keinen Terminplan hat, aus dem sich ein Ende ergibt — ohne Horizont wäre die
+           Wochenlast nicht bestimmt.</p>
+
+        <h4 class="settings-subtitle">Aufwand je Leistungsphase und Rolle</h4>
+        <p class="hint">Gilt für jedes Projekt, das in seiner eigenen Aufwandsmaske keinen Wert
+           trägt — also für die meisten. 0 = zählt nicht zur Auslastung, 1 = voller Aufwand.</p>
+        <div id="setAufwandMatrix" class="settings-matrix-wrap"></div>
+
+        <div class="toolbar">
+          <button class="secondary small" onclick="saveAuslastungSettings()">Speichern</button>
+        </div>
+      </section>
+
+      <section class="settings-card" id="adminTerminCard" data-admin-section="termine" style="display:none">
+        <h3 class="settings-card-title">Termine &amp; Sitzungen <span class="settings-scope">firmenweit · nur Administratoren</span></h3>
+        <div class="settings-field-grid">
+          <label class="settings-field"><span>Arbeitsstunden je Person und Werktag</span>
+            <input type="number" id="setStundenProTag" min="1" max="24" step="0.5"></label>
+        </div>
+        <label class="settings-check">
+          <input type="checkbox" id="setAutoLock">
+          <span>Ältere Sitzungen automatisch sperren</span>
+        </label>
+        <p class="hint">Ist das aus, bleibt jede Sitzung bearbeitbar. Bereits gesperrte Sitzungen
+           bleiben gesperrt — entsperrt wird weiterhin bewusst über „Sitzung entsperren".</p>
+        <div class="toolbar">
+          <button class="secondary small" onclick="saveTerminSettings()">Speichern</button>
+        </div>
+
+        <!-- Die Oberfläche zeigt sonst nirgends mehr, welche Sitzung gerade
+             offen ist — dafür genügt eine Zeile, da es ohnehin immer nur
+             eine gibt. Diese Liste ist die einzige Stelle, die alle
+             Sitzungen nebeneinander zeigt: zur Kontrolle und um eine
+             gesperrte für eine nachträgliche Korrektur zu entsperren. -->
+        <h4 class="settings-subtitle">Sitzungen</h4>
+        <p class="hint">Jede Sitzung ist ein Wochenstand für Speicherung und Verlauf — bearbeitet
+           wird immer nur die eine offene. Eine gesperrte Sitzung lässt sich hier entsperren und
+           öffnen, etwa um einen Kommentar nachträglich zu korrigieren; beim nächsten Laden sperrt
+           die Automatik sie wieder, sofern sie aktiv ist.</p>
+        <div class="template-admin-list" id="adminSessionsList"></div>
+      </section>
+
+      <section class="settings-card" id="adminHolidayCard" data-admin-section="feiertage" style="display:none">
+        <h3 class="settings-card-title">Feiertage <span class="settings-scope">firmenweit · nur Administratoren</span></h3>
+        <p class="hint">Arbeitsfreie Tage zählen bei der Terminplan-Berechnung aus dem Honorar und
+           bei der Ressourcen-Auslastung nicht als Arbeitstag. Vorher kannte die Anwendung nur Wochenenden.</p>
+        <div id="holidayYearHint" class="settings-warn" style="display:none;margin-bottom:10px"></div>
+
+        <h4 class="settings-subtitle">Gesetzliche Feiertage übernehmen</h4>
+        <p class="hint">Werden aus dem Kalender berechnet (feste Termine plus alles, was am
+           Osterdatum hängt) — kein Netzdienst, kein Internetzugang nötig. Vorgeschlagen, nicht
+           automatisch eingetragen: Feiertage verschieben jeden gerechneten Terminplan.</p>
+        <div class="settings-inline-field">
+          <span>Jahr</span>
+          <input type="number" id="holidayYear" min="1970" max="2200" step="1" style="width:90px">
+          <span>Bundesland</span>
+          <select id="holidayState"></select>
+          <button class="secondary small" onclick="suggestHolidays()">Vorschlagen</button>
+        </div>
+        <div id="holidaySuggestion"></div>
+
+        <h4 class="settings-subtitle">Hinterlegte Tage</h4>
+        <div id="adminHolidayList" class="settings-holiday-list"></div>
+        <div class="template-add-row">
+          <input type="date" id="holidayNewDate">
+          <input type="text" id="holidayNewName" placeholder="Bezeichnung, z. B. „Betriebsruhe“">
+          <button class="secondary small" onclick="addHoliday()">+ Einzelner Tag</button>
+        </div>
+      </section>
+
+      <section class="settings-card" id="adminBetriebCard" data-admin-section="betrieb" style="display:none">
+        <h3 class="settings-card-title">Betrieb &amp; Sicherheit <span class="settings-scope">firmenweit · nur Administratoren</span></h3>
+        <div class="settings-field-grid">
+          <label class="settings-field"><span>Aufbewahrte automatische Backups</span>
+            <input type="number" id="setMaxBackups" min="1" max="500" step="1"></label>
+          <label class="settings-field"><span>Gültigkeit einer Anmeldung (Tage)</span>
+            <input type="number" id="setSessionTage" min="1" max="365" step="1"></label>
+          <label class="settings-field"><span>Fehlversuche bis zur Anmeldesperre</span>
+            <input type="number" id="setLoginVersuche" min="1" max="100" step="1"></label>
+          <label class="settings-field"><span>Dauer der Anmeldesperre (Minuten)</span>
+            <input type="number" id="setLoginSperre" min="1" max="1440" step="1"></label>
+        </div>
+        <p class="hint">Die Gültigkeit wirkt auf neue Anmeldungen; bestehende behalten ihre Laufzeit.</p>
+        <div class="toolbar">
+          <button class="secondary small" onclick="saveBetriebSettings()">Speichern</button>
+        </div>
+      </section>
+
+      <section class="settings-card settings-card-wide" id="adminTemplateCard" data-admin-section="vorlagen" style="display:none">
+        <h3 class="settings-card-title">Aufgaben-Vorlagen <span class="settings-scope">firmenweit · nur Administratoren</span></h3>
+        <p class="hint">Wiederkehrende Schritte einer Leistungsphase. Im Projektbereich fügt
+           „+ Vorlage" sie als Aufgaben ein; danach sind es ganz normale Aufgaben — eine später
+           geänderte Vorlage wirkt NICHT rückwirkend.</p>
+        <label class="settings-inline-field">
+          <span>Leistungsphase</span>
+          <select id="adminTemplateLph" onchange="renderAdminTemplates()"></select>
+        </label>
+        <div id="templateAdminList" class="template-admin-list"></div>
+        <div class="template-add-row">
+          <input type="text" id="templateNewTitle" placeholder="Neuer Schritt, z. B. „LV erstellen“">
+          <input type="number" id="templateNewOffset" value="0" min="0" title="Start in Tagen nach dem Startdatum">
+          <input type="number" id="templateNewDuration" value="1" min="1" title="Dauer in Tagen">
+          <button class="secondary small" onclick="addTemplateEntry()">+ Schritt</button>
+        </div>
+      </section>
+      <section class="settings-card settings-card-wide" id="adminUsersCard" data-admin-section="benutzer" style="display:none">
+        <h3 class="settings-card-title">Benutzerverwaltung <span class="settings-scope">nur Administratoren</span></h3>
+        <p class="hint">Konten anlegen, bearbeiten, deaktivieren, Passwoerter zuruecksetzen und
+           Abwesenheiten pflegen. Die <strong>Wochenstunden</strong> hier sind die Bezugsgroesse der
+           Auslastungs-Ampel; die <strong>Person-ID</strong> verbindet das Konto mit den
+           Aufgaben-Zuordnungen und fuellt damit „Meine Aufgaben".</p>
+        <div id="generatedPasswordBox"></div>
+
+        <div class="toolbar admin-toolbar">
+          <button onclick="openNewUserModal()">+ Neuer Benutzer</button>
+        </div>
+
+        <div class="table-wrap">
+          <table id="usersTable">
+            <thead>
+              <tr>
+                <th>Benutzername</th>
+                <th>Anzeigename</th>
+                <th>E-Mail</th>
+                <th>Rolle</th>
+                <th>Abteilung</th>
+                <th>Kürzel</th>
+                <th>Std./Woche</th>
+                <th>Person-ID</th>
+                <th>Status</th>
+                <th>Aktionen</th>
+              </tr>
+            </thead>
+            <tbody id="usersTableBody"></tbody>
+          </table>
+        </div>
+      </section>
+
+      <section class="settings-card" id="adminDatenbankCard" data-admin-section="datenbank" style="display:none">
+        <h3 class="settings-card-title">Datenbank &amp; Sitzungen <span class="settings-scope">nur Administratoren</span></h3>
+
+        <h4 class="settings-subtitle">Sicherung</h4>
+        <p class="hint">Der Server legt bei jedem Start selbst eine Sicherung an (Anzahl siehe
+           „Betrieb &amp; Sicherheit"). „DB Backup" lädt zusätzlich den aktuellen Stand herunter.
+           <strong>Die Datei enthält die komplette Datenbank samt Sitzungs-Token</strong> — sie
+           gehört nicht in fremde Hände.</p>
+        <div class="toolbar">
+          <button class="secondary small" onclick="downloadBackup()">DB Backup herunterladen</button>
+        </div>
+
+        <h4 class="settings-subtitle">Wiederherstellen</h4>
+        <p class="hint">Spielt eine mit „DB Backup" erzeugte Datei ein und <strong>ersetzt damit
+           alle Sitzungsdaten</strong>. Konten, Rollen, Abwesenheiten und Datei-Freigaben bleiben
+           unberührt. Unmittelbar vorher sichert der Server den aktuellen Stand, ein Einspielen
+           lässt sich also rückgängig machen.</p>
+        <div class="toolbar">
+          <button class="secondary small" onclick="importDb()">DB Import…</button>
+        </div>
+
+        <!-- Das Löschen einzelner Sitzungen ist zur Sitzungsliste unter
+             "Termine & Sitzungen" gewandert (renderAdminSitzungen()) — dort
+             steht ohnehin schon, welche Sitzung welche ist; ein zweiter,
+             von "der im Menüband gewählten" abhängiger Knopf hier wäre seit
+             dem Wegfall der Menüband-Auswahl gegenstandslos gewesen. -->
+      </section>
+
+    </div>
+
+    <div id="adminNote" class="settings-note"></div>
+  </div>
+
+</div>
+
+  <!-- ===================== PROJEKTBEREICH (#plan) =====================
+       Der eigene Bereich EINES Projekts — frueher die eigenstaendige Seite
+       public/project-plan.html, jetzt ein ganz normaler Bereich dieser Seite.
+       Der Wechsel dorthin laeuft ueber showTab('plan') (js/tabs-auth.js) wie
+       jeder andere Navigationswechsel, sodass Menueband und Seitenleiste
+       stehen bleiben; geoeffnet wird er ueber openProjectPlan() (js/gantt.js).
+       Er steht bewusst AUSSERHALB von .container, weil er seine eigene
+       Kopfzeile und eigene Innenabstaende mitbringt (siehe plan-styles.css).
+       Die fuenf Unterbereiche (Dashboard, Terminplan, Aufgaben, Dateien,
+       Einstellungen) schaltet .plan-nav um (showPlanSection() in
+       js/plan/plan-sections.js); alle liegen gleichzeitig im DOM. -->
+  <div id="plan" style="display:none">
+  <div class="plan-page">
+  <div class="plan-header">
+    <span class="plan-id" id="planIdBadge"></span>
+    <h1 id="planTitle">Projektplan</h1>
+    <div class="tag-chip-list" id="planTagsList"></div>
+    <div class="plan-header-spacer"></div>
+    <div class="subtitle" id="planSubtitle"></div>
+    <div class="plan-avatar-stack" id="planPeopleList"></div>
+    <div class="plan-header-actions">
+      <button class="theme-toggle-circle" onclick="todoMail()" title="E-Mail erstellen">
+        <span class="icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><rect x="3.5" y="5.5" width="17" height="13" rx="2"/><path d="m4 6.5 8 6.5 8-6.5"/></svg></span>
+      </button>
+      <button class="theme-toggle-circle" onclick="closePlanPage()" title="Schließen">
+        <span class="icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"><line x1="6" y1="6" x2="18" y2="18"/><line x1="18" y1="6" x2="6" y2="18"/></svg></span>
+      </button>
+    </div>
+  </div>
+
+  <!-- Bereichs-Navigation des Projektbereichs: schaltet zwischen den fünf
+       Bereichen um (showPlanSection() in js/plan/plan-sections.js). Die
+       Bereiche liegen alle gleichzeitig im DOM und werden nur ein- bzw.
+       ausgeblendet, damit die vorhandenen Render-Funktionen ihre Elemente
+       unabhängig von der Sichtbarkeit befüllen können. -->
+  <nav class="plan-nav" id="planNav">
+    <button class="plan-nav-item" data-section="dashboard" onclick="showPlanSection('dashboard')">Dashboard</button>
+    <button class="plan-nav-item" data-section="terminplan" onclick="showPlanSection('terminplan')">Terminplan</button>
+    <button class="plan-nav-item" data-section="aufgaben" onclick="showPlanSection('aufgaben')">Aufgaben</button>
+    <button class="plan-nav-item" data-section="leistung" onclick="showPlanSection('leistung')">Leistung</button>
+    <button class="plan-nav-item" data-section="dateien" onclick="showPlanSection('dateien')">Dateien</button>
+    <button class="plan-nav-item" data-section="protokolle" onclick="showPlanSection('protokolle')">Protokolle</button>
+    <button class="plan-nav-item" data-section="einstellungen" onclick="showPlanSection('einstellungen')">Einstellungen</button>
+  </nav>
+
+  <div class="plan-body">
+    <div class="plan-main">
+      <div class="plan-main-content">
+
+        <!-- ===================== Bereich: Dashboard ===================== -->
+        <section class="plan-section" id="planSection-dashboard" data-section="dashboard">
+          <div class="plan-kpi-row" id="planKpiRow"></div>
+
+          <div class="plan-panel-grid">
+            <div class="plan-panel">
+              <h3 class="plan-panel-title">Kommentar der Sitzung</h3>
+              <!-- Nur zu lesen: Der Kommentar entsteht in der wöchentlichen
+                   Besprechung und wird deshalb allein im Wochenbericht
+                   erfasst. Die frühere Werkzeugleiste (Fett/Farben) ist mit
+                   dem Bearbeiten hier entfallen. -->
+              <div class="status" id="planStatusWrap">
+                <div class="status-edit" id="planStatusEdit"></div>
+              </div>
+              <div class="plan-verweis-row" id="planStatusVerweis"></div>
+            </div>
+
+            <div class="plan-panel">
+              <h3 class="plan-panel-title">Leistungsphasen</h3>
+              <div class="board-lph-list" id="planLphList"></div>
+              <div class="plan-verweis-row" id="planLphVerweis"></div>
+            </div>
+
+            <div class="plan-panel">
+              <h3 class="plan-panel-title">Nächste Termine</h3>
+              <div id="planDashUpcoming"></div>
+            </div>
+
+            <div class="plan-panel">
+              <h3 class="plan-panel-title">Team</h3>
+              <div id="planDashTeam"></div>
+            </div>
+
+          </div>
+
+          <div class="plan-card-row">
+            <div class="plan-mini-card" onclick="openResourceModal()">
+              <div class="plan-mini-card-head"><span class="plan-mini-card-title">Ressourcen-Auslastung</span><span class="plan-mini-card-expand">Öffnen ↗</span></div>
+              <div id="planResourceSummary"></div>
+            </div>
+            <div class="plan-mini-card" onclick="openFilesPanel()">
+              <div class="plan-mini-card-head"><span class="plan-mini-card-title">Dateien &amp; Freigaben</span><span class="plan-mini-card-expand">Öffnen ↗</span></div>
+              <div id="planFilesSummary"></div>
+            </div>
+            <div class="plan-mini-card" onclick="openProtokollePanel()">
+              <div class="plan-mini-card-head"><span class="plan-mini-card-title">Protokolle</span><span class="plan-mini-card-expand">Öffnen ↗</span></div>
+              <div id="planProtokolleSummary"></div>
+            </div>
+            <div class="plan-mini-card" onclick="openHistoryModal()">
+              <div class="plan-mini-card-head"><span class="plan-mini-card-title">Verlauf</span><span class="plan-mini-card-expand">Öffnen ↗</span></div>
+              <div id="planHistorySummary"></div>
+            </div>
+          </div>
+        </section>
+
+        <!-- ===================== Bereich: Terminplan ==================== -->
+        <section class="plan-section" id="planSection-terminplan" data-section="terminplan">
+          <div class="plan-main-header">
+            <label>Zeitraum:</label>
+            <input type="text" id="planGanttRange" class="range-picker-display" placeholder="Zeitraum wählen…" readonly
+              onclick="openRangePicker({ anchor: this, startInputId: 'planGanttStart', endInputId: 'planGanttEnd', displayId: 'planGanttRange', onApply: renderPlanGantt })">
+            <input type="hidden" id="planGanttStart">
+            <input type="hidden" id="planGanttEnd">
+            <button class="secondary" onclick="fitPlanGanttRange()">Zeitraum anpassen</button>
+            <label><input type="checkbox" id="planShowVacation" checked onchange="renderPlanGantt()"> Urlaub anzeigen</label>
+            <label title="Termine der vorherigen Sitzung als gestrichelten Umriss einblenden"><input type="checkbox" id="planShowGhost" checked onchange="renderPlanGantt()"> Vorwoche</label>
+            <button class="secondary" onclick="zoomPlanGantt(-1)" title="Verkleinern">−</button>
+            <button class="secondary" onclick="zoomPlanGantt(1)" title="Vergrößern">+</button>
+            <button onclick="addPlanMilestone()" id="addMilestoneBtn">+ Meilenstein</button>
+            <button onclick="addTodo()" id="addTodoBtn">+ TODO</button>
+            <button onclick="openTemplateModal()" id="templateBtn" title="Standard-Aufgaben einer Leistungsphase einfügen">+ Vorlage</button>
+            <button onclick="openHonorarModal()" id="honorarBtn" title="Terminplan aus Honorar und Leistungsphasen-Anteilen errechnen">+ Terminplan</button>
+            <button onclick="autoScheduleTodos()" id="autoScheduleBtn" title="Aufgaben nach Abhängigkeiten automatisch anordnen">Auto-Schedule</button>
+            <button onclick="toggleCriticalPath()" id="criticalPathBtn" title="Kritischen Pfad ein-/ausblenden">Kritischer Pfad</button>
+            <!-- Nur für Sandbox-Pläne der Planung sichtbar (renderPlanPage(),
+                 js/plan/plan-state.js) — ein echtes Projekt hat keinen
+                 vergleichbaren Gantt-PDF-Export. -->
+            <button class="secondary" onclick="exportSandboxPlanPDF(PlanApp.project.id)" id="sandboxPdfBtn" style="display:none">Als PDF exportieren</button>
+          </div>
+          <div id="planWarnings"></div>
+          <div id="planGanttContainer" class="gantt-container"></div>
+
+          <div class="plan-panel" style="margin-top:18px">
+            <h3 class="plan-panel-title">Ressourcen-Auslastung</h3>
+            <div id="resourceLoadContainer"></div>
+          </div>
+        </section>
+
+        <!-- ====================== Bereich: Aufgaben ===================== -->
+        <section class="plan-section" id="planSection-aufgaben" data-section="aufgaben">
+          <div class="plan-main-header">
+            <button onclick="addTodo()" id="addTodoBtnList">+ Aufgabe</button>
+            <button onclick="addPlanMilestone()" id="addMilestoneBtnList">+ Meilenstein</button>
+            <button onclick="openTemplateModal()" id="templateBtnList" title="Standard-Aufgaben einer Leistungsphase einfügen">+ Vorlage</button>
+            <button onclick="openHonorarModal()" id="honorarBtnList" title="Terminplan aus Honorar und Leistungsphasen-Anteilen errechnen">+ Terminplan</button>
+            <button class="secondary" onclick="autoScheduleTodos()" id="autoScheduleBtnList" title="Aufgaben nach Abhängigkeiten automatisch anordnen">Auto-Schedule</button>
+          </div>
+
+          <div class="plan-panel">
+            <h3 class="plan-panel-title">Aufgaben <span class="plan-panel-count" id="planTodoCount"></span></h3>
+            <div id="planTodoList" class="plan-task-list"></div>
+          </div>
+
+          <div class="plan-panel" style="margin-top:18px">
+            <h3 class="plan-panel-title">Meilensteine <span class="plan-panel-count" id="planMilestoneCount"></span></h3>
+            <div id="planMilestoneList" class="plan-task-list"></div>
+          </div>
+        </section>
+
+        <!-- ===================== Bereich: Leistung ====================== -->
+        <!-- Leistungsstand & Abrechnung: der erbrachte Leistungswert aus
+             Honorar × HOAI-Anteil je Phase × Fortschritt der Phase
+             (renderPlanLeistung(), js/plan/plan-leistung.js).
+             Ein eigener Bereich und keine Dashboard-Karte: Die Aufschlüsselung
+             hat eine Zeile je beauftragter Leistungsphase mit fünf Spalten und
+             stünde im Raster des Dashboards entweder gedrängt oder ein zweites
+             Mal — genau die Doppelung, die überall sonst gerade beseitigt
+             wurde. Die Zahlen beruhen auf Honorar und beauftragten Phasen aus
+             dem Bereich "Einstellungen" und auf dem Fortschritt, der im
+             Wochenbericht erfasst wird; hier wird nur gerechnet, nichts
+             eingegeben. -->
+        <section class="plan-section" id="planSection-leistung" data-section="leistung">
+          <div class="plan-panel plan-panel-wide">
+            <h3 class="plan-panel-title">Leistungsstand &amp; Abrechnung</h3>
+            <div id="planLeistungWrap" class="plan-leistung-wrap"></div>
+          </div>
+        </section>
+
+        <!-- ====================== Bereich: Dateien ====================== -->
+        <section class="plan-section" id="planSection-dateien" data-section="dateien">
+          <div class="plan-panel">
+            <h3 class="plan-panel-title">Datei hochladen</h3>
+            <div id="filesNoProjectHint" class="hint" style="display:none">Dieses Projekt hat keine Projektnummer und kann daher keine Dateien erhalten.</div>
+            <div id="filesUploadSection" class="plan-files-upload">
+              <div class="form-row">
+                <label>Datei</label>
+                <input type="file" id="fileUploadInput">
+              </div>
+              <div class="form-row">
+                <label>Prüfer (mehrfach möglich)</label>
+                <div id="fileUploadReviewers" class="todo-depends-list"></div>
+              </div>
+              <div class="toolbar">
+                <button onclick="submitFileUpload()">Hochladen</button>
+              </div>
+            </div>
+          </div>
+
+          <div class="plan-panel" style="margin-top:18px">
+            <h3 class="plan-panel-title">Dateien &amp; Freigaben</h3>
+            <div id="filesListContainer" class="files-list"></div>
+          </div>
+        </section>
+
+        <!-- ===================== Bereich: Protokolle ===================== -->
+        <section class="plan-section" id="planSection-protokolle" data-section="protokolle">
+          <div id="protokolleNoProjectHint" class="hint" style="display:none">Dieses Projekt hat keine Projektnummer und kann daher keine Protokolle erhalten.</div>
+          <div id="protokolleContainer"></div>
+        </section>
+
+        <!-- =================== Bereich: Einstellungen =================== -->
+        <section class="plan-section" id="planSection-einstellungen" data-section="einstellungen">
+          <div id="planSettingsLockHint" class="hint" style="display:none">Diese Sitzung ist gesperrt — Einstellungen können nicht geändert werden.</div>
+
+          <div class="plan-panel-grid">
+            <div class="plan-panel">
+              <h3 class="plan-panel-title">Projektangaben</h3>
+              <!-- Projektnummer, Bezeichnung und Schlagwörter waren zuvor
+                   zusätzlich im eigenen Tab "Projekte" bearbeitbar, der
+                   dieselben Projekte ein zweites Mal auflistete. Er ist in die
+                   Projektliste aufgegangen; gepflegt werden sie jetzt hier. -->
+              <div class="form-row">
+                <label>Projektnummer</label>
+                <input type="text" id="settingsProjNr" placeholder="z. B. 26-4071"
+                       onchange="setPlanProjNr(this.value)"
+                       title="Kennzeichen des Projekts. Hochgeladene Dateien hängen an dieser Nummer — eine Änderung wird deshalb noch einmal abgefragt.">
+              </div>
+              <div class="form-row">
+                <label>Projektname</label>
+                <input type="text" id="settingsProjName" placeholder="Bezeichnung"
+                       onchange="setPlanProjName(this.value)">
+              </div>
+              <!-- Auftragsstatus: Anfrage → Angebot → beauftragt →
+                   abgeschlossen. Der Sprung auf "beauftragt" öffnet den
+                   Beauftragungs-Dialog (js/auftrag.js), weil dazu Honorar und
+                   beauftragte Leistungsphasen gehören. -->
+              <div class="form-row">
+                <label>Auftragsstatus</label>
+                <div id="settingsAuftragsstatus"></div>
+              </div>
+              <div class="form-row">
+                <label>Gruppe</label>
+                <select id="planGroupSelect" onchange="setPlanGroup(this.value)">
+                  <option>Aktive Projekte</option>
+                  <option>Kleine Projekte</option>
+                  <option>In Anbahnung</option>
+                  <option>Allgemein</option>
+                </select>
+              </div>
+              <div class="form-row">
+                <label>Amtierende Leistungsphase</label>
+                <select id="planActiveLpSelect" onchange="setPlanActiveLp(this.value)"></select>
+              </div>
+              <div class="form-row">
+                <label>Honorar (netto)</label>
+                <input type="number" id="settingsHonorar" min="0" step="100" placeholder="0"
+                       onchange="setHonorarBetrag(this.value)"
+                       title="Vereinbartes Netto-Honorar. Grundlage der Terminplan-Berechnung und dauerhaft am Projekt gespeichert.">
+              </div>
+              <!-- Projektgröße: Ersatz für ein fehlendes Honorar. Die
+                   Auslastung rechnet in Stunden und braucht dafür einen
+                   Geldwert; ist keiner hinterlegt, tritt diese Zahl mal dem
+                   Referenzhonorar (Admin → Auslastung) an seine Stelle. -->
+              <div class="form-row">
+                <label>Projektgröße</label>
+                <!-- Zahlenfeld statt Regler: Ein Schieber legt eine
+                     Feinabstufung nahe, die eine grobe Schätzung nicht hat,
+                     und lässt sich schlechter treffen als eine getippte Zahl. -->
+                <input type="number" id="settingsGroesse" min="0" max="1" step="0.05" value="0"
+                       placeholder="z. B. 0,40" style="max-width:160px"
+                       onchange="setPlanGroesse(this.value)">
+                <span class="hint" id="settingsGroesseHinweis" style="margin:4px 0 0"></span>
+              </div>
+              <div class="form-row">
+                <label>Schlagwörter</label>
+                <div class="tag-chip-list" id="settingsProjTags"></div>
+              </div>
+              <div class="form-row">
+                <label>Gewerke</label>
+                <div id="settingsGewerke" class="beauftragte-lp-grid"></div>
+                <span class="hint" style="margin:4px 0 0">
+                  Bestimmt, in welcher Gewerke-Besprechung des Wochenberichts dieses Projekt erscheint.
+                </span>
+              </div>
+              <div class="form-row">
+                <label>Aufwand je Phase</label>
+                <button type="button" class="secondary small" id="settingsAufwandBtn" onclick="planOpenAufwand()"
+                        title="Gewichtung des Aufwands je Leistungsphase und Rolle — Grundlage der Auslastungsrechnung.">Gewichtung bearbeiten</button>
+              </div>
+            </div>
+
+            <div class="plan-panel">
+              <h3 class="plan-panel-title">Beauftragte Leistungsphasen</h3>
+              <p class="hint" style="margin-top:0">Welche Leistungsphasen für dieses Projekt beauftragt sind. Grundlage der Terminplan-Berechnung aus dem Honorar; der Wochenbericht zeigt ebenfalls nur diese Phasen.</p>
+              <div id="settingsBeauftragteLp" class="beauftragte-lp-grid"></div>
+            </div>
+
+            <div class="plan-panel plan-panel-wide">
+              <h3 class="plan-panel-title">Beteiligte</h3>
+              <p class="hint" style="margin-top:0">Wer diesem Projekt zugeordnet ist — kräftig die Hauptverantwortung, blass die Unterstützung. Geändert wird die Zuordnung im Wochenbericht.</p>
+              <div class="board-role-mini" id="planAssignMatrix"></div>
+              <div class="plan-verweis-row" id="planAssignVerweis"></div>
+            </div>
+          </div>
+        </section>
+
+      </div>
+    </div>
+  </div>
+  </div>
+  </div>
+  </div>
+  </div>
+</div>
+
+<!-- Aufwand je Leistungsphase Modal -->
+<div class="modal-bg" id="lpModal" style="display:none">
+  <div class="modal">
+    <h2>Aufwand je Leistungsphase</h2>
+    <p style="color:#888;margin-bottom:6px" id="lpModalProject"></p>
+    <p class="hint" style="margin-bottom:10px">
+      Rollenbezogene Gewichtungsfaktoren je Leistungsphase (Standardwerte laut
+      Vorlage im Code). Die amtierende Leistungsphase wird pro Projekt im Tab
+      „Projekte" gewählt.
+    </p>
+    <div id="lpModalRows"></div>
+    <div class="toolbar" style="margin-top:12px">
+      <button onclick="saveLpModal()">Speichern</button>
+      <button class="secondary" onclick="closeLpModal()">Abbrechen</button>
+    </div>
+  </div>
+</div>
+
+<!-- Neues Projekt Modal (inkl. LP-Aufwand) -->
+<!-- Assistent "Neues Projekt" (js/projekt-wizard.js). Er ersetzt den
+     früheren Dialog #newProjModal, der alle Felder auf einmal zeigte — samt
+     einer 27-Felder-Matrix für den Aufwand je Phase und Rolle. Der Rumpf
+     wird vollständig aus JavaScript gefüllt; hier steht nur die Hülle. -->
+<div class="modal-bg" id="wizardModal" style="display:none">
+  <div class="modal wizard-modal">
+    <div class="wiz-kopf">
+      <h2>Neues Projekt</h2>
+      <button type="button" class="wiz-schliessen" onclick="closeNewProjWizard()" title="Abbrechen">×</button>
+    </div>
+    <div id="wizardBody"></div>
+  </div>
+</div>
+
+<!-- Beauftragung: der Übergang vom Angebot zum beauftragten Projekt
+     (js/auftrag.js). Erfasst genau die Angaben, die zur Beauftragung gehören
+     und die der Terminplan aus dem Honorar braucht (js/plan/plan-honorar.js):
+     vereinbartes Netto-Honorar und beauftragte Leistungsphasen. -->
+<div class="modal-bg" id="beauftragungModal" style="display:none">
+  <div class="modal">
+    <h2>Beauftragung</h2>
+    <p style="color:#888;margin-bottom:2px" id="beauftragungProjekt"></p>
+    <p class="hint" style="margin:0 0 10px" id="beauftragungStatusHinweis"></p>
+    <div class="form-row">
+      <label>Honorar (netto)</label>
+      <!-- type="number" wie im Honorar-Dialog (#honorarBetrag): Der Browser
+           liefert den Wert dann immer mit Punkt als Dezimaltrenner, und ein
+           Tausenderpunkt ("48.500") kann gar nicht erst als 48,5 durchgehen. -->
+      <input type="number" min="0" step="100" id="beauftragungHonorar" placeholder="z. B. 48500" style="width:100%"
+             title="Vereinbartes Netto-Honorar in Euro. Grundlage des Terminplans aus dem Honorar.">
+    </div>
+    <div class="form-row">
+      <label>Beauftragte Leistungsphasen</label>
+      <div id="beauftragungBeauftragteLp" class="beauftragte-lp-grid"></div>
+      <span class="hint" style="margin:4px 0 0">
+        Das Honorar wird auf genau diese Phasen verteilt.
+      </span>
+    </div>
+    <!-- Nur sichtbar, solange das Projekt in „In Anbahnung" liegt: Diese
+         Gruppe wird von der Auslastung nicht eingerechnet. -->
+    <div class="form-row" id="beauftragungGruppeWrap" style="display:none">
+      <label class="person-chip-label">
+        <input type="checkbox" id="beauftragungGruppeCheck">
+        Projekt aus „In Anbahnung" nach „Aktive Projekte" verschieben
+      </label>
+      <span class="hint" style="margin:4px 0 0">
+        Projekte in „In Anbahnung" zählen in der Auslastung nicht mit.
+      </span>
+    </div>
+    <div class="toolbar" style="margin-top:12px">
+      <button onclick="saveBeauftragung(false)">Als beauftragt kennzeichnen</button>
+      <button onclick="saveBeauftragung(true)" title="Speichert und öffnet den Projektbereich, dort „+ Terminplan“">Beauftragen und zum Terminplan</button>
+      <button class="secondary" onclick="closeBeauftragungModal()">Abbrechen</button>
+    </div>
+  </div>
+</div>
+
+<!-- Neuer Terminplan (js/planung/planung.js) — schlanker Anlege-Dialog der
+     Planung-Sandbox: nur Name + Art, bewusst kein mehrstufiger Assistent wie
+     "Neues Projekt" (der verlangt Gewerke/Team/Auftragsstatus, die hier nicht
+     zutreffen), siehe CLAUDE.md "Planung — projektunabhängige Terminplan-
+     Sandbox". -->
+<div class="modal-bg" id="neuerTerminplanModal" style="display:none">
+  <div class="modal">
+    <h2>Neuer Terminplan</h2>
+    <p class="hint">Unabhängig von einem echten Projekt — für Angebote, Kapazitätstests oder eigene Vorhaben.</p>
+    <div class="form-row">
+      <label>Name</label>
+      <input type="text" id="planungName" placeholder="z. B. Angebot Sporthalle Menden" style="width:100%">
+    </div>
+    <div class="form-row">
+      <label style="display:block;margin-bottom:10px">Wie soll's losgehen?</label>
+      <div class="planung-choice-cards">
+        <div class="choice-card" data-art="honorar" onclick="waehlePlanungArt('honorar')">
+          <span class="choice-card-icon">€</span>
+          <div class="choice-card-title">Aus Honorar berechnen</div>
+          <div class="choice-card-desc">Honorar und Leistungsphasen angeben, der vorhandene Terminplan-Rechner erstellt die Aufgaben.</div>
+        </div>
+        <div class="choice-card" data-art="leer" onclick="waehlePlanungArt('leer')">
+          <span class="choice-card-icon">✎</span>
+          <div class="choice-card-title">Leer beginnen</div>
+          <div class="choice-card-desc">Direkt in den leeren Terminplan, Aufgaben und Meilensteine von Hand anlegen.</div>
+        </div>
+      </div>
+    </div>
+    <div class="toolbar" style="margin-top:12px">
+      <button onclick="erstellePlanungTerminplan()">Anlegen</button>
+      <button class="secondary" onclick="schliesseNeuerTerminplanDialog()">Abbrechen</button>
+    </div>
+  </div>
+</div>
+
+<!-- ===================== Dialoge des Projektbereichs =====================
+     Gehoeren zum Bereich #plan (frueher project-plan.html) und liegen wie alle
+     anderen Dialoge dieser Seite auf oberster Ebene, damit .modal-bg den
+     ganzen Bildschirm ueberdeckt. Befuellt werden sie von den Modulen unter
+     public/js/plan/ (plan-modals.js, plan-templates.js, plan-honorar.js,
+     plan-history.js). -->
+<!-- Verlaufs-Modal: Kommentar-Historie des Projekts über alle Sitzungen -->
+<div class="modal-bg" id="planHistoryModal" style="display:none">
+  <div class="modal modal-wide">
+    <h2>Verlauf</h2>
+    <p class="hint" style="margin-top:-4px">Status-Kommentare dieses Projekts aus allen Sitzungen, neueste zuerst. Aufgeführt sind nur Sitzungen, in denen der Text tatsächlich geändert wurde.</p>
+    <div id="planHistoryList" class="history-list"></div>
+    <div class="toolbar" style="margin-top:16px">
+      <button class="secondary" onclick="closeHistoryModal()">Schließen</button>
+    </div>
+  </div>
+</div>
+
+<!-- Protokoll-Import: externes Protokoll (PDF/Word) hochladen, Punkte werden
+     serverseitig heuristisch erkannt (POST /project-protokolle/import,
+     js/plan/plan-protokoll.js) — Ergebnis landet als ganz normales,
+     editierbares Protokoll, keine eigene Vorschau-Oberfläche nötig. -->
+<div class="modal-bg" id="protokollImportModal" style="display:none">
+  <div class="modal">
+    <h2>Protokoll importieren</h2>
+    <p class="hint">Ein extern erstelltes Protokoll (PDF oder Word) hochladen — die
+      App versucht, die Punkte automatisch zu erkennen. Das Ergebnis ist ein
+      Entwurf: bitte vor dem Speichern prüfen und bei Bedarf anpassen.</p>
+    <div class="form-row">
+      <label>Datei</label>
+      <input type="file" id="protokollImportFile" accept=".pdf,.docx">
+    </div>
+    <div class="form-row">
+      <label>Erkennung</label>
+      <select id="protokollImportErkennung"></select>
+    </div>
+    <div class="form-row">
+      <label>Datum</label>
+      <input type="text" id="protokollImportDatumDisplay" class="range-picker-display" placeholder="Datum wählen…" readonly
+        onclick="openDatePicker({ anchor: this, inputId: 'protokollImportDatum', displayId: 'protokollImportDatumDisplay' })">
+      <input type="hidden" id="protokollImportDatum">
+    </div>
+    <div class="form-row">
+      <label>Betreff</label>
+      <input type="text" id="protokollImportBetreff" placeholder="z. B. Baubesprechung TGA">
+    </div>
+    <div class="form-row">
+      <label>Ort</label>
+      <input type="text" id="protokollImportOrt">
+    </div>
+    <span class="field-error" id="protokollImportError" hidden></span>
+    <!-- Läuft nur bei der KI-Erkennung an, kann dort je nach Anbieter/
+         eigenem Server (KI_TIMEOUT_MS_LOKAL, server.js) bis zu 30 Minuten
+         dauern — ohne diesen Hinweis wirkte der Dialog in der Zeit wie
+         hängengeblieben. -->
+    <div class="protokoll-import-loading" id="protokollImportLoading" hidden>
+      <span class="protokoll-import-spinner" aria-hidden="true"></span>
+      <span>Importiere … bei KI-Erkennung über einen eigenen Server kann dies
+        bis zu 30 Minuten dauern.</span>
+    </div>
+    <div class="toolbar" style="margin-top:12px">
+      <button onclick="importiereProtokoll()">Importieren</button>
+      <button class="secondary" onclick="schliesseProtokollImportDialog()">Abbrechen</button>
+    </div>
+  </div>
+</div>
+
+<!-- Vorlagen-Dialog: Standard-Aufgaben einer Leistungsphase einfügen.
+     Eigenständiger Dialog — der frühere gemeinsame Dialog mit Modus-Umschalter
+     ("Aus Vorlage" / "Aus Honorar") wurde in zwei getrennte Dialoge aufgeteilt,
+     die je eine eigene Schaltfläche in der GANTT-Toolbar haben. Damit steht auf
+     dem Knopf, was dahinter passiert, und keine der beiden Masken trägt die
+     Eingaben der jeweils anderen mit. -->
+<div class="modal-bg" id="lphTemplateModal" style="display:none">
+  <div class="modal modal-wide">
+    <h2>Aufgaben aus Vorlage</h2>
+
+    <div class="template-head-grid">
+      <div class="form-row">
+        <label>Leistungsphase</label>
+        <select id="templateLphSelect" onchange="renderTemplateList()"></select>
+      </div>
+      <div class="form-row">
+        <label>Startdatum</label>
+        <input type="text" id="templateStartDisplay" class="range-picker-display" placeholder="Datum wählen…" readonly
+          onclick="openDatePicker({ anchor: this, inputId: 'templateStart', displayId: 'templateStartDisplay', onApply: renderTemplateList })">
+        <input type="hidden" id="templateStart">
+      </div>
+    </div>
+
+    <label class="form-row" style="margin-bottom:4px"><span>Schritte</span></label>
+    <div id="templateTaskList" class="todo-depends-list"></div>
+
+    <!-- Gepflegt werden die Vorlagen im Bereich „Einstellungen"; hier werden
+         sie nur noch eingefügt. Der Verweis erscheint nur für Administratoren
+         (renderTemplateHint() in js/plan/plan-templates.js). -->
+    <p class="hint" id="templateAdminHint" style="display:none">
+      Vorlagen pflegen: <a href="/Einstellungen" onclick="closeTemplateModal();showTab('settings');return false;">Einstellungen → Aufgaben-Vorlagen</a>
+    </p>
+
+    <div class="toolbar" style="margin-top:16px">
+      <button onclick="applyTemplate()">Aufgaben einfügen</button>
+      <button class="secondary" onclick="closeTemplateModal()">Abbrechen</button>
+    </div>
+  </div>
+</div>
+
+<!-- Honorar-Dialog: kompletten Terminplan aus dem Honorar errechnen
+     (js/plan/plan-honorar.js). Zweiter der beiden getrennten Dialoge, siehe
+     Kommentar beim Vorlagen-Dialog oben. -->
+<div class="modal-bg" id="honorarPlanModal" style="display:none">
+  <div class="modal modal-wide">
+    <h2>Terminplan aus Honorar</h2>
+
+    <div class="template-head-grid">
+      <div class="form-row">
+        <label>Honorar (netto)</label>
+        <input type="number" id="honorarBetrag" min="0" step="100" placeholder="0"
+               onchange="setHonorarBetrag(this.value)"
+               title="Vereinbartes Netto-Honorar. Wird am Projekt gespeichert und bleibt erhalten.">
+      </div>
+      <div class="form-row">
+        <label>Beginn der ersten Leistungsphase</label>
+        <input type="text" id="honorarStartDisplay" class="range-picker-display" placeholder="Datum wählen…" readonly
+          onclick="openDatePicker({ anchor: this, inputId: 'honorarStart', displayId: 'honorarStartDisplay', onApply: renderHonorarPlan })">
+        <input type="hidden" id="honorarStart">
+      </div>
+    </div>
+
+    <div class="form-row">
+      <label>Beauftragte Leistungsphasen</label>
+      <div id="honorarBeauftragteLp" class="beauftragte-lp-grid"></div>
+    </div>
+
+    <label class="honorar-check" title="Sind nur einzelne Phasen beauftragt, ist das vereinbarte Honorar das Honorar für genau diese Phasen. Ohne Normierung bliebe ein Teil des Honorars unverplant.">
+      <input type="checkbox" id="honorarNormieren" checked onchange="renderHonorarPlan()">
+      Honorar auf die beauftragten Phasen normieren
+    </label>
+
+    <div id="honorarPlanTable" class="honorar-plan-wrap"></div>
+
+    <!-- Anteile und Stundensatz werden im Bereich „Einstellungen" gepflegt;
+         hier wird damit nur gerechnet. Der Verweis erscheint nur für
+         Administratoren (renderHonorarHint() in js/plan/plan-honorar.js). -->
+    <p class="hint" id="honorarAdminHint" style="display:none">
+      Anteile und Stundensatz pflegen: <a href="/Einstellungen" onclick="closeHonorarModal();showTab('settings');return false;">Einstellungen → Honorar</a>
+    </p>
+
+    <div class="toolbar" style="margin-top:16px">
+      <button onclick="applyHonorarPlan()">Terminplan einfügen</button>
+      <button class="secondary" onclick="closeHonorarModal()">Abbrechen</button>
+    </div>
+  </div>
+</div>
+
+<!-- Meilenstein-Modal -->
+<div class="modal-bg" id="milestoneModal" style="display:none">
+  <div class="modal">
+    <h2>Meilenstein</h2>
+    <div class="form-row">
+      <label>Name</label>
+      <input type="text" id="milestoneEditName" placeholder="Name">
+    </div>
+    <div class="form-row">
+      <label>Datum</label>
+      <!-- Getrennte Felder wie bei allen anderen Datumseingaben der Seite:
+           sichtbares Anzeigefeld (deutsches Format) + verstecktes ISO-Feld.
+           Vorher war beides dasselbe Feld, weshalb dort "2026-03-15" stand. -->
+      <input type="text" id="milestoneEditDateDisplay" class="range-picker-display" placeholder="Datum wählen…" readonly
+        onclick="openDatePicker({ anchor: this, inputId: 'milestoneEditDate', displayId: 'milestoneEditDateDisplay' })">
+      <input type="hidden" id="milestoneEditDate">
+    </div>
+    <div class="form-row">
+      <label>Position</label>
+      <select id="milestoneEditPosition">
+        <option value="">Oben in der Projektzeile</option>
+      </select>
+    </div>
+    <div class="form-row">
+      <label>Vorgänger (mehrfach möglich)</label>
+      <div id="milestoneEditDependsOn" class="todo-depends-list"></div>
+    </div>
+    <div class="toolbar">
+      <button onclick="saveMilestoneEdit()">Speichern</button>
+      <button class="danger" onclick="deleteMilestoneEdit()">Löschen</button>
+      <button class="secondary" onclick="closeMilestoneModal()">Abbrechen</button>
+    </div>
+  </div>
+</div>
+
+<!-- TODO-Modal (Stufe B: Status-Segment statt Erledigt+Fortschritt, Zuständige
+     als Personen-Chips, Abhängigkeiten eingeklappt mit Zähler/Suche,
+     "Speichern & Neu", Fehler am Feld statt alert(), Esc/Strg+Enter). Befüllt
+     und ausgewertet von openTodoModal()/saveTodoEdit() in js/plan/plan-modals.js. -->
+<div class="modal-bg" id="todoModal" style="display:none">
+  <div class="modal">
+    <div class="modal-head">
+      <h2 id="todoModalTitle">Aufgabe bearbeiten</h2>
+      <span class="modal-kbd" id="todoModalKbd">Esc · Strg+↵</span>
+    </div>
+
+    <div class="form-row">
+      <label for="todoEditTitle">Titel</label>
+      <input type="text" id="todoEditTitle" placeholder="Titel">
+      <span class="field-error" id="todoEditTitleError" hidden></span>
+    </div>
+
+    <div class="form-row">
+      <label>Zeitraum</label>
+      <div class="field-inline">
+        <input type="text" id="todoEditRange" class="range-picker-display" placeholder="Start – Ende wählen…" readonly
+          onclick="openRangePicker({ anchor: this, startInputId: 'todoEditStart', endInputId: 'todoEditEnd', displayId: 'todoEditRange', onApply: refreshTodoDuration })">
+        <span class="field-badge" id="todoEditDuration" hidden></span>
+      </div>
+      <input type="hidden" id="todoEditStart">
+      <input type="hidden" id="todoEditEnd">
+      <span class="field-error" id="todoEditRangeError" hidden></span>
+      <p class="hint">Ohne Zeitraum erscheint die Aufgabe nur unter „Aufgaben“, nicht im Terminplan.</p>
+    </div>
+
+    <div class="form-row">
+      <label>Zuständige</label>
+      <div id="todoEditAssignees" class="person-chips"></div>
+    </div>
+
+    <div class="form-row">
+      <label>Status</label>
+      <div class="segmented" id="todoEditStatus">
+        <button type="button" data-status="offen" aria-pressed="false" onclick="setTodoEditStatus('offen')"><span class="segmented-dot"></span>Offen</button>
+        <button type="button" data-status="arbeit" aria-pressed="false" onclick="setTodoEditStatus('arbeit')"><span class="segmented-dot"></span>In Arbeit</button>
+        <button type="button" data-status="fertig" aria-pressed="false" onclick="setTodoEditStatus('fertig')"><span class="segmented-dot"></span>Erledigt</button>
+      </div>
+      <div class="progress-row" id="todoEditProgressRow">
+        <input type="range" id="todoEditProgress" min="0" max="100" step="5" value="0" aria-label="Fortschritt"
+          oninput="onTodoProgressInput(this)">
+        <output id="todoEditProgressVal">0 %</output>
+      </div>
+    </div>
+
+    <div class="form-row">
+      <details class="fold" id="todoEditDependsFold">
+        <summary>
+          <span class="fold-caret">▶</span>
+          <span>Abhängigkeiten</span>
+          <span class="fold-count zero" id="todoEditDependsCount">0</span>
+        </summary>
+        <div class="fold-body">
+          <div class="fold-search">
+            <span class="fold-search-icon">⌕</span>
+            <input type="text" id="todoEditDependsSearch" placeholder="Aufgabe oder Meilenstein suchen…" oninput="filterTodoDepends()">
+          </div>
+          <div id="todoEditDependsOn" class="todo-depends-list flat" onchange="refreshTodoDependsCount()"></div>
+        </div>
+      </details>
+    </div>
+
+    <div class="modal-footer">
+      <div class="toolbar">
+        <button onclick="saveTodoEdit()">Speichern</button>
+        <button class="secondary" id="todoEditSaveNew" onclick="saveTodoEdit(true)">Speichern &amp; Neu</button>
+      </div>
+      <div class="toolbar">
+        <button class="danger" id="todoEditDelete" onclick="deleteTodoEdit()">Löschen</button>
+        <button class="secondary" onclick="closeTodoModal()">Abbrechen</button>
+      </div>
+    </div>
+  </div>
+</div>
+
+<!-- Abwesenheits-Modal (Urlaube der Projektbeteiligten) -->
+<div class="modal-bg" id="absenceModal" style="display:none">
+  <div class="modal">
+    <h2 id="absenceModalTitle">Abwesenheiten</h2>
+    <div class="form-row">
+      <div id="absenceModalList"></div>
+    </div>
+    <div class="absence-form" id="absenceModalForm">
+      <input type="text" id="absenceEditRange" class="range-picker-display" placeholder="Zeitraum wählen…" readonly
+        onclick="openRangePicker({ anchor: this, startInputId: 'absenceEditStart', endInputId: 'absenceEditEnd', displayId: 'absenceEditRange' })">
+      <input type="hidden" id="absenceEditStart">
+      <input type="hidden" id="absenceEditEnd">
+      <select id="absenceEditType">
+        <option>Urlaub</option>
+        <option>Krank</option>
+        <option>Fortbildung</option>
+        <option>Sonstiges</option>
+      </select>
+      <input type="text" id="absenceEditNote" placeholder="Notiz (optional)" style="width:140px">
+      <button class="secondary small" onclick="addPlanAbsence()">+ Abwesenheit</button>
+    </div>
+    <div class="toolbar" style="margin-top:12px">
+      <button class="secondary" onclick="closeAbsenceModal()">Schließen</button>
+    </div>
+  </div>
+</div>
+
+<!-- ===================== Dialoge der Benutzerverwaltung =====================
+     Gehoeren zum Abschnitt „Benutzerverwaltung" des Bereichs #admin (frueher
+     die eigenstaendige Seite admin-users.html) und liegen wie alle anderen
+     Dialoge auf oberster Ebene, damit .modal-bg den ganzen Bildschirm
+     ueberdeckt. Befuellt werden sie von js/admin-users.js. -->
+<!-- Neuer-Benutzer-Modal -->
+<div class="modal-bg" id="newUserModal" style="display:none">
+  <div class="modal">
+    <h2>Neuer Benutzer</h2>
+    <div class="form-row">
+      <label>Benutzername</label>
+      <input type="text" id="newUserUsername" placeholder="z. B. mmustermann" autocomplete="off">
+    </div>
+    <div class="form-row">
+      <label>Anzeigename</label>
+      <input type="text" id="newUserDisplayName" placeholder="z. B. Max Mustermann" oninput="onNewUserDisplayNameInput()">
+    </div>
+    <div class="form-row">
+      <label>E-Mail</label>
+      <input type="email" id="newUserEmail" placeholder="max.mustermann@beispiel.de">
+    </div>
+    <div class="form-row">
+      <label>Rolle</label>
+      <select id="newUserRole" onchange="onUserRoleChange('new')">
+        <option value="member">Mitglied</option>
+        <option value="admin">Administrator</option>
+        <option value="kiosk">Kiosk (Wandtafel-Konto)</option>
+      </select>
+      <p class="hint" id="newUserRoleHint" style="display:none">Ein Kiosk-Konto hat nur Lesezugriff für die Wandtafel und keine Fachrolle.</p>
+    </div>
+    <div class="form-row">
+      <label>Abteilung</label>
+      <select id="newUserDepartment" required></select>
+    </div>
+    <div class="form-row">
+      <label>Kürzel</label>
+      <input type="text" id="newUserInitials" placeholder="wird aus dem Anzeigenamen vorgeschlagen" maxlength="4">
+      <p class="hint">Kurzform fürs Projektboard (2-4 Zeichen), wird vorgeschlagen und kann angepasst werden.</p>
+    </div>
+    <div class="form-row">
+      <label>Wochenstunden</label>
+      <input type="number" id="newUserCapacity" min="0" max="80" step="0.5" placeholder="z. B. 40">
+      <p class="hint">Vertragliche Arbeitszeit. Die Auslastung misst die Person daran: Eine halbe Stelle gilt schon bei halber Last als voll ausgelastet. Leer = volle Stelle.</p>
+    </div>
+    <div class="form-row">
+      <label>Person-ID</label>
+      <input type="text" id="newUserPersonId" placeholder="wird aus dem Anzeigenamen vorgeschlagen">
+      <p class="hint">Verknüpft den Account mit einem Eintrag in der Projektbeteiligten-Liste (personIdForName). Bei Kollisionen anpassen.</p>
+    </div>
+    <div class="form-row">
+      <label>Fachrolle(n)</label>
+      <div class="role-checkboxes" id="newUserRoleCheckboxes"></div>
+    </div>
+    <div class="form-row">
+      <label>Passwort</label>
+      <div class="role-checkboxes">
+        <label><input type="radio" name="newUserPwMode" value="generate" checked onchange="onNewUserPwModeChange()"> Zufällig generieren</label>
+        <label><input type="radio" name="newUserPwMode" value="manual" onchange="onNewUserPwModeChange()"> Manuell festlegen</label>
+      </div>
+      <input type="password" id="newUserPassword" placeholder="mind. 8 Zeichen" style="display:none;margin-top:8px" autocomplete="new-password">
+    </div>
+    <div id="newUserError" style="color:#c00;"></div>
+    <div class="toolbar" style="margin-top:12px">
+      <button onclick="saveNewUser()">Anlegen</button>
+      <button class="secondary" onclick="closeNewUserModal()">Abbrechen</button>
+    </div>
+  </div>
+</div>
+
+<!-- Benutzer-bearbeiten-Modal -->
+<div class="modal-bg" id="editUserModal" style="display:none">
+  <div class="modal">
+    <h2>Benutzer bearbeiten</h2>
+    <p class="hint" id="editUserUsernameLabel" style="margin-bottom:10px"></p>
+    <div class="form-row">
+      <label>Anzeigename</label>
+      <input type="text" id="editUserDisplayName">
+    </div>
+    <div class="form-row">
+      <label>E-Mail</label>
+      <input type="email" id="editUserEmail">
+    </div>
+    <div class="form-row">
+      <label>Rolle</label>
+      <select id="editUserRole" onchange="onUserRoleChange('edit')">
+        <option value="member">Mitglied</option>
+        <option value="admin">Administrator</option>
+        <option value="kiosk">Kiosk (Wandtafel-Konto)</option>
+      </select>
+      <p class="hint" id="editUserRoleHint" style="display:none">Ein Kiosk-Konto hat nur Lesezugriff für die Wandtafel und keine Fachrolle.</p>
+    </div>
+    <div class="form-row">
+      <label>Abteilung</label>
+      <select id="editUserDepartment" required></select>
+    </div>
+    <div class="form-row">
+      <label>Kürzel</label>
+      <input type="text" id="editUserInitials" maxlength="4">
+    </div>
+    <div class="form-row">
+      <label>Wochenstunden</label>
+      <input type="number" id="editUserCapacity" min="0" max="80" step="0.5" placeholder="leer = volle Stelle">
+      <p class="hint">Vertragliche Arbeitszeit; Grundlage der Auslastungs-Ampel.</p>
+    </div>
+    <div class="form-row">
+      <label>Person-ID</label>
+      <input type="text" id="editUserPersonId">
+    </div>
+    <div class="form-row">
+      <label>Fachrolle(n)</label>
+      <div class="role-checkboxes" id="editUserRoleCheckboxes"></div>
+    </div>
+    <div class="form-row">
+      <label>Abwesenheiten</label>
+      <div id="editUserAbsenceList" class="absence-list"></div>
+      <div class="absence-form">
+        <input type="date" id="editUserAbsenceStart">
+        <input type="date" id="editUserAbsenceEnd">
+        <select id="editUserAbsenceType">
+          <option>Urlaub</option>
+          <option>Krank</option>
+          <option>Fortbildung</option>
+          <option>Sonstiges</option>
+        </select>
+        <input type="text" id="editUserAbsenceNote" placeholder="Notiz (optional)" style="width:140px">
+        <button class="secondary small" onclick="addEditUserAbsence()">+ Abwesenheit</button>
+      </div>
+      <div id="editUserAbsenceError" style="color:#c00;"></div>
+    </div>
+    <div id="editUserError" style="color:#c00;"></div>
+    <div class="toolbar" style="margin-top:12px">
+      <button onclick="saveEditUser()">Speichern</button>
+      <button class="secondary" onclick="closeEditUserModal()">Abbrechen</button>
+    </div>
+  </div>
+</div>
+
+<!-- Aufgabe aus dem Kommentar (js/wochenbericht/wochenbericht.js).
+     Macht aus einem im Meeting gefassten Beschluss eine echte Aufgabe im Plan
+     des Projekts — bis dahin blieben solche Absprachen Fließtext im Kommentar
+     und tauchten im Terminplan nie auf. -->
+<div class="modal-bg" id="todoKommentarModal" style="display:none">
+  <div class="modal">
+    <h2>Aufgabe anlegen</h2>
+    <p class="hint" id="todoKommentarProjekt" style="margin-top:-4px"></p>
+    <div class="form-row">
+      <label for="todoKommentarTitel">Was ist zu tun?</label>
+      <input type="text" id="todoKommentarTitel" placeholder="z. B. „LV an T.W. zur Prüfung">
+      <span class="hint" style="margin:4px 0 0">Vorgeschlagen ist die erste Zeile des Kommentars.</span>
+    </div>
+    <div class="form-row">
+      <label>Zuständige</label>
+      <div id="todoKommentarPersonen" class="person-chips"></div>
+    </div>
+    <div class="form-row">
+      <label for="todoKommentarEnde">Fällig am</label>
+      <input type="date" id="todoKommentarEnde">
+      <span class="hint" style="margin:4px 0 0">Vorgeschlagen ist die kommende Woche.</span>
+    </div>
+    <div class="field-error" id="todoKommentarFehler" hidden></div>
+    <div class="toolbar">
+      <button type="button" onclick="saveTodoAusKommentar()">Aufgabe anlegen</button>
+      <button type="button" class="secondary" onclick="closeTodoAusKommentar()">Abbrechen</button>
+    </div>
+  </div>
+</div>
+
+<!-- Protokoll der Sitzung (js/wochenbericht/wochenbericht.js). Stellt
+     zusammen, was sich gegenüber der vorherigen Sitzung geändert hat, samt
+     der heute angelegten Aufgaben. -->
+<div class="modal-bg" id="protokollModal" style="display:none">
+  <div class="modal modal-wide">
+    <h2>Protokoll der Sitzung</h2>
+    <p class="hint" style="margin-top:-4px">
+      <span id="protokollAnzahl"></span> — unveränderte Projekte stehen nicht drin.
+    </p>
+    <textarea id="protokollText" rows="16" class="protokoll-text" spellcheck="false"></textarea>
+    <div class="toolbar" style="margin-top:12px">
+      <button type="button" onclick="kopiereProtokoll()">In die Zwischenablage</button>
+      <button type="button" class="secondary" onclick="protokollAlsMail()">Als Mail öffnen</button>
+      <span class="hint" id="protokollHinweis" style="margin:0"></span>
+      <span class="comment-foot-spacer"></span>
+      <button type="button" class="secondary" onclick="closeBerichtProtokoll()">Schließen</button>
+    </div>
+  </div>
+</div>
+
+<!-- Passwort ändern (js/auth.js). Zwei Betriebsarten: freiwillig aus dem
+     Bereich „Einstellungen" heraus und ERZWUNGEN, wenn das Konto
+     must_change_password trägt — dann ohne Abbrechen. Der Server verlangt in
+     beiden Fällen das aktuelle Passwort. -->
+<div class="modal-bg" id="passwordModal" style="display:none">
+  <div class="modal">
+    <h2>Passwort ändern</h2>
+    <p class="hint" id="passwordForcedHint" hidden>
+      Für dieses Konto ist ein Passwortwechsel erforderlich — das Startpasswort
+      wurde von einem Administrator vergeben. Erst danach geht es weiter.
+    </p>
+    <form id="passwordForm" onsubmit="submitPasswordChange(event)">
+      <div class="form-row">
+        <label for="passwordCurrent">Aktuelles Passwort</label>
+        <input type="password" id="passwordCurrent" autocomplete="current-password" required>
+      </div>
+      <div class="form-row">
+        <label for="passwordNew">Neues Passwort</label>
+        <input type="password" id="passwordNew" autocomplete="new-password" minlength="8" required>
+        <span class="hint" style="margin:4px 0 0">Mindestens 8 Zeichen.</span>
+      </div>
+      <div class="form-row">
+        <label for="passwordRepeat">Neues Passwort wiederholen</label>
+        <input type="password" id="passwordRepeat" autocomplete="new-password" minlength="8" required>
+      </div>
+      <div class="field-error" id="passwordError" hidden></div>
+      <div class="toolbar">
+        <button type="submit">Passwort ändern</button>
+        <button type="button" class="secondary" id="passwordCancelBtn" onclick="closePasswordModal()">Abbrechen</button>
+      </div>
+    </form>
+  </div>
+</div>
+
+<!-- Login-Overlay: blockiert die gesamte App ohne gültige Session (siehe js/auth.js) -->
+<div id="loginOverlay" style="display:none;" class="modal-bg">
+  <div class="modal">
+    <h2>Anmelden</h2>
+    <form id="loginForm">
+      <div class="form-row"><label>Benutzername</label><input type="text" id="loginUsername" autocomplete="username" required></div>
+      <div class="form-row"><label>Passwort</label><input type="password" id="loginPassword" autocomplete="current-password" required></div>
+      <div id="loginError" style="color:#c00;"></div>
+      <div class="toolbar"><button type="submit">Anmelden</button></div>
+    </form>
+  </div>
+</div>
+
+<script src="/js/globals.js?v=7"></script>
+<script src="/js/utils.js?v=18"></script>
+<script src="/js/icons.js?v=2"></script>
+<script src="/js/ui.js?v=9"></script>
+<script src="/js/date-picker.js?v=5"></script>
+<script src="/js/server.js?v=6"></script>
+<script src="/js/auth.js?v=4"></script>
+<script src="/js/store.js?v=10"></script>
+<script src="/js/weeks.js?v=11"></script>
+<script src="/js/board/board.js?v=30"></script>
+<script src="/js/wochenbericht/wochenbericht.js?v=20"></script>
+<script src="/js/people/people.js?v=7"></script>
+<script src="/js/planung/planung.js?v=1"></script>
+<script src="/js/projects/projects.js?v=7"></script>
+<script src="/js/load/load.js?v=18"></script>
+<!-- auftrag.js: Auftragsstatus und Dialog "Beauftragung". Nach load.js, weil
+     der Neues-Projekt-Dialog dort die Statusauswahl mit AUFTRAGSSTATUS füllt. -->
+<script src="/js/auftrag.js?v=1"></script>
+<!-- Assistent "Neues Projekt": braucht auftrag.js (Auftragsstatus) und
+     load.js (faktorFormat), steht deshalb dahinter. -->
+<script src="/js/projekt-wizard.js?v=1"></script>
+<script src="/js/dashboard/dashboard.js?v=5"></script>
+<!-- wand.js braucht berechneAuslastung()/loadAmpelColor()/kapazitaetsFaktor()/
+     stundenFormat() (load.js), classifyProjectChange()/findPreviousWeek()
+     (wochenbericht.js), statusPreviewText() (board.js) und
+     relativerTag()/tageBis()/initialsFor() (dashboard.js) — alle laden
+     bereits vorher, die Reihenfolge hier ist also nur Zuordnung zum
+     Tab-Ordner, keine neue Abhängigkeit nach vorn. -->
+<script src="/js/wand/wand.js?v=11"></script>
+<script src="/js/settings/settings.js?v=9"></script>
+<script src="/js/admin/admin.js?v=11"></script>
+<script src="/js/admin-users.js?v=4"></script>
+<script src="/js/gantt.js?v=7"></script>
+<!-- Module des Projektbereichs (#plan). Sie liefen frueher nur in
+     project-plan.html; seit der Projektbereich ein Bereich dieser Seite ist,
+     gehoeren sie hierher. Reihenfolge wie gehabt: plan-state.js legt
+     window.PlanApp an, plan-history.js muss VOR plan-build-gantt.js stehen
+     (das seine Vorwochen-Helfer nutzt), und alle zusammen muessen nach
+     js/gantt.js kommen, dessen buildGanttHtml() plan-build-gantt.js
+     umhuellt. -->
+<script src="/js/plan/plan-state.js?v=12"></script>
+<script src="/js/plan/plan-sections.js?v=5"></script>
+<script src="/js/plan/plan-info.js?v=7"></script>
+<script src="/js/plan/plan-history.js?v=3"></script>
+<script src="/js/plan/plan-build-gantt.js?v=7"></script>
+<script src="/js/plan/plan-gantt.js?v=9"></script>
+<script src="/js/plan/plan-drag.js?v=6"></script>
+<script src="/js/plan/plan-modals.js?v=7"></script>
+<script src="/js/plan/plan-tasks.js?v=2"></script>
+<script src="/js/plan/plan-files.js?v=3"></script>
+<script src="/js/plan/plan-protokoll.js?v=17"></script>
+<script src="/js/plan/plan-templates.js?v=4"></script>
+<script src="/js/plan/plan-honorar.js?v=6"></script>
+<!-- plan-leistung.js muss NACH plan-honorar.js stehen: es umhuellt dessen
+     invalidateHonorarConfig(), damit eine Aenderung der Anteile auch seinen
+     Zwischenspeicher verwirft. -->
+<script src="/js/plan/plan-leistung.js?v=1"></script>
+<script src="/js/plan/plan-settings.js?v=7"></script>
+<script src="/js/plan/plan-schedule.js?v=5"></script>
+<script src="/js/tabs-auth.js?v=14"></script>
+<script src="/js/pdf.js?v=23"></script>
+<script src="/js/backup.js?v=2"></script>
+<script src="/js/import.js?v=1"></script>
+<script src="/js/init.js?v=12"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/public/Test.html b/public/Test.html
deleted file mode 100644
index 771ce82..0000000
--- a/public/Test.html
+++ /dev/null
@@ -1,255 +0,0 @@
-<!DOCTYPE html>
-<!--
-  HAUPTSEITE der Projektübersicht (wird vom Express-Server unter "/" ausgeliefert).
-  Die Seite zeigt die vier Tabs Projektboard, Auslastung, Projekte und Projektbeteiligte
-  und verwaltet wöchentliche Sitzungen (Sitzungswahl, -anlage, -duplikat und -löschung im
-  seitlichen Menü) je Abteilung (ELT, HLS, Architektur). Sie lädt das gemeinsame Stylesheet
-  styles.css sowie der Reihe nach die Module js/globals.js, js/utils.js, js/ui.js,
-  js/date-picker.js, js/server.js, js/store.js, js/weeks.js, danach die
-  tab-spezifischen Module js/board/board.js, js/people/people.js,
-  js/projects/projects.js, js/load/load.js sowie js/gantt.js, js/showmode.js,
-  js/tabs-auth.js, js/pdf.js und js/init.js; crypto-js und pdfmake kommen von einem
-  CDN. Über openProjectPlan()
-  aus js/gantt.js öffnet diese Seite die Projektplan-Ansicht project-plan.html in einem
-  neuen Tab, die nur die gemeinsamen Module plus die js/plan/*-Module lädt.
--->
-<html lang="de">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>Projektübersicht Elektro</title>
-<link rel="stylesheet" href="/styles.css?v=3">
-  <script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.1.1/crypto-js.min.js"></script>
-  <script src="https://cdnjs.cloudflare.com/ajax/libs/pdfmake/0.2.10/pdfmake.min.js"></script>
-  <script src="https://cdnjs.cloudflare.com/ajax/libs/pdfmake/0.2.10/vfs_fonts.js"></script>
- </head>
-<body>
-<div class="dept-tabs">
-  <button class="menu-corner-btn" onclick="toggleHeader()" title="Menü öffnen/schließen" aria-expanded="false" aria-controls="headerMenu">
-    <span class="header-toggle-icon">☰</span>
-  </button>
-  <div class="dept-tabs-center">
-    <button class="dept-tab active" data-dept="ELT" onclick="switchDepartment('ELT')">ELT</button>
-    <button class="dept-tab" data-dept="HLS" onclick="switchDepartment('HLS')">HLS</button>
-    <button class="dept-tab" data-dept="ARCH" onclick="switchDepartment('ARCH')">Architektur</button>
-  </div>
-</div>
-
-<header>
-  <div class="header-bar">
-    <h1 id="pageTitle">Projektübersicht Elektro</h1>
-    <img src="/dein_bild.ico" alt="Logo" class="header-logo">
-  </div>
-</header>
-
-<div id="headerMenu" class="side-menu" aria-hidden="true">
-  <div class="side-menu-header">
-    <span>Menü</span>
-    <div class="side-menu-header-actions">
-      <button class="theme-toggle-circle" id="themeToggle" onclick="toggleTheme()" title="Hell/Dunkel umschalten">
-        <span id="themeIcon">🌙</span>
-      </button>
-      <button class="header-toggle secondary" onclick="toggleHeader()" title="Menü schließen">
-        <span class="header-toggle-icon">✕</span>
-      </button>
-    </div>
-  </div>
-  <div class="side-menu-content">
-    <div class="menu-section">
-      <div class="menu-label">Sitzung (KW)</div>
-      <select id="weekSelect" onchange="switchWeek(this.value)"></select>
-      <div id="weekDateDisplay" class="week-date"></div>
-    </div>
-
-    <hr class="menu-divider">
-
-    <div class="menu-section">
-      <div class="menu-label">Sitzungen verwalten</div>
-      <button onclick="newWeek()">+ Neue Sitzung</button>
-      <button class="secondary" onclick="cloneWeek()">Sitzung duplizieren</button>
-      <button class="danger" onclick="deleteWeek()">Sitzung löschen</button>
-    </div>
-
-    <hr class="menu-divider">
-
-    <div class="menu-section">
-      <div class="menu-label">Präsentation</div>
-      <button class="secondary" onclick="exportPDF()">PDF Export</button>
-      <button class="secondary" onclick="startShowMode()">Show Mode</button>
-    </div>
-
-    <hr class="menu-divider">
-
-    <div class="menu-section">
-      <div class="menu-label">Backup</div>
-      <button class="secondary" onclick="exportCSV()">CSV Export</button>
-      <button class="secondary" onclick="downloadBackup()">DB Backup</button>
-      <button class="secondary" onclick="importDb()">DB Import</button>
-    </div>
-  </div>
-</div>
-
-<!-- Show Mode Overlay -->
-<div id="showModeOverlay" class="show-mode-overlay" style="display:none;" onclick="pauseShowMode()">
-  <div class="show-mode-header">
-    <span id="showModeTitle">Show Mode</span>
-    <button class="secondary" onclick="stopShowMode()">Beenden</button>
-  </div>
-  <div id="showModeContent" class="show-mode-content"></div>
-  <div id="showModePaused" class="show-mode-paused" style="display:none;">Pausiert – berühre zum Fortsetzen</div>
-</div>
-<div id="sideMenuBackdrop" class="side-menu-backdrop" onclick="toggleHeader()"></div>
-
-<div class="tabs">
-  <button class="tab active" data-tab="board" onclick="showTab('board')">Projektboard</button>
-  <button class="tab" data-tab="load" onclick="showTab('load')">Auslastung</button>
-  <button class="tab" data-tab="projects" onclick="showTab('projects')">Projekte</button>
-  <button class="tab" data-tab="people" onclick="showTab('people')">Projektbeteiligte</button>
-</div>
-
-<div class="container">
-  <!-- BOARD -->
-  <div id="board">
-    <div class="legend">
-      <span><span class="swatch" style="background:#2f855a"></span> Beteiligt X</span>
-      <span><span class="swatch" style="background:#d69e2e"></span> Optional (X)</span>
-      </div>
-    <div class="table-wrap">
-      <table id="boardTable"></table>
-    </div>
-    <div id="boardLegend"></div>
-  </div>
-
-  <!-- LOAD -->
-  <div id="load" style="display:none">
-    <div class="section-title">Auslastung der Projektbeteiligten</div>
-    <div class="toolbar" style="margin-bottom:12px">
-      <label>Auswertung:</label>
-      <select id="loadScope" onchange="renderLoad()">
-        <option value="current">Aktuelle Sitzung</option>
-        <option value="all">Alle Sitzungen (Historie)</option>
-      </select>
-      <span class="hint">Auswertung über den rollenspezifischen Gewichtungsfaktor je Leistungsphase.</span>
-    </div>
-    <div class="load-grid" id="loadGrid"></div>
-  </div>
-
-  <!-- PROJECTS -->
-  <div id="projects" style="display:none">
-    <div class="section-title">Projekte verwalten</div>
-    <div class="toolbar" style="margin-bottom:12px">
-      <button onclick="openNewProjModal()">+ Neues Projekt</button>
-    </div>
-    <div id="projectsList"></div>
-  </div>
-
-  <!-- PEOPLE -->
-  <div id="people" style="display:none">
-    <div class="section-title">Projektbeteiligte verwalten</div>
-    <div class="toolbar" style="margin-bottom:12px; align-items: flex-start;">
-      <input type="text" id="newPersonName" placeholder="Kürzel (z.B. AP)" style="width:100px">
-      <input type="text" id="newPersonFullName" placeholder="Voller Name (z.B. Anton Peters)">
-      <input type="text" id="newPersonEmail" placeholder="E-Mail (z.B. anton.peters@rauschenberg-ing.de)">
-      <div class="role-checkboxes">
-        <label><input type="checkbox" name="newPersonRoles" value="Planung"> Planung</label>
-        <label><input type="checkbox" name="newPersonRoles" value="Projektleitung"> Projektleitung</label>
-        <label><input type="checkbox" name="newPersonRoles" value="Bauüberwachung"> Bauüberwachung</label>
-      </div>
-      <button onclick="addPerson()">+ Person hinzufügen</button>
-    </div>
-    <div id="peopleList"></div>
-  </div>
-</div>
-
-<!-- Passwort Modal -->
-<div class="modal-bg" id="passwordModal">
-  <div class="modal">
-    <h2>Zugriff erforderlich</h2>
-    <p style="color:#666;margin-bottom:12px">Bitte geben Sie das Passwort ein, um auf diesen Bereich zuzugreifen.</p>
-    <div class="form-row">
-      <label>Passwort</label>
-      <input type="password" id="passwordInput" placeholder="Passwort eingeben" onkeypress="if(event.key==='Enter') confirmPassword()">
-    </div>
-    <div class="toolbar">
-      <button onclick="confirmPassword()">Bestätigen</button>
-      <button class="secondary" onclick="closePasswordModal()">Abbrechen</button>
-    </div>
-  </div>
-</div>
-
-<!-- Aufwand je Leistungsphase Modal -->
-<div class="modal-bg" id="lpModal" style="display:none">
-  <div class="modal">
-    <h2>Aufwand je Leistungsphase</h2>
-    <p style="color:#888;margin-bottom:6px" id="lpModalProject"></p>
-    <p class="hint" style="margin-bottom:10px">
-      Rollenbezogene Gewichtungsfaktoren je Leistungsphase (Standardwerte laut
-      Vorlage im Code). Die amtierende Leistungsphase wird pro Projekt im Tab
-      „Projekte" gewählt.
-    </p>
-    <div id="lpModalRows"></div>
-    <div class="toolbar" style="margin-top:12px">
-      <button onclick="saveLpModal()">Speichern</button>
-      <button class="secondary" onclick="closeLpModal()">Abbrechen</button>
-    </div>
-  </div>
-</div>
-
-<!-- Neues Projekt Modal (inkl. LP-Aufwand) -->
-<div class="modal-bg" id="newProjModal" style="display:none">
-  <div class="modal">
-    <h2>Neues Projekt</h2>
-    <div class="form-row">
-      <label>Projekt-Nr.</label>
-      <input type="text" id="newProjNr" placeholder="z. B. 26-4001" style="width:100%">
-    </div>
-    <div class="form-row">
-      <label>Bezeichnung</label>
-      <input type="text" id="newProjName" placeholder="Projektbezeichnung" style="width:100%">
-    </div>
-    <div class="form-row">
-      <label>Gruppe</label>
-      <select id="newProjGroup" style="width:100%">
-        <option>Aktive Projekte</option>
-        <option>Kleine Projekte</option>
-        <option>In Anbahnung</option>
-        <option>Allgemein</option>
-      </select>
-    </div>
-    <div class="form-row">
-      <label>Aktive Leistungsphase</label>
-      <select id="newProjActiveLP" style="width:100%"></select>
-    </div>
-    <p class="hint" style="margin:8px 0 10px">
-      Rollenbezogener Gewichtungsfaktor je Leistungsphase (Standardwerte laut
-      Vorlage im Code).
-    </p>
-    <div id="newProjLpRows"></div>
-    <div class="toolbar" style="margin-top:12px">
-      <button onclick="saveNewProj()">Anlegen</button>
-      <button class="secondary" onclick="closeNewProjModal()">Abbrechen</button>
-    </div>
-  </div>
-</div>
-
-<script src="/js/globals.js?v=5"></script>
-<script src="/js/utils.js?v=5"></script>
-<script src="/js/ui.js?v=5"></script>
-<script src="/js/date-picker.js?v=5"></script>
-<script src="/js/server.js?v=5"></script>
-<script src="/js/store.js?v=5"></script>
-<script src="/js/weeks.js?v=5"></script>
-<script src="/js/board/board.js?v=6"></script>
-<script src="/js/people/people.js?v=6"></script>
-<script src="/js/projects/projects.js?v=6"></script>
-<script src="/js/load/load.js?v=6"></script>
-<script src="/js/gantt.js?v=5"></script>
-<script src="/js/showmode.js?v=5"></script>
-<script src="/js/tabs-auth.js?v=5"></script>
-<script src="/js/pdf.js?v=5"></script>
-<script src="/js/csv.js?v=1"></script>
-<script src="/js/backup.js?v=1"></script>
-<script src="/js/import.js?v=1"></script>
-<script src="/js/init.js?v=5"></script>
-</body>
-</html>
\ No newline at end of file
diff --git a/public/js/admin-users.js b/public/js/admin-users.js
index 5dfebda..4fc19ed 100644
--- a/public/js/admin-users.js
+++ b/public/js/admin-users.js
@@ -69,6 +69,21 @@
     return Array.from(document.querySelectorAll('#' + containerId + ' input[type="checkbox"]:checked')).map(cb => cb.value);
   }
 
+  // onUserRoleChange: wird beim Wechsel der Systemrolle in einem der beiden
+  // Formulare aufgerufen (which = 'new'|'edit'). Ein Kiosk-Konto kann keine
+  // Fachrolle haben (server.js weist das sonst mit 400 zurück) — die
+  // Checkboxen werden deshalb schon hier abgehakt entfernt und gesperrt,
+  // statt den Fehler erst nach dem Absenden zu zeigen.
+  window.onUserRoleChange = function(which){
+    const istKiosk = document.getElementById(which + 'UserRole').value === 'kiosk';
+    const hint = document.getElementById(which + 'UserRoleHint');
+    if(hint) hint.style.display = istKiosk ? '' : 'none';
+    document.querySelectorAll('#' + which + 'UserRoleCheckboxes input[type="checkbox"]').forEach(cb => {
+      cb.disabled = istKiosk;
+      if(istKiosk) cb.checked = false;
+    });
+  };
+
   // formulareVorbereitet: Abteilungs-Auswahl und Rollen-Ankreuzfelder muessen
   // nur einmal aufgebaut werden; renderAdminUsers() laeuft aber bei jedem
   // Wechsel in den Abschnitt.
@@ -137,7 +152,7 @@
         <td>${esc(u.username)}</td>
         <td>${esc(u.displayName)}</td>
         <td>${esc(u.email || '')}</td>
-        <td>${u.role === 'admin' ? 'Administrator' : 'Mitglied'}</td>
+        <td>${u.role === 'admin' ? 'Administrator' : u.role === 'kiosk' ? 'Kiosk' : 'Mitglied'}</td>
         <td>${deptLabel}</td>
         <td>${esc(u.initials || '')}</td>
         <td>${u.capacityHours ? esc(fmtCapacity(u.capacityHours)) : '<span class="hint" style="margin:0">voll</span>'}</td>
@@ -247,8 +262,10 @@
     // Ohne Fachrolle ist der Benutzer in der ganzen Anwendung unsichtbar:
     // peopleByRole() (js/utils.js) gruppiert ausschließlich über die Rollen —
     // das Konto erschiene weder als Board-Spalte noch in der Auslastung noch
-    // im PDF-Export, ohne dass es dafür irgendeinen Hinweis gäbe.
-    if(!roles || roles.length === 0){
+    // im PDF-Export, ohne dass es dafür irgendeinen Hinweis gäbe. Für ein
+    // Kiosk-Konto gilt das nicht — es soll gerade NICHT in Boards/Auslastung
+    // auftauchen, server.js weist eine gesetzte Fachrolle dort sogar zurück.
+    if(role !== 'kiosk' && (!roles || roles.length === 0)){
       errEl.textContent = 'Bitte mindestens eine Rolle wählen (Planung, Projektleitung oder Bauüberwachung) — sonst erscheint der Benutzer in keinem Projektboard.';
       return;
     }
@@ -301,6 +318,7 @@
     document.querySelectorAll('#editUserRoleCheckboxes input[type="checkbox"]').forEach(cb => {
       cb.checked = userRoles.includes(cb.value);
     });
+    onUserRoleChange('edit');
     document.getElementById('editUserError').textContent = '';
     document.getElementById('editUserAbsenceError').textContent = '';
     document.getElementById('editUserAbsenceStart').value = '';
diff --git a/public/js/admin/admin.js b/public/js/admin/admin.js
index 0875ad6..a3704a1 100644
--- a/public/js/admin/admin.js
+++ b/public/js/admin/admin.js
@@ -48,7 +48,7 @@
 // ADMIN_SECTIONS: die Abschnitte in der Reihenfolge der Seitenleiste. Die
 // EINE Stelle, an der ein Abschnitt definiert wird — Schlüssel (zugleich
 // URL-Fragment) und Überschrift. Die Zuordnung zum Markup läuft über das
-// Attribut data-admin-section, sowohl an der Karte in Test.html als auch am
+// Attribut data-admin-section, sowohl an der Karte in App.html als auch am
 // Unterpunkt in der Seitenleiste; ein neuer Abschnitt braucht damit nur einen
 // Eintrag hier plus die Karte. `wide` hebt die Breitenbegrenzung des Rasters
 // auf — die Benutzertabelle hat zehn Spalten und scrollte sonst quer.
diff --git a/public/js/auftrag.js b/public/js/auftrag.js
index 49170ce..c8cc673 100644
--- a/public/js/auftrag.js
+++ b/public/js/auftrag.js
@@ -11,7 +11,7 @@
 // (p.beauftragteLP). Deshalb erfasst der Dialog "Beauftragung" beides in EINEM
 // Schritt — direkt danach ist der Terminplan rechenbar.
 //
-// Geladen von Test.html als gemeinsames Modul (klassisches Skript, alle
+// Geladen von App.html als gemeinsames Modul (klassisches Skript, alle
 // Funktionen liegen dadurch auf window). Genutzt werden LPHS aus
 // js/globals.js, esc() aus js/utils.js, currentWeek()/save()/markWeekDirty()
 // aus js/store.js, isWeekLocked() aus js/weeks.js und openProjectPlan() aus
diff --git a/public/js/auth.js b/public/js/auth.js
index d3ac259..f14c11b 100644
--- a/public/js/auth.js
+++ b/public/js/auth.js
@@ -1,12 +1,12 @@
 // -----------------------------
 // Projektübersicht — Authentifizierung (Login-Overlay, Session, Logout)
 // -----------------------------
-// Wird von Test.html direkt nach
+// Wird von App.html direkt nach
 // js/server.js geladen, da checkAuthAndInit() baseUrl() benötigt. Ersetzt den
 // früheren rein clientseitigen Passwortschutz (js/tabs-auth.js) durch eine
 // echte serverseitige Session (server.js: /login, /logout, /whoami). Ohne
 // gültige Session zeigt checkAuthAndInit() das blockierende Login-Overlay
-// (#loginOverlay/#loginForm, siehe Test.html); nach
+// (#loginOverlay/#loginForm, siehe App.html); nach
 // erfolgreichem Login läuft der eigentliche Seiteneinstieg (per Callback
 // übergeben) wie gewohnt weiter.
 //
@@ -33,7 +33,8 @@ let currentUser = null;
 function renderUserBar(){
   const info = document.getElementById('userBarInfo');
   if(info && currentUser){
-    const roleLabel = currentUser.role === 'admin' ? 'Administrator' : 'Mitglied';
+    const roleLabel = currentUser.role === 'admin' ? 'Administrator'
+      : currentUser.role === 'kiosk' ? 'Kiosk' : 'Mitglied';
     info.textContent = (currentUser.displayName || currentUser.username) + ' (' + roleLabel + ')';
   }
   const navAdminSection = document.getElementById('navAdminSection');
diff --git a/public/js/backup.js b/public/js/backup.js
index 65ef7e1..5d800c7 100644
--- a/public/js/backup.js
+++ b/public/js/backup.js
@@ -3,7 +3,7 @@
 // -----------------------------
 // Stellt downloadBackup() bereit: lädt einen konsistenten Snapshot der
 // SQLite-Datenbank über GET /backup als .db-Datei herunter (VACUUM INTO,
-// WAL-sicher). Hängt im Seitenmenü von Test.html am Button "DB Backup" und
+// WAL-sicher). Hängt im Seitenmenü von App.html am Button "DB Backup" und
 // nutzt baseUrl() aus js/server.js. Ergänzt das automatische Backup, das der
 // Server beim Start in sessions/backups/ ablegt.
 
@@ -21,8 +21,10 @@ async function downloadBackup(){
       throw new Error(msg);
     }
     const blob = await res.blob();
-    const filename = 'projektuebersicht_backup_'
-      + new Date().toISOString().slice(0, 10) + '.db';
+    // heuteIso() (js/utils.js) statt toISOString(): Letzteres rechnet nach
+    // UTC um und datierte das Backup zwischen 0 und 2 Uhr Ortszeit auf den
+    // Vortag.
+    const filename = 'projektuebersicht_backup_' + heuteIso() + '.db';
 
     const url = URL.createObjectURL(blob);
     const a = document.createElement('a');
diff --git a/public/js/board/board.js b/public/js/board/board.js
index 129f4a7..ff7fe76 100644
--- a/public/js/board/board.js
+++ b/public/js/board/board.js
@@ -1,56 +1,70 @@
 // -----------------------------
-// Projektübersicht — Board (Haupttabelle)
+// Projektübersicht — Board (Listenansicht)
 // -----------------------------
-// Diese Datei rendert das Projektboard (Tab "Projektboard" in `Test.html`),
-// die zentrale Tabelle mit Projekten, Status-Kommentaren, Personen-Spalten
-// (Anwesenheit/Zuordnung) und Leistungsphasen in Prozent. Sie wird von
-// `Test.html` nach `js/weeks.js` (vor `js/people/people.js`) geladen und stellt
-// globale Funktionen wie `renderBoard()`, `statusFocus()`, `cycleAssign()`,
-// `editLph()` und `delProj()` bereit. Sie nutzt `currentWeek()`/
+// Diese Datei rendert das Projektboard (Tab "Projektboard" in `App.html`) als
+// schlanke, aufklappbare Liste statt der früheren breiten Matrix (eine Spalte
+// je Person/Leistungsphase): jede Zeile zeigt auf einen Blick Kürzel-Avatare
+// der zugeordneten Personen, die aktuelle Leistungsphase samt Prozentwert und
+// eine einzeilige Status-Vorschau; ein Klick auf die Zeile klappt darunter das
+// Detailpanel auf (voller Status-Editor, vollständige Rollen-Zuordnung, alle
+// LPH-Balken). Sie wird von `App.html` nach `js/weeks.js` (vor
+// `js/people/people.js`) geladen und stellt globale Funktionen wie
+// `renderBoard()`, `toggleBoardRow()`, `cycleAssign()`,
+// und `editLph()` bereit. Sie nutzt `currentWeek()`/
 // `isWeekLocked()` aus `js/weeks.js`, `lpActiveList()` aus `js/load/load.js`,
-// `assignKey()` aus `js/utils.js` und `openProjectPlan()` aus `js/gantt.js`.
+// `assignKey()`, `statusFocus()`, `sanitizeStatusHtml()` und
+// `getProgressColor()` aus `js/utils.js` sowie `openProjectPlan()` aus
+// `js/gantt.js` — navigiert bewusst im selben Tab (kein window.open() mehr),
+// ein Klick auf den Rest der Zeile klappt stattdessen nur das Detailpanel
+// auf/zu (toggleBoardRow()). editLph()/cycleAssign() rufen zusätzlich
+// renderWochenbericht() (js/wochenbericht/wochenbericht.js) auf, da dessen
+// Karten dieselben renderBoardDrawer()-Bedienelemente nutzen, aber in einem
+// eigenen DOM-Container (#wochenberichtContent) liegen.
 
-// currentStatusEditor: aktuell fokussiertes contenteditable-Element des
-// Status-Editors; wird für die Formatierungs-Toolbar (`formatStatus`) benötigt.
-let currentStatusEditor = null;
-// currentStatusPid: Projekt-ID der gerade fokussierten Status-Zelle; wird beim
-// Speichern des Status (`statusBlur`) verwendet.
-let currentStatusPid = null;
+// boardRowOpen: UI-Zustand, welche Projekt-Zeile ihr Detailpanel aufgeklappt
+// darstellt (Key = Projekt-ID, Wert = boolean). Reine Anzeige-Steuerung, lebt
+// außerhalb von renderBoard() und übersteht daher dessen Neuaufbauten (z. B.
+// nach einer Zuordnungs- oder Prozent-Änderung im offenen Panel). Nicht
+// persistiert — jede Sitzung startet mit eingeklappten Zeilen.
+let boardRowOpen = {};
 
-// statusFocus: merkt sich das fokussierte Status-Element und die zugehörige
-// Projekt-ID (`el`, `pid`), damit die Toolbar und das Blur-Speichern sie nutzen.
-function statusFocus(el, pid){
-  currentStatusEditor = el;
-  currentStatusPid = pid;
+// toggleBoardRow: klappt das Detailpanel einer Projekt-Zeile auf bzw. zu.
+// Parameter: pid (Projekt-ID). Keine Rückgabe.
+function toggleBoardRow(pid){
+  boardRowOpen[pid] = !boardRowOpen[pid];
+  renderBoard();
+  // Der Wochenbericht und die Wandtafel rendern dieselben Projektzeilen in
+  // einem eigenen Container. Ohne diesen Aufruf merkten sie sich den Klick
+  // zwar, zeigten die Zeile aber erst nach einem Tab-Wechsel auf- bzw.
+  // zugeklappt.
+  if(typeof renderWochenbericht === 'function') renderWochenbericht();
+  if(typeof renderWandboard === 'function') renderWandboard();
 }
 
-// statusBlur: übernimmt den Inhalt des Status-Editors (`el`) als neuen Status
-// des Projekts `pid` und räumt die Editor-Merker wieder ab, wenn `el` das
-// zuletzt fokussierte Element war.
-function statusBlur(el, pid){
-  const val = statusValueFromHtml(el.innerHTML);
-  editProj(pid, 'status', val);
-  if(currentStatusEditor === el){ currentStatusEditor = null; currentStatusPid = null; }
-}
-
-// statusValueFromHtml: normalisiert den HTML-Inhalt eines Status-Editors.
-// Liefert bei reinem Leerraum '' zurück, sonst den unveränderten HTML-String
-// (Formatierung bleibt erhalten). Parameter: `html`, Rückgabe: String.
-function statusValueFromHtml(html){
+// statusPreviewText: liefert eine einzeilige Klartext-Vorschau eines
+// Status-HTML-Werts (Tags entfernt, überflüssiger Leerraum/Zeilenumbrüche zu
+// einem Leerzeichen zusammengefasst) für die eingeklappte Zeile — die volle
+// Formatierung bleibt dem aufgeklappten Editor vorbehalten. Parameter: html
+// (String). Rückgabe: String.
+function statusPreviewText(html){
+  if(!html) return '';
   const tmp = document.createElement('div');
-  tmp.innerHTML = html;
-  const text = (tmp.textContent || tmp.innerText || '').replace(/\u00A0/g, ' ');
-  return text.trim() === '' ? '' : html;
+  // Bereinigen, BEVOR der Wert ins DOM geht: Auch ein nicht eingehängtes
+  // Element lädt Ressourcen und führt deren Fehler-Handler aus, ungefiltertes
+  // innerHTML wäre hier also ein Einfallstor.
+  tmp.innerHTML = sanitizeStatusHtml(html);
+  // Zeilen- und Absatzgrenzen zuerst in Leerzeichen überführen: textContent
+  // ignoriert sie, sonst klebte das letzte Wort einer Zeile am ersten der
+  // nächsten ("… KW 40.Freigabe steht aus").
+  tmp.querySelectorAll('br').forEach(el => el.replaceWith(document.createTextNode(' ')));
+  tmp.querySelectorAll('p, div').forEach(el => el.append(document.createTextNode(' ')));
+  return (tmp.textContent || tmp.innerText || '').replace(/\s+/g, ' ').trim();
 }
 
-// formatStatus: wendet einen document.execCommand-Befehl (z.B. 'bold',
-// 'foreColor') auf das fokussierte Status-Element an. Parameter: `command`,
-// optionaler `value`; keine Rückgabe.
-function formatStatus(command, value){
-  if(!currentStatusEditor) return;
-  currentStatusEditor.focus();
-  document.execCommand(command, false, value || null);
-}
+// HINWEIS: statusBlur() ist entfallen. Seit der Kommentar-Editor ein
+// <textarea> ist (renderCommentEditor/saveBoardComment), gab es keinen Aufrufer
+// mehr; die Funktion schrieb ungefiltertes innerHTML in p.status und wäre beim
+// erneuten Verdrahten ein Einfallstor gewesen.
 
 // peopleByRole liegt jetzt im gemeinsamen Modul js/utils.js (benötigt auch
 // die Projektplan-Seite, die board.js nicht lädt).
@@ -65,33 +79,537 @@ function roleClass(role){
   return 'role-' + role.toLowerCase().replace(/\s+/g,'-');
 }
 
-// renderBoard: baut die HTML-Tabelle für das Board auf (Kopf, Zeilen, Zellen).
-// Liest die aktuelle Woche, gruppiert Projekte nach Gruppe, sortiert sie nach
-// `order` und erzeugt die Status-, Personen- und LPH-Zellen. Bei gesperrten
-// Sitzungen werden alle Bearbeitungs-Handler deaktiviert und ein Hinweis samt
-// Entsperren-Button angezeigt. Aktualisiert außerdem die Legende mit den
-// vollständigen Namen und Anwesenheiten. Keine Parameter, keine Rückgabe.
+// renderBoardRow: baut die eingeklappte Zeile eines Projekts (Nr., Name +
+// Tags, Status-Vorschau, Avatar-Stapel der Zugeordneten, Phasen-Badge) sowie
+// bei Bedarf das aufgeklappte Detailpanel darunter. Parameter: p (Projekt),
+// allPeople (Array `{person, role}`, alle Rollen), locked (Boolean).
+// Rückgabe: HTML-String.
+// BOARD_OPTS: die Einstellungen der Projektliste. Sie zeigt wie der
+// Wochenbericht nur die beauftragten Leistungsphasen (Rückfall auf alle, wenn
+// keine hinterlegt sind — p.beauftragteLP leer, siehe renderBoardDrawer()),
+// nur in der ausführlichen statt der dichten Fassung, und nichts davon ist
+// hier bearbeitbar (nurAnsicht).
+const BOARD_OPTS = { nurAnsicht: true, nurBeauftragteLph: true };
+
+function renderBoardRow(p, allPeople, locked, weekLabel, opts){
+  const isOpen = !!boardRowOpen[p.id];
+  const tags = Array.isArray(p.tags) ? p.tags : [];
+  const tagsHtml = tags.map(t => `<span class="tag-chip">${esc(t)}</span>`).join('');
+  const previewText = statusPreviewText(p.status);
+  const isNew = p.statusState === 'new';
+
+  // Avatar-Stapel der eingeklappten Zeile: nur tatsächlich zugeordnete
+  // Personen (Zustand 1 = Haupt oder 2 = optional), volle Rollen-Matrix nur
+  // im aufgeklappten Detailpanel (siehe renderBoardDrawer).
+  const stackHtml = allPeople.map(entry=>{
+    const state = p.assign[assignKey(entry.person.id, entry.role)] || 0;
+    if(state === 0) return '';
+    return `<span class="board-avatar ${roleClass(entry.role)} state-${state}" title="${esc(entry.person.fullName || entry.person.name)} · ${esc(entry.role)}">${esc(entry.person.name)}</span>`;
+  }).join('');
+
+  const aktLp = lpActiveList(p)[0];
+  const aktPct = aktLp && p.lph[aktLp] !== undefined && p.lph[aktLp] !== '' ? p.lph[aktLp] : null;
+  const phaseHtml = aktLp
+    ? `<span class="phase-pill">${esc(aktLp)}${aktPct !== null ? ' · ' + esc(aktPct) + '%' : ''}</span>`
+    : `<span class="phase-pill muted">Keine aktive LP</span>`;
+
+  // Ziehbar und mit Griff: Die Reihenfolge innerhalb einer Gruppe und der
+  // Wechsel zwischen Gruppen wurden zuvor im eigenen Tab "Projekte" gepflegt,
+  // der dieselben Projekte ein zweites Mal auflistete. Beides geschieht jetzt
+  // hier, in der einen Projektliste.
+  let html = `<div class="board-row${isOpen ? ' open' : ''}" data-project-id="${p.id}" ${locked ? '' : 'draggable="true" ondragstart="handleDragStart(event)" ondragend="handleDragEnd(event)"'}>`;
+  html += `<div class="board-row-main" onclick="toggleBoardRow('${p.id}')">`;
+  html += locked ? '' : `<span class="drag-handle" title="Verschieben" onclick="event.stopPropagation()">${icon('grip')}</span>`;
+  html += `<span class="board-chev">${icon('chevronRight')}</span>`;
+  html += `<span class="board-nr">${esc(p.nr) || '<span class="hint" style="margin:0">ohne Nr.</span>'}</span>`;
+  html += `<div class="board-name-wrap">
+      <span class="board-name" onclick="event.stopPropagation();openProjectPlan('${p.id}')" title="Projektplan öffnen">${esc(p.name)}</span>
+      ${typeof auftragsstatusChip === 'function' ? auftragsstatusChip(p) : ''}
+      ${tagsHtml}
+      <div class="board-status-line">${isNew ? '<span class="board-newdot" title="Neuer Kommentar"></span>' : ''}${previewText ? esc(previewText) : '<span class="hint" style="margin:0">Kein Kommentar</span>'}</div>
+    </div>`;
+  html += `<div class="board-avatar-stack">${stackHtml}</div>`;
+  html += phaseHtml;
+  // Listenoperationen am Zeilenende (aus dem früheren Projekte-Tab). Das
+  // Bearbeiten der Projektangaben führt in den Projektbereich, wo sie ihren
+  // einen Ort haben — hier steht nur, was die LISTE betrifft.
+  html += `<div class="board-row-actions" onclick="event.stopPropagation()">
+      <button type="button" class="secondary small" onclick="openProjectPlan('${p.id}')" title="Projektbereich öffnen">Öffnen</button>
+      ${locked ? '' : `<button type="button" class="danger small" onclick="delProjectFromList('${p.id}')" title="Projekt aus dieser Sitzung löschen">Löschen</button>`}
+    </div>`;
+  html += `</div>`; // board-row-main
+
+  if(isOpen) html += renderBoardDrawer(p, allPeople, locked, weekLabel, opts);
+  html += `</div>`; // board-row
+  return html;
+}
+
+// ---------- Kommentar-Editor (Board-Schublade und Wochenbericht) ----------
+// Der Kommentar eines Projekts zu einer Sitzung (p.status) wird nicht mehr in
+// einem contenteditable-Feld mit document.execCommand-Leiste bearbeitet,
+// sondern in einem normalen Textfeld mit ausdrücklichem Speichern. Dazu
+// kommen Verfasser und Zeitstempel (p.statusAuthor/p.statusAt, Spalten
+// status_author/status_at in der Tabelle projects) sowie der scrollbare
+// Verlauf der vorangegangenen Sitzungen aus projectStatusHistory()
+// (js/utils.js), der bisher nur auf der Projektplan-Seite sichtbar war.
+//
+// Zusammenspiel mit cloneWeek() (js/weeks.js): Beim Duplizieren einer Sitzung
+// wird der Kommentartext NICHT mehr mitkopiert — man schreibt den Kommentar
+// dieser Woche, statt den der Vorwoche zu überschreiben. Wenn sich nichts
+// geändert hat, übernimmt der Knopf "übernehmen" am jeweiligen Verlaufs-
+// Eintrag dessen Text in das Textfeld.
+
+// boardCommentBaseline: der zuletzt gespeicherte Kommentartext je Projekt-ID,
+// Vergleichsbasis für die "ungespeichert"-Anzeige und für "Verwerfen".
+// Wird bei jedem Aufbau der Schublade neu gesetzt.
+let boardCommentBaseline = {};
+
+// commentAuthorLine: Kopfzeile des Editors — wer den gespeicherten Kommentar
+// verfasst hat und wann. Bestandskommentare ohne Verfasser (vor der
+// Einführung von status_author) werden als "unbekannt" ausgewiesen, statt
+// stillschweigend die aktuell angemeldete Person zu behaupten.
+// Parameter: p (Projekt). Rückgabe: HTML-String.
+function commentAuthorLine(p){
+  const hasText = statusPreviewText(p.status) !== '';
+  if(!hasText){
+    const me = (currentUser && currentUser.displayName) || '';
+    return me
+      ? `<span class="comment-who"><span class="comment-av">${esc(initialsForName(me))}</span>${esc(me)}</span><span class="comment-sep">·</span><span>neuer Eintrag</span>`
+      : `<span>neuer Eintrag</span>`;
+  }
+  const author = p.statusAuthor || '';
+  const at = p.statusAt ? formatCommentStamp(p.statusAt) : '';
+  const who = author
+    ? `<span class="comment-who"><span class="comment-av">${esc(initialsForName(author))}</span>${esc(author)}</span>`
+    : `<span class="comment-who comment-unknown">Verfasser unbekannt</span>`;
+  return who + (at ? `<span class="comment-sep">·</span><span>${esc(at)}</span>` : '');
+}
+
+// formatCommentStamp: ISO-Zeitstempel als "TT.MM.JJJJ, HH:MM". Parameter:
+// iso (String). Rückgabe: String (leer bei ungültigem Wert).
+function formatCommentStamp(iso){
+  const d = new Date(iso);
+  if(isNaN(d.getTime())) return '';
+  const pad = n => String(n).padStart(2, '0');
+  return `${pad(d.getDate())}.${pad(d.getMonth()+1)}.${d.getFullYear()}, ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+
+// renderCommentEditor: der vollständige Kommentarbereich der Schublade —
+// Editor mit Kopf-/Fußzeile und darunter der eingeklappte, scrollbare
+// Verlauf.
+//
+// In der dichten Fassung (dicht = true, nur Wochenbericht) entfallen zwei
+// Elemente, die dort je Karte rund 60 px kosteten, ohne etwas beizutragen:
+//   * Die eigene KOPFZEILE mit Verfasser und Tastenkürzel. Der Verfasser
+//     rückt in die Fußzeile neben die Knöpfe — dieselbe Angabe, eine Zeile
+//     weniger. Die Tastenkürzel stehen als Titel am Textfeld.
+//   * Der Aufklapper "FRÜHERE SITZUNGEN". Er ist seit dem Verlauf eine
+//     Doppelung: Der zeigt dieselben Kommentare und mehr. Seine einzige
+//     eigene Funktion — einen früheren Text übernehmen — hat der Verlauf
+//     übernommen (renderProjektVerlauf(), js/utils.js).
+// Parameter: p (Projekt), weekLabel (String), locked (Boolean),
+// dicht (Boolean). Rückgabe: HTML-String.
+function renderCommentEditor(p, weekLabel, locked, dicht){
+  const html = sanitizeStatusHtml(p.status || '');
+  boardCommentBaseline[p.id] = html;
+
+  if(locked){
+    return `<div class="comment-block" data-pid="${esc(p.id)}">
+        <div class="comment-head-line">${commentAuthorLine(p)}</div>
+        <div class="comment-readonly">${html || '<span class="hint">Kein Kommentar erfasst.</span>'}</div>
+      </div>`;
+  }
+
+  const kopf = dicht ? '' : `<div class="comment-editor-head">
+          ${commentAuthorLine(p)}
+          <span class="comment-kbd">Strg+↵ speichern · Esc verwerfen</span>
+        </div>`;
+  const verfasserImFuss = dicht ? `<span class="comment-foot-author">${commentAuthorLine(p)}</span>` : '';
+  // Der frühere Aufklapper "Frühere Sitzungen" ist entfallen. Er zeigte nur
+  // den Kommentartext und auch den nur für Sitzungen mit tatsächlicher
+  // Änderung — eine dritte, engere Auswahl neben dem Verlauf im
+  // Wochenbericht und dem Dialog im Projektbereich. Alle drei Stellen nutzen
+  // jetzt renderProjektVerlauf() (js/utils.js) und zeigen damit dasselbe.
+  const verlaufAufklapper = '';
+
+  // richtextToolbarHtml() (js/utils.js): Fett/Kursiv/Farbe für den Kommentar
+  // (Eriks Wunsch) — anders als kopf (der Autor-/Tastenkürzel-Kopf) IMMER
+  // gezeigt, auch im dichten Modus: "dicht" ist hier die reguläre, zweispaltig
+  // kompakte Wochenbericht-Kartenansicht (nicht eine lange Liste vieler
+  // Karten), genau die Stelle, an der der Kommentar normalerweise bearbeitet
+  // wird — die Werkzeugleiste ist klein genug, um dort nicht zu stören.
+  const formatLeiste = richtextToolbarHtml('.comment-field');
+  const feldAttrs = `${dicht ? 'title="Strg+↵ speichern · Esc verwerfen" ' : ''}`
+    + `oninput="markCommentDirty(this)" onkeydown="boardCommentKey(event, this)" onblur="boardCommentBlur(this)"`;
+  return `<div class="comment-block" data-pid="${esc(p.id)}">
+      <div class="comment-editor">
+        ${kopf}
+        <div class="richtext-wrap">
+          ${formatLeiste}
+          ${richtextFeldHtml('comment-field', html, 'Was gibt es diese Woche zu diesem Projekt?', feldAttrs)}
+        </div>
+        <div class="comment-editor-foot">
+          <button type="button" class="small" onmousedown="event.preventDefault()" onclick="saveBoardComment(this)">Speichern</button>
+          <button type="button" class="secondary small"
+            onmousedown="event.preventDefault();discardBoardComment(this)">Verwerfen</button>
+          ${verfasserImFuss}
+          <span class="comment-foot-spacer"></span>
+          <span class="comment-dirty" hidden>● ungespeichert</span>
+        </div>
+      </div>
+      ${verlaufAufklapper}
+    </div>`;
+}
+
+// pendingCommentFocus: Projekt-ID des Kommentarfelds, in das der Nutzer gerade
+// klickt. Hintergrund: Ein Klick in ein anderes Kommentarfeld löst zuerst den
+// Fokusverlust des bisherigen aus; dessen Blur-Netz speichert und rendert
+// Board UND Wochenbericht neu — das angeklickte Feld ist dann längst durch ein
+// neues Element ersetzt, der Klick geht ins Leere und die nächsten
+// Tastenanschläge landen nirgends. Die Absicht wird deshalb in der
+// Capture-Phase festgehalten und nach dem Neu-Rendern wiederhergestellt.
+let pendingCommentFocus = null;
+
+document.addEventListener('mousedown', function(e){
+  const field = e.target && e.target.closest ? e.target.closest('.comment-field') : null;
+  const block = field && field.closest('.comment-block');
+  pendingCommentFocus = block ? block.dataset.pid : null;
+}, true);
+
+// restorePendingCommentFocus: setzt den Fokus nach einem Neu-Rendern in das
+// Kommentarfeld, das der Nutzer anklicken wollte, und stellt den Cursor ans
+// Textende. Ohne gemerkte Absicht oder ohne Treffer passiert nichts.
+// Keine Parameter, keine Rückgabe.
+function restorePendingCommentFocus(){
+  const pid = pendingCommentFocus;
+  pendingCommentFocus = null;
+  if(!pid) return;
+  const sel = '.comment-block[data-pid="' + ((window.CSS && CSS.escape) ? CSS.escape(pid) : pid) + '"] .comment-field';
+  // Board und Wochenbericht rendern dieselben Projekte; das sichtbare Feld
+  // gewinnt (offsetParent ist null, solange der Tab ausgeblendet ist).
+  const kandidaten = Array.from(document.querySelectorAll(sel));
+  const field = kandidaten.find(f => f.offsetParent !== null) || kandidaten[0];
+  if(!field) return;
+  richtextCursorAnsEnde(field);
+}
+
+// commentParts: löst von einem beliebigen Bedienelement aus dessen
+// Kommentar-Block auf und liefert Projekt-ID, Textfeld und Hinweis-Element.
+//
+// Warum nicht über Element-IDs: Projektboard und Wochenbericht rendern
+// dieselben Projekte gleichzeitig (der Bericht nutzt renderBoardDrawer()
+// wieder). Feste IDs wie "bc_text_<pid>" wären dann doppelt vergeben, und
+// document.getElementById() liefert immer den ersten Treffer — im
+// Wochenbericht getippter Text wurde dadurch beim Speichern durch den Inhalt
+// des (unsichtbaren) Board-Felds ersetzt. Über closest() trifft jede Aktion
+// garantiert den Block, in dem sie ausgelöst wurde.
+// Parameter: el (Element innerhalb des Blocks). Rückgabe: Objekt oder null.
+function commentParts(el){
+  if(!el || !el.closest) return null;
+  // Erst der eigene Block; findet sich keiner, der Block derselben Karte.
+  // Gebraucht seit der Verlauf (js/wochenbericht/wochenbericht.js) einen
+  // "übernehmen"-Knopf trägt: Er steht UNTER dem Spaltenraster und damit
+  // ausserhalb von .comment-block, gehört aber zum selben Projekt.
+  const block = el.closest('.comment-block')
+    || (el.closest('.report-card') || document).querySelector('.comment-block');
+  if(!block) return null;
+  return {
+    block,
+    pid: block.dataset.pid,
+    field: block.querySelector('.comment-field'),
+    dirty: block.querySelector('.comment-dirty')
+  };
+}
+
+// markCommentDirty: blendet den "ungespeichert"-Hinweis ein bzw. aus, indem
+// der Feldinhalt mit dem zuletzt gespeicherten Stand verglichen wird.
+// Parameter: el (Element im Kommentar-Block). Keine Rückgabe.
+function markCommentDirty(el){
+  const c = commentParts(el);
+  if(!c || !c.field || !c.dirty) return;
+  c.dirty.hidden = c.field.innerHTML === (boardCommentBaseline[c.pid] || '');
+}
+
+// saveBoardComment: schreibt den Feldinhalt als neuen Kommentar des Projekts,
+// samt Verfasser (angemeldete Person) und Zeitstempel, und rendert neu.
+// Wird nichts geändert, passiert nichts — ein unverändertes Feld soll weder
+// den Zeitstempel noch den Verfasser überschreiben. Parameter: el (Element im
+// Kommentar-Block). Rückgabe: keine.
+function saveBoardComment(el){
+  if(guardWeekLocked()) return;
+  const c = commentParts(el);
+  if(!c || !c.field) return;
+  const html = sanitizeStatusHtml(c.field.innerHTML);
+  if(html === (boardCommentBaseline[c.pid] || '')) return;
+
+  const p = currentWeek().projects.find(x => x.id === c.pid);
+  if(!p) return;
+
+  const before = (p.status || '').trim();
+  if(before === '' && html !== '') p.statusState = 'new';
+  else if(html === '') delete p.statusState;
+
+  p.status = html;
+  if(html === ''){
+    p.statusAuthor = '';
+    p.statusAt = '';
+  } else {
+    p.statusAuthor = (currentUser && currentUser.displayName) || '';
+    p.statusAt = new Date().toISOString();
+  }
+  boardCommentBaseline[c.pid] = html;
+  save();
+  renderBoard();
+  if(typeof renderWochenbericht === 'function') renderWochenbericht();
+  // Beide Ansichten wurden komplett neu aufgebaut — den Fokus in das Feld
+  // zurückholen, das der Nutzer gerade anklicken wollte.
+  restorePendingCommentFocus();
+}
+
+// discardBoardComment: setzt das Textfeld auf den zuletzt gespeicherten Stand
+// zurück. Parameter: el (Element im Kommentar-Block). Keine Rückgabe.
+function discardBoardComment(el){
+  const c = commentParts(el);
+  if(!c || !c.field) return;
+  c.field.innerHTML = boardCommentBaseline[c.pid] || '';
+  markCommentDirty(c.field);
+  richtextCursorAnsEnde(c.field);
+}
+
+// boardCommentKey: Tastaturbedienung des Kommentarfelds — Strg/Cmd+Enter
+// speichert, Escape verwirft. Ein einfaches Enter bleibt der Zeilenumbruch.
+// Parameter: e (KeyboardEvent), el (das Textfeld). Keine Rückgabe.
+function boardCommentKey(e, el){
+  if(e.key === 'Enter' && (e.ctrlKey || e.metaKey)){
+    saveBoardComment(el);
+    e.preventDefault();
+  } else if(e.key === 'Escape'){
+    discardBoardComment(el);
+    e.preventDefault();
+  }
+}
+
+// boardCommentBlur: Sicherheitsnetz — wer tippt und dann woanders hin klickt,
+// verliert seinen Text nicht. Entspricht dem früheren Verhalten von
+// statusBlur(). Bedienelemente, bei denen der Fokusverlust stören würde
+// ("Verwerfen", "übernehmen", die Anwesenheits-Kacheln), unterdrücken ihn per
+// onmousedown/preventDefault. Parameter: el (das Textfeld). Keine Rückgabe.
+function boardCommentBlur(el){
+  saveBoardComment(el);
+}
+
+// takeCommentFromHistory: übernimmt den Kommentartext einer früheren Sitzung
+// in das Textfeld der aktuellen — für den häufigen Fall "gegenüber der
+// Vorwoche unverändert". Gespeichert wird erst durch Speichern (oder das
+// Blur-Netz), sodass der Text vorher noch angepasst werden kann. Parameter:
+// el (der geklickte Knopf), weekLabel (Bezeichnung der Quell-Sitzung).
+// Keine Rückgabe.
+function takeCommentFromHistory(el, weekLabel){
+  if(guardWeekLocked()) return;
+  const c = commentParts(el);
+  if(!c || !c.field) return;
+  const p = currentWeek().projects.find(x => x.id === c.pid);
+  if(!p || !p.projectUid) return;
+
+  // Zwei Quellen, weil zwei Aufrufer: Der Aufklapper "Frühere Sitzungen"
+  // listet projectStatusHistory() — also nur Sitzungen, in denen sich der
+  // Text tatsächlich GEÄNDERT hat. Der Verlauf im Wochenbericht zeigt dagegen
+  // JEDE frühere Sitzung. Verwies der Knopf dort auf eine Woche ohne
+  // Textänderung, fand find() nichts und das Übernehmen blieb wirkungslos.
+  const entry = projectStatusHistory(p.projectUid).find(e => e.week.label === weekLabel);
+  const html = entry
+    ? entry.html
+    : (v => v ? sanitizeStatusHtml(v.project.status || '') : null)(
+        projectVersionsForUid(p.projectUid).find(v => v.week.label === weekLabel));
+  if(html === null || html === undefined) return;
+
+  c.field.innerHTML = sanitizeStatusHtml(html);
+  markCommentDirty(c.field);
+  richtextCursorAnsEnde(c.field);
+}
+
+// renderBoardDrawer: baut das aufgeklappte Detailpanel einer Projekt-Zeile —
+// links der volle Status-Editor (unverändert gegenüber der früheren Matrix-
+// Zelle) plus alle LPH-Balken, rechts die vollständige Rollen-/Personen-
+// Zuordnung als klickbare Avatar-Chips. Parameter: p (Projekt), allPeople
+// (Array `{person, role}`), locked (Boolean). Rückgabe: HTML-String.
+function renderBoardDrawer(p, allPeople, locked, weekLabel, opts){
+  // opts.dicht: die dichte Fassung der Karte (Wochenbericht). Sie zeigt
+  // dieselben Angaben und dieselben Bedienelemente wie die normale, nur
+  // enger gesetzt: die Leistungsphasen stehen als EINE Leiste nebeneinander
+  // statt als bis zu zehn Zeilen untereinander, und die Beteiligten rücken
+  // darunter statt in eine eigene Spalte. Die Zeilenform bestimmte bisher die
+  // Höhe der ganzen Karte — bei 29 Projekten ergab das rund 17
+  // Bildschirmseiten, durch die man sich im Teammeeting hindurchscrollen
+  // musste. Im Projektboard, wo die Karte nur beim Aufklappen einer Zeile
+  // erscheint, bleibt es bei der ausführlichen Fassung.
+  //
+  // nurBeauftragteLph: sowohl im Wochenbericht als auch im Projektboard
+  // werden nur die Leistungsphasen gezeigt, für die das Projekt beauftragt
+  // ist (p.beauftragteLP, gesetzt beim Anlegen oder im Honorar-Dialog). Ist
+  // nichts hinterlegt — was auf ältere Bestandsprojekte zutrifft —, bleibt es
+  // bei der vollständigen Liste, sonst stünde dort gar nichts.
+  // opts.nurAnsicht: die Karte zeigt, sie erfasst nicht.
+  //
+  // Kommentar, Fortschritt je Leistungsphase und die Zuordnung der
+  // Beteiligten entstehen in der wöchentlichen Besprechung und werden deshalb
+  // allein im Wochenbericht gepflegt. Zuvor waren dieselben drei Angaben an
+  // drei Stellen bearbeitbar (Projektboard, Wochenbericht, Projektbereich) —
+  // niemand wusste, welche die richtige ist, und zwei Personen konnten
+  // dasselbe Feld an verschiedenen Stellen ändern. Dieselbe Karte, dieselben
+  // Werte, nur ohne Eingabefelder und mit einem Verweis dorthin, wo sie
+  // gepflegt werden. Eine gesperrte Sitzung wirkt weiterhin zusätzlich.
+  const ansicht = !!(opts && opts.nurAnsicht);
+  const starr = ansicht || locked;
+
+  const beauftragt = Array.isArray(p.beauftragteLP) ? p.beauftragteLP : [];
+  const nurBeauftragte = !!(opts && opts.nurBeauftragteLph) && beauftragt.length > 0;
+  const sichtbareLphs = nurBeauftragte ? LPHS.filter(l => beauftragt.includes(l)) : LPHS;
+  const aktLp = lpActiveList(p)[0];
+
+  // lphLeiste: die Leistungsphasen nebeneinander statt gestapelt — seit
+  // Variante A (Eriks Wahl aus dem Layout-Vergleich) die EINE Darstellung für
+  // Leistungsphasen in dieser Schublade, nicht mehr nur die dichte
+  // Wochenbericht-Karte. Jede Phase ist ein schmales Feld mit der
+  // Phasennummer und ihrem Eingabefeld; der Füllstand steckt als senkrechter
+  // Verlauf im Feld-Hintergrund. Die amtierende Phase bleibt hervorgehoben.
+  const lphLeiste = sichtbareLphs.map(l=>{
+    const v = (p.lph[l]!==undefined && p.lph[l]!="") ? p.lph[l] : "";
+    const aktiv = l === aktLp;
+    const inputAttr = starr ? 'readonly tabindex="-1"' : `onchange="editLph('${p.id}','${l}',this.value)"`;
+    const pct = v !== "" ? Math.min(100, parseFloat(v)||0) : 0;
+    // Deckkraft 4d (30 %): Bei 33 (20 %) war der Füllstand auf dem dunklen
+    // Feld-Hintergrund praktisch nicht zu sehen, und damit hätte die Leiste
+    // den Balken der Zeilenform ersatzlos verloren.
+    const fuellung = pct > 0
+      ? ` style="background:linear-gradient(to top, ${getProgressColor(pct)}4d ${pct}%, transparent ${pct}%)"`
+      : '';
+    return `<div class="board-lph-cell${aktiv ? ' lp-aktiv' : ''}${ansicht ? ' is-ansicht' : ''}${locked ? ' locked-cell' : ''}"${fuellung} title="${esc(l)}${aktiv ? ' · amtierende Leistungsphase' : ''}">
+        <span class="board-lph-cell-label">${esc(l.replace('LPH ', ''))}</span>
+        <input type="text" value="${esc(v)}" ${inputAttr} placeholder="-">
+      </div>`;
+  }).join('');
+
+  const roleRows = ROLES.map(r=>{
+    const entries = allPeople.filter(e=>e.role===r);
+    const chips = entries.length ? entries.map(entry=>{
+      const state = p.assign[assignKey(entry.person.id, entry.role)] || 0;
+      const click = starr ? '' : `onclick="cycleAssign('${p.id}','${entry.person.id}','${entry.role}')"`;
+      return `<span class="board-avatar ${roleClass(entry.role)} state-${state}${ansicht ? ' is-ansicht' : ''}${locked ? ' locked-cell' : ''}" ${click} title="${esc(entry.person.fullName || entry.person.name)}">${esc(entry.person.name)}</span>`;
+    }).join('') : `<span class="hint" style="margin:0">Niemand hinterlegt</span>`;
+    return `<div class="board-role-row"><span class="board-role-label ${roleClass(r)}">${esc(r)}</span><div class="board-role-chips">${chips}</div></div>`;
+  }).join('');
+
+  // Dichte Fassung: zwei Spalten — links der Kommentar, rechts die
+  // Leistungsphasen-Leiste und darunter die Beteiligten.
+  //
+  // Zwischenzeitlich waren es drei Spalten, weil die gestapelten Beteiligten
+  // die Karte höher machten und damals 29 Karten untereinander standen. Seit
+  // der Wochenbericht eine Tagesordnung ist, ist immer nur EIN Projekt
+  // geöffnet — die Höhe der Karte kostet nichts mehr, während die Breite
+  // knapp ist: Neben der Projektliste blieben für drei Spalten nur noch
+  // 137 px für die Beteiligten, zu wenig für Rollenname und Kürzel.
+  //
+  // Die Beteiligten behalten ihre Zeile je Rolle — anders als im Entwurf, wo
+  // sie zu einer flachen Reihe zusammengefasst waren: Ein Kürzel kann in
+  // mehreren Rollen vorkommen, und cycleAssign() braucht die Rolle. Ohne sie
+  // wäre beim Klicken nicht erkennbar, welche Zuordnung man durchschaltet.
+  if(opts && opts.dicht){
+    return `<div class="board-drawer board-drawer-dicht">
+        <div class="board-drawer-grid">
+          <div class="drawer-col drawer-col-comment">
+            <h4>Kommentar${weekLabel ? ' zur Sitzung ' + esc(weekLabel) : ''}</h4>
+            ${renderCommentEditor(p, weekLabel, locked, true)}
+          </div>
+          <div class="drawer-col drawer-col-kompakt">
+            <h4>${nurBeauftragte ? 'Beauftragte Leistungsphasen' : 'Leistungsphasen'}</h4>
+            <div class="board-lph-leiste">${lphLeiste}</div>
+            <h4 class="drawer-h4-zweit">Beteiligte</h4>
+            <div class="board-role-mini">${roleRows}</div>
+          </div>
+        </div>
+        ${typeof renderProjektVerlauf === 'function' ? renderProjektVerlauf(p, weekLabel, locked) : ''}
+      </div>`;
+  }
+
+  // Die drei Blöcke stehen als gleichrangige Geschwister im Raster, damit der
+  // aufrufende Kontext ihre Anordnung allein über CSS bestimmen kann: das
+  // Projektboard stellt Kommentar und Leistungsphasen übereinander in die
+  // linke Spalte (grid-template-areas in styles.css), der Wochenbericht
+  // nebeneinander in drei Spalten. Inhalt und Reihenfolge sind in beiden
+  // Fällen identisch.
+  return `<div class="board-drawer">
+      <div class="board-drawer-grid">
+        <div class="drawer-col drawer-col-comment">
+          <h4>Kommentar${weekLabel ? ' zur Sitzung ' + esc(weekLabel) : ''}</h4>
+          ${ansicht ? renderKommentarAnsicht(p, locked) : renderCommentEditor(p, weekLabel, locked)}
+        </div>
+        <div class="drawer-col drawer-col-lph">
+          <h4>${nurBeauftragte ? 'Beauftragte Leistungsphasen' : 'Leistungsphasen'}</h4>
+          <div class="board-lph-leiste">${lphLeiste}</div>
+        </div>
+        <div class="drawer-col drawer-col-people">
+          <h4>Beteiligte</h4>
+          <div class="board-role-mini">${roleRows}</div>
+        </div>
+      </div>
+      ${ansicht ? renderBerichtVerweis(p, locked) : ''}
+      ${typeof renderProjektVerlauf === 'function' ? renderProjektVerlauf(p, weekLabel, locked) : ''}
+    </div>`;
+}
+
+// renderKommentarAnsicht: der Kommentar der laufenden Sitzung, nur zu lesen.
+// Parameter: p (Projekt), locked. Rückgabe: HTML-String.
+function renderKommentarAnsicht(p, locked){
+  const text = sanitizeStatusHtml(p.status || '');
+  return `<div class="status-edit is-ansicht locked-cell">${text ||
+    '<span class="hint" style="margin:0">Für diese Sitzung ist noch kein Kommentar erfasst.</span>'}</div>`;
+}
+
+// renderBerichtVerweis: der Weg zur Bearbeitung. Der Verweis springt in den
+// Wochenbericht UND stellt dort dieses Projekt ein — ohne das müsste man es
+// in einer Liste von dreißig wiederfinden.
+// Parameter: p (Projekt), locked. Rückgabe: HTML-String.
+function renderBerichtVerweis(p, locked){
+  if(locked) return '<div class="drawer-verweis"><span class="hint" style="margin:0">Die Sitzung ist gesperrt.</span></div>';
+  const uid = esc(p.projectUid || '');
+  return `<div class="drawer-verweis">
+      <span class="hint" style="margin:0">Kommentar, Fortschritt und Zuordnung werden in der Besprechung erfasst.</span>
+      <button type="button" class="plan-verweis" onclick="springZumWochenbericht('${uid}')">Im Wochenbericht bearbeiten →</button>
+    </div>`;
+}
+
+// renderBoard: baut die Listenansicht des Boards auf (eine Bubble-Card je
+// Projektgruppe mit den Projekten als Zeilen, siehe renderBoardRow()). Liest
+// die aktuelle Woche, gruppiert Projekte nach Gruppe und sortiert sie nach
+// `order`. Bei gesperrten Sitzungen werden alle Bearbeitungs-Handler
+// deaktiviert und ein Hinweis samt Entsperren-Button angezeigt. Aktualisiert
+// außerdem die Legende mit den vollständigen Namen und Anwesenheiten. Keine
+// Parameter, keine Rückgabe.
 function renderBoard(){
   const w = currentWeek();
+  const container = document.getElementById('boardTable');
+  // Ohne geladene Sitzung (Ladefehler, oder die letzte Sitzung wurde von
+  // jemand anderem gelöscht) griff der Code ungeprüft auf w.projects zu — der
+  // TypeError riss renderAll() mit und ließ die Oberfläche halb gerendert
+  // stehen. Alle Schwester-Renderer prüfen das bereits selbst.
+  if(!w){
+    if(container) container.innerHTML = '<div class="hint">Keine Sitzung geladen.</div>';
+    return;
+  }
   const locked = isWeekLocked(w);
-  const table = document.getElementById('boardTable');
   const grouped = peopleByRole(w);
+  const allPeople = [];
+  ROLES.forEach(r=> grouped[r].forEach(entry=>allPeople.push(entry)));
 
-  // Kopfzeilen: Rollen und Leistungsphasen
-  let h1 = `<tr><th rowspan="2">Pr.-Nr.</th><th rowspan="2">Bezeichnung</th><th rowspan="2">Status / Kommentar</th>`;
-  ROLES.forEach(r=>{ h1 += `<th class="${roleClass(r)}" colspan="${Math.max(1,grouped[r].length)}">${r}</th>`; });
-  h1 += `<th colspan="${LPHS.length}">Leistungsphasen (%)</th><th rowspan="2"></th></tr>`;
-
-  let h2 = `<tr>`;
-  ROLES.forEach(r=>{
-    if(grouped[r].length===0) h2 += `<th class="rot ${roleClass(r)}">–</th>`;
-    grouped[r].forEach(entry=> h2 += `<th class="rot ${roleClass(entry.role)}">${esc(entry.person.name)}</th>`);
-  });
-  LPHS.forEach(l=> h2 += `<th class="rot">${l}</th>`);
-  h2 += `</tr>`;
-
-  // Projekte nach Gruppen (z.B. "Aktive Projekte") zusammenfassen
+  // Projekte nach Gruppen (z.B. "Aktive Projekte") zusammenfassen.
+  //
+  // Alle vier Standardgruppen werden vorbelegt, auch wenn sie leer sind: Sonst
+  // entstünde für eine leer geräumte Gruppe keine Ablagefläche, und ein
+  // Projekt ließe sich nicht mehr dorthin ziehen. (Aus dem früheren
+  // Projekte-Tab übernommen, der hierin aufgegangen ist.)
   const groups = {};
+  GROUP_ORDER.forEach(g => { groups[g] = []; });
   w.projects.forEach(p=>{ (groups[p.group]||(groups[p.group]=[])).push(p); });
 
   // Projekte nach ihrer Reihenfolge sortieren
@@ -99,169 +617,29 @@ function renderBoard(){
     groups[g].sort((a, b) => (a.order || 0) - (b.order || 0));
   });
 
-  let body = "";
-  const allPeople = [];
-  ROLES.forEach(r=> grouped[r].forEach(entry=>allPeople.push(entry)));
-
-  // Jede Gruppe als Abschnitt, dann Zeilen für Projekte
+  let html = "";
   sortGroups(Object.keys(groups)).forEach(g=>{
-    const colspan = 3 + allPeople.length + LPHS.length + 1; // Spaltenanzahl für Gruppentitel
-    body += `<tr class="group-header"><td colspan="${colspan}">${esc(g)}</td></tr>`;
-    groups[g].forEach(p=>{
-      body += `<tr>`;
-      body += `<td class="left">${esc(p.nr)}</td>`;
-      body += `<td class="left proj-name" style="cursor:pointer" onclick="openProjectPlan('${p.id}')" title="Projektplan öffnen">${esc(p.name)}</td>`;
-      // Status-Editor: contenteditable mit kleiner Toolbar (Fett, Farben, Absätze mit Enter)
-      const statusClass = p.statusState === 'new' ? 'status-new' : p.statusState === 'duplicated' ? 'status-duplicated' : '';
-      const statusEditable = locked ? 'false' : 'true';
-      const statusToolbar = locked ? '' : `
-        <div class="status-toolbar" tabindex="-1">
-          <button type="button" title="Fett" onmousedown="event.preventDefault();formatStatus('bold')"><b>B</b></button>
-          <button type="button" title="Rot" class="color-red" onmousedown="event.preventDefault();formatStatus('foreColor','#c53030')">A</button>
-          <button type="button" title="Grün" class="color-green" onmousedown="event.preventDefault();formatStatus('foreColor','#2f855a')">A</button>
-          <button type="button" title="Blau" class="color-blue" onmousedown="event.preventDefault();formatStatus('foreColor','#2b6cb0')">A</button>
-          <button type="button" title="Schwarz" class="color-black" onmousedown="event.preventDefault();formatStatus('foreColor','#1a1a1a')">A</button>
-          <button type="button" title="Absatz" onmousedown="event.preventDefault();formatStatus('formatBlock','P')">¶</button>
-        </div>`;
-      const statusClick = locked ? '' : `onfocus="statusFocus(this,'${p.id}')" onblur="statusBlur(this,'${p.id}')"`;
-      const safeStatus = sanitizeStatusHtml(p.status || '');
-      body += `<td class="status ${locked ? 'locked-cell' : ''}">
-        ${statusToolbar}
-        <div class="status-edit ${statusClass}" contenteditable="${statusEditable}" ${statusClick}>${safeStatus}</div>
-      </td>`;
-
-      // Personen-Spalten: Klick wechselt Zustand (nicht, optional, Hauptverantwortung)
-      allPeople.forEach(entry=>{
-        const state = p.assign[assignKey(entry.person.id, entry.role)] || 0; // 0=keine,1=Haupt,2=optional
-        const cls = state===1?'on':state===2?'optional':'';
-        const txt = state===1?'X':state===2?'(X)':'';
-        const click = locked ? '' : `onclick="cycleAssign('${p.id}','${entry.person.id}','${entry.role}')"`;
-        body += `<td class="person-cell ${roleClass(entry.role)} ${cls} ${locked ? 'locked-cell' : ''}" ${click}>${txt}</td>`;
-      });
-
-      // LPH-Spalten mit Prozentwerten und Fortschrittsbalken;
-      // die amtierende Leistungsphase (Tab "Projekte") wird farblich markiert.
-      const aktLp = lpActiveList(p)[0];
-      LPHS.forEach(l=>{
-        const v = (p.lph[l]!==undefined && p.lph[l]!="") ? p.lph[l] : "";
-        const aktiv = l === aktLp;
-        const inputAttr = locked ? 'readonly tabindex="-1"' : `onchange="editLph('${p.id}','${l}',this.value)"`;
-        body += `<td class="lph-cell ${locked ? 'locked-cell' : ''}${aktiv ? ' lp-aktiv' : ''}"${aktiv ? ' title="Aktive Leistungsphase"' : ''}><input type="text" value="${esc(v)}" ${inputAttr} placeholder="-">`;
-        if(v!=""){ const pct = Math.min(100, parseFloat(v)||0);
-          body += `<div class="bar"><div style="width:${pct}%;background:${getProgressColor(pct)}"></div></div>`; }
-        body += `</td>`;
-      });
-      body += `</tr>`;
-    });
-
+    html += `<div class="section-title">${esc(g)}</div>`;
+    // Klasse "projects-sortable": Die Ablage-Handler aus
+    // js/projects/projects.js (handleDrop/reorderProjects) finden ihre
+    // Container über diesen Selektor. Sie bleiben dort, weil sie auch die
+    // Reihenfolge-Logik für die Daten enthalten — hier wird nur dieselbe
+    // Ablagefläche aufgespannt.
+    html += `<div class="board-list projects-sortable" data-group="${esc(g)}" ${locked ? '' : 'ondragover="handleDragOver(event)" ondrop="handleDrop(event)"'}>`;
+    groups[g].forEach(p=>{ html += renderBoardRow(p, allPeople, locked, w.label, BOARD_OPTS); });
+    if(groups[g].length === 0) html += `<div class="hint" style="padding:6px 2px 12px">Keine Projekte — Projekt hierher ziehen.</div>`;
+    html += `</div>`;
   });
-
-  let lockNotice = '';
+  // Sperr-Hinweis über der Projektliste. Er stand früher im Container der
+  // Kürzel-Legende unter dem Board; seit die Legende entfallen ist, gehört er
+  // dorthin, wo er gilt — über die Liste, die man nicht bearbeiten kann.
   if(locked){
-    lockNotice = `<div class="lock-notice" style="margin-bottom:10px;padding:8px 12px;background:#fff5f5;border:1px solid #fc8181;border-radius:6px;color:#c53030;font-weight:bold;font-size:12px;">
-      Diese Sitzung ist gesperrt. Bearbeiten nur nach Passworteingabe möglich.
-      <button type="button" class="secondary small" style="margin-left:12px;" onclick="unlockCurrentWeek()">Entsperren</button>
-    </div>`;
+    html = `<div class="lock-notice">
+      Diese Sitzung ist gesperrt. Bearbeiten nur nach Entsperren möglich.
+      <button type="button" class="secondary small" onclick="unlockCurrentWeek()">Entsperren</button>
+    </div>` + html;
   }
-
-  table.innerHTML = `<thead>${h1}${h2}</thead><tbody>${body}</tbody>`;
-
-  // Legende mit vollständigen Namen und Anwesenheitstracking
-  let legendeHtml = lockNotice + `<div style="margin-bottom:8px; font-weight:bold; color:var(--accent);">Legende Projektkürzel${locked ? '' : ' (klick für Anwesenheit)'}:</div>`;
-  const weekAttendance = w?.attendance || {};
-  const legendeItems = [];
-  allPeople.forEach(entry=>{
-    if(!legendeItems.some(item=>item.id===entry.person.id)){
-      legendeItems.push({id:entry.person.id, name:entry.person.name, fullName:entry.person.fullName||entry.person.name});
-    }
-  });
-  legendeHtml += `<div class="legend-list">` + legendeItems.map(item=>{
-    const isPresent = weekAttendance[item.id];
-    const cursor = locked ? 'not-allowed' : 'pointer';
-    const click = locked ? '' : `onclick="toggleAttendance('${item.id}')"`;
-    return `<div class="legend-item${isPresent?' present':''}${locked ? ' locked-legend-item' : ''}" ${click}><span>${esc(item.name)}</span> = ${esc(item.fullName)}</div>`;
-  }).join('') + `</div>`;
-  document.getElementById('boardLegend').innerHTML = legendeHtml;
-  adjustStickyOffsets();
-}
-
-// sanitizeStatusHtml: bereinigt übergebenen Status-HTML. Erlaubt nur eine kleine
-// Whitelist an HTML-Tags/Attributen (Formatierung), damit keine Skripte
-// eingeschleust werden können; im style-Attribut sind nur color/font-weight
-// erlaubt. Parameter: `html` (String). Rückgabe: bereinigter HTML-String ('' bei
-// leerem Eingabewert).
-function sanitizeStatusHtml(html){
-  if(!html) return '';
-  const div = document.createElement('div');
-  div.innerHTML = html;
-  const allowedTags = new Set(['B','STRONG','I','EM','U','P','BR','DIV','SPAN','FONT']);
-  const allowedAttrs = new Set(['style']);
-  const walk = (node) => {
-    for(let i = node.childNodes.length - 1; i >= 0; i--){
-      const child = node.childNodes[i];
-      if(child.nodeType === 3) continue;
-      if(child.nodeType === 1){
-        if(!allowedTags.has(child.tagName.toUpperCase())){
-          while(child.firstChild) node.insertBefore(child.firstChild, node);
-          node.removeChild(child);
-          continue;
-        }
-        for(let j = child.attributes.length - 1; j >= 0; j--){
-          const attr = child.attributes[j].name;
-          if(!allowedAttrs.has(attr.toLowerCase())) child.removeAttribute(attr);
-        }
-        if(child.hasAttribute('style')){
-          // Erlaubt nur color und font-weight im style-Attribut
-          const style = child.getAttribute('style');
-          const safe = (style || '').split(';').map(s => s.trim()).filter(s => {
-            const prop = s.split(':')[0].trim().toLowerCase();
-            return prop === 'color' || prop === 'font-weight';
-          }).join('; ');
-          if(safe) child.setAttribute('style', safe);
-          else child.removeAttribute('style');
-        }
-        walk(child);
-      }
-    }
-  };
-  walk(div);
-  return div.innerHTML;
-}
-
-
-// getProgressColor: erzeugt eine HSL-Farbe basierend auf Prozentwert
-// (grün → gelb → rot). Parameter `pct`: Zahl 0–100 (wird geklemmt).
-// Rückgabe: Farb-String für den Fortschrittsbalken.
-function getProgressColor(pct){
-  const hue = Math.round(Math.max(0, Math.min(100, pct)) * 1.2);
-  return `hsl(${hue},70%,40%)`;
-}
-
-// adjustStickyOffsets: berechnet die reale Höhe der ersten Kopfzeile
-// der Board-Tabelle und setzt den top-Wert der zweiten sticky-Kopfzeile
-// entsprechend, damit beide Zeilen exakt aneinander anschließen
-// (keine Lücke/Überlappung beim Scrollen). Keine Parameter, keine Rückgabe.
-function adjustStickyOffsets(){
-  const firstRow = document.querySelector('#boardTable thead tr:nth-child(1)');
-  if(!firstRow) return;
-  const h = firstRow.getBoundingClientRect().height;
-  document.querySelectorAll('#boardTable thead tr:nth-child(2) th').forEach(th=>{
-    th.style.top = h + 'px';
-  });
-}
-
-// toggleAttendance: togglet den Anwesenheitsstatus (boolean in `w.attendance`)
-// eines Projektbeteiligten für die aktuelle Sitzung und rendert das Board neu.
-// Parameter `personId`: stabile Personen-ID. Keine Rückgabe; bei gesperrter
-// Woche über `guardWeekLocked()` abgebrochen.
-function toggleAttendance(personId){
-  if(guardWeekLocked()) return;
-  const w = currentWeek();
-  if(!w) return;
-  if(!w.attendance) w.attendance = {};
-  w.attendance[personId] = !w.attendance[personId];
-  save();
-  renderBoard();
+  container.innerHTML = html;
 }
 
 // cycleAssign: wechselt die Zuweisung einer Person zu einem Projekt zyklisch
@@ -275,7 +653,7 @@ function cycleAssign(pid, personId, role){
   const cur = p.assign[key]||0;
   const next = (cur+1)%3;
   if(next===0) delete p.assign[key]; else p.assign[key]=next;
-  save(); renderBoard();
+  save(); renderBoard(); renderWochenbericht();
 }
 
 // editLph: setzt oder entfernt den Prozentwert einer Leistungsphase für ein
@@ -287,36 +665,9 @@ function editLph(pid,lph,val){
   val = val.trim();
   if(val==="") delete p.lph[lph];
   else p.lph[lph]=val.replace('%','');
-  save(); renderBoard();
+  save(); renderBoard(); renderWochenbericht();
 }
 
-// editProj: aktualisiert ein Feld eines Projekts; für Status wird zusätzlich
-// ein flag `statusState` gesetzt (='new' beim Anlegen eines neuen Kommentars),
-// wenn zuvor noch kein Status existierte. Parameter: `pid` (Projekt-ID),
-// `field` (Feldname), `val` (neuer Wert). Keine Rückgabe.
-function editProj(pid,field,val){
-  if(guardWeekLocked()) return;
-  const p = currentWeek().projects.find(x=>x.id===pid);
-  if(!p) return;
-  if(field==='status'){
-    const before = (p.status||"").trim();
-    const after = val.trim();
-    if(before === "" && after !== ""){
-      p.statusState = 'new';
-    } else if(after === ""){
-      delete p.statusState;
-    }
-  }
-  p[field]=val; save();
-}
-
-// delProj: löscht ein Projekt (per Bestätigungsdialog) aus der aktuellen
-// Sitzung. Parameter `pid`: Projekt-ID. Keine Rückgabe; bei gesperrter Woche
-// abgebrochen.
-function delProj(pid){
-  if(guardWeekLocked()) return;
-  if(!confirm("Projekt aus dieser Sitzung löschen?")) return;
-  const w = currentWeek();
-  w.projects = w.projects.filter(x=>x.id!==pid);
-  save(); renderBoard();
-}
\ No newline at end of file
+// HINWEIS: delProj() ist entfallen — seit der neuen Zeilendarstellung des
+// Boards gibt es dort keinen Löschen-Knopf mehr. Projekte werden im
+// Projekte-Tab entfernt (delProjectFromList(), js/projects/projects.js).
\ No newline at end of file
diff --git a/public/js/csv.js b/public/js/csv.js
deleted file mode 100644
index f2d7dce..0000000
--- a/public/js/csv.js
+++ /dev/null
@@ -1,42 +0,0 @@
-// -----------------------------
-// Projektübersicht — CSV/ZIP-Export
-// -----------------------------
-// Stellt exportCSV() bereit: lädt den ZIP mit den übersichtlichen CSV-Dateien
-// der aktuellen Abteilung über GET /export-csv und stößt den Download an.
-// Hängt im Seitenmenü von Test.html am Button "CSV Export" und nutzt baseUrl()
-// aus js/server.js sowie currentDepartment aus js/globals.js. Der ZIP enthält
-// pro logischer Entität eine CSV (Wochen, Personen, Projekte, …), erzeugt vom
-// Server (siehe server.js im Projekt-Root).
-
-// exportCSV: fordert den CSV-Export der aktuellen Abteilung an und lädt ihn
-// als ZIP-Datei herunter. Kein Parameter, keine Rückgabe; Fehler werden über
-// ein Alert gemeldet.
-async function exportCSV(){
-  try {
-    const dept = currentDepartment || 'ELT';
-    const res = await fetch(baseUrl() + '/export-csv?department=' + encodeURIComponent(dept));
-    if(!res.ok){
-      let msg = 'Server HTTP ' + res.status;
-      try {
-        const json = await res.json();
-        if(json && json.error) msg = json.error;
-      } catch(e){ /* Antwort war kein JSON */ }
-      throw new Error(msg);
-    }
-    const blob = await res.blob();
-    const filename = 'Projektuebersicht_' + dept + '_'
-      + new Date().toISOString().slice(0, 10) + '.zip';
-
-    const url = URL.createObjectURL(blob);
-    const a = document.createElement('a');
-    a.href = url;
-    a.download = filename;
-    document.body.appendChild(a);
-    a.click();
-    a.remove();
-    setTimeout(() => URL.revokeObjectURL(url), 1000);
-  } catch(err){
-    console.error('CSV-Export fehlgeschlagen:', err);
-    alert('CSV-Export fehlgeschlagen: ' + (err.message || err));
-  }
-}
\ No newline at end of file
diff --git a/public/js/dashboard/dashboard.js b/public/js/dashboard/dashboard.js
index db44d2b..7e9dc40 100644
--- a/public/js/dashboard/dashboard.js
+++ b/public/js/dashboard/dashboard.js
@@ -1,7 +1,7 @@
 // -----------------------------
 // Projektübersicht — Dashboard ("Meine Aufgaben"-Tab)
 // -----------------------------
-// Modul für den ersten Tab der Hauptseite (Test.html, Ladereihenfolge:
+// Modul für den ersten Tab der Hauptseite (App.html, Ladereihenfolge:
 // ... → load → dashboard → gantt → ...). Das Dashboard ist die Startübersicht
 // nach dem Login; alles darin stammt aus einem einzigen GET /my-dashboard.
 //
diff --git a/public/js/gantt.js b/public/js/gantt.js
index a62cd53..86c5347 100644
--- a/public/js/gantt.js
+++ b/public/js/gantt.js
@@ -1,19 +1,16 @@
 // -----------------------------
 // Projektübersicht — GANTT-Diagramm (gemeinsam genutzt)
 // -----------------------------
-// Gemeinsames Modul für das GANTT-Diagramm: Es wird von Test.html (nach
-// js/load/load.js) UND von project-plan.html geladen – dort zusammen mit globals,
-// utils, ui, date-picker, csv, server und den js/plan/*-Modulen, aber OHNE
-// js/store.js, js/weeks.js, js/board/board.js usw. Es darf daher auf der Plan-Seite
-// keine Hauptseiten-spezifischen Funktionen voraussetzen; Funktionen, die
-// currentWeek()/isWeekLocked() aus js/weeks.js brauchen (renderGantt,
-// fitGanttRange, openProjectPlan), werden nur vom Hauptfenster aufgerufen.
-// Das Modul stellt u. a. buildGanttHtml(), renderGantt(), fitGanttRange(),
-// projectAssignees(), ganttRangeFromProjects() sowie openProjectPlan()/
-// findProjectForPlan() bereit. Die Plan-Seite erweitert buildGanttHtml() über
-// js/plan/plan-build-gantt.js und bezieht Beteiligte/Range über
-// projectAssignees()/ganttRangeFromProjects() aus diesem Modul.
-
+// Gemeinsames Modul für das GANTT-Diagramm. Es wird von App.html nach
+// js/load/load.js geladen und ist die Grundlage sowohl der Übersichts-
+// Diagramme als auch des Terminplans im Projektbereich: die Module unter
+// js/plan/ setzen darauf auf und müssen deshalb NACH dieser Datei stehen.
+// Das Modul stellt u. a. buildGanttHtml(), projectAssignees(),
+// ganttRangeFromProjects() sowie openProjectPlan()/closePlanPage()/
+// bereit. js/plan/plan-build-gantt.js umhüllt
+// buildGanttHtml() und ergänzt sie um TODO- und Meilensteinzeilen; diese
+// Erweiterung greift nur bei gesetzter Option showTodos, die Aufrufe der
+// Übersicht bleiben also unverändert.
 // ganttModalProjectId: reservierte Projekt-ID für GANTT-Modal-Dialoge (zurzeit ungenutzt).
 let ganttModalProjectId = null;
 
@@ -35,7 +32,7 @@ function ensurePlan(p){
 function projectAssignees(p, week = null){
   const w = week || currentWeek();
   const people = w ? (w.people || []) : [];
-  const globalList = db.globalPeople[currentDepartment] || [];
+  const globalList = db.globalPeople || [];
   const result = [];
   people.forEach(person => {
     const globalPerson = globalList.find(gp => gp.id === person.id);
@@ -63,7 +60,12 @@ function projectColor(p){
 // Projekt-/TODO-/Meilenstein-Terminen sowie den Abwesenheiten der globalen
 // Personen, jeweils erweitert um padDays Tage (Standard 7). Parameter:
 // projects = Projekt-Array, padDays = Puffer; Rückgabe: { start, end } als Date.
-function ganttRangeFromProjects(projects, padDays = 7){
+// Parameter `personIds` (optional): Beschränkt die berücksichtigten
+// Abwesenheiten auf diese Personen. Ohne die Einschränkung zog die Elternzeit
+// eines völlig unbeteiligten Kollegen den Zeitraum jedes Projektbereichs bis
+// weit in die Zukunft — obwohl die zugehörige Urlaubszeile gar nicht gezeichnet
+// wird (renderPlanGantt() filtert sie auf die Projektbeteiligten).
+function ganttRangeFromProjects(projects, padDays = 7, personIds = null){
   let min = null, max = null;
   projects.forEach(p => {
     const plan = p.plan;
@@ -89,8 +91,10 @@ function ganttRangeFromProjects(projects, padDays = 7){
       });
     });
   });
-  // Urlaub berücksichtigen
-  (db.globalPeople[currentDepartment] || []).forEach(person => {
+  // Urlaub berücksichtigen (nur von Personen, deren Zeilen auch gezeichnet werden)
+  const relevant = personIds ? new Set(personIds) : null;
+  (db.globalPeople || []).forEach(person => {
+    if(relevant && !relevant.has(person.id)) return;
     (person.absences || []).forEach(a => {
       const s = parseDateISO(a.start), e = parseDateISO(a.end);
       if(s){ if(!min || s < min) min = s; if(!max || s > max) max = s; }
@@ -105,37 +109,11 @@ function ganttRangeFromProjects(projects, padDays = 7){
   return { start: addDays(min, -padDays), end: addDays(max, padDays) };
 }
 
-// fitGanttRange: setzt die Datumsfelder (ganttStart/ganttEnd) auf den
-// automatisch berechneten Projekt-Zeitrahmen und rendert das Diagramm neu.
-function fitGanttRange(){
-  const w = currentWeek(); if(!w) return;
-  const range = ganttRangeFromProjects(w.projects, 7);
-  document.getElementById('ganttStart').value = formatDateISO(range.start);
-  document.getElementById('ganttEnd').value = formatDateISO(range.end);
-  renderGantt();
-}
-
-// renderGantt: rendert das GANTT-Diagramm der aktuellen Woche in
-// ganttContainer. Nutzt die Datumsfelder bzw. fällt auf den Projekt-Zeitrahmen
-// zurück; bei gesperrter Woche ist die Ansicht nicht editierbar.
-function renderGantt(){
-  const w = currentWeek();
-  const container = document.getElementById('ganttContainer');
-  if(!w || !container){
-    if(container) container.innerHTML = '<div class="hint">Keine Sitzung ausgewählt.</div>';
-    return;
-  }
-  let start = parseDateISO(document.getElementById('ganttStart').value);
-  let end = parseDateISO(document.getElementById('ganttEnd').value);
-  if(!start || !end){
-    const range = ganttRangeFromProjects(w.projects, 7);
-    start = range.start; end = range.end;
-    document.getElementById('ganttStart').value = formatDateISO(start);
-    document.getElementById('ganttEnd').value = formatDateISO(end);
-  }
-  const showVacation = document.getElementById('ganttShowVacation').checked;
-  container.innerHTML = buildGanttHtml(w.projects, start, end, { showVacation, editable: !isWeekLocked(w) });
-}
+// HINWEIS: Die frühere GANTT-Ansicht der Hauptseite (renderGantt/fitGanttRange)
+// ist entfallen. Sie griff auf die Elemente #ganttContainer/#ganttStart/
+// #ganttEnd/#ganttShowVacation zu, die es in keiner der drei HTML-Seiten mehr
+// gibt — ein Aufruf hätte sofort geworfen. Das GANTT lebt heute ausschließlich
+// im Projektbereich (renderPlanGantt/fitPlanGanttRange in js/plan/plan-gantt.js).
 
 // buildGanttHtml: erzeugt das HTML des GANTT-Diagramms (Kopf mit Monaten/
 // KW-Zellen, Wochenend-Hintergrund, Heute-Linie, Urlaubs- und Projektzeilen
@@ -250,7 +228,7 @@ function buildGanttHtml(projects, start, end, options = {}){
 
   // Urlaubszeilen
   if(showVacation){
-    let allPeople = db.globalPeople[currentDepartment] || [];
+    let allPeople = db.globalPeople || [];
     // Optional: nur Urlaub bestimmter Personen anzeigen
     if(options.vacationPeople && Array.isArray(options.vacationPeople)){
       const allowed = new Set(options.vacationPeople);
@@ -327,36 +305,31 @@ function buildGanttHtml(projects, start, end, options = {}){
 
 // ---------- Projektplan-Navigation ----------
 
-// openProjectPlan: öffnet project-plan.html in einem neuen Tab. Weil
-// Projekt-IDs nicht persistent sind, werden Wochen-Label und Proj.-Nr. als
-// URL-Parameter übergeben; Abteilung und Projektname stehen im Pfad nach dem
-// Schema "/<Abteilung>/Projektplan/<Projektname>". Parameter: pid =
-// Projekt-ID der aktuellen Woche. Kein Rückgabewert.
+// openProjectPlan: öffnet den Projektbereich EINES Projekts. Das war einmal
+// eine Navigation auf ein eigenes Dokument (project-plan.html); inzwischen
+// ist der Projektbereich der Bereich #plan derselben Seite, also genügt ein
+// gewöhnlicher Bereichswechsel — Menüband und Seitenleiste bleiben stehen,
+// die Sitzungsdaten sind schon geladen, nichts blitzt weiß auf.
+// Weil Projekt-IDs beim Duplizieren einer Sitzung neu vergeben werden,
+// merkt sich der Bereich stabile Werte (Sitzungs-Label, Projekt-Nr./-Name);
+// aus ihnen baut updateRouteUrl() auch die verschickbare Adresse
+// "/Projektplan/<Projektname>?weekLabel=…&projNr=…".
+// Parameter: pid = Projekt-ID der aktuellen Sitzung. Kein Rückgabewert.
 function openProjectPlan(pid){
   const w = currentWeek(); if(!w) return;
   const p = w.projects.find(x => x.id === pid); if(!p) return;
-  // Projekt-IDs sind in der DB stabil, aber die Plan-Seite ist eine separate
-  // Route. Daher werden stabile Werte (Label, Projekt-Nr.) in der URL übergeben.
-  // Absoluter Pfad mit Abteilung und Projektname als Route-Segment, damit der
-  // Aufruf auch von Deep-Link-URLs wie "/HLS/Auslastung" funktioniert.
-  const url = new URL('/' + currentDepartment + '/' + PLAN_SLUG + '/' + encodeURIComponent(p.name || ''), window.location.origin);
-  url.searchParams.set('weekLabel', w.label);
-  url.searchParams.set('projNr', p.nr || '');
-  window.open(url.toString(), '_blank');
+  setPlanTarget(w.label, p.nr || '', p.name || '');
+  showTab('plan');
+  window.scrollTo(0, 0);
 }
 
-// Diese Funktion wird von project-plan.html aufgerufen, um das aktuelle
-// Wochen-/Projekt-Objekt im Hauptfenster zu finden.
-// Parameter: department, weekId, projectId; Rückgabe: { week, project } oder
-// null, wenn die Woche/Abteilung nicht (synchron) auflösbar ist.
-function findProjectForPlan(department, weekId, projectId){
-  if(currentDepartment !== department){
-    const targetWeek = db.weeks.find(w => w.id === weekId);
-    if(!targetWeek) return null;
-    // temporär umschalten ist unpraktisch, daher versuchen wir über load-all
-    return null;
-  }
-  const w = db.weeks.find(x => x.id === weekId);
-  if(!w) return null;
-  return { week: w, project: w.projects.find(x => x.id === projectId) };
+// closePlanPage: Gegenstück zu openProjectPlan() für den "Schließen"-Knopf
+// in der Kopfzeile des Projektbereichs. Früher ging es hier in der
+// Browser-Historie zurück, weil der Projektbereich ein eigenes Dokument war.
+// Jetzt ist es ein schlichter Bereichswechsel zurück auf das Projektboard
+// (bzw. auf den Bereich, aus dem geöffnet wurde). Kein Parameter, keine
+// Rückgabe.
+function closePlanPage(){
+  const back = (typeof previousTab === 'string' && previousTab && previousTab !== 'plan') ? previousTab : 'board';
+  showTab(back);
 }
\ No newline at end of file
diff --git a/public/js/globals.js b/public/js/globals.js
index 32d630b..dda8248 100644
--- a/public/js/globals.js
+++ b/public/js/globals.js
@@ -1,7 +1,7 @@
 // -----------------------------
 // Projektübersicht — globale Konstanten & Zustand
 // -----------------------------
-// Diese Datei wird als Erstes von Test.html geladen und
+// Diese Datei wird als Erstes von App.html geladen und
 // legt alle zentralen Konstanten (Leistungsphasen, Rollen, Gruppen, Abteilungen,
 // Farben, Passwort-Hash) sowie den globalen In-Memory-Zustand (db, currentTab)
 // fest. Sie stellt keine Funktionen, sondern nur Daten bereit, auf die alle
@@ -45,6 +45,14 @@ let APP_SETTINGS = {
   vollzeitStundenProWoche: 40,
   auslastungSchwelleGelb: 0.75,
   auslastungSchwelleRot: 1.0,
+  // referenzHonorar/verteilzeitraumWochen fehlten hier, obwohl
+  // berechneAuslastung() (js/load/load.js) beide liest. Die Aufrufstellen
+  // fingen das mit eigenen Rückfallwerten ab (|| 250000, || 12) — die Vorgabe
+  // stand damit an drei Stellen, und eine im Admin-Bereich geänderte
+  // Server-Vorgabe wäre an den Rückfallwerten vorbeigelaufen. Werte identisch
+  // zu APP_SETTING_DEFS (server.js), wie bei allen Schlüsseln hier.
+  referenzHonorar: 250000,
+  verteilzeitraumWochen: 12,
   aufwandVorlage: {
     'LPH 1': { Planung: 0.4, Projektleitung: 0.2, Bauüberwachung: 0 },
     'LPH 2': { Planung: 0.4, Projektleitung: 0.2, Bauüberwachung: 0 },
@@ -138,6 +146,7 @@ const TAB_SLUGS = {
   people:   'Projektbeteiligte',
   planung:  'Planung',
   dashboard:'MeineAufgaben',
+  wand:     'Wandtafel',
   settings: 'Einstellungen',
   admin:    'Admin'
 };
@@ -148,7 +157,7 @@ const TAB_BY_SLUG = Object.fromEntries(Object.entries(TAB_SLUGS).map(([k,v]) =>
 // aber nicht mehr erzeugt, weil er in TAB_SLUGS fehlt.
 TAB_BY_SLUG['Projekte'] = 'board';
 
-// PLAN_SLUG: URL-Schlüssel des Projektbereichs (Bereich #plan von Test.html),
+// PLAN_SLUG: URL-Schlüssel des Projektbereichs (Bereich #plan von App.html),
 // im gleichen Deep-Link-Schema wie die Tabs: "/Projektplan/<Projektname>",
 // dazu ?weekLabel=…&projNr=… als Parameter. Steht nicht in TAB_SLUGS, weil
 // die Adresse das geöffnete Projekt mitträgt und deshalb nicht fest ist —
diff --git a/public/js/import.js b/public/js/import.js
index 41fdb92..ac39bde 100644
--- a/public/js/import.js
+++ b/public/js/import.js
@@ -4,25 +4,23 @@
 // Stellt importDb() bereit: wählt über einen Datei-Dialog eine mit "DB Backup"
 // erzeugte .db-Datei aus, lädt sie als rohen Binär-Body an POST /import und
 // lädt nach erfolgreicher Wiederherstellung die Seite neu. Da der Import den
-// kompletten Datenbestand ersetzt, ist er passwortgeschützt (gleiche Logik wie
-// Wochen-Löschung über requestedAction/isAuthenticated, siehe js/tabs-auth.js
-// und js/weeks.js) und wird zusätzlich im Browser per Bestätigungsdialog
-// abgesichert.
+// kompletten Datenbestand ersetzt, ist die Route serverseitig admin-only
+// abgesichert (requireRole('admin'), server.js); der Button ist im UI
+// zusätzlich nur für Admins sichtbar (js/auth.js: renderUserBar()). Zusätzlich
+// wird der Import im Browser per Bestätigungsdialog abgesichert.
 
-// importDb: öffnet bei Bedarf das Passwort-Modal (requestedAction 'importDb')
-// und startet danach den Datei-Dialog für das Backup. Parameter `skipAuth=true`
-// überspringt die Passwortabfrage (wird von confirmPassword() genutzt).
-// Keine Rückgabe.
-function importDb(skipAuth = false){
-  if(!skipAuth && !isAuthenticated){
-    requestedAction = { type: 'importDb' };
-    document.getElementById('passwordModal').style.display = 'flex';
-    document.getElementById('passwordInput').value = '';
-    document.getElementById('passwordInput').focus();
-    return;
-  }
-  if(!confirm('Datenbank-Backup wirklich wiederherstellen?\n\nAlle aktuellen Daten werden ersetzt.')){
-    requestedAction = null;
+// importDb: bestätigt die destruktive Aktion und startet danach den
+// Datei-Dialog für das Backup. Keine Rückgabe.
+function importDb(){
+  // Genau benennen, was ersetzt wird: Der Server tauscht nur die
+  // Sitzungstabellen (IMPORT_TABLES in server.js). Benutzerkonten, Rollen,
+  // Abwesenheiten, hochgeladene Dateien und deren Freigaben bleiben stehen —
+  // die frühere Formulierung "Alle aktuellen Daten werden ersetzt" führte in
+  // die Irre, etwa beim Versuch, einen gelöschten Benutzer zurückzuholen.
+  if(!confirm('Datenbank-Backup wirklich wiederherstellen?\n\n'
+      + 'ERSETZT WERDEN: alle Sitzungen mit Projekten, Zuordnungen, Kommentaren, Terminplänen und Aufgaben.\n\n'
+      + 'NICHT BETROFFEN: Benutzerkonten, Rollen, Abwesenheiten, hochgeladene Dateien und deren Freigaben.\n\n'
+      + 'Der aktuelle Stand wird vorher automatisch als Backup gesichert.')){
     return;
   }
   const input = document.createElement('input');
@@ -30,14 +28,10 @@ function importDb(skipAuth = false){
   input.accept = '.db,application/octet-stream,application/x-sqlite3';
   input.onchange = () => {
     const file = input.files && input.files[0];
-    if(!file){
-      requestedAction = null;
-      return;
-    }
+    if(!file) return;
     uploadBackup(file);
   };
   input.click();
-  requestedAction = null;
 }
 
 // uploadBackup: lädt die gewählte .db-Datei als rohen Binär-Body an
@@ -51,6 +45,7 @@ async function uploadBackup(file){
       body: file
     });
     if(!res.ok){
+      if(res.status === 403){ alert('Nur Administratoren dürfen die Datenbank importieren.'); return; }
       let msg = 'Server HTTP ' + res.status;
       try {
         const json = await res.json();
@@ -58,10 +53,12 @@ async function uploadBackup(file){
       } catch(e){ /* Antwort war kein JSON */ }
       throw new Error(msg);
     }
-    alert('Datenbank-Backup erfolgreich wiederhergestellt.\nDie Seite wird neu geladen.');
+    alert('Sitzungsdaten aus dem Backup wiederhergestellt.\n\n'
+        + 'Benutzerkonten, Abwesenheiten und hochgeladene Dateien wurden dabei nicht verändert.\n'
+        + 'Die Seite wird neu geladen.');
     window.location.reload();
   } catch(err){
     console.error('DB-Import fehlgeschlagen:', err);
     alert('DB-Import fehlgeschlagen: ' + (err.message || err));
   }
-}
\ No newline at end of file
+}
diff --git a/public/js/init.js b/public/js/init.js
index b32452d..ef517b5 100644
--- a/public/js/init.js
+++ b/public/js/init.js
@@ -2,10 +2,10 @@
 // Projektübersicht — Init / Start
 // -----------------------------
 // Einstiegsmodul der Hauptseite: wird als letztes Skript ausschließlich von
-// Test.html geladen und startet direkt beim Laden den Initialisierungsablauf
+// App.html geladen und startet direkt beim Laden den Initialisierungsablauf
 // (automatische Ausführung unten in der Datei, nur wenn ein 'board'-Element
 // existiert). Es stellt renderAll(),
-// initUiState() und syncRangeDisplay() bereit und nutzt loadUiState()/
+// initUiState() bereit und nutzt loadUiState()/
 // loadTheme()/loadHeaderState()/loadSidebarCollapseState() aus js/ui.js, load() aus js/store.js,
 // showTab()/TAB_PANELS aus js/tabs-auth.js sowie die Render-Funktionen
 // renderBoard()/renderWochenbericht()/renderLoad()/renderProjects()/renderPeople()
@@ -58,21 +58,6 @@ function initUiState(){
   showTab(tab);
 }
 
-// syncRangeDisplay: schreibt den aus zwei Datumsfeldern (startId/endId)
-// berechneten Zeitraum als deutschen Text (z. B. "05.04.2026 – 11.04.2026")
-// in das Anzeigefeld displayId. Parameter: die drei Element-IDs; kein Rückgabewert.
-function syncRangeDisplay(displayId, startId, endId){
-  const disp = document.getElementById(displayId);
-  if(!disp) return;
-  const sEl = document.getElementById(startId);
-  const eEl = document.getElementById(endId);
-  const s = sEl ? parseDateISO(sEl.value) : null;
-  const e = eEl ? parseDateISO(eEl.value) : null;
-  const from = s ? formatDateDE(s) : '';
-  const to   = e ? formatDateDE(e) : from;
-  disp.value = from ? (from + ' – ' + to) : '';
-}
-
 // Automatische Initialisierung der Hauptseite — seit Projektbereich und
 // Benutzerverwaltung eigene Bereiche sind, ist sie die einzige Seite. Der eigentliche
 // Start läuft erst nach erfolgreicher Anmeldung (checkAuthAndInit(), js/auth.js) —
diff --git a/public/js/load/load.js b/public/js/load/load.js
index c323298..0df3bfc 100644
--- a/public/js/load/load.js
+++ b/public/js/load/load.js
@@ -1,14 +1,14 @@
 // -----------------------------
 // Projektübersicht — Auslastung (Load) & Aufwand je Leistungsphase
 // -----------------------------
-// Modul für den Auslastungs-Tab der Hauptseite (Test.html, Ladereihenfolge:
+// Modul für den Auslastungs-Tab der Hauptseite (App.html, Ladereihenfolge:
 // globals → utils → ui → date-picker → csv → server → store → weeks → board →
 // people → projects → load → gantt → …). Es stellt renderLoad(), das LP-
 // Aufwand-Modal und das Neues-Projekt-Modal bereit. Genutzt werden LPHS/ROLES
 // aus js/globals.js, currentWeek()/save() aus js/store.js, guardWeekLocked()
 // aus js/weeks.js sowie peopleByRole()/assignKey() aus js/utils.js.
 // Die Auslastungs-Logik (berechneAuslastung, lpActiveList, faktorFormat,
-// pdfLoadAmpelColor, stundenFormat) wird zusätzlich von js/pdf.js für den
+// stundenFormat) wird zusätzlich von js/pdf.js für den
 // PDF-Export wiederverwendet.
 //
 // Datenmodell je Projekt (rollen- und leistungsphasenspezifisch):
@@ -313,20 +313,6 @@ function berechneAuslastung(mitarbeiter, projekt, aktuelleLP, rolle, status, all
   return { stunden, load: stunden / vollzeit, quelle: basis.quelle, wochen, phase };
 }
 
-// groesseText: beschriftet die Projektgröße für die Eingabemasken.
-//
-// Nur die Zahl, KEIN Eurobetrag daneben. Intern wird die Größe zwar über das
-// Referenzhonorar in einen Betrag umgerechnet (projektBasisHonorar()) — die
-// Zahl neben dem Feld auszuweisen, gäbe der Schätzung aber eine Genauigkeit,
-// die sie nicht hat: "0,40 · rund 100.000 €" liest sich wie ein Honorar,
-// obwohl es ein grober Umfang ist.
-// Parameter: wert (0–1). Rückgabe: String.
-function groesseText(wert){
-  const n = Math.max(0, Math.min(1, parseFloat(wert) || 0));
-  if(n <= 0) return '— keine Angabe';
-  return n.toFixed(2).replace('.', ',');
-}
-
 // stundenFormat: Wochenstunden in deutscher Schreibweise, eine
 // Nachkommastelle. Ab 100 h ohne Nachkomma — die Genauigkeit einer
 // Hochrechnung reicht dort nicht für Zehntel.
@@ -359,16 +345,12 @@ function loadAmpelColor(x){
   // nicht mehr nur einen Balken, sondern die große Zahl am Zeilenende. Die
   // früheren Festwerte (#c53030/#d69e2e/#2f855a) waren für den hellen Grund
   // gewählt und standen im dunklen Thema zu dunkel; --red/--amber/--green
-  // sind dort hellere Töne (siehe styles.css). Für den PDF-Export gilt
-  // weiterhin pdfLoadAmpelColor() mit druckfreundlichen Festwerten — ein PDF
-  // hat kein Thema.
+  // sind dort hellere Töne (siehe styles.css). Ein Gegenstück mit
+  // druckfreundlichen Festwerten gab es für den PDF-Export (pdfLoadAmpelColor);
+  // es ist mit dem gewerkeübergreifenden Sitzungs-PDF entfallen — die
+  // verbliebenen Exporte zeigen keine Auslastung mehr.
   return x >= schwelleRot() ? 'var(--red)' : x >= schwelleGelb() ? 'var(--amber)' : 'var(--green)';
 }
-// pdfLoadAmpelColor: Ampel-Farbe für den PDF-Export (js/pdf.js) mit gleichen
-// Schwellen wie loadAmpelColor, aber dunkleren, druckfreundlichen Farbtönen.
-function pdfLoadAmpelColor(x){
-  return x >= schwelleRot() ? '#D70015' : x >= schwelleGelb() ? '#B25000' : '#248A3D';
-}
 
 // ---------- LP-Aufwand Eingabemaske ----------
 
@@ -531,14 +513,13 @@ function projektFarbe(name){
 // Mittelwert: geteilt wird durch die Zahl der Sitzungen, in denen die Person
 // überhaupt im Teilnehmerkreis stand — nicht durch alle vorhandenen.
 function renderLoad(){
-  const scope = document.getElementById('loadScope').value;
   const selectedWeek = currentWeek();
-  const weeks = scope==='all' ? db.weeks : (selectedWeek ? [selectedWeek] : []);
+  const weeks = selectedWeek ? [selectedWeek] : [];
   if(weeks.length === 0){
     document.getElementById('loadGrid').innerHTML = '<div class="hint">Keine Sitzung ausgewählt oder die Daten werden noch geladen.</div>';
     return;
   }
-  const grouped = scope==='all' ? peopleByRole(db.weeks) : peopleByRole(selectedWeek);
+  const grouped = peopleByRole(selectedWeek);
   const stats = {};
   const personen = {};   // fullName -> { person, stunden, rollen:Set }
   ROLES.forEach(r=>{
diff --git a/public/js/pdf.js b/public/js/pdf.js
index 97d2ec7..d32d7c3 100644
--- a/public/js/pdf.js
+++ b/public/js/pdf.js
@@ -62,7 +62,15 @@ function pdfStatusText(htmlStatus){
   if(!htmlStatus) return { text: '', style: 'td' };
 
   const root = document.createElement('div');
-  root.innerHTML = htmlStatus;
+  // sanitizeStatusHtml() ist hier PFLICHT, nicht Kosmetik: Der Server
+  // speichert status/text unverändert (keine serverseitige Bereinigung), und
+  // innerHTML führt Handler auch dann aus, wenn das Element gar nicht im
+  // Dokument hängt — ein <img onerror=…>, das ein angemeldeter Nutzer über
+  // die API in einen Kommentar oder Protokollpunkt schreibt, liefe sonst in
+  // der Sitzung JEDER Person, die daraus ein PDF erzeugt. Die Anzeige am
+  // Bildschirm bereinigt an ihren eigenen Stellen bereits; nur dieser Pfad
+  // fehlte. Geprüft: ohne diese Zeile feuert der Handler tatsächlich.
+  root.innerHTML = sanitizeStatusHtml(htmlStatus);
 
   const parts = [];
 
@@ -175,13 +183,13 @@ function pdfNormalizeColor(v){
   return null;
 }
 
-// loadLogoPng: lädt dein_bild.ico und konvertiert es via Canvas nach PNG.
+// loadLogoPng: lädt logo.ico und konvertiert es via Canvas nach PNG.
 // pdfmake unterstützt nur JPEG und PNG, kein ICO.
 // Gibt null zurück, wenn Laden oder Dekodieren fehlschlägt.
 async function loadLogoPng(size){
   size = size || 256;
   try {
-    const res = await fetch(baseUrl() + '/dein_bild.ico');
+    const res = await fetch(baseUrl() + '/logo.ico');
     if(!res.ok) return null;
     const blob = await res.blob();
     const url  = URL.createObjectURL(blob);
@@ -959,19 +967,51 @@ async function exportProtokollPDF(protokollId){
             return cell;
           };
           const nummer = nummerById.get(p.id) || '';
-          const nummerText = p.neu
-            ? { text: [nummer, { text: '\nNEU', fontSize: 5.5, bold: true, color: '#8A6D00' }] }
-            : { text: nummer };
-          const statusCell = zelle({ text: p.erledigt ? 'erledigt' : 'offen', alignment: 'center' });
+          // Erstellungsdatum steht ausgegraut unter der Nummer statt in
+          // einer eigenen Spalte — auf Eriks Wunsch, damit die Tabelle
+          // keine zusätzliche Spalte bekommt.
+          const erstelltText = formatDateDE(parseDateISO(p.erstelltAm));
+          const nummerParts = [nummer];
+          if(p.neu) nummerParts.push({ text: '\nNEU', fontSize: 5.5, bold: true, color: '#8A6D00' });
+          if(erstelltText) nummerParts.push({ text: '\n' + erstelltText, fontSize: 5.5, bold: false, color: '#86868B' });
+          // entfaelltNaechstes: Gnadenrunde eines erledigten Punkts (Eriks
+          // Wunsch) — derselbe Hinweis wie am Bildschirm
+          // (.protokoll-chip-entfaellt, plan-protokoll.js), hier unter dem
+          // Erstellungsdatum statt in einer eigenen Spalte, aus demselben
+          // Platzgrund wie erstelltText oben.
+          if(p.entfaelltNaechstes) nummerParts.push({ text: '\nEntfällt im nächsten Protokoll', fontSize: 5.5, bold: true, color: '#D70015' });
+          const nummerText = { text: nummerParts };
+          const statusLabel = { offen: 'offen', erledigt: 'erledigt', info: 'Info' }[p.status] || 'offen';
+          const statusCell = zelle({ text: statusLabel, alignment: 'center' });
+          // themaGeaendert/textGeaendert: wie am Bildschirm (.ist-geaendert,
+          // plan-styles.css) markiert nur die Thema/Vereinbarung-Zelle gelb,
+          // nicht die ganze Zeile wie bei einem echten neuen Punkt (p.neu,
+          // oben in zelle()) — pdfmake kennt keine Hintergrundfarbe je
+          // Textlauf innerhalb einer Zelle, nur je ganzer Zelle, deshalb
+          // bekommt hier ausnahmsweise die ganze Thema-Zelle den Ton, auch
+          // wenn nur eines der beiden Felder sich geändert hat. Bei p.neu
+          // erübrigt sich das (die ganze Zeile ist ohnehin schon gelb).
+          // p.text ist bereits sanitiziertes HTML (contenteditable-Feld mit
+          // Fett/Kursiv/Farbe, richtextToolbarHtml()/js/utils.js, Eriks
+          // Wunsch) — dieselbe pdfStatusText() wie der Wochenbericht-
+          // Kommentar wandelt es direkt in eine pdfmake-Textstruktur mit
+          // echten Auszeichnungen, ohne Zwischenschritt.
+          const textLaeufe = p.text ? pdfStatusText(p.text).text : '';
+          const themaZelle = zelle({ text: [
+            p.thema ? { text: p.thema, bold: true } : '',
+            p.thema && p.text ? '\n' : '',
+            ...(Array.isArray(textLaeufe) ? textLaeufe : (textLaeufe ? [{ text: textLaeufe }] : []))
+          ] });
+          if(!p.neu && (p.themaGeaendert || p.textGeaendert)) themaZelle.fillColor = '#FFF6DB';
           body.push([
             zelle(nummerText, { bold: true }),
-            zelle({ text: [p.thema ? { text: p.thema, bold: true } : '', p.text ? { text: (p.thema ? '\n' : '') + p.text } : ''] }),
+            themaZelle,
             zelle({ text: p.zustaendig || '' }),
             zelle({ text: formatDateDE(parseDateISO(p.termin)) || '—' }),
             statusCell
           ]);
         });
-        punkteBlock.push({ table: { widths: [28, '*', 72, 42, 30], body }, layout: pdfWbGridLayout(true), margin: [0, 0, 0, 8] });
+        punkteBlock.push({ table: { widths: [34, '*', 72, 42, 30], body }, layout: pdfWbGridLayout(true), margin: [0, 0, 0, 8] });
       });
     }
 
diff --git a/public/js/people/people.js b/public/js/people/people.js
index cec167c..fe7077d 100644
--- a/public/js/people/people.js
+++ b/public/js/people/people.js
@@ -1,242 +1,98 @@
 // -----------------------------
-// Projektübersicht — Personen-Verwaltung (global pro Abteilung)
+// Projektübersicht — Personen-Ansicht (global, NUR LESEND)
 // -----------------------------
-// Diese Datei rendert den Personen-Tab (Tab "Projektbeteiligte" in `Test.html`)
-// und verwaltet die globale Personenliste pro Abteilung: Anlegen, Bearbeiten,
-// Löschen, Rollen-Auswahl, Drag-and-Drop-Sortierung sowie Urlaub/Abwesenheiten.
-// Sie wird von `Test.html` nach `js/board/board.js` (vor `js/projects/projects.js`) geladen
-// und stellt globale Funktionen wie `addPerson()`, `delPerson()`,
-// `editPerson()`, `renderPeople()` und `addAbsence()` bereit. Genutzt wird sie
-// u.a. von `js/board/board.js` (`renderBoard`), `js/gantt.js` und
-// `js/plan/plan-modals.js`; die Sortier-Hilfe `getDragAfterElement()` liegt in
-// `js/projects/projects.js`.
+// Diese Datei rendert den Personen-Tab (Tab "Projektbeteiligte" in `App.html`)
+// als reine Anzeige. Seit der Ablösung von people/person_roles/person_absences
+// (server.js) werden Projektbeteiligte ausschließlich in der zentralen
+// Benutzerverwaltung (Bereich „Admin“) gepflegt; Anlegen/Bearbeiten/Löschen/
+// Drag-and-Drop-Sortierung/Abwesenheits-Formulare gibt es hier bewusst nicht
+// mehr. EINE Ausnahme ist geblieben bzw. wieder dazugekommen: der
+// Teilnehmerkreis der aktuellen Sitzung (`currentWeek().people`). Er entsteht
+// nur beim Anlegen einer neuen Sitzung und wird beim Duplizieren
+// unverändert übernommen — ohne die Schaltflächen hier ("Zur Sitzung
+// hinzufügen"/"Aus Sitzung entfernen") wäre ein neu angelegter Benutzer in
+// keiner laufenden Sitzung zuordenbar, weder im Board noch in der
+// Auslastung noch in der Anwesenheit. Die Personendaten selbst kommen unverändert über `db.globalPeople`
+// (befüllt via `GET /load-all`, serverseitig jetzt aus `users`/`user_roles`/
+// `user_absences` zusammengesetzt, firmenweit ohne Abteilungstrennung). Sie
+// wird von `App.html` nach `js/board/board.js` (vor `js/projects/projects.js`)
+// geladen und stellt die globale Funktion `renderPeople()` bereit, die u.a.
+// von `js/tabs-auth.js` (`showTab()`) und `js/init.js` aufgerufen wird.
 
-// addPerson: fügt eine neue Person der globalen Liste hinzu und
-// synchronisiert sie in die aktuelle Sitzung.
-function addPerson(){
-  if(guardWeekLocked()) return;
-  const w = currentWeek();
-  if(!w) return;
-  const name = document.getElementById('newPersonName').value.trim();
-  const fullName = document.getElementById('newPersonFullName').value.trim();
-  const email = document.getElementById('newPersonEmail').value.trim();
-  if(!name){ alert("Kürzel eingeben."); return; }
-  const roles = [...document.querySelectorAll('input[name="newPersonRoles"]:checked')].map(el=>el.value);
-  if(roles.length===0){ alert("Bitte mindestens eine Rolle auswählen."); return; }
-
-  const person = {id:personIdForName(name), name, fullName:fullName||name, email:email, role:roles};
-
-  // Globale Liste aktualisieren
-  if(!Array.isArray(db.globalPeople[currentDepartment])) db.globalPeople[currentDepartment] = [];
-  const existing = db.globalPeople[currentDepartment].find(p => p.id === person.id);
-  if(existing){
-    alert('Eine Person mit diesem Kürzel existiert bereits.');
-    return;
-  }
-  db.globalPeople[currentDepartment].push(person);
-
-  // Aktuelle Sitzung aktualisieren
-  if(!Array.isArray(w.people)) w.people = [];
-  if(!w.people.find(p => p.id === person.id)){
-    w.people.push(JSON.parse(JSON.stringify(person)));
-  }
-
-  document.getElementById('newPersonName').value='';
-  document.getElementById('newPersonFullName').value='';
-  document.getElementById('newPersonEmail').value='';
-  document.querySelectorAll('input[name="newPersonRoles"]').forEach(el=>el.checked=false);
-  save({people:true}); renderPeople(); renderBoard();
-}
-
-// delPerson: entfernt eine Person aus der globalen Liste. Bereits in
-// historischen Sitzungen verwendete Personen bleiben dort sichtbar, da
-// jede Sitzung ihre eigene Kopie der Personendaten speichert.
-function delPerson(id){
-  if(!confirm("Person global löschen? Sie bleibt in bereits existierenden Sitzungen sichtbar, wird aber in neuen Sitzungen nicht mehr angeboten.")) return;
-
-  // Erst prüfen, ob die Person in der aktuellen Sitzung noch zugeordnet ist –
-  // erst danach die globalen Listen verändern, sonst wäre die globale Löschung
-  // trotz Abbruch bereits durchgeführt (und würde über save() persistiert).
-  const w = currentWeek();
-  if(w){
-    const inUse = w.projects.some(p => Object.keys(p.assign).some(k => k.startsWith(id + '|')));
-    if(inUse){
-      alert('Die Person ist in der aktuellen Sitzung noch Projekten zugeordnet. Bitte zuerst die Zuordnungen entfernen.');
-      return;
-    }
-  }
-
-  // Aus globaler Liste entfernen
-  if(Array.isArray(db.globalPeople[currentDepartment])){
-    db.globalPeople[currentDepartment] = db.globalPeople[currentDepartment].filter(p=>p.id!==id);
-  }
-
-  // Aus aktueller Sitzung entfernen
-  if(w){
-    w.people = (w.people || []).filter(p=>p.id!==id);
-  }
-
-  save({people:true}); renderPeople(); renderBoard();
-}
-
-// editPerson: ändert Name/Vollname/Rolle sowohl global als auch in der
-// aktuellen Sitzung. Historische Sitzungen bleiben unverändert.
-// Bei Feld `name` wird die ID migriert (`personIdForName`) und die
-// Zuordnungen/Anwesenheiten werden umgeschrieben. Parameter: `id`
-// (Personen-ID), `field` (Feldname), `val` (neuer Wert). Keine Rückgabe.
-function editPerson(id,field,val){
-  if(guardWeekLocked()) return;
-  const w = currentWeek();
-  if(!w) return;
-
-  // Global aktualisieren
-  const globalPeople = db.globalPeople[currentDepartment] || [];
-  const globalPerson = globalPeople.find(p => p.id === id);
-
-  if(field === 'name'){
-    const newName = val.trim();
-    if(!newName) return;
-    const newId = personIdForName(newName);
-    if(newId !== id && globalPeople.some(p => p.id === newId)){
-      alert('Dieses Kürzel wird bereits verwendet.');
-      return;
-    }
-    if(globalPerson){
-      globalPerson.name = newName;
-      globalPerson.id = newId;
-    }
-    // Aktuelle Sitzung aktualisieren und Zuordnungen migrieren
-    const localPerson = (w.people || []).find(p => p.id === id);
-    if(localPerson){
-      localPerson.name = newName;
-      localPerson.id = newId;
-    }
-    w.projects.forEach(p => {
-      const newAssign = {};
-      Object.keys(p.assign).forEach(k => {
-        const [oldId, role] = k.split('|');
-        if(oldId === id){
-          newAssign[assignKey(newId, role)] = p.assign[k];
-        } else {
-          newAssign[k] = p.assign[k];
-        }
-      });
-      p.assign = newAssign;
-      if(p.plan && Array.isArray(p.plan.people)){
-        p.plan.people = p.plan.people.map(pid => pid === id ? newId : pid);
-      }
-    });
-    if(w.attendance){
-      if(w.attendance[id]){
-        w.attendance[newId] = true;
-        delete w.attendance[id];
-      }
-    }
-    save({people:true}); renderPeople(); renderBoard();
-    return;
-  }
-
-  if(field === 'role'){
-    const roles = Array.isArray(val) ? [...new Set(val)] : val ? [val] : [];
-    if(globalPerson) globalPerson.role = roles;
-    const localPerson = (w.people || []).find(p => p.id === id);
-    if(localPerson) localPerson.role = roles;
-  } else {
-    if(globalPerson) globalPerson[field] = val;
-    const localPerson = (w.people || []).find(p => p.id === id);
-    if(localPerson) localPerson[field] = val;
-  }
-  save({people:true}); renderPeople(); renderBoard();
-}
-
-// togglePersonRole: fügt eine Rolle (`role`) zur Person `id` hinzu bzw. entfernt
-// sie (je nach Checkbox-Zustand `checked`), sowohl global als auch in der
-// aktuellen Sitzung. Keine Rückgabe.
-function togglePersonRole(id, role, checked){
-  if(guardWeekLocked()) return;
-  const w = currentWeek();
-  if(!w) return;
-
-  const globalPeople = db.globalPeople[currentDepartment] || [];
-  const globalPerson = globalPeople.find(p => p.id === id);
-  const localPerson = (w.people || []).find(p => p.id === id);
-
-  function updateRoles(person){
-    person.role = Array.isArray(person.role) ? [...person.role] : person.role ? [person.role] : [];
-    if(checked){
-      if(!person.role.includes(role)) person.role.push(role);
-    } else {
-      person.role = person.role.filter(r=>r!==role);
-    }
-  }
-
-  if(globalPerson) updateRoles(globalPerson);
-  if(localPerson) updateRoles(localPerson);
-  save({people:true}); renderPeople(); renderBoard();
-}
-
-// renderPeople: baut die HTML-Liste der Personen für den Personen-Tab auf
-// (Karten mit Bearbeitungsfeldern, Rollen-Checkboxen, aufklappbaren
-// Abwesenheiten und Drag-Handle). Bei gesperrter Sitzung wird das
-// Abwesenheits-Formular ausgeblendet. Keine Parameter, keine Rückgabe.
+// renderPeople: baut die schreibgeschützte Liste (`.people-readonly`, eine
+// Bubble-Card mit den Personen als Listenzeilen) der Personen für den
+// Personen-Tab auf (Zeilen mit Kürzel, Vollname, E-Mail, Rollen,
+// aufklappbaren Abwesenheiten). Kein Formular, keine Lösch-/
+// Bearbeiten-Aktionen, kein Drag-Handle. Zeigt zusätzlich einen Hinweis auf
+// die zentrale Benutzerverwaltung (Link nur für Admins sichtbar). Keine
+// Parameter, keine Rückgabe.
 function renderPeople(){
-  const people = db.globalPeople[currentDepartment] || [];
-  const locked = isWeekLocked(currentWeek());
-  let html = `<div class="people-sortable"
-    ondragover="handlePersonDragOver(event)"
-    ondrop="handlePersonDrop(event)">`;
-  people.forEach(p=>{
+  const people = db.globalPeople || [];
+  const isAdmin = typeof currentUser !== 'undefined' && !!currentUser && currentUser.role === 'admin';
+  const w = currentWeek();
+  const inWeek = new Set((w && Array.isArray(w.people) ? w.people : []).map(p => p.id));
+  const locked = !w || isWeekLocked(w);
+
+  let html = `<div class="hint" style="margin-bottom:12px">Projektbeteiligte werden zentral in der Benutzerverwaltung gepflegt.`
+    + (isAdmin ? ` <a href="/Admin#benutzer" onclick="showAdminSection('benutzer');return false;">Zur Benutzerverwaltung</a>` : '')
+    + `</div>`;
+  html += `<div class="hint" style="margin-bottom:12px">Wer in der aktuellen Sitzung`
+    + (w ? ` <b>${esc(w.label)}</b>` : '')
+    + ` mitwirkt, erscheint als Spalte im Projektboard, in der Auslastung und in der Anwesenheit.`
+    + (locked ? ` Die Sitzung ist gesperrt — der Kreis kann nicht geändert werden.` : '')
+    + `</div>`;
+
+  if(people.length === 0){
+    html += '<div class="hint">Keine Personen vorhanden.</div>';
+    document.getElementById('peopleList').innerHTML = html;
+    return;
+  }
+
+  html += `<div class="people-readonly">`;
+  people.forEach(p => {
     const isOpen = personAbsenceOpen[p.id];
+    const roles = Array.isArray(p.role) ? p.role : [];
+    const dabei = inWeek.has(p.id);
+    // Die Schaltfläche liegt IM Kopfbereich, der das Aufklappen auslöst —
+    // stopPropagation verhindert, dass ein Klick darauf zusätzlich die
+    // Abwesenheiten auf- oder zuklappt.
+    const weekAction = locked ? '' : (dabei
+      ? `<button type="button" class="secondary small" onclick="event.stopPropagation(); removePersonFromCurrentWeek('${esc(p.id)}')">Aus Sitzung entfernen</button>`
+      : `<button type="button" class="small" onclick="event.stopPropagation(); addPersonToCurrentWeek('${esc(p.id)}')">Zur Sitzung hinzufügen</button>`);
     html += `<div class="person-card${isOpen ? ' open' : ''}" data-person-id="${p.id}">`;
-    html += `<div class="person-header" onclick="togglePersonAbsences('${p.id}')">
-      ${locked ? '' : `<span class="drag-handle" style="cursor:grab;color:#999;margin-right:8px" onclick="event.stopPropagation()" ondragstart="handlePersonDragStart(event)" ondragend="handlePersonDragEnd(event)" draggable="true">⋮⋮</span>`}
-      <span class="person-toggle">${isOpen ? '▼' : '▶'}</span>
-      <input type="text" value="${esc(p.name)}" onclick="event.stopPropagation()" onchange="editPerson('${p.id}','name',this.value)" style="width:80px;" placeholder="Kürzel">
-      <input type="text" value="${esc(p.fullName||p.name)}" onclick="event.stopPropagation()" onchange="editPerson('${p.id}','fullName',this.value)" style="width:180px;" placeholder="Voller Name">
-      <input type="text" value="${esc(p.email)}" onclick="event.stopPropagation()" onchange="editPerson('${p.id}','email',this.value)" style="width:180px;" placeholder="E-Mail">
-      <div class="role-checkboxes" onclick="event.stopPropagation()">${ROLES.map(rr=>`<label><input type="checkbox" onchange="togglePersonRole('${p.id}','${rr}',this.checked)" value="${rr}" ${p.role.includes(rr)?'checked':''}> ${rr}</label>`).join('')}</div>
-      <button class="danger small" onclick="event.stopPropagation(); delPerson('${p.id}')">Löschen</button>
+    html += `<div class="person-header" onclick="togglePersonAbsences('${esc(p.id)}')">
+      <span class="person-toggle">${icon('chevronRight')}</span>
+      <strong>${esc(p.name)}</strong>
+      <span>${esc(p.fullName || '')}</span>
+      <span class="hint" style="margin:0">${esc(p.email || '')}</span>
+      <span>${roles.length ? roles.map(r => esc(r)).join(', ') : '<span class="hint" style="margin:0">Keine Rolle</span>'}</span>
+      <span class="person-week-state">${dabei ? 'in dieser Sitzung' : '<span class="hint" style="margin:0">nicht in dieser Sitzung</span>'}</span>
+      ${weekAction}
     </div>`;
 
-    // Aufklappbare Abwesenheiten
     html += `<div class="person-absences" style="display:${isOpen ? 'block' : 'none'}">`;
-    const absences = p.absences || [];
+    const absences = Array.isArray(p.absences) ? p.absences : [];
     if(absences.length > 0){
       html += `<div class="absence-list">`;
       absences.forEach(a => {
         html += `<div class="absence-chip">
           <span>${esc(a.type || 'Abwesenheit')}: ${formatDateDE(parseDateISO(a.start))}–${formatDateDE(parseDateISO(a.end))}</span>
           ${a.note ? `<small>${esc(a.note)}</small>` : ''}
-          ${locked ? '' : `<button class="danger small" onclick="deleteAbsence('${p.id}','${a.id}')">×</button>`}
         </div>`;
       });
       html += `</div>`;
-    }
-    if(!locked){
-      html += `<div class="absence-form">
-        <input type="text" id="absenceRange_${p.id}" class="range-picker-display" placeholder="Zeitraum wählen…" readonly
-          onclick="event.stopPropagation(); openRangePicker({ anchor: this, startInputId: 'absenceStart_${p.id}', endInputId: 'absenceEnd_${p.id}', displayId: 'absenceRange_${p.id}' })">
-        <input type="hidden" id="absenceStart_${p.id}">
-        <input type="hidden" id="absenceEnd_${p.id}">
-        <select id="absenceType_${p.id}">
-          <option>Urlaub</option>
-          <option>Krank</option>
-          <option>Fortbildung</option>
-          <option>Sonstiges</option>
-        </select>
-        <input type="text" id="absenceNote_${p.id}" placeholder="Notiz (optional)" style="width:140px">
-        <button class="secondary small" onclick="addAbsence('${p.id}')">+ Abwesenheit</button>
-      </div>`;
+    } else {
+      html += `<div class="hint">Keine Abwesenheiten hinterlegt.</div>`;
     }
     html += `</div></div>`;
   });
   html += `</div>`;
-  if(people.length===0) html = '<div class="hint">Keine Personen vorhanden.</div>';
-  document.getElementById('peopleList').innerHTML=html;
+  document.getElementById('peopleList').innerHTML = html;
 }
 
 // personAbsenceOpen: UI-Zustand, welche Personen-Karte ihre Abwesenheiten
-// aufgeklappt darstellt (Key = Personen-ID, Wert = boolean).
+// aufgeklappt darstellt (Key = Personen-ID, Wert = boolean). Reine Anzeige-
+// Steuerung, wird nicht persistiert.
 let personAbsenceOpen = {};
 
 // togglePersonAbsences: klappt die Abwesenheits-Liste einer Person auf bzw. zu
@@ -246,122 +102,53 @@ function togglePersonAbsences(personId){
   renderPeople();
 }
 
-// draggedPerson: die während eines Drag-and-Drop-Vorgangs verschobene
-// Personen-Karte (DOM-Element) bzw. null nach dem Loslassen.
-let draggedPerson = null;
-
-// getPersonCard: liefert die nächstgelegene Personen-Karte (`.person-card`).
-// Parameter `el`: Event-Ziel-Element. Rückgabe: Karten-Element oder null.
-function getPersonCard(el){
-  return el && el.closest ? el.closest('.person-card') : null;
-}
-
-// handlePersonDragStart: startet das Ziehen einer Personen-Karte, merkt sich
-// diese in `draggedPerson` und verringert ihre Deckkraft. Rückgabe: keine.
-function handlePersonDragStart(event){
-  draggedPerson = getPersonCard(event.target);
-  if(!draggedPerson) return;
-  event.dataTransfer.effectAllowed = 'move';
-  draggedPerson.style.opacity = '0.5';
-}
-
-// handlePersonDragOver: erlaubt das Ablegen während des Überfahrens
-// (verhindert den Standard-Drop-Typ und setzt `dropEffect='move'`).
-function handlePersonDragOver(event){
-  event.preventDefault();
-  event.dataTransfer.dropEffect = 'move';
-}
-
-// handlePersonDrop: legt die gezogene Personen-Karte an der Zielposition
-// innerhalb `.people-sortable` ab (per `getDragAfterElement`) und speichert
-// die neue Reihenfolge über `reorderPeople()`.
-function handlePersonDrop(event){
-  event.preventDefault();
-  const targetCard = getPersonCard(event.target);
-  if(!draggedPerson || draggedPerson === targetCard) return;
-  const sortable = document.querySelector('.people-sortable');
-  if(!sortable) return;
-  const afterElement = getDragAfterElement(sortable, event.clientY, '.person-card:not([style*="opacity"])');
-  if(afterElement == null){
-    sortable.appendChild(draggedPerson);
-  } else {
-    sortable.insertBefore(draggedPerson, afterElement);
-  }
-  reorderPeople();
-}
-
-// handlePersonDragEnd: stellt die Deckkraft der Karte wieder her und setzt
-// `draggedPerson` zurück (Ende des Drag-Vorgangs).
-function handlePersonDragEnd(event){
-  const card = getPersonCard(event.target);
-  if(card) card.style.opacity = '1';
-  draggedPerson = null;
-}
-
-// reorderPeople: übernimmt die im DOM vorgefundene Reihenfolge der
-// Personen-Karten in die globale Personenliste der Abteilung UND die
-// Personen-Kopie der aktuellen Woche (letztere bestimmt die Spaltenreihenfolge
-// im Projektboard), dann speichern. Keine Parameter, keine Rückgabe.
-function reorderPeople(){
+// addPersonToCurrentWeek: nimmt eine Person aus der globalen Liste in den
+// Teilnehmerkreis der aktuellen Sitzung auf. Nötig, weil der Kreis sonst nur
+// beim Anlegen einer neuen Sitzung entsteht: Ein später angelegter Benutzer
+// tauchte in laufenden (und in allen daraus duplizierten) Sitzungen nirgends
+// auf. Geschrieben wird über den normalen save()-Weg — `week.people` ist Teil
+// des Wochen-Datensatzes, den /save-week ohnehin schreibt.
+// Parameter: personId (String). Keine Rückgabe.
+function addPersonToCurrentWeek(personId){
   if(guardWeekLocked()) return;
-  const sortable = document.querySelector('.people-sortable');
-  if(!sortable) return;
-  const people = db.globalPeople[currentDepartment] || [];
-  if(people.length === 0) return;
-  const newPeople = [];
-  [...sortable.querySelectorAll('[data-person-id]')].forEach(item => {
-    const person = people.find(p => p.id === item.dataset.personId);
-    if(person) newPeople.push(person);
-  });
-  if(newPeople.length === people.length){
-    db.globalPeople[currentDepartment] = newPeople;
-    // Wochen-Kopie auf dieselbe Reihenfolge bringen, damit das Board sie nutzt
-    const w = currentWeek();
-    if(w && Array.isArray(w.people)){
-      const byId = {};
-      w.people.forEach(p => { byId[p.id] = p; });
-      const newWeekPeople = [];
-      newPeople.forEach(p => { if(byId[p.id]) newWeekPeople.push(byId[p.id]); });
-      if(newWeekPeople.length === w.people.length) w.people = newWeekPeople;
-    }
-    save({people:true});
-  }
+  const w = currentWeek();
+  if(!w) return;
+  if(!Array.isArray(w.people)) w.people = [];
+  if(w.people.some(p => p.id === personId)) return;
+  const person = (db.globalPeople || []).find(p => p.id === personId);
+  if(!person){ alert('Diese Person ist nicht mehr in der Benutzerverwaltung vorhanden.'); return; }
+  // Tiefe Kopie: Der Teilnehmerkreis friert Name und Rollen zum Zeitpunkt der
+  // Sitzung ein (genauso wie newWeek() es tut) und darf sich später nicht
+  // rückwirkend mit der globalen Liste ändern.
+  w.people.push(JSON.parse(JSON.stringify(person)));
+  save();
+  renderAll();
 }
 
-// ---------- Urlaub / Abwesenheiten ----------
-
-// addAbsence: legt für eine Person eine neue Abwesenheit an, die aus dem
-// Bereichspicker (Start-/Enddatum), Typ und Notiz des Formulars gelesen wird.
-// Prüft Datumsfolge, sortiert die Liste nach Startdatum und speichert.
-// Parameter `personId`: Personen-ID. Keine Rückgabe.
-function addAbsence(personId){
+// removePersonFromCurrentWeek: nimmt eine Person wieder aus dem
+// Teilnehmerkreis der aktuellen Sitzung heraus. Verweigert wird das, solange
+// sie noch einem Projekt dieser Sitzung zugeordnet ist — sonst bliebe eine
+// Zuordnung ohne zugehörige Spalte zurück. Parameter: personId (String).
+function removePersonFromCurrentWeek(personId){
   if(guardWeekLocked()) return;
-  const people = db.globalPeople[currentDepartment] || [];
-  const person = people.find(p => p.id === personId);
+  const w = currentWeek();
+  if(!w || !Array.isArray(w.people)) return;
+  const person = w.people.find(p => p.id === personId);
   if(!person) return;
-  const start = document.getElementById('absenceStart_' + personId).value;
-  const end = document.getElementById('absenceEnd_' + personId).value;
-  const type = document.getElementById('absenceType_' + personId).value;
-  const note = document.getElementById('absenceNote_' + personId).value.trim();
-  if(!start || !end){ alert('Bitte Start- und Enddatum angeben.'); return; }
-  if(parseDateISO(end) < parseDateISO(start)){ alert('Enddatum liegt vor Startdatum.'); return; }
-  if(!Array.isArray(person.absences)) person.absences = [];
-  person.absences.push({ id: uid(), start, end, type, note });
-  person.absences.sort((a,b) => parseDateISO(a.start) - parseDateISO(b.start));
-  save({week:false, people:true});
-  renderPeople();
-  if(currentTab === 'gantt') renderGantt();
-}
 
-// deleteAbsence: entfernt eine Abwesenheit (`absenceId`) aus der Liste der
-// Person (`personId`), speichert und rendert neu. Keine Rückgabe.
-function deleteAbsence(personId, absenceId){
-  if(guardWeekLocked()) return;
-  const people = db.globalPeople[currentDepartment] || [];
-  const person = people.find(p => p.id === personId);
-  if(!person || !person.absences) return;
-  person.absences = person.absences.filter(a => a.id !== absenceId);
-  save({week:false, people:true});
-  renderPeople();
-  if(currentTab === 'gantt') renderGantt();
-}
\ No newline at end of file
+  const zugeordnet = (w.projects || []).filter(proj => {
+    const assign = proj.assign || {};
+    return Object.keys(assign).some(key => key === personId || key.indexOf(personId + '|') === 0);
+  });
+  if(zugeordnet.length > 0){
+    alert('"' + (person.fullName || person.name) + '" ist in dieser Sitzung noch ' + zugeordnet.length
+        + ' Projekt(en) zugeordnet:\n\n' + zugeordnet.map(p => '· ' + (p.name || p.nr)).join('\n')
+        + '\n\nBitte zuerst die Zuordnungen im Projektboard entfernen.');
+    return;
+  }
+
+  w.people = w.people.filter(p => p.id !== personId);
+  if(w.attendance) delete w.attendance[personId];
+  save();
+  renderAll();
+}
diff --git a/public/js/plan/plan-drag.js b/public/js/plan/plan-drag.js
index 3fdeecb..4fdbbd4 100644
--- a/public/js/plan/plan-drag.js
+++ b/public/js/plan/plan-drag.js
@@ -32,8 +32,8 @@
   }
 
   // onGanttTodoMouseDown: startet das Zeilen-Ziehen, wenn der Greif-Handler
-  // (⋮⋮) einer TODO-/Meilenstein-Zeile gedrückt wird, und merkt sich Zeile
-  // und Startposition in app.todoDrag.
+  // (Icon "grip", .gantt-todo-drag) einer TODO-/Meilenstein-Zeile gedrückt
+  // wird, und merkt sich Zeile und Startposition in app.todoDrag.
   function onGanttTodoMouseDown(e){
     if(app.isLocked()) return;
     const handle = e.target.closest('.gantt-todo-drag');
@@ -113,7 +113,11 @@
     const plan = app.ensurePlanLocal();
     const todos = Array.isArray(plan.todos) ? plan.todos : [];
     const milestones = Array.isArray(plan.milestones) ? plan.milestones : [];
-    const todoIds = todos.map(t => t.id);
+    // Nur terminierte Aufgaben (Start UND Ende gesetzt) haben überhaupt eine
+    // eigene GANTT-Zeile (siehe plan-build-gantt.js) und damit einen
+    // Ziehgriff — Aufgaben ohne Termin bleiben an ihrer Stelle
+    // in plan.todos stehen, sie können hier gar nicht bewegt worden sein.
+    const scheduledIds = new Set(todos.filter(t => t.start && t.end).map(t => t.id));
 
     // Alle beweglichen Zeilen in aktueller DOM-Reihenfolge
     const rows = [...chart.querySelectorAll(DRAGGABLE_GANTT_ROW_SELECTOR)];
@@ -125,17 +129,19 @@
     // Position (before:/after:) sind eigene Zeilen. Meilensteine ohne Position
     // liegen in der Projektzeile und werden hier nicht umsortiert, deshalb nur
     // die positionierten zählen.
-    if(todoRowIds.length !== todoIds.length) return;
+    if(todoRowIds.length !== scheduledIds.size) return;
     const positionedIds = milestones.filter(m => m.position && /^(before|after):/.test(m.position)).map(m => m.id);
     if(milestoneRowIds.length !== positionedIds.length) return;
 
-    // TODOs neu ordnen
-    const newTodos = [];
-    todoRowIds.forEach(id => {
-      const t = todos.find(x => x.id === id);
-      if(t) newTodos.push(t);
+    // TODOs neu ordnen: nur die Positionen der terminierten Aufgaben werden
+    // gemäß der neuen DOM-Reihenfolge neu belegt (todoRowIds); Aufgaben ohne
+    // Termin behalten exakt ihren bisherigen Platz in der Liste.
+    let nextRowIdIdx = 0;
+    plan.todos = todos.map(t => {
+      if(!scheduledIds.has(t.id)) return t;
+      const id = todoRowIds[nextRowIdIdx++];
+      return todos.find(x => x.id === id) || t;
     });
-    plan.todos = newTodos;
 
     // Meilenstein-Positionen neu berechnen
     // Regeln:
@@ -382,9 +388,12 @@
     const totalDays = daysBetween(rangeStart, rangeEnd) + 1;
     const dayOffset = Math.max(0, Math.min(totalDays - 1, Math.round(x / rect.width * totalDays)));
     const date = formatDateISO(addDays(rangeStart, dayOffset));
-    openTodoModal(null);
-    document.getElementById('todoEditStart').value = date;
-    document.getElementById('todoEditEnd').value = date;
+    // Über prefill statt nachträglich in die versteckten Felder schreiben:
+    // openTodoModal() setzt damit auch die sichtbare Zeitraum-Anzeige, das
+    // Dauer-Kennzeichen und den Vergleichsstand für "ungespeicherte
+    // Änderungen" (sonst stand im Feld "Start – Ende wählen…", und Esc fragte
+    // grundlos nach dem Verwerfen).
+    openTodoModal(null, { start: date, end: date });
   }
 
   // updateProjectDates: setzt Start und Ende des Projekt-Plans und speichert.
@@ -415,23 +424,80 @@
     }
   }
 
-  // updateVacationDates: schreibt die verschobenen Urlaubsdaten sowohl in die
-  // lokale Sitzungs-Kopie der Person als auch in die globale Personenliste
-  // und speichert beides.
+  // updateVacationDates: übernimmt die per Drag verschobenen Urlaubsdaten
+  // sofort optimistisch in lokale Sitzungs-Kopie und globale Personenliste
+  // (damit das GANTT unmittelbar danach die neue Position zeichnet), und
+  // persistiert sie asynchron über die /users/:id/absences-Endpunkte — es
+  // gibt seit der Ablösung von people/person_roles/person_absences keinen
+  // /save-people-Schreibpfad und kein PATCH auf Abwesenheiten mehr, daher:
+  // alte Abwesenheit löschen, neue mit den verschobenen Daten anlegen (dabei
+  // vergibt der Server eine neue ID, die hier übernommen wird). Kein
+  // Benutzerkonto für die Person gefunden -> klare Fehlermeldung statt
+  // stillem Fehlschlag.
   function updateVacationDates(personId, absenceId, start, end){
     const localPerson = (app.week.people || []).find(p => p.id === personId);
-    if(localPerson && localPerson.absences){
-      const a = localPerson.absences.find(x => x.id === absenceId);
-      if(a){ a.start = start; a.end = end; }
-    }
-    const globalPeople = db.globalPeople[app.department] || [];
+    const localAbsence = localPerson && Array.isArray(localPerson.absences)
+      ? localPerson.absences.find(x => x.id === absenceId) : null;
+    const globalPeople = db.globalPeople || [];
     const globalPerson = globalPeople.find(p => p.id === personId);
-    if(globalPerson && globalPerson.absences){
-      const a = globalPerson.absences.find(x => x.id === absenceId);
-      if(a){ a.start = start; a.end = end; }
-    }
-    app.savePlan();
-    app.saveGlobalPeople();
+    const globalAbsence = globalPerson && Array.isArray(globalPerson.absences)
+      ? globalPerson.absences.find(x => x.id === absenceId) : null;
+    if(!globalAbsence) return;
+    const type = globalAbsence.type || '';
+    const note = globalAbsence.note || '';
+    // Ursprungstermine merken: Scheitert das Speichern (Netz, fehlende
+    // Berechtigung), wird die optimistisch verschobene Anzeige wieder auf den
+    // Server-Stand zurückgesetzt, statt etwas zu zeigen, das dort nicht gilt.
+    const vorher = { start: globalAbsence.start, end: globalAbsence.end };
+    const zuruecksetzen = () => {
+      if(localAbsence){ localAbsence.start = vorher.start; localAbsence.end = vorher.end; }
+      globalAbsence.start = vorher.start; globalAbsence.end = vorher.end;
+      renderPlanGantt();
+    };
+
+    if(localAbsence){ localAbsence.start = start; localAbsence.end = end; }
+    globalAbsence.start = start; globalAbsence.end = end;
+
+    app.getUserIdForPersonId(personId).then(userId => {
+      if(!userId){
+        app.showToast('Für diese Person existiert kein Benutzerkonto – Abwesenheit konnte nicht gespeichert werden.');
+        zuruecksetzen();
+        return;
+      }
+      // Ergebnis des Löschens prüfen, BEVOR neu angelegt wird: Schlug das
+      // Anlegen danach fehl (Netz, 400), war die alte Abwesenheit bereits weg
+      // — die Anzeige zeigte sie aber weiter, und nach dem nächsten Neuladen
+      // fehlte sie ersatzlos.
+      return fetch(baseUrl() + '/users/' + userId + '/absences/' + encodeURIComponent(absenceId), { method: 'DELETE' })
+        .then(r => {
+          if(!r.ok){
+            // 403 heißt: Der Eintrag stammt von jemand anderem (siehe
+            // DELETE /users/:id/absences/:absenceId in server.js).
+            return r.json().catch(() => ({})).then(json => {
+              throw new Error((json && json.error) || ('Alte Abwesenheit konnte nicht entfernt werden (HTTP ' + r.status + ')'));
+            });
+          }
+          return fetch(baseUrl() + '/users/' + userId + '/absences', {
+          method: 'POST',
+          headers: {'Content-Type':'application/json; charset=utf-8'},
+          body: JSON.stringify({ start, end, type, note })
+          });
+        })
+        .then(r => r.json().then(json => ({ ok: r.ok, json }))).then(({ ok, json }) => {
+          if(!ok || !json || !json.ok){
+            app.showToast('Abwesenheit konnte nicht gespeichert werden: ' + ((json && json.error) || 'unbekannter Fehler')
+                + ' — bitte die Seite neu laden.');
+            return;
+          }
+          globalAbsence.id = json.absence.id;
+          if(localAbsence) localAbsence.id = json.absence.id;
+          renderPlanGantt();
+        });
+    }).catch(err => {
+      console.error('Abwesenheit verschieben fehlgeschlagen:', err);
+      app.showToast('Abwesenheit konnte nicht verschoben werden: ' + (err.message || err));
+      zuruecksetzen();
+    });
   }
 
   // Drag-Funktionalität erst nach geladenem DOM registrieren
diff --git a/public/js/plan/plan-files.js b/public/js/plan/plan-files.js
index fcd5e9c..d3b82dc 100644
--- a/public/js/plan/plan-files.js
+++ b/public/js/plan/plan-files.js
@@ -175,7 +175,7 @@
 
   // renderFilesSummary: füllt die Kompakt-Vorschau der "Dateien & Freigaben"-
   // Karte unter dem GANTT (Cockpit-Layout, #planFilesSummary in
-  // Test.html) aus filesCache — Name der zuletzt hochgeladenen Datei
+  // App.html) aus filesCache — Name der zuletzt hochgeladenen Datei
   // (Server liefert /project-files bereits nach created_at DESC sortiert,
   // filesCache[0] ist also die neueste) sowie einen Hinweis auf noch
   // ausstehende Prüfungen.
diff --git a/public/js/plan/plan-gantt.js b/public/js/plan/plan-gantt.js
index b7766e4..cfdcba0 100644
--- a/public/js/plan/plan-gantt.js
+++ b/public/js/plan/plan-gantt.js
@@ -91,7 +91,7 @@
   }
 
   // renderPlanWarnings: füllt das Hinweisband über dem GANTT
-  // (#planWarnings in Test.html) mit den Urlaubs-Kollisionen des
+  // (#planWarnings in App.html) mit den Urlaubs-Kollisionen des
   // Projekts — Aufgaben, deren Zeitraum in die Abwesenheit einer zugeordneten
   // Person fällt. Die Prüfung selbst liegt in plan-build-gantt.js
   // (app.absenceConflictsForTodo), damit Balken-Markierung und diese Liste
@@ -131,7 +131,7 @@
   }
 
   // renderPlanKpis: füllt die KPI-Kachelzeile über dem GANTT (Cockpit-Layout,
-  // #planKpiRow in Test.html) mit vier Kennzahlen, die alle aus den
+  // #planKpiRow in App.html) mit vier Kennzahlen, die alle aus den
   // bereits vorhandenen Plan-Daten abgeleitet sind (keine neue Datenquelle):
   // Gesamtfortschritt (Ø-Fortschritt aller TODOs), offene Aufgaben (inkl.
   // überfällige), nächster anstehender Meilenstein und Team-Auslastung
diff --git a/public/js/plan/plan-history.js b/public/js/plan/plan-history.js
index 038909a..b9ed1d2 100644
--- a/public/js/plan/plan-history.js
+++ b/public/js/plan/plan-history.js
@@ -94,7 +94,7 @@
   }
 
   // renderPlanHistory: füllt die Kompakt-Karte "Verlauf" (#planHistorySummary
-  // in Test.html) — Anzahl der Einträge und die Sitzung des letzten
+  // in App.html) — Anzahl der Einträge und die Sitzung des letzten
   // Kommentarwechsels. Wird von renderPlanPage() (plan-state.js) nach dem
   // Laden aufgerufen. Keine Parameter, keine Rückgabe.
   window.renderPlanHistory = function(){
diff --git a/public/js/plan/plan-info.js b/public/js/plan/plan-info.js
index 25beecc..bef03fd 100644
--- a/public/js/plan/plan-info.js
+++ b/public/js/plan/plan-info.js
@@ -42,7 +42,7 @@
   // alle echten Leistungsphasen (inkl. LPH 9), aber ohne die Sammelkategorie
   // "W+M". Entspricht AUFWAND_LPS in js/load/load.js, hier separat definiert,
   // weil load.js auf der Projektplan-Seite bewusst nicht geladen wird (siehe
-  // Kopfkommentar in Test.html). Bewusst per Filter statt per
+  // Kopfkommentar in App.html). Bewusst per Filter statt per
   // Index-Schnitt, damit eine spätere Ergänzung von LPHS nicht stillschweigend
   // durchs Raster fällt.
   const PLAN_ACTIVE_LPS = LPHS.filter(l => l !== 'W+M');
diff --git a/public/js/plan/plan-modals.js b/public/js/plan/plan-modals.js
index 3a099b0..f78ba89 100644
--- a/public/js/plan/plan-modals.js
+++ b/public/js/plan/plan-modals.js
@@ -615,18 +615,6 @@
     openTodoModal(null);
   };
 
-  // updateTodo: setzt ein einzelnes Feld (z. B. done) einer Aufgabe direkt
-  // und speichert sowie rendert neu. Parameter: idx (Index), field
-  // (Feldname), value (neuer Wert).
-  window.updateTodo = function(idx, field, value){
-    if(app.isLocked()) return;
-    const plan = app.ensurePlanLocal();
-    if(!plan.todos[idx]) return;
-    plan.todos[idx][field] = value;
-    app.savePlan();
-    renderPlanGantt();
-  };
-
   // toggleTodoDone: schaltet den Erledigt-Status der Aufgabe am Index um,
   // speichert und rendert neu.
   window.toggleTodoDone = function(idx){
diff --git a/public/js/plan/plan-protokoll.js b/public/js/plan/plan-protokoll.js
index 9ed0d85..26c5c45 100644
--- a/public/js/plan/plan-protokoll.js
+++ b/public/js/plan/plan-protokoll.js
@@ -144,17 +144,20 @@
   };
 
   // gruppenReihenfolge: liefert die vorkommenden Gruppennamen in der
-  // Reihenfolge ihres ersten Auftretens unter den Punkten (array_order) —
-  // "Ohne Gruppe" (leerer String) immer zuerst, wenn vorhanden.
+  // Reihenfolge ihres ersten Auftretens unter den Punkten (array_order).
+  // Jeder Punkt gehört jetzt zu einer Gruppe (siehe fuegeNeueGruppeHinzu()/
+  // "+ Neue Gruppe" unten) — eine frühere Sonderrolle "Ohne Gruppe" (leerer
+  // String, immer zuerst) gibt es nicht mehr; ein einzelner Punkt mit leerer
+  // Gruppe (nur noch aus Altbeständen von vor dieser Umstellung möglich)
+  // bekommt ganz normal eine eigene, leer betitelte Gruppenzeile wie jede
+  // andere — kein Sonderfall im Code nötig.
   function gruppenReihenfolge(){
     const namen = [];
-    let hatOhneGruppe = false;
     (currentProtokoll.punkte || []).forEach(p => {
       const g = String(p.gruppe || '').trim();
-      if(!g){ hatOhneGruppe = true; return; }
       if(!namen.includes(g)) namen.push(g);
     });
-    return (hatOhneGruppe ? [''] : []).concat(namen);
+    return namen;
   }
 
   // ---------- Nachträgliches Umordnen ----------
@@ -162,15 +165,13 @@
   // Die Reihenfolge in `currentProtokoll.punkte` (= array_order) bestimmt
   // sowohl die Anzeige-Reihenfolge als auch — über berechneProtokollNummern()
   // — die Nummern. Zwei getrennte, aufeinander abgestimmte Stellschrauben:
-  // ein Punkt lässt sich nur INNERHALB seiner eigenen Gruppe (bzw. innerhalb
-  // "Ohne Gruppe") verschieben (die Zeile steht dort ohnehin nur im passenden
-  // Abschnitt), eine ganze Gruppe lässt sich als Block gegenüber den anderen
-  // Gruppen verschieben — das ändert, welche Gruppe die Nummer "1" bekommt.
-  // "Ohne Gruppe" bleibt bewusst immer der erste Abschnitt (siehe
-  // gruppenReihenfolge()) und ist deshalb hier nicht mitverschiebbar.
+  // ein Punkt lässt sich nur INNERHALB seiner eigenen Gruppe verschieben (die
+  // Zeile steht dort ohnehin nur im passenden Abschnitt), eine ganze Gruppe
+  // lässt sich als Block gegenüber den anderen Gruppen verschieben — das
+  // ändert, welche Gruppe die Nummer "1" bekommt.
 
   // verschiebePunkt: vertauscht einen Punkt mit seinem Vorgänger/Nachfolger
-  // INNERHALB derselben Gruppe (bzw. "Ohne Gruppe"). Parameter: idx (Index in
+  // INNERHALB derselben Gruppe. Parameter: idx (Index in
   // currentProtokoll.punkte), richtung (-1 = nach oben, +1 = nach unten).
   // Keine Rückgabe; rendert nur den Punkte-Block neu.
   window.verschiebePunkt = function(idx, richtung){
@@ -192,24 +193,24 @@
   // verschiebeGruppe: verschiebt eine ganze Gruppe (alle ihre Punkte als
   // Block, ihre eigene Reihenfolge bleibt untereinander erhalten) gegenüber
   // den anderen Gruppen — ändert damit auch die Gruppennummer. Baut die
-  // Punkteliste dafür komplett neu auf: "Ohne Gruppe" zuerst (unverändert),
-  // danach jede Gruppe in der neuen Reihenfolge. Parameter: gruppe (Name),
-  // richtung (-1 = nach vorn, +1 = nach hinten). Keine Rückgabe.
+  // Punkteliste dafür komplett in der neuen Gruppenreihenfolge neu auf.
+  // Parameter: gruppe (Name), richtung (-1 = nach vorn, +1 = nach hinten).
+  // Keine Rückgabe.
   window.verschiebeGruppe = function(gruppe, richtung){
     if(!currentProtokoll || app.isLocked()) return;
     const punkte = currentProtokoll.punkte;
     const namen = [];
     punkte.forEach(p => {
       const g = String(p.gruppe || '').trim();
-      if(g && !namen.includes(g)) namen.push(g);
+      if(!namen.includes(g)) namen.push(g);
     });
-    const pos = namen.indexOf(gruppe);
+    const pos = namen.indexOf(String(gruppe || '').trim());
     const zielPos = pos + richtung;
     if(pos === -1 || zielPos < 0 || zielPos >= namen.length) return;
     const tmpName = namen[pos];
     namen[pos] = namen[zielPos];
     namen[zielPos] = tmpName;
-    const neu = punkte.filter(p => !String(p.gruppe || '').trim());
+    const neu = [];
     namen.forEach(g => {
       punkte.filter(p => String(p.gruppe || '').trim() === g).forEach(p => neu.push(p));
     });
@@ -348,7 +349,7 @@
   // setzeProtokollImportLadezustand: blendet den Ladehinweis ein/aus und
   // sperrt alle Felder + Knöpfe des Dialogs währenddessen — ohne das gab es
   // während eines länger laufenden KI-Aufrufs (bis zu KI_TIMEOUT_MS_LOKAL =
-  // 5 Minuten bei einem eigenen Server, server.js) keinerlei Rückmeldung,
+  // 30 Minuten bei einem eigenen Server, server.js) keinerlei Rückmeldung,
   // der Dialog wirkte hängengeblieben, und ein zweiter Klick auf
   // "Importieren" hätte denselben Import doppelt losgeschickt.
   function setzeProtokollImportLadezustand(aktiv){
@@ -538,89 +539,275 @@
       </div>`;
   }
 
-  // renderPunkteBlockHtml: baut nur den Punkte-Block (in Abschnitten je
-  // Gruppe) — eigene Funktion, weil er nach einer Gruppenänderung isoliert
+  // renderPunkteBlockHtml: baut nur den Punkte-Block — EINE durchgehende
+  // Tabelle (dieselben Spalten wie der PDF-Export, js/pdf.js), mit einer
+  // vollbreiten Gruppen-Kopfzeile je Abschnitt statt eigener Tabellen je
+  // Gruppe — eigene Funktion, weil sie nach einer Gruppenänderung isoliert
   // neu gerendert wird, ohne den Rest der Detailansicht (und damit den Fokus
   // in anderen Feldern) anzufassen.
+  // PROTOKOLL_GRUPPEN_FARBEN/protokollGruppeFarbe: der Farbbalken der
+  // Gruppen-Kopfzeile wird — wie projektFarbe() in js/load/load.js für die
+  // Auslastung — aus dem Gruppennamen gehasht statt fest zugeordnet, damit
+  // eine Gruppe ihre Farbe behält, egal an welcher Position sie steht.
+  // Eigene, von den Status-Farben (Amber/Grün/Teal/Rot) getrennte Palette,
+  // damit eine Gruppenfarbe nie wie ein Status aussieht.
+  const PROTOKOLL_GRUPPEN_FARBEN = ['#5b63d6', '#8b5cf6', '#c2419a', '#4f8ef7', '#7a52c7'];
+  function protokollGruppeFarbe(name){
+    let hash = 0;
+    const s = String(name || '');
+    for(let i = 0; i < s.length; i++) hash = (hash * 31 + s.charCodeAt(i)) >>> 0;
+    return PROTOKOLL_GRUPPEN_FARBEN[hash % PROTOKOLL_GRUPPEN_FARBEN.length];
+  }
+
+  // ausgewaehlterPunkt: der gerade im Schreibbereich geöffnete Punkt, als
+  // OBJEKT-Referenz (nicht als Index). Die Punkte wandern beim Verschieben
+  // und beim Umsortieren einer ganzen Gruppe durch das Array; eine gemerkte
+  // Zahl zeigte danach auf einen anderen Punkt, die Referenz überlebt jede
+  // dieser Umstellungen unverändert. Nur ein Speichern tauscht die Objekte
+  // aus (der Server liefert frische) — dort wird die Auswahl über ihre
+  // Position wiederhergestellt, siehe speichereProtokoll().
+  let ausgewaehlterPunkt = null;
+
+  // waehlePunkt: öffnet einen Punkt im Schreibbereich. Parameter: idx (Index
+  // in currentProtokoll.punkte). Keine Rückgabe.
+  window.waehlePunkt = function(idx){
+    if(!currentProtokoll || !currentProtokoll.punkte[idx]) return;
+    ausgewaehlterPunkt = currentProtokoll.punkte[idx];
+    const block = document.getElementById('protokollPunkteBlock');
+    if(block) block.innerHTML = renderPunkteBlockHtml();
+  };
+
+  // listenUnterzeile: die kleine zweite Zeile eines Listeneintrags —
+  // Zuständig und Termin, so weit vorhanden. Parameter: punkt. Rückgabe:
+  // String.
+  function listenUnterzeile(punkt){
+    const teile = [];
+    const zust = String(punkt.zustaendig || '').trim();
+    if(zust) teile.push(zust);
+    const termin = formatDateDE(parseDateISO(punkt.termin));
+    if(termin) teile.push(termin);
+    return teile.join(' · ') || 'noch nichts erfasst';
+  }
+
+  // aktualisiereListenZeile: schreibt Thema, Zuständig/Termin und den
+  // Status-Punkt eines Listeneintrags neu — gezielt am vorhandenen Element,
+  // OHNE den Block neu zu rendern. Nötig, weil im Schreibbereich getippter
+  // Text sofort links in der Liste erscheinen soll, ein Neu-Rendern dabei
+  // aber den Eingabefokus (und die Schreibmarke) zerstören würde — dieselbe
+  // Begründung wie im Datei-Kopfkommentar. Parameter: idx. Keine Rückgabe.
+  function aktualisiereListenZeile(idx){
+    const punkt = currentProtokoll && currentProtokoll.punkte[idx];
+    const zeile = document.getElementById('protokollListeZeile_' + idx);
+    if(!punkt || !zeile) return;
+    const titel = zeile.querySelector('.titel');
+    if(titel){
+      const thema = String(punkt.thema || '').trim();
+      titel.textContent = thema || 'Ohne Thema';
+      titel.classList.toggle('ist-leer', !thema);
+    }
+    const sub = zeile.querySelector('.sub');
+    if(sub) sub.textContent = listenUnterzeile(punkt);
+    const dot = zeile.querySelector('.protokoll-punkt-dot');
+    if(dot) dot.setAttribute('data-status', punkt.status || 'offen');
+  }
+
+  // renderPunkteBlockHtml: baut den Punkte-Block als ZWEI nebeneinander
+  // liegende Bereiche (Eriks Auswahl „Liste + Schreibbereich" aus dem
+  // Protokoll-schreiben-Mockup) statt der früheren durchgehenden Tabelle:
+  // links eine schmale, überfliegbare Liste aller Punkte (nach Gruppen
+  // gegliedert, je Zeile Nummer, Thema, Status-Punkt und darunter
+  // Zuständig/Termin), rechts der Schreibbereich für den EINEN gerade
+  // ausgewählten Punkt mit großem Thema-Feld, mehrzeiligem Textfeld und
+  // Zuständig/Termin als ordentlichen Formularfeldern.
+  //
+  // Warum weg von der Tabelle: ein Protokollpunkt ist ein kleiner Fließtext,
+  // keine Tabellenzelle. In der Spalte blieben für den Text rund 60 % der
+  // Breite bei drei, vier sichtbaren Zeilen; Thema und Text klebten
+  // übereinander, und die Formatierungsleiste saß eingeklemmt dazwischen.
+  // Der Schreibbereich gibt dem Text eine lesbare Zeilenlänge und jedem Feld
+  // eine eigene Beschriftung.
+  //
+  // Eigene Funktion, weil sie nach jeder strukturellen Änderung (Punkt/Gruppe
+  // anlegen, löschen, verschieben, auswählen) isoliert neu gerendert wird,
+  // ohne den Rest der Detailansicht anzufassen. Reine Feldänderungen rendern
+  // dagegen NICHT neu, sondern aktualisieren die Liste gezielt über
+  // aktualisiereListenZeile() oben.
   function renderPunkteBlockHtml(){
     const p = currentProtokoll;
     const locked = app.isLocked();
     const gruppen = gruppenReihenfolge();
-    const gruppenNamen = gruppen.filter(g => g); // ohne '' für die Datalist-Vorschläge
-
     const nummern = window.berechneProtokollNummern(p.punkte);
-    const gruppenHtml = gruppen.map(gruppe => {
+
+    // Auswahl nachziehen: fehlt sie oder zeigt sie auf einen inzwischen
+    // gelöschten Punkt, rückt der erste vorhandene nach.
+    let aktivIdx = p.punkte.indexOf(ausgewaehlterPunkt);
+    if(aktivIdx === -1){
+      aktivIdx = p.punkte.length ? 0 : -1;
+      ausgewaehlterPunkt = aktivIdx >= 0 ? p.punkte[aktivIdx] : null;
+    }
+
+    const offeneAnzahl = p.punkte.filter(x => (x.status || 'offen') === 'offen').length;
+    const kopfText = p.punkte.length
+      ? `${p.punkte.length} ${p.punkte.length === 1 ? 'Punkt' : 'Punkte'} · ${offeneAnzahl} offen`
+      : 'Noch keine Punkte';
+
+    const listeHtml = gruppen.map(gruppe => {
       const punkteDerGruppe = p.punkte
         .map((punkt, idx) => ({ punkt, idx }))
         .filter(x => String(x.punkt.gruppe || '').trim() === gruppe);
-      const titel = gruppe ? esc(gruppe) : 'Ohne Gruppe';
-      const addBtn = locked ? '' : `<span class="protokoll-gruppe-add" onclick="fuegePunktHinzu('${esc(gruppe)}')">+ Punkt</span>`;
-      // "Ohne Gruppe" bleibt fest der erste Abschnitt (siehe gruppenReihenfolge()) —
-      // nur echte Gruppen lassen sich gegeneinander verschieben.
       let moveBtns = '';
-      if(gruppe && !locked){
-        const gPos = gruppenNamen.indexOf(gruppe);
-        const hochDisabled = gPos <= 0 ? 'disabled' : '';
-        const runterDisabled = gPos >= gruppenNamen.length - 1 ? 'disabled' : '';
+      if(!locked){
+        const gPos = gruppen.indexOf(gruppe);
         moveBtns = `<span class="protokoll-gruppe-move">
-            <button type="button" class="secondary small" ${hochDisabled} onclick="verschiebeGruppe('${esc(gruppe)}', -1)" title="Gruppe nach vorn">↑</button>
-            <button type="button" class="secondary small" ${runterDisabled} onclick="verschiebeGruppe('${esc(gruppe)}', 1)" title="Gruppe nach hinten">↓</button>
+            <button type="button" class="secondary small" ${gPos <= 0 ? 'disabled' : ''} onclick="verschiebeGruppe('${esc(gruppe)}', -1)" title="Gruppe nach vorn">↑</button>
+            <button type="button" class="secondary small" ${gPos >= gruppen.length - 1 ? 'disabled' : ''} onclick="verschiebeGruppe('${esc(gruppe)}', 1)" title="Gruppe nach hinten">↓</button>
           </span>`;
       }
-      const zeilen = punkteDerGruppe.map(({ punkt, idx }, pos) => renderPunktZeileHtml(punkt, idx, nummern[idx], pos === 0, pos === punkteDerGruppe.length - 1)).join('');
-      return `<div class="protokoll-gruppe">
-          <div class="protokoll-gruppe-head"><span class="protokoll-gruppe-name${gruppe ? '' : ' is-leer'}">${titel}</span>${moveBtns}${addBtn}</div>
-          ${zeilen || '<span class="hint">Keine Punkte in dieser Gruppe.</span>'}
+      const kopf = `<div class="protokoll-liste-gruppe" style="--protokoll-gruppe-farbe: ${protokollGruppeFarbe(gruppe)}">
+          <input class="protokoll-gruppe-heading" value="${esc(gruppe)}" placeholder="Gruppenname …" ${locked ? 'disabled' : ''}
+            onchange="currentProtokollUmbenenneGruppe('${esc(gruppe)}', this.value)">
+          <span class="count">${punkteDerGruppe.length}</span>${moveBtns}
         </div>`;
+      const zeilen = punkteDerGruppe.map(({ punkt, idx }) =>
+        renderListenZeileHtml(punkt, idx, nummern[idx], idx === aktivIdx)).join('');
+      const addZeile = locked ? '' : `<div class="protokoll-liste-neu" onclick="fuegePunktHinzu('${esc(gruppe)}')">+ Punkt</div>`;
+      return kopf + zeilen + addZeile;
     }).join('');
 
-    const datalist = `<datalist id="protokollGruppenListe">${gruppenNamen.map(g => `<option value="${esc(g)}">`).join('')}</datalist>`;
-    const addOhneGruppe = locked ? '' : `<div class="add-row-btn" onclick="fuegePunktHinzu('')">+ Punkt (ohne Gruppe)</div>`;
+    const leerHinweis = listeHtml ? '' : '<div class="protokoll-liste-leer">Noch keine Punkte erfasst.</div>';
+    const neueGruppe = locked ? '' : `<div class="protokoll-liste-neu ist-gruppe" onclick="fuegeNeueGruppeHinzu()">+ Neue Gruppe</div>`;
 
     return `<div class="protokoll-block-head"><h4>Punkte</h4></div>
-      ${gruppenHtml || '<span class="hint">Noch keine Punkte.</span>'}
-      ${datalist}
-      ${addOhneGruppe}
+      <div class="protokoll-split">
+        <div class="protokoll-liste">
+          <div class="protokoll-liste-kopf">${esc(kopfText)}</div>
+          ${listeHtml}${leerHinweis}${neueGruppe}
+        </div>
+        ${renderSchreibbereichHtml(aktivIdx, nummern)}
+      </div>
       <div class="legend">
         <span class="legend-item"><span class="legend-swatch neu"></span>Neu in diesem Protokoll</span>
-        <span class="legend-item"><span class="legend-swatch fortgeschrieben"></span>Aus vorigem Protokoll fortgeschrieben</span>
-        <span class="legend-item"><span class="legend-swatch erledigt"></span>Erledigt (läuft nicht weiter mit)</span>
+        <span class="legend-item"><span class="legend-swatch info"></span>Info (läuft nicht weiter mit)</span>
       </div>`;
   }
 
-  function renderPunktZeileHtml(punkt, idx, nummer, istErste, istLetzte){
+  // renderListenZeileHtml: ein Eintrag der linken Liste. Bewusst knapp —
+  // Nummer, Thema, Status-Punkt und darunter Zuständig/Termin; alles
+  // Weitere steht im Schreibbereich. Parameter: punkt, idx, nummer,
+  // istAktiv. Rückgabe: HTML-String.
+  function renderListenZeileHtml(punkt, idx, nummer, istAktiv){
+    const thema = String(punkt.thema || '').trim();
+    const neuChip = punkt.neu ? '<span class="protokoll-chip-neu">Neu</span>' : '';
+    return `<div class="protokoll-liste-zeile${istAktiv ? ' ist-aktiv' : ''}" id="protokollListeZeile_${idx}" onclick="waehlePunkt(${idx})">
+        <span class="nr">${esc(nummer)}</span>
+        <span class="titel${thema ? '' : ' ist-leer'}">${esc(thema || 'Ohne Thema')}</span>
+        <span class="protokoll-punkt-dot" data-status="${esc(punkt.status || 'offen')}" title="${esc(PROTOKOLL_PUNKT_STATUS_LABEL[punkt.status || 'offen'] || 'Offen')}"></span>
+        <span class="sub">${esc(listenUnterzeile(punkt))}</span>
+        ${neuChip}
+      </div>`;
+  }
+
+  // PROTOKOLL_PUNKT_STATUS_LABEL: Anzeigetext je Status im Status-Umschalter
+  // unten — einzige Stelle, die die drei Werte kennt, damit ein vierter
+  // Status (sollte es den je geben) nur hier ergänzt werden müsste.
+  const PROTOKOLL_PUNKT_STATUS_LABEL = { offen: 'Offen', erledigt: 'Erledigt', info: 'Info' };
+
+  // renderSchreibbereichHtml: die rechte Hälfte — der EINE gerade
+  // ausgewählte Punkt, mit echtem Platz zum Schreiben. Parameter: idx (Index
+  // in currentProtokoll.punkte, -1 = kein Punkt vorhanden), nummern (das
+  // Ergebnis von berechneProtokollNummern()). Rückgabe: HTML-String.
+  function renderSchreibbereichHtml(idx, nummern){
     const locked = app.isLocked();
+    if(idx < 0){
+      return `<div class="protokoll-schreiben ist-leer">
+          <p>Noch kein Punkt angelegt.</p>
+          ${locked ? '' : '<p class="hint">Links über „+ Neue Gruppe" beginnen — jeder Punkt gehört zu einer Gruppe.</p>'}
+        </div>`;
+    }
+    const punkt = currentProtokoll.punkte[idx];
     const terminDisplay = formatDateDE(parseDateISO(punkt.termin)) || '';
     const neuChip = punkt.neu ? '<span class="protokoll-chip-neu">Neu</span>' : '';
-    const moveBtns = locked ? '' : `<span class="protokoll-punkt-move">
-        <button type="button" class="secondary small" ${istErste ? 'disabled' : ''} onclick="verschiebePunkt(${idx}, -1)" title="Innerhalb der Gruppe nach oben">↑</button>
-        <button type="button" class="secondary small" ${istLetzte ? 'disabled' : ''} onclick="verschiebePunkt(${idx}, 1)" title="Innerhalb der Gruppe nach unten">↓</button>
-      </span>`;
-    return `<div class="protokoll-punkt${punkt.neu ? ' is-neu' : ''}${punkt.erledigt ? ' is-erledigt' : ''}" id="protokollPunkt_${idx}">
-        <div class="protokoll-punkt-top-row">
-          <span class="protokoll-punkt-nr" title="Errechnet sich automatisch aus Gruppe und Reihenfolge">${esc(nummer)}</span>
-          ${moveBtns}
-          <input type="text" class="protokoll-punkt-gruppe" list="protokollGruppenListe" value="${esc(punkt.gruppe)}"
-            placeholder="Gruppe (z. B. ELT, HLS) …" ${locked ? 'disabled' : ''}
-            onchange="currentProtokollSetzePunktGruppe(${idx}, this.value)">
-          ${neuChip}
-          <input type="text" class="protokoll-punkt-thema" value="${esc(punkt.thema)}" placeholder="Thema" ${locked ? 'disabled' : ''}
-            oninput="currentProtokollSetzePunktFeld(${idx}, 'thema', this.value)">
-          <label class="protokoll-punkt-erledigt-toggle"><input type="checkbox" ${punkt.erledigt ? 'checked' : ''} ${locked ? 'disabled' : ''}
-            onchange="currentProtokollSetzePunktErledigt(${idx}, this.checked)"> erledigt</label>
-          ${locked ? '' : `<span class="protokoll-row-remove" onclick="entfernePunkt(${idx})" title="Punkt entfernen">✕</span>`}
+    // entfaelltNaechstes: vom Server gesetzt, wenn dieser Punkt beim
+    // Fortschreiben aus einem erledigten Punkt des vorigen Protokolls
+    // entstand — seine Gnadenrunde (Eriks Wunsch: ein erledigter Punkt
+    // taucht noch EIN Protokoll lang auf, bevor er entfällt). Nie vom
+    // Client gesetzt (siehe PUT .../:id, server.js).
+    const entfaelltChip = punkt.entfaelltNaechstes
+      ? '<span class="protokoll-chip-entfaellt" title="Dieser Punkt wurde bereits als erledigt fortgeschrieben — im übernächsten Protokoll taucht er nicht mehr auf.">Entfällt im nächsten Protokoll</span>'
+      : '';
+    // themaGeaendert/textGeaendert: vom Server gesetzt (siehe
+    // loadProtokollDetail(), server.js) für einen fortgeschriebenen Punkt
+    // (neu=0), dessen Thema bzw. Text sich gegenüber der Fassung im
+    // UNMITTELBAR vorangegangenen Protokoll geändert hat — markiert NUR das
+    // jeweils geänderte Feld, der Punkt selbst ist ja derselbe geblieben.
+    const themaGeaendertClass = punkt.themaGeaendert ? ' ist-geaendert' : '';
+    const textGeaendertClass = punkt.textGeaendert ? ' ist-geaendert' : '';
+    const status = punkt.status || 'offen';
+
+    // Verschieben gilt wie bisher nur INNERHALB der eigenen Gruppe — die
+    // Knöpfe sind an den Rändern dieser Gruppe gesperrt, nicht an denen der
+    // Gesamtliste.
+    const gruppe = String(punkt.gruppe || '').trim();
+    const idxDerGruppe = currentProtokoll.punkte
+      .map((x, i) => ({ x, i }))
+      .filter(e => String(e.x.gruppe || '').trim() === gruppe)
+      .map(e => e.i);
+    const posInGruppe = idxDerGruppe.indexOf(idx);
+    const kopfAktionen = locked ? '' : `<span class="protokoll-punkt-move">
+        <button type="button" class="secondary small" ${posInGruppe <= 0 ? 'disabled' : ''} onclick="verschiebePunkt(${idx}, -1)" title="Innerhalb der Gruppe nach oben">↑</button>
+        <button type="button" class="secondary small" ${posInGruppe >= idxDerGruppe.length - 1 ? 'disabled' : ''} onclick="verschiebePunkt(${idx}, 1)" title="Innerhalb der Gruppe nach unten">↓</button>
+      </span>
+      <span class="protokoll-row-remove" onclick="entfernePunkt(${idx})" title="Punkt entfernen">✕</span>`;
+
+    const statusButtons = Object.keys(PROTOKOLL_PUNKT_STATUS_LABEL).map(s =>
+      `<button type="button" class="${s}${s === status ? ' is-active' : ''}" ${locked ? 'disabled' : ''}
+         onclick="currentProtokollSetzePunktStatus(${idx}, '${s}')">${PROTOKOLL_PUNKT_STATUS_LABEL[s]}</button>`).join('');
+
+    return `<div class="protokoll-schreiben">
+        <div class="protokoll-schreiben-kopf">
+          <span class="nr" title="Errechnet sich automatisch aus Gruppe und Reihenfolge">${esc(nummern[idx])}</span>
+          <span class="gruppe">${esc(gruppe)}</span>
+          ${neuChip}${entfaelltChip}
+          <span class="rechts">
+            <div class="protokoll-status-switch ist-waagerecht">${statusButtons}</div>
+            ${kopfAktionen}
+          </span>
         </div>
-        <textarea class="protokoll-punkt-text" rows="2" placeholder="Text / Vereinbarung" ${locked ? 'disabled' : ''}
-          oninput="currentProtokollSetzePunktFeld(${idx}, 'text', this.value)">${esc(punkt.text)}</textarea>
-        <div class="protokoll-punkt-foot">
-          <label>Zuständig <input type="text" value="${esc(punkt.zustaendig)}" ${locked ? 'disabled' : ''}
-            oninput="currentProtokollSetzePunktFeld(${idx}, 'zustaendig', this.value)"></label>
-          <label>Termin
-            <input type="text" id="protokollPunktTerminDisplay_${idx}" class="range-picker-display" value="${esc(terminDisplay)}" placeholder="—" readonly
+
+        <div class="protokoll-schreiben-feld">
+          <span class="protokoll-feld-label">Thema</span>
+          <input type="text" class="protokoll-punkt-thema${themaGeaendertClass}" value="${esc(punkt.thema)}"
+            placeholder="Worum geht es?" ${locked ? 'disabled' : ''}
+            oninput="currentProtokollSetzePunktFeld(${idx}, 'thema', this.value)">
+        </div>
+
+        <div class="richtext-wrap">
+          ${locked ? '' : richtextToolbarHtml('.protokoll-punkt-text')}
+          <div class="protokoll-schreiben-feld">
+            <span class="protokoll-feld-label">Vereinbarung · Text</span>
+            ${richtextFeldHtml('protokoll-punkt-text' + textGeaendertClass, sanitizeStatusHtml(punkt.text),
+              'Was wurde besprochen oder vereinbart?',
+              `oninput="currentProtokollSetzePunktFeld(${idx}, 'text', this.innerHTML)"`, !locked)}
+          </div>
+        </div>
+
+        <div class="protokoll-schreiben-raster">
+          <div>
+            <span class="protokoll-feld-label">Zuständig</span>
+            <input type="text" value="${esc(punkt.zustaendig)}" placeholder="Name oder Firma" ${locked ? 'disabled' : ''}
+              oninput="currentProtokollSetzePunktFeld(${idx}, 'zustaendig', this.value)">
+          </div>
+          <div>
+            <span class="protokoll-feld-label">Termin</span>
+            <input type="text" id="protokollPunktTerminDisplay_${idx}" class="range-picker-display" value="${esc(terminDisplay)}" placeholder="— kein Termin" readonly
               onclick="${locked ? '' : `openDatePicker({ anchor: this, inputId: 'protokollPunktTermin_${idx}', displayId: 'protokollPunktTerminDisplay_${idx}', onApply: function(){ syncProtokollPunktTermin(${idx}); } })`}">
             <input type="hidden" id="protokollPunktTermin_${idx}" value="${esc(punkt.termin)}">
-          </label>
-          <span class="protokoll-punkt-erstellt" title="Datum, an dem dieser Punkt zum ersten Mal erfasst wurde — bleibt beim Fortschreiben unverändert">Erstellt ${esc(formatDateDE(parseDateISO(punkt.erstelltAm)) || '—')}</span>
+          </div>
+        </div>
+
+        <div class="protokoll-schreiben-fuss">
+          Erstellt am ${esc(formatDateDE(parseDateISO(punkt.erstelltAm)) || '—')}
+          <span class="hint">— bleibt beim Fortschreiben unverändert</span>
         </div>
       </div>`;
   }
@@ -639,29 +826,47 @@
     if(!currentProtokoll || !currentProtokoll.teilnehmer[idx]) return;
     currentProtokoll.teilnehmer[idx][feld] = wert;
   };
+  // Thema/Zuständig schlagen sofort auf den Listeneintrag links durch, ohne
+  // den Block neu zu rendern (sonst wäre der Fokus beim Tippen weg, siehe
+  // aktualisiereListenZeile() oben).
   window.currentProtokollSetzePunktFeld = function(idx, feld, wert){
     if(!currentProtokoll || !currentProtokoll.punkte[idx]) return;
     currentProtokoll.punkte[idx][feld] = wert;
+    if(feld === 'thema' || feld === 'zustaendig') aktualisiereListenZeile(idx);
   };
   window.syncProtokollPunktTermin = function(idx){
     if(!currentProtokoll || !currentProtokoll.punkte[idx]) return;
     const el = document.getElementById('protokollPunktTermin_' + idx);
     if(el) currentProtokoll.punkte[idx].termin = el.value;
+    aktualisiereListenZeile(idx);
   };
-  window.currentProtokollSetzePunktErledigt = function(idx, checked){
+  window.currentProtokollSetzePunktStatus = function(idx, status){
     if(!currentProtokoll || !currentProtokoll.punkte[idx]) return;
-    currentProtokoll.punkte[idx].erledigt = checked;
-    const row = document.getElementById('protokollPunkt_' + idx);
-    if(row) row.classList.toggle('is-erledigt', checked);
+    currentProtokoll.punkte[idx].status = status;
+    // Gezielt die beiden betroffenen Stellen nachziehen statt neu zu rendern:
+    // der aktive Knopf im Umschalter und der farbige Punkt im Listeneintrag.
+    document.querySelectorAll('.protokoll-schreiben .protokoll-status-switch button').forEach(btn => {
+      btn.classList.toggle('is-active', btn.classList.contains(status));
+    });
+    aktualisiereListenZeile(idx);
   };
-  // currentProtokollSetzePunktGruppe: einzige Punkt-Feldänderung, die neu
-  // rendert (nur den Punkte-Block, siehe renderPunkteBlockHtml) — ändert
-  // sich die Gruppe, muss der Punkt sichtbar in den passenden Abschnitt
-  // wandern. Läuft über onchange (Blur/Enter), nicht oninput, damit während
-  // des Tippens nicht bei jedem Zeichen neu gerendert wird.
-  window.currentProtokollSetzePunktGruppe = function(idx, wert){
-    if(!currentProtokoll || !currentProtokoll.punkte[idx]) return;
-    currentProtokoll.punkte[idx].gruppe = wert;
+  // currentProtokollUmbenenneGruppe: ersetzt currentProtokollSetzePunktGruppe
+  // (bis eben: ein Feld PRO Punkt, das genau diesen einen Punkt umhängte).
+  // Jetzt ist die Gruppen-Kopfzeile selbst das Eingabefeld (Eriks Wunsch) —
+  // ein Umbenennen wirkt auf ALLE Punkte dieser Gruppe gleichzeitig. Trägt
+  // der neue Name den einer bereits bestehenden anderen Gruppe, verschmelzen
+  // beide Gruppen schlicht dadurch, dass ab jetzt beide Punktmengen denselben
+  // gruppe-Wert tragen — kein Sonderfall nötig. Läuft über onchange
+  // (Blur/Enter), nicht oninput, damit während des Tippens nicht bei jedem
+  // Zeichen neu gerendert wird.
+  window.currentProtokollUmbenenneGruppe = function(alterName, neuerName){
+    if(!currentProtokoll) return;
+    const alt = String(alterName || '').trim();
+    const neu = String(neuerName || '').trim();
+    if(alt === neu) return;
+    currentProtokoll.punkte.forEach(punkt => {
+      if(String(punkt.gruppe || '').trim() === alt) punkt.gruppe = neu;
+    });
     const block = document.getElementById('protokollPunkteBlock');
     if(block) block.innerHTML = renderPunkteBlockHtml();
   };
@@ -684,17 +889,54 @@
     // aus Gruppe und Position (siehe berechneProtokollNummern() oben).
     // erstelltAm nur als Vorschau bis zum nächsten Speichern — maßgeblich ist
     // immer, was der Server beim Speichern setzt (server.js, PUT .../:id).
-    currentProtokoll.punkte.push({
+    const neuerPunkt = {
       id: null, nummer: '', gruppe: gruppe || '', neu: true,
-      thema: '', text: '', zustaendig: '', termin: '', erledigt: false,
-      erstelltAm: currentProtokoll.datum || ''
-    });
+      thema: '', text: '', zustaendig: '', termin: '', status: 'offen',
+      erstelltAm: currentProtokoll.datum || '', entfaelltNaechstes: false
+    };
+    currentProtokoll.punkte.push(neuerPunkt);
+    // Den neuen Punkt gleich im Schreibbereich öffnen und ins Thema-Feld
+    // springen — sonst stünde er zwar links in der Liste, rechts bliebe
+    // aber der vorige Punkt stehen und man müsste ihn erst anklicken.
+    ausgewaehlterPunkt = neuerPunkt;
     const block = document.getElementById('protokollPunkteBlock');
     if(block) block.innerHTML = renderPunkteBlockHtml();
+    const themaFeld = block && block.querySelector('.protokoll-schreiben .protokoll-punkt-thema');
+    if(themaFeld) themaFeld.focus();
+  };
+  // fuegeNeueGruppeHinzu: eigener, ausdrücklicher Weg, eine neue Gruppe
+  // anzulegen (Eriks Wunsch). Gruppe bleibt weiterhin freier Text ohne eigene
+  // Tabelle (siehe CLAUDE.md "### Protokolle") — eine Gruppe ohne jeden
+  // Punkt hätte in diesem Modell nirgends eine Repräsentation, deshalb legt
+  // dieser Knopf die Gruppe zusammen mit ihrem ersten (leeren) Punkt an. Ein
+  // nicht kollidierender Platzhaltername ("Neue Gruppe", bei Bedarf
+  // "Neue Gruppe 2" …) wird direkt danach in der großen Gruppen-Überschrift
+  // (nicht mehr einem Feld am Punkt, siehe currentProtokollUmbenenneGruppe()
+  // oben) fokussiert und markiert, damit er sich sofort überschreiben lässt.
+  window.fuegeNeueGruppeHinzu = function(){
+    if(!currentProtokoll || app.isLocked()) return;
+    const bestehende = new Set(gruppenReihenfolge());
+    let name = 'Neue Gruppe';
+    let n = 2;
+    while(bestehende.has(name)){ name = 'Neue Gruppe ' + n; n++; }
+    fuegePunktHinzu(name);
+    const block = document.getElementById('protokollPunkteBlock');
+    const input = block
+      ? Array.from(block.querySelectorAll('.protokoll-gruppe-heading')).find(el => el.value === name)
+      : null;
+    if(input){ input.focus(); input.select(); }
   };
   window.entfernePunkt = function(idx){
     if(!currentProtokoll || app.isLocked()) return;
+    // War der gelöschte Punkt der geöffnete, rückt der an seine Stelle
+    // getretene nach (bzw. der letzte, wenn es der letzte war) — sonst
+    // stünde der Schreibbereich leer da, obwohl noch Punkte vorhanden sind.
+    const warAusgewaehlt = currentProtokoll.punkte[idx] === ausgewaehlterPunkt;
     currentProtokoll.punkte.splice(idx, 1);
+    if(warAusgewaehlt){
+      const ersatz = Math.min(idx, currentProtokoll.punkte.length - 1);
+      ausgewaehlterPunkt = ersatz >= 0 ? currentProtokoll.punkte[ersatz] : null;
+    }
     const block = document.getElementById('protokollPunkteBlock');
     if(block) block.innerHTML = renderPunkteBlockHtml();
   };
@@ -711,7 +953,16 @@
     // Anzeigen aber immer die Neuberechnung, nie dieser gespeicherte Wert —
     // siehe berechneProtokollNummern()).
     const nummern = window.berechneProtokollNummern(currentProtokoll.punkte);
-    currentProtokoll.punkte.forEach((p, idx) => { p.nummer = nummern[idx]; });
+    // text kommt live aus dem contenteditable-Feld (this.innerHTML,
+    // currentProtokollSetzePunktFeld()) — ein Einfügen von außerhalb könnte
+    // dort ungefiltertes HTML hinterlassen (contenteditable übernimmt
+    // eingefügte Formatierung standardmäßig); vor dem Senden deshalb
+    // dieselbe Bereinigung wie beim Board-Kommentar (saveBoardComment(),
+    // js/board/board.js).
+    currentProtokoll.punkte.forEach((p, idx) => {
+      p.nummer = nummern[idx];
+      p.text = sanitizeStatusHtml(p.text || '');
+    });
     const body = {
       datum: currentProtokoll.datum,
       betreff: currentProtokoll.betreff,
@@ -719,6 +970,11 @@
       teilnehmer: currentProtokoll.teilnehmer.filter(t => String(t.name || '').trim()),
       punkte: currentProtokoll.punkte
     };
+    // Die Auswahl hängt an der OBJEKT-Referenz des Punkts (siehe dort) — der
+    // Server liefert gleich frische Objekte zurück, die Referenz zeigt dann
+    // ins Leere. Die Reihenfolge bleibt beim Speichern erhalten (array_order),
+    // also lässt sich die Auswahl über ihre Position wiederherstellen.
+    const auswahlPos = currentProtokoll.punkte.indexOf(ausgewaehlterPunkt);
     fetch(baseUrl() + '/project-protokolle/' + encodeURIComponent(currentProtokoll.id), {
       method: 'PUT',
       headers: { 'Content-Type': 'application/json; charset=utf-8' },
@@ -728,6 +984,7 @@
       .then(({ ok, d }) => {
         if(!ok || !d.ok){ alert('Protokoll konnte nicht gespeichert werden: ' + (d && d.error ? d.error : 'unbekannter Fehler')); return; }
         currentProtokoll = d.protokoll;
+        ausgewaehlterPunkt = (auswahlPos >= 0 && currentProtokoll.punkte[auswahlPos]) || null;
         renderProtokollDetail();
         ladeProtokollListe();
       })
@@ -753,6 +1010,12 @@
       });
   };
 
+  // Die Rückmeldung der Formatierungsleiste (hervorgehoben + "✓ Markiert"
+  // sobald Text ausgewählt ist, sonst blass + "Erst Text markieren") ist ein
+  // gemeinsamer, dokumentweiter Lauscher in js/utils.js geworden (gilt jetzt
+  // auch für den Board-Kommentar) — hier war er ursprünglich fest auf den
+  // Protokoll-Schreibbereich zugeschnitten.
+
   // renderPlanProtokolle: zentrale Render-Funktion, von showPlanSection()
   // (plan-sections.js) beim Wechsel in den Bereich aufgerufen — zeigt je
   // nach Zustand Liste oder Detail (rendert dabei nichts neu, nur aus dem
diff --git a/public/js/plan/plan-sections.js b/public/js/plan/plan-sections.js
index 96e2427..5a4587e 100644
--- a/public/js/plan/plan-sections.js
+++ b/public/js/plan/plan-sections.js
@@ -3,8 +3,8 @@
 // -----------------------------
 // Der Projektbereich ist der EIGENE BEREICH eines Projekts — seit dem Umbau
 // kein eigenes Dokument mehr, sondern der Bereich #plan der Hauptseite
-// Test.html. Er gliedert sich in sieben Unterbereiche, zwischen denen die
-// Leiste .plan-nav umschaltet (Markup in Test.html):
+// App.html. Er gliedert sich in sieben Unterbereiche, zwischen denen die
+// Leiste .plan-nav umschaltet (Markup in App.html):
 //
 //   dashboard      — Kennzahlen, Sitzungskommentar, Leistungsphasen-
 //                    Fortschritt, nächste Termine, Team, Kompakt-Karten
@@ -35,7 +35,7 @@
 
   // PLAN_SECTIONS: gültige Bereichsschlüssel in der Reihenfolge der
   // Navigationsleiste. Muss zu den data-section-Attributen in
-  // Test.html passen.
+  // App.html passen.
   const PLAN_SECTIONS = ['dashboard', 'terminplan', 'aufgaben', 'leistung', 'dateien', 'protokolle', 'einstellungen'];
 
   // showPlanSection: schaltet auf einen Bereich um, hebt den zugehörigen
diff --git a/public/js/plan/plan-state.js b/public/js/plan/plan-state.js
index b113434..a9e4c09 100644
--- a/public/js/plan/plan-state.js
+++ b/public/js/plan/plan-state.js
@@ -1,23 +1,38 @@
 // -----------------------------
-// Projektplan — Zustand, Initialisierung & Daten laden
+// Projektbereich — Zustand, Einstieg & Projektauswahl
 // -----------------------------
-// Dieses Modul wird als erstes der plan-*-Module von public/project-plan.html
-// geladen und definiert window.PlanApp als gemeinsamen Zustand aller
-// Projektplan-Module. Es liest die URL-Route (Abteilung + Projektname, z. B.
-// "/HLS/Projektplan/Gymnasium%20Hemer") und die URL-Parameter (weekLabel,
-// projNr), über die das zu bearbeitende Projekt adressiert wird.
-// Nach DOMContentLoaded werden Theme, Toolbar-Buttons und die Sitzungsdaten
-// über die Server-API geladen. Die hier definierten Funktionen (savePlan,
-// isLocked, showToast u. a.) werden über app.* den anderen plan-Modulen
-// bereitgestellt, die alle in einem IIFE mit window.PlanApp laufen.
+// Dieses Modul wird als erstes der plan-*-Module von public/App.html geladen
+// und definiert window.PlanApp als gemeinsamen Zustand aller Module des
+// Projektbereichs.
+//
+// WICHTIG — geändert gegenüber der früheren Fassung: Der Projektbereich war
+// einmal eine eigene Seite (public/project-plan.html) mit eigenem
+// Einstiegspunkt. Sie las Sitzung und Projekt aus der URL und lud sich ihren
+// Datenbestand über GET /load-all selbst. Beides ist entfallen: Der
+// Projektbereich ist jetzt ein Bereich der Hauptseite (#plan in App.html),
+// der über showTab('plan') eingeblendet wird wie jeder andere. Er arbeitet
+// deshalb auf dem bereits geladenen In-Memory-Bestand db.weeks (js/store.js)
+// und braucht weder einen eigenen Ladevorgang noch eine eigene
+// Anmeldeprüfung.
+//
+// Einstieg sind zwei Schritte: setPlanTarget(weekLabel, projNr, projName)
+// merkt sich das Ziel, openPlanView() sucht es in db.weeks und rendert den
+// Bereich. Getrennt sind sie, weil showTab('plan') (js/tabs-auth.js) aus dem
+// Ziel zuerst die Adresszeile schreibt und den Bereich einblendet — das GANTT
+// kann sich erst vermessen, wenn sein Container sichtbar ist. Gesetzt wird
+// das Ziel von openProjectPlan() (js/gantt.js) und beim Seitenstart aus einem
+// Deep-Link "/Projektplan/<Projektname>?weekLabel=…&projNr=…"
+// (applyUrlRoute() in js/ui.js, ausgewertet in js/init.js).
+// Die hier definierten Funktionen (savePlan, isLocked, showToast u. a.)
+// stellen sich über app.* den anderen plan-Modulen bereit, die alle in einem
+// IIFE mit window.PlanApp laufen.
 
-// PlanApp: gemeinsamer, modulübergreifender Zustand der Projektplan-Seite.
+// PlanApp: gemeinsamer, modulübergreifender Zustand des Projektbereichs.
 window.PlanApp = {
-  params: new URLSearchParams(location.search),
-  department: '',
   weekLabel: '',
   projNr: '',
   projName: '',
+  sandboxPlanId: '',    // gesetzt von openSandboxPlan() — Sandbox-Pläne werden über id adressiert, nicht über nr/name
   week: null,          // planWeek
   project: null,       // planProject
   pxPerDay: 14,        // Zoomstufe GANTT (null = an Containerbreite anpassen)
@@ -34,88 +49,117 @@ window.PlanApp = {
 
 (function(){
   const app = window.PlanApp;
-  // Abteilung und Projektname aus dem Deep-Link-Pfad
-  // "/<Abteilung>/Projektplan/<Projektname>" lesen. Fallback auf die früheren
-  // Query-Parameter ?department=/&projName= für alte project-plan.html-Links.
-  const routeMatch = window.location.pathname.match(/^\/([^/]+)\/(?:Projektplan|project-plan\.html)(?:\/(.+))?\/?$/);
-  app.department = routeMatch ? routeMatch[1] : (app.params.get('department') || 'ELT');
-  app.weekLabel = app.params.get('weekLabel');
-  app.projNr = app.params.get('projNr') || '';
-  let projNameFromRoute = '';
-  if(routeMatch && routeMatch[2]){
-    try { projNameFromRoute = decodeURIComponent(routeMatch[2]); }
-    catch(e) { projNameFromRoute = app.params.get('projName') || ''; }
-  }
-  app.projName = projNameFromRoute || (app.params.get('projName') || '');
 
-  // init: Einstiegspunkt nach DOMContentLoaded. Übernimmt das Theme aus
-  // localStorage/System, prüft die URL-Parameter und bricht mit Fehlermeldung
-  // ab, falls kein Projekt ausgewählt wurde. Sonst bindet es die Toolbar und
-  // startet das Laden der Daten.
-  function init(){
-    loadTheme(); // Theme aus localStorage / System übernehmen
-    if(!app.weekLabel || !app.projName){
-      document.getElementById('planTitle').textContent = 'Fehler';
-      document.getElementById('planSubtitle').textContent = 'Kein Projekt ausgewählt.';
-      return;
+  // planFail: zeigt einen Fehler in der Kopfzeile des Projektbereichs an und
+  // blendet die Bereichsleiste aus, weil ohne Projekt jeder Unterbereich nur
+  // in eine leere Maske führte. Parameter: title, subtitle (Strings).
+  function planFail(title, subtitle){
+    const t = document.getElementById('planTitle');
+    const sub = document.getElementById('planSubtitle');
+    if(t) t.textContent = title;
+    if(sub) sub.textContent = subtitle;
+    const badge = document.getElementById('planIdBadge');
+    if(badge) badge.textContent = '';
+    app.project = null;
+    app.hidePlanNav();
+  }
+
+  // setPlanTarget: merkt sich, welches Projekt der Bereich zeigen soll —
+  // adressiert über Sitzungs-Label und Projekt-Nr./-Bezeichnung, NICHT über
+  // project.id, die beim Duplizieren einer Sitzung (cloneWeek(), js/weeks.js)
+  // neu vergeben wird. Bewusst getrennt vom Rendern: showTab('plan')
+  // (js/tabs-auth.js) schreibt aus diesen Werten zuerst die Adresszeile und
+  // blendet den Bereich ein, und erst der sichtbare Bereich lässt sich
+  // vermessen — das GANTT braucht die Containerbreite. Parameter:
+  // weekLabel, projNr, projName (Strings). Keine Rückgabe.
+  window.setPlanTarget = function(weekLabel, projNr, projName){
+    app.weekLabel = weekLabel || '';
+    app.projNr = projNr || '';
+    app.projName = projName || '';
+    app.sandboxPlanId = '';
+  };
+
+  // openSandboxPlan: das Gegenstück zu setPlanTarget()+showTab('plan') für
+  // einen Terminplan der Planung-Sandbox (js/planung/planung.js). Sandbox-
+  // Pläne haben keine Projektnummer und werden nie geklont (cloneWeek()
+  // betrifft nur echte Wochen) — ihre id bleibt also stabil und ist die
+  // einzige verlässliche Adressierung, anders als bei echten Projekten
+  // (dort nr/name, siehe setPlanTarget()). Parameter: planId. Keine Rückgabe.
+  window.openSandboxPlan = function(planId){
+    app.weekLabel = SANDBOX_WEEK_LABEL;
+    app.projNr = '';
+    app.projName = '';
+    app.sandboxPlanId = planId || '';
+    showTab('plan');
+  };
+
+  // openPlanView: sucht Sitzung und Projekt im bereits geladenen Bestand
+  // db.weeks (js/store.js) und rendert den Bereich. Einen eigenen
+  // Ladevorgang gibt es nicht mehr — der Projektbereich teilt sich den
+  // Datenbestand mit allen anderen Bereichen der Seite. Wird von
+  // showTab('plan') gerufen (und von dort aus auch nach jedem erneuten
+  // Laden, siehe load() in js/store.js). Rückgabe: true, wenn das Projekt
+  // gefunden und gerendert wurde.
+  window.openPlanView = function(){
+    app.showPlanNav();
+
+    // Planung-Sandbox: eigener, einfacherer Zweig — eine feste, reservierte
+    // "Sitzung" (db.sandboxWeek, nie Teil von db.weeks, siehe js/store.js)
+    // und Adressierung über die stabile Plan-id statt über nr/name.
+    if(app.weekLabel === SANDBOX_WEEK_LABEL){
+      if(!app.sandboxPlanId){
+        planFail('Kein Terminplan gewählt', 'Diesen Bereich öffnet ein Klick auf einen Terminplan im Bereich „Planung".');
+        return false;
+      }
+      app.week = db.sandboxWeek || null;
+      app.project = (app.week && Array.isArray(app.week.projects))
+        ? app.week.projects.find(p => p.id === app.sandboxPlanId) || null
+        : null;
+      if(!app.project){
+        planFail('Nicht gefunden', 'Dieser Terminplan wurde nicht gefunden — er wurde möglicherweise gelöscht.');
+        return false;
+      }
+      app.projNr = '';
+      app.projName = app.project.name || '';
+      renderPlanPage();
+      return true;
     }
-    currentDepartment = app.department; // global aus globals.js
-    bindToolbarButtons();
-    loadPlanData();
-  }
 
-  // bindToolbarButtons: verbindet die Toolbar-Buttons (TODO hinzufügen,
-  // Auto-Schedule, Kritischer Pfad) mit ihren globalen Funktionen der
-  // anderen plan-Module. Die Buttons binden ihre Handler bereits über das
-  // onclick-Attribut in project-plan.html; hier werden nur Lücken gefüllt,
-  // falls ein Button-Element fehlt.
-  function bindToolbarButtons(){
-  }
-
-  // loadPlanData: lädt alle Sitzungen und die globale Personenliste der
-  // Abteilung über die Server-API (JSON-Dokumente), sortiert die Wochen
-  // chronologisch und sucht daraus die Ziel-Woche bzw. das Ziel-Projekt. Zeigt
-  // Fehlermeldungen der Reihenfolge nach im Seitenkopf an und startet sonst
-  // renderPlanPage().
-  function loadPlanData(){
-    if(!window.fetch){
-      document.getElementById('planSubtitle').textContent = 'Netzwerk nicht verfügbar.';
-      return;
+    if(!app.weekLabel || (!app.projNr && !app.projName)){
+      planFail('Kein Projekt gewählt', 'Diesen Bereich öffnet ein Klick auf ein Projekt im Projektboard oder im Tab „Projekte".');
+      return false;
     }
-    const url = baseUrl() + '/load-all?department=' + encodeURIComponent(app.department);
-    fetch(url)
-      .then(r => { if(!r.ok) throw new Error('Server HTTP '+r.status); return r.json(); })
-      .then(data => {
-        db = { weeks: [], currentWeek: null, globalPeople: {} };
-        db.globalPeople[app.department] = Array.isArray(data.people) ? data.people : [];
-        db.weeks = (Array.isArray(data.weeks) ? data.weeks : [])
-          .filter(w => w && typeof w.label === 'string')
-          .map(w => {
-            if(!Array.isArray(w.people)) w.people = [];
-            if(!Array.isArray(w.projects)) w.projects = [];
-            if(!w.attendance) w.attendance = {};
-            return w;
-          });
-        db.weeks.sort((a,b) => weekSortKey(a.label).localeCompare(weekSortKey(b.label)));
-        app.week = db.weeks.find(w => w.label === app.weekLabel);
-        if(!app.week){
-          document.getElementById('planTitle').textContent = 'Nicht gefunden';
-          document.getElementById('planSubtitle').textContent = 'Sitzung "' + esc(app.weekLabel) + '" konnte nicht geladen werden.';
-          return;
-        }
-        app.project = app.week.projects.find(p => (p.nr || '') === app.projNr && (p.name || '') === app.projName);
-        if(!app.project){
-          document.getElementById('planTitle').textContent = 'Nicht gefunden';
-          document.getElementById('planSubtitle').textContent = 'Projekt nicht in dieser Sitzung vorhanden.';
-          return;
-        }
-        renderPlanPage();
-      })
-      .catch(err => {
-        document.getElementById('planTitle').textContent = 'Fehler beim Laden';
-        document.getElementById('planSubtitle').textContent = err.message;
-      });
-  }
+    // Vor dem ersten erfolgreichen load() ist db.weeks noch leer (Deep-Link
+    // direkt auf "/Projektplan/…"). Dann ist das kein Fehler, sondern nur
+    // noch nicht so weit: load() ruft showTab(currentTab) erneut auf.
+    if(!Array.isArray(db.weeks) || db.weeks.length === 0){
+      const t = document.getElementById('planTitle');
+      const sub = document.getElementById('planSubtitle');
+      if(t) t.textContent = app.projName || 'Projektbereich';
+      if(sub) sub.textContent = 'Sitzungsdaten werden geladen…';
+      return false;
+    }
+    app.week = db.weeks.find(w => w.label === app.weekLabel) || null;
+    if(!app.week){
+      planFail('Nicht gefunden', 'Sitzung "' + app.weekLabel + '" konnte nicht geladen werden.');
+      return false;
+    }
+    // Projekt-Nr. ist der stabile Schlüssel; die Bezeichnung dient nur als
+    // Rückfallebene für Projekte, die (noch) keine Nummer haben.
+    const projects = app.week.projects || [];
+    app.project = projects.find(p => (p.nr || '') === app.projNr && (p.name || '') === app.projName)
+      || (app.projNr ? projects.find(p => (p.nr || '') === app.projNr) : null)
+      || projects.find(p => (p.name || '') === app.projName)
+      || null;
+    if(!app.project){
+      planFail('Nicht gefunden', 'Projekt nicht in dieser Sitzung vorhanden.');
+      return false;
+    }
+    app.projNr = app.project.nr || '';
+    app.projName = app.project.name || '';
+    renderPlanPage();
+    return true;
+  };
 
   // ensurePlanLocal: stellt sicher, dass das Plan-Objekt des Projekts die
   // erwartete Struktur hat (inkl. Migration alter Einzel-Abhängigkeiten).
@@ -139,21 +183,98 @@ window.PlanApp = {
     return !!app.week.locked;
   }
 
-  // renderPlanPage: setzt Titel und Untertitel der Seite aus Projekt und Woche,
-  // blendet den Meilenstein-Button bei gesperrter Woche aus und startet die
-  // GANTT-Anzeige über fitPlanGanttRange().
+  // isSandboxPlan: liefert true, wenn der aktuell geöffnete Plan zur
+  // Planung-Sandbox gehört statt zu einem echten Projekt. Zentraler Merker
+  // für alle plan-*-Module, die dort Abschnitte ausblenden, die nur bei
+  // einem echten Projekt Sinn ergeben (Dateien, Leistung, Auftragsstatus,
+  // Projektnummer, Gewerke, Projektgröße, Kommentar/Verlauf — siehe CLAUDE.md
+  // "Planung — projektunabhängige Terminplan-Sandbox"). Rückgabe: Boolescher Wert.
+  function isSandboxPlan(){
+    return !!app.week && app.week.label === SANDBOX_WEEK_LABEL;
+  }
+
+  // renderPlanPage: setzt die kompakte, einzeilige Titelzeile aus Projekt und
+  // Woche (Nr.-Badge, Name, Tags, Sitzungslabel, Beteiligte als
+  // überlappender Avatar-Stapel — siehe renderProjectAssignees()), baut das
+  // Projektinfo-Panel auf (renderPlanInfo(), js/plan/plan-info.js: Status,
+  // Gruppe, amtierende Leistungsphase, LPH-Prozentliste) sowie den
+  // Dateien-Bereich (initPlanFiles(), js/plan/plan-files.js: Upload, Freigabe,
+  // Kommentare) und den Einstellungen-Bereich (renderPlanSettings(),
+  // js/plan/plan-settings.js: Honorar, beauftragte Leistungsphasen), blendet
+  // die Schaltflächen zum Anlegen neuer Aufgaben bei gesperrter Woche aus,
+  // startet die GANTT-Anzeige über fitPlanGanttRange() und schaltet zuletzt
+  // auf den sichtbaren Bereich (app.initPlanSections(), js/plan/plan-sections.js).
   function renderPlanPage(){
     const p = app.project;
     const plan = ensurePlanLocal();
-    document.getElementById('planTitle').textContent = (p.nr ? p.nr + ' – ' : '') + p.name;
-    document.getElementById('planSubtitle').textContent = app.week.label + (app.week.date ? ' · ' + formatWeekDate(app.week.date) : '');
+    const sandbox = isSandboxPlan();
+    const planIdBadge = document.getElementById('planIdBadge');
+    if(planIdBadge) planIdBadge.textContent = p.nr || '';
+    document.getElementById('planTitle').textContent = p.name;
+    // Für die Sandbox NICHT das rohe week.label ("__sandbox__") anzeigen —
+    // das ist ein interner Marker, kein für Nutzer bestimmter Sitzungsname.
+    document.getElementById('planSubtitle').textContent = sandbox
+      ? 'Planung — unabhängig von einem laufenden Projekt'
+      : app.week.label + (app.week.date ? ' · ' + formatWeekDate(app.week.date) : '');
 
-    // GANTT inkl. TODOs
-    const addMilestoneBtn = document.getElementById('addMilestoneBtn');
+    const planPeopleList = document.getElementById('planPeopleList');
+    if(planPeopleList) planPeopleList.innerHTML = renderProjectAssignees();
+
+    const tags = Array.isArray(p.tags) ? p.tags : [];
+    const planTagsList = document.getElementById('planTagsList');
+    if(planTagsList){
+      planTagsList.innerHTML = tags.map(t => `<span class="tag-chip">${esc(t)}</span>`).join('');
+    }
+
+    // Projektinfo-Panel (Status, Gruppe, amtierende Leistungsphase, LPH-
+    // Prozentliste) — siehe js/plan/plan-info.js.
+    renderPlanInfo();
+
+    // Dateien-Bereich (Upload, Freigabe, Kommentare) — siehe js/plan/plan-files.js.
+    initPlanFiles();
+
+    // Protokolle-Bereich (Besprechungsprotokolle) — siehe js/plan/plan-protokoll.js.
+    // Wie initPlanFiles() unbedingt aufgerufen (nicht erst beim Öffnen des
+    // Bereichs), lädt bei vorhandener Projektnummer die Protokollliste.
+    if(typeof initPlanProtokoll === 'function') initPlanProtokoll();
+
+    // Verlauf über alle Sitzungen (Kommentar-Historie) — siehe js/plan/plan-history.js.
+    renderPlanHistory();
+
+    // Einstellungen-Bereich (Honorar, beauftragte Leistungsphasen,
+    // Projektangaben) — siehe js/plan/plan-settings.js.
+    renderPlanSettings();
+
+    // Schaltflächen, die neue Aufgaben/Meilensteine erzeugen — in gesperrten
+    // Sitzungen nicht möglich. Die Liste enthält die Knöpfe beider Bereiche:
+    // Terminplan (…Btn) und Aufgaben (…BtnList), siehe App.html.
     const locked = isLocked();
-    if(addMilestoneBtn) addMilestoneBtn.style.display = locked ? 'none' : '';
+    ['addMilestoneBtn', 'addTodoBtn', 'templateBtn', 'honorarBtn', 'autoScheduleBtn',
+     'addTodoBtnList', 'addMilestoneBtnList', 'templateBtnList', 'honorarBtnList', 'autoScheduleBtnList']
+      .forEach(id => {
+        const btn = document.getElementById(id);
+        if(btn) btn.style.display = locked ? 'none' : '';
+      });
 
+    // "Dateien" (keine Projektnummer, kein sinnvoller Prüf-Workflow),
+    // "Leistung" (echte Abrechnung/Auftragsstatus-abhängig) und "Protokolle"
+    // (hängt wie Dateien an project.nr) ergeben für einen Terminplan ohne
+    // echtes Projekt keinen Sinn — Bereichsknöpfe ausblenden.
+    document.querySelectorAll('#planNav .plan-nav-item[data-section="dateien"], #planNav .plan-nav-item[data-section="leistung"], #planNav .plan-nav-item[data-section="protokolle"]')
+      .forEach(btn => { btn.style.display = sandbox ? 'none' : ''; });
+
+    // Gantt-PDF-Export (js/pdf.js, exportSandboxPlanPDF()) gibt es nur für
+    // Sandbox-Pläne der Planung — ein echtes Projekt hat kein Äquivalent.
+    const sandboxPdfBtn = document.getElementById('sandboxPdfBtn');
+    if(sandboxPdfBtn) sandboxPdfBtn.style.display = sandbox ? '' : 'none';
+
+    // GANTT inkl. TODOs (rendert am Ende auch Aufgabenliste und Dashboard mit)
     fitPlanGanttRange();
+
+    // Sichtbaren Bereich wählen (URL-Fragment, sonst Dashboard) — siehe
+    // js/plan/plan-sections.js. Steht bewusst am Ende: erst wenn alle
+    // Bereiche befüllt sind, wird einer davon eingeblendet.
+    app.initPlanSections();
   }
 
   // Entfernt eine gelöschte ID aus allen dependsOn-Listen (TODOs und Meilensteine)
@@ -166,58 +287,84 @@ window.PlanApp = {
     });
   }
 
-  // Beteiligte des Projekts (Haupt + Optional) mit E-Mail aus der globalen Liste
+  // planRoleClass: Kopie von roleClass() aus js/board/board.js (dort nicht
+  // geladen) — erzeugt dieselben CSS-Klassen wie im Board, damit die
+  // Avatar-Kreise hier dieselben Rollenfarben (.board-avatar in styles.css)
+  // nutzen. Parameter: role (String). Rückgabe: Klassen-String.
+  function planRoleClass(role){
+    return 'role-' + String(role || '').toLowerCase().replace(/\s+/g, '-');
+  }
+
+  // Beteiligte des Projekts (Haupt + Optional) mit E-Mail aus der globalen
+  // Liste, als überlappender Avatar-Stapel für die kompakte Titelzeile
+  // (dieselben Kreise/Farben wie im Projektboard-Detailpanel, siehe
+  // .board-avatar in styles.css). Voller Name + Rolle stehen im Tooltip.
   function renderProjectAssignees(){
     const assignees = projectAssignees(app.project, app.week);
-    if(assignees.length === 0) return '<span class="hint">Keine Zuordnungen im Projektboard.</span>';
+    if(assignees.length === 0) return '';
     return assignees.map(a => {
-      const cls = a.state === 1 ? 'main' : a.state === 2 ? 'optional' : '';
-      return `<span class="todo-assignee ${cls}">${esc(a.person.name)}${a.role ? ' (' + esc(a.role) + ')' : ''}</span>`;
+      const title = (a.person.fullName || a.person.name) + (a.role ? ' · ' + a.role : '');
+      return `<span class="board-avatar ${planRoleClass(a.role)} state-${a.state}" title="${esc(title)}">${esc(a.person.name)}</span>`;
     }).join('');
   }
 
-  // Speichern: nur diese Sitzung; globale Personenliste nicht überschreiben.
-  // In-Flight-Schutz: läuft bereits ein Save, wird kein zweiter POST mit
-  // identischer Revisions-Basis abgeschickt (der würde fälschlich als 409-
-  // Konflikt gemeldet). Stattdessen wird ein Folgesave eingereiht, der nach
-  // Abschluss des laufenden Saves mit der dann frischen Revision nachzieht.
-  let savePlanRunning = false;
-  let savePlanQueued = false;
+  // savePlan: merkt die Sitzung des Projektbereichs als geändert vor und
+  // stößt den gewöhnlichen, entprellten Speicherlauf an (js/store.js).
+  //
+  // Früher schrieb der Projektbereich mit einem eigenen sendWeekToServer()
+  // direkt zum Server, weil er eine eigene Seite war und store.js dort gar
+  // nicht geladen wurde. In einer Seite wären daraus zwei Schreiber auf
+  // dieselbe Sitzung geworden: beide senden dieselbe Revisions-Basis, und der
+  // langsamere bekäme einen scheinbaren 409-Konflikt gemeldet. Deshalb geht
+  // jetzt auch der Projektbereich durch syncAllToServer() — mitsamt dessen
+  // In-Flight-Schutz, Wiederholung nach Netzfehlern, Konfliktbehandlung und
+  // Anmelde-Prüfung. markWeekDirty() bekommt bewusst app.week.label statt
+  // save() zu rufen: save() markiert die AKTUELL gewählte Sitzung, und ein
+  // Deep-Link kann den Projektbereich auf eine andere gestellt haben.
   function savePlan(){
     if(!app.week || !app.project) return;
-    if(savePlanRunning){ savePlanQueued = true; return; }
-    savePlanRunning = true;
-    sendWeekToServer(app.week)
-      .then(res => {
-        // Lokale Revisions-Basis aktualisieren, damit spätere eigene Saves
-        // nicht fälschlich als Konflikt gemeldet werden.
-        if(res && res.updatedAt) app.week.updatedAt = res.updatedAt;
-      })
-      .catch(err => {
-        if(err && err.conflict){
-          showToast('Konflikt: Die Sitzung wurde zwischenzeitlich geändert. Bitte Seite neu laden.');
-          console.error('Speichern fehlgeschlagen (Konflikt):', err.message || err);
-        } else {
-          console.error('Speichern fehlgeschlagen:', err);
-        }
-      })
-      .finally(() => {
-        savePlanRunning = false;
-        if(savePlanQueued){ savePlanQueued = false; savePlan(); }
-      });
+    markWeekDirty(app.week.label);
+    scheduleSessionSync();
   }
 
-  // saveGlobalPeople: schreibt die globale Personenliste der Abteilung als
-  // JSON-Array auf den Server. Auch eine leere Liste wird gespeichert, damit
-  // das Löschen der letzten Person erhalten bleibt.
-  function saveGlobalPeople(){
-    const people = db.globalPeople[app.department] || [];
-    sendPeopleToServer(people).catch(err => console.error('Speichern Personen fehlgeschlagen:', err));
+  // userIdByPersonIdPromise: Cache der Zuordnung Person-ID (String, z. B.
+  // "p_max_mustermann") -> numerische users.id. Seit der Ablösung von
+  // people/person_roles/person_absences gibt es keinen /save-people-Schreibpfad
+  // mehr; Abwesenheiten werden direkt gegen /users/:id/absences geschrieben
+  // (siehe plan-modals.js/plan-drag.js), wofür die numerische User-ID benötigt
+  // wird. Lazy geladen über GET /users (liefert seit Phase 1 auch personId)
+  // und für die Lebensdauer der Seite zwischengespeichert.
+  let userIdByPersonIdPromise = null;
+  function loadUserIdByPersonId(){
+    if(!userIdByPersonIdPromise){
+      userIdByPersonIdPromise = fetch(baseUrl() + '/users')
+        .then(r => { if(!r.ok) throw new Error('Server HTTP '+r.status); return r.json(); })
+        .then(data => {
+          const map = {};
+          (Array.isArray(data.users) ? data.users : []).forEach(u => {
+            if(u.personId) map[u.personId] = u.id;
+          });
+          return map;
+        })
+        .catch(err => {
+          // Cache zurücksetzen, damit ein späterer Aufruf es erneut versucht.
+          userIdByPersonIdPromise = null;
+          throw err;
+        });
+    }
+    return userIdByPersonIdPromise;
+  }
+
+  // getUserIdForPersonId: liefert die numerische users.id für eine Personen-ID
+  // oder null, falls keine passende (aktive) Benutzer-Zuordnung existiert (z. B.
+  // eine Person ohne Login-Konto). Rückgabe: Promise.
+  function getUserIdForPersonId(personId){
+    return loadUserIdByPersonId().then(map => (map && Object.prototype.hasOwnProperty.call(map, personId)) ? map[personId] : null);
   }
 
   // Person in der globalen Liste finden (dort werden Abwesenheiten gepflegt)
   function findGlobalPerson(personId){
-    return (db.globalPeople[app.department] || []).find(p => p.id === personId) || null;
+    return (db.globalPeople || []).find(p => p.id === personId) || null;
   }
 
   // countPersonAbsences: zählt die Abwesenheiten einer Person anhand der
@@ -247,14 +394,13 @@ window.PlanApp = {
   // (plan-drag, plan-modals, plan-schedule) sie direkt nutzen können.
   app.ensurePlanLocal = ensurePlanLocal;
   app.isLocked = isLocked;
+  app.isSandboxPlan = isSandboxPlan;
   app.removeDependencyRefs = removeDependencyRefs;
   app.renderProjectAssignees = renderProjectAssignees;
+  app.planRoleClass = planRoleClass;
   app.savePlan = savePlan;
-  app.saveGlobalPeople = saveGlobalPeople;
+  app.getUserIdForPersonId = getUserIdForPersonId;
   app.findGlobalPerson = findGlobalPerson;
   app.countPersonAbsences = countPersonAbsences;
   app.showToast = showToast;
-
-  // Seitenstart: erst initialisieren, wenn das DOM geladen ist
-  document.addEventListener('DOMContentLoaded', init);
 })();
\ No newline at end of file
diff --git a/public/js/projects/projects.js b/public/js/projects/projects.js
index 668f299..1a799ba 100644
--- a/public/js/projects/projects.js
+++ b/public/js/projects/projects.js
@@ -1,15 +1,27 @@
 // -----------------------------
-// Projektübersicht — Projekte (Listen-Ansicht)
+// Projektübersicht — Projektliste (Ablage-Logik)
 // -----------------------------
-// Diese Datei rendert den Projekte-Tab (Tab "Projekte" in `Test.html`) als
-// sortierbare Listenansicht: Projekte werden nach Gruppe ("Aktive Projekte",
-// "Kleine Projekte" usw.) gruppiert, inline bearbeitbar und per
-// Drag-and-Drop umsortiert. Sie wird von `Test.html` nach `js/people/people.js`
-// (vor `js/load/load.js`) geladen und stellt globale Funktionen wie
-// `renderProjects()`, `editProjectField()`, `editProjectActiveLP()` sowie die
-// Drag-and-Drop-Handler und die Sortier-Hilfe `getDragAfterElement()` bereit.
-// Letztere wird auch von `js/people/people.js` (Personen-Sortierung) genutzt;
-// `renderBoard()` aus `js/board/board.js` wird nach Änderungen aktualisiert.
+// Der eigene Tab "Projekte" ist entfallen. Er listete dieselben Projekte ein
+// zweites Mal auf und ließ dieselben Angaben — Nummer, Bezeichnung, Gruppe,
+// amtierende Leistungsphase, Schlagwörter, Aufwand — ein zweites Mal
+// bearbeiten. Diese Angaben haben ihren einen Ort jetzt im Projektbereich
+// (js/plan/plan-settings.js, js/plan/plan-info.js); die Liste selbst ist im
+// Projektboard aufgegangen (renderBoard(), js/board/board.js).
+//
+// Was hier bleibt, betrifft die LISTE, nicht die einzelnen Angaben:
+//
+//   * delProjectFromList()  — Projekt aus der Sitzung löschen
+//   * die Drag-and-Drop-Handler + reorderProjects() — Reihenfolge innerhalb
+//     einer Gruppe und Wechsel zwischen Gruppen. Das Board spannt dieselbe
+//     Ablagefläche auf (.projects-sortable mit data-group), damit diese
+//     Handler unverändert weiterarbeiten.
+//   * getDragAfterElement() — Sortier-Hilfe, auch von js/people/people.js
+//     genutzt
+//
+// editProjectField()/editProjectActiveLP()/addProjectTag()/removeProjectTag()
+// stehen weiterhin bereit: Der Beauftragungs-Dialog und die Auslastungs-Maske
+// rufen sie auf. renderProjects() rendert nur noch, wenn ein Element
+// #projectsList vorhanden ist — sonst übernimmt renderBoard().
 
 // delProjectFromList: löscht ein Projekt (per Bestätigungsdialog) in der
 // Listen-Ansicht. Parameter `id`: Projekt-ID. Keine Rückgabe; bei gesperrter
@@ -55,16 +67,67 @@ function editProjectActiveLP(id, value){
   save(); renderProjects(); renderBoard(); renderLoad();
 }
 
+// addProjectTag: fügt dem Projekt einen neuen Tag hinzu (getrimmt, nicht
+// leer, keine exakten Duplikate). Initialisiert `p.tags`, falls es fehlt
+// oder kein Array ist. Parameter: `projectId`, `tag` (roher Eingabetext).
+// Keine Rückgabe; bei gesperrter Sitzung abgebrochen.
+function addProjectTag(projectId, tag){
+  if(guardWeekLocked()) return;
+  const val = String(tag || '').trim();
+  if(!val) return;
+  const w = currentWeek();
+  const p = w.projects.find(x=>x.id===projectId);
+  if(!p) return;
+  if(!Array.isArray(p.tags)) p.tags = [];
+  if(p.tags.includes(val)) return;
+  p.tags.push(val);
+  save(); renderProjects(); renderBoard();
+}
+
+// removeProjectTag: entfernt einen Tag aus dem Projekt (exakter Textvergleich).
+// Parameter: `projectId`, `tag`. Keine Rückgabe; bei gesperrter Sitzung
+// abgebrochen.
+function removeProjectTag(projectId, tag){
+  if(guardWeekLocked()) return;
+  const w = currentWeek();
+  const p = w.projects.find(x=>x.id===projectId);
+  if(!p) return;
+  p.tags = (Array.isArray(p.tags) ? p.tags : []).filter(t => t !== tag);
+  save(); renderProjects(); renderBoard();
+}
+
+// handleProjectTagKeydown: fügt bei Enter oder Komma im Tag-Eingabefeld den
+// aktuellen Feldinhalt als neuen Tag hinzu (das Eingabefeld wird ohnehin
+// beim anschließenden renderProjects() frisch/leer neu aufgebaut). Parameter:
+// `event` (KeyboardEvent), `projectId`. Keine Rückgabe.
+function handleProjectTagKeydown(event, projectId){
+  if(event.key !== 'Enter' && event.key !== ','){
+    return;
+  }
+  event.preventDefault();
+  addProjectTag(projectId, event.target.value);
+}
+
 // renderProjects: baut die HTML-Liste der Projekte auf, gruppiert nach `group`
 // und sortiert je Gruppe nach `order`. Jedes Projekt erhält Felder für Nr.,
 // Name, Gruppe, aktive LP sowie Drag-and-Drop-Handler. Keine Parameter, keine
 // Rückgabe.
 function renderProjects(){
+  // Ohne #projectsList gibt es den eigenen Projekte-Bereich nicht mehr — die
+  // Liste steht im Projektboard. Der Aufruf bleibt dennoch überall stehen
+  // (renderAll(), editProjectField(), …), damit kein Pfad ins Leere greift.
+  const listEl = document.getElementById('projectsList');
+  if(!listEl) return;
   const w = currentWeek();
   if(!w) return;
   const locked = isWeekLocked(w);
   let html="";
   const groups = {};
+  // Alle Standardgruppen vorbelegen: Ohne das entsteht für eine leer geräumte
+  // Gruppe weder Überschrift noch Ablagefläche — ein Projekt ließ sich dann
+  // nur noch über das Auswahlfeld zurückverschieben, und der Hinweis
+  // "Keine Projekte." unten war toter Code.
+  ['Aktive Projekte','Kleine Projekte','In Anbahnung','Allgemein'].forEach(g => { groups[g] = []; });
   w.projects.forEach(p=>{ (groups[p.group]||(groups[p.group]=[])).push(p); });
   Object.keys(groups).forEach(g=>{
     groups[g].sort((a,b)=>(a.order||0)-(b.order||0));
@@ -74,28 +137,37 @@ function renderProjects(){
     html += `<div class="section-title">${esc(g)}</div>`;
     html += `<div class="projects-sortable" data-group="${g}" ${locked ? '' : 'ondragover="handleDragOver(event)" ondrop="handleDrop(event)"'}>`;
     groups[g].forEach(p=>{
-      html += `<div class="person-list-item" ${locked ? '' : 'draggable="true" ondragstart="handleDragStart(event)" ondragend="handleDragEnd(event)"'} data-project-id="${p.id}">
-        ${locked ? '' : `<span class="drag-handle" style="cursor:grab;color:#999;margin-right:8px">⋮⋮</span>`}
-        <input type="text" value="${esc(p.nr)}" onchange="editProjectField('${p.id}','nr',this.value)" style="width:100px" placeholder="Proj-Nr">
-        <input type="text" value="${esc(p.name)}" onchange="editProjectField('${p.id}','name',this.value)" style="width:200px" placeholder="Bezeichnung">
-        <select onchange="editProjectField('${p.id}','group',this.value)">
+      const tags = Array.isArray(p.tags) ? p.tags : [];
+      html += `<div class="person-list-item project-item" ${locked ? '' : 'draggable="true" ondragstart="handleDragStart(event)" ondragend="handleDragEnd(event)"'} data-project-id="${p.id}">
+        ${locked ? '' : `<span class="drag-handle" style="cursor:grab;color:#999">${icon('grip')}</span>`}
+        <input type="text" value="${esc(p.nr)}" onchange="editProjectField('${p.id}','nr',this.value)" style="width:100px" placeholder="Proj-Nr" ${locked ? 'disabled' : ''}>
+        <input type="text" value="${esc(p.name)}" onchange="editProjectField('${p.id}','name',this.value)" style="width:200px" placeholder="Bezeichnung" ${locked ? 'disabled' : ''}>
+        <select onchange="editProjectField('${p.id}','group',this.value)" ${locked ? 'disabled' : ''}>
           <option ${p.group==='Aktive Projekte'?'selected':''}>Aktive Projekte</option>
           <option ${p.group==='Kleine Projekte'?'selected':''}>Kleine Projekte</option>
           <option ${p.group==='In Anbahnung'?'selected':''}>In Anbahnung</option>
           <option ${p.group==='Allgemein'?'selected':''}>Allgemein</option>
         </select>
-        <select onchange="editProjectActiveLP('${p.id}',this.value)" title="Aktive Leistungsphase wählen">
+        <select onchange="editProjectActiveLP('${p.id}',this.value)" title="Aktive Leistungsphase wählen" ${locked ? 'disabled' : ''}>
           <option value="" ${lpActiveList(p).length===0?'selected':''}>Aktive LP: keine</option>
           ${AUFWAND_LPS.map(l => `<option value="${l}" ${lpActiveList(p)[0]===l?'selected':''}>${l}</option>`).join('')}
         </select>
-        <button class="secondary small" onclick="openLpModal('${p.id}')">✎ LP-Aufwand</button>
-        <button class="danger small" onclick="delProjectFromList('${p.id}')">Löschen</button>
+        <div class="project-tags-row">
+          <div class="tag-chip-list">
+            ${tags.map(tag => `<span class="tag-chip" data-tag="${esc(tag)}">${esc(tag)}${locked ? '' : ` <span class="tag-remove" title="Tag entfernen" onclick="removeProjectTag('${p.id}', this.closest('.tag-chip').dataset.tag)">×</span>`}</span>`).join('')}
+          </div>
+          ${locked ? '' : `<input type="text" class="tag-input" placeholder="+ Tag" onkeydown="handleProjectTagKeydown(event,'${p.id}')">`}
+        </div>
+        <div class="project-card-footer">
+          <button class="secondary small" onclick="openLpModal('${p.id}')" ${locked ? 'disabled' : ''}>LP-Aufwand</button>
+          <button class="danger small" onclick="delProjectFromList('${p.id}')" ${locked ? 'disabled' : ''}>Löschen</button>
+        </div>
       </div>`;
     });
+    if(groups[g].length===0) html+=`<div class="hint" style="padding:4px 2px 10px">Keine Projekte — Projekt hierher ziehen.</div>`;
     html += `</div>`;
-    if(groups[g].length===0) html+=`<div class="hint">Keine Projekte.</div>`;
   });
-  document.getElementById('projectsList').innerHTML=html;
+  listEl.innerHTML = html;
 }
 
 // Drag-and-Drop Handling für Projekte
@@ -135,7 +207,12 @@ function handleDrop(event){
     sourceSortable.dataset && sortable.dataset &&
     sourceSortable.dataset.group === sortable.dataset.group;
   if(isSameGroup){
-    const afterElement = getDragAfterElement(sortable, event.clientY);
+    // Die Ablagefläche der Projektliste enthält .board-row-Zeilen, der
+    // Personen-/Projekte-Aufbau .person-list-item. getDragAfterElement()
+    // braucht den passenden Selektor, sonst findet es keine Nachbarn und
+    // hängt jedes Projekt ans Gruppenende.
+    const sel = sortable.querySelector('.board-row') ? '.board-row:not([style*="opacity"])' : undefined;
+    const afterElement = getDragAfterElement(sortable, event.clientY, sel);
     if(afterElement == null){
       sortable.appendChild(draggedProject);
     } else {
@@ -151,7 +228,13 @@ function handleDrop(event){
 // handleDragEnd: stellt die Deckkraft der gezogenen Zeile wieder her und
 // setzt `draggedProject` zurück (Ende des Drag-Vorgangs).
 function handleDragEnd(event){
-  event.currentTarget.style.opacity = '1';
+  // Attribut entfernen statt auf 1 setzen: getDragAfterElement() schließt jedes
+  // Element mit style="…opacity…" von der Positionsberechnung aus. Nach einem
+  // abgebrochenen Ziehen (Loslassen außerhalb der Liste) blieb das Attribut
+  // stehen, und die Zeile wurde beim nächsten Ablegen ignoriert — das Projekt
+  // landete dann am Gruppenende statt an der gewünschten Stelle.
+  event.currentTarget.style.removeProperty('opacity');
+  if(event.currentTarget.getAttribute('style') === '') event.currentTarget.removeAttribute('style');
   draggedProject = null;
 }
 
@@ -197,6 +280,8 @@ function reorderProjects(){
     });
   });
   save();
-  renderProjects();
+  // renderProjects() nur, solange der eigene Projekte-Bereich existiert; die
+  // Projektliste im Board rendert renderBoard().
+  if(typeof renderProjects === 'function' && document.getElementById('projectsList')) renderProjects();
   renderBoard();
 }
\ No newline at end of file
diff --git a/public/js/server.js b/public/js/server.js
index e7281a3..9a718c1 100644
--- a/public/js/server.js
+++ b/public/js/server.js
@@ -3,13 +3,16 @@
 // -----------------------------
 // Diese Datei kapselt die HTTP-Kommunikation mit dem Express-Server (siehe
 // server.js im Projekt-Root) und wird nach js/date-picker.js von beiden
-// HTML-Einstiegspunkten geladen. Sie stellt baseUrl, blobToDataUrl,
-// sendWeekToServer, sendPeopleToServer und deleteWeekFromServer bereit.
-// Genutzt wird sie von js/store.js (syncAllToServer, Speichern aller Wochen
-// und der Personenliste), js/weeks.js (Wochen-Löschung) und
-// js/plan/plan-state.js (savePlan schreibt direkt die aktuelle Woche über
-// sendWeekToServer). Die Daten werden als strukturierte JSON-Objekte an die
-// SQLite-API des Servers übergeben (keine CSV-Strings mehr).
+// HTML-Einstiegspunkten geladen. Sie stellt baseUrl,
+// sendWeekToServer und deleteWeekFromServer bereit. Genutzt wird sie von
+// js/store.js (syncAllToServer, Speichern aller Wochen), js/weeks.js
+// (Wochen-Löschung) und js/plan/plan-state.js (savePlan schreibt direkt die
+// aktuelle Woche über sendWeekToServer). Die Daten werden als strukturierte
+// JSON-Objekte an die SQLite-API des Servers übergeben (keine CSV-Strings
+// mehr). Die globale Personenliste hat seit der Ablösung von
+// people/person_roles/person_absences keinen eigenen Schreibpfad mehr
+// (Projektbeteiligte werden über die Benutzerverwaltung gepflegt, siehe
+// /admin/users bzw. /users/:id/absences).
 
 // baseUrl: dynamische Server-URL, damit die App auch von anderen Geraeten im Netzwerk erreichbar ist.
 // Fallback auf localhost:3003, wenn die Seite als lokale Datei geladen wurde.
@@ -22,17 +25,6 @@ function baseUrl(){
   return 'http://localhost:3003';
 }
 
-// blobToDataUrl: liest einen Blob als Data-URL ein (z. B. für Bilddaten)
-// Parameter: blob (Blob). Rückgabe: Promise, das die Data-URL auflöst.
-function blobToDataUrl(blob){
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onloadend = () => resolve(reader.result);
-    reader.onerror = reject;
-    reader.readAsDataURL(blob);
-  });
-}
-
 // sendWeekToServer: POSTet ein komplettes Wochen-Objekt (JSON) an
 // <baseUrl>/save-week. Parameter: week (Objekt). Rückgabe: Promise mit
 // Server-Antwort. `baseUpdatedAt` übermittelt die Revision, auf der die
@@ -46,7 +38,6 @@ function sendWeekToServer(week){
     headers:{'Content-Type':'application/json; charset=utf-8'},
     body:JSON.stringify({
       week,
-      department:currentDepartment,
       baseUpdatedAt:(week && week.updatedAt) ? week.updatedAt : undefined
     })
   }).then(r=>{
@@ -59,30 +50,33 @@ function sendWeekToServer(week){
         err.updatedAt = json.updatedAt;
         throw err;
       }
-      throw new Error('Server HTTP '+r.status);
+      const err = new Error((json && json.error) || ('Server HTTP '+r.status));
+      err.status = r.status;
+      err.label = (week && week.label) || '';
+      throw err;
     });
   });
 }
 
-// sendPeopleToServer: POSTet die globale Personenliste einer Abteilung als
-// JSON-Array an <baseUrl>/save-people. Parameter: people (Array).
-// Rückgabe: Promise mit Server-Antwort.
-function sendPeopleToServer(people){
-  if(!window.fetch) return Promise.reject(new Error('fetch nicht verfügbar'));
-  return fetch(baseUrl() + '/save-people',{
-    method:'POST',
-    headers:{'Content-Type':'application/json; charset=utf-8'},
-    body:JSON.stringify({people, department:currentDepartment})
-  }).then(r=>{ if(!r.ok) throw new Error('Server HTTP '+r.status); return r.json(); });
-}
-
 // deleteWeekFromServer: fordert das Löschen einer Woche über POST /delete-week an
 // Parameter: label (String, das Wochen-Label). Rückgabe: Promise mit Server-Antwort.
+// Bei einer Fehler-Antwort (z. B. 403 „Keine Berechtigung“) trägt der geworfene
+// Error zusätzlich `status` (HTTP-Statuscode), damit Aufrufer (js/weeks.js)
+// gezielt darauf reagieren können.
 function deleteWeekFromServer(label){
   if(!window.fetch) return Promise.reject(new Error('fetch nicht verfügbar'));
   return fetch(baseUrl() + '/delete-week', {
     method: 'POST',
     headers: {'Content-Type':'application/json; charset=utf-8'},
-    body: JSON.stringify({ label, department: currentDepartment })
-  }).then(r=>{ if(!r.ok) throw new Error('Server HTTP '+r.status); return r.json(); });
+    body: JSON.stringify({ label })
+  }).then(r=>{
+    if(!r.ok){
+      return r.json().catch(()=>({})).then(json => {
+        const err = new Error((json && json.error) || ('Server HTTP '+r.status));
+        err.status = r.status;
+        throw err;
+      });
+    }
+    return r.json();
+  });
 }
diff --git a/public/js/showmode.js b/public/js/showmode.js
deleted file mode 100644
index b5d8479..0000000
--- a/public/js/showmode.js
+++ /dev/null
@@ -1,170 +0,0 @@
-// -----------------------------
-// Projektübersicht — Show Mode
-// -----------------------------
-// Präsentationsmodus für die Hauptseite (nur von Test.html geladen, nach
-// js/gantt.js, vor js/tabs-auth.js). Er durchläuft automatisch die in
-// SHOW_MODE_SEQUENCE hinterlegten Ansichten (Board und Auslastung) und zeigt
-// sie in einem Vollbild-Overlay. Genutzt werden showTab() aus
-// js/tabs-auth.js, setHeaderCollapsed() aus js/ui.js sowie renderBoard()/
-// renderLoad() aus js/board/board.js/js/load/load.js. Der gesamte Lauf-
-// Zustand liegt in den Modulvariablen am Dateikopf.
-
-// showModeActive: true, solange der Show Mode läuft
-let showModeActive = false;
-// showModeTimer: Timer-Handle für den Wechsel zur nächsten Folie
-let showModeTimer = null;
-// showModeResumeTimer: Timer-Handle für die automatische Fortsetzung nach einer Pause
-let showModeResumeTimer = null;
-// showModePaused: true, wenn der Durchlauf gerade pausiert ist
-let showModePaused = false;
-// showModeOriginal: Tab vor dem Start, wird beim Beenden wiederhergestellt
-let showModeOriginal = { tab: DEFAULT_TAB };
-const SHOW_MODE_SLIDE_DURATION = 10000; // 10 Sekunden pro Slide
-const SHOW_MODE_PAUSE_DURATION = 60000; // 1 Minute Pause
-// SHOW_MODE_SEQUENCE: Reihenfolge der Slides (Ansicht), die zyklisch
-// durchlaufen wird
-const SHOW_MODE_SEQUENCE = [
-  { view: 'board' },
-  { view: 'load' }
-];
-// showModeIndex: Position innerhalb der SHOW_MODE_SEQUENCE
-let showModeIndex = 0;
-
-// startShowMode: startet den Präsentationsmodus (falls nicht schon aktiv):
-// merkt sich Abteilung/Tab, zeigt das Overlay, kollabiert das Menü und beginnt
-// den Slide-Durchlauf. Kein Rückgabewert.
-function startShowMode(){
-  if(showModeActive) return;
-  showModeActive = true;
-  showModePaused = false;
-  showModeOriginal = { tab: currentTab };
-  showModeIndex = 0;
-
-  const overlay = document.getElementById('showModeOverlay');
-  if(overlay) overlay.style.display = 'flex';
-
-  // Menü schließen, falls offen
-  setHeaderCollapsed(true, false);
-
-  showModeNextSlide();
-}
-
-// stopShowMode: beendet den Präsentationsmodus: stoppt alle Timer, verbirgt
-// das Overlay und stellt den Tab des ursprünglichen Zustands wieder her
-// (renderAll danach). Kein Rückgabewert.
-function stopShowMode(){
-  showModeActive = false;
-  showModePaused = false;
-  clearTimeout(showModeTimer);
-  clearTimeout(showModeResumeTimer);
-
-  const overlay = document.getElementById('showModeOverlay');
-  if(overlay) overlay.style.display = 'none';
-
-  // Inhalt leeren: Die Kopie enthält dieselben Element-IDs wie das echte Board
-  // bzw. der Auslastungs-Tab (#boardTable, #loadGrid, #loadScope) und steht im
-  // Dokument VOR ihnen. Blieb sie stehen, trafen renderBoard()/renderLoad()
-  // ab dann die tote Kopie im ausgeblendeten Overlay — die sichtbare Ansicht
-  // fror auf dem Stand vor der Präsentation ein, bis die Seite neu geladen wurde.
-  const content = document.getElementById('showModeContent');
-  if(content) content.innerHTML = '';
-
-  // Ursprünglichen Zustand wiederherstellen.
-  currentTab = showModeOriginal.tab;
-  showTab(currentTab);
-  renderAll();
-}
-
-// pauseShowMode: pausiert den Durchlauf (Anzeige "Pausiert") und startet die
-// automatische Fortsetzung nach SHOW_MODE_PAUSE_DURATION; bei erneutem Aufruf
-// im pausierten Zustand wird sofort fortgesetzt. Kein Rückgabewert.
-function pauseShowMode(){
-  if(!showModeActive) return;
-  if(showModePaused){
-    // bereits pausiert -> sofort fortsetzen
-    resumeShowMode();
-    return;
-  }
-  showModePaused = true;
-  clearTimeout(showModeTimer);
-  clearTimeout(showModeResumeTimer);
-  const pausedEl = document.getElementById('showModePaused');
-  if(pausedEl) pausedEl.style.display = 'block';
-  showModeResumeTimer = setTimeout(() => {
-    if(showModeActive && showModePaused) resumeShowMode();
-  }, SHOW_MODE_PAUSE_DURATION);
-}
-
-// resumeShowMode: setzt einen pausierten Durchlauf fort (Timer aufräumen,
-// Hinweis ausblenden) und zeigt die nächste Folie. Kein Rückgabewert.
-function resumeShowMode(){
-  if(!showModeActive) return;
-  showModePaused = false;
-  clearTimeout(showModeResumeTimer);
-  const pausedEl = document.getElementById('showModePaused');
-  if(pausedEl) pausedEl.style.display = 'none';
-  showModeNextSlide();
-}
-
-// showModeNextSlide: stellt die nächste Folie der SHOW_MODE_SEQUENCE dar:
-// setzt Titel und Ladehinweis und kopiert danach die aktuelle Ansicht ins
-// Overlay. Kein Rückgabewert.
-function showModeNextSlide(){
-  if(!showModeActive || showModePaused) return;
-
-  const slide = SHOW_MODE_SEQUENCE[showModeIndex % SHOW_MODE_SEQUENCE.length];
-  showModeIndex++;
-
-  const titleEl = document.getElementById('showModeTitle');
-  if(titleEl){
-    titleEl.textContent = slide.view === 'load' ? 'Auslastung' : 'Projektboard';
-  }
-
-  // Ladehinweis anzeigen, damit der alte Inhalt nicht kurz sichtbar flackert
-  const content = document.getElementById('showModeContent');
-  if(content){
-    content.innerHTML = '<div class="show-mode-loading">Lädt…</div>';
-  }
-
-  showTab(slide.view);
-  renderAll();
-  requestAnimationFrame(() => {
-    requestAnimationFrame(() => {
-      copyCurrentViewToShowMode();
-      scheduleNextShowModeSlide();
-    });
-  });
-}
-
-// scheduleNextShowModeSlide: plant den Wechsel zur nächsten Folie nach
-// SHOW_MODE_SLIDE_DURATION (außer im pausierten/inaktiven Zustand).
-function scheduleNextShowModeSlide(){
-  if(!showModeActive || showModePaused) return;
-  clearTimeout(showModeTimer);
-  showModeTimer = setTimeout(() => {
-    showModeNextSlide();
-  }, SHOW_MODE_SLIDE_DURATION);
-}
-
-// copyCurrentViewToShowMode: kopiert das gerenderte HTML des aktuellen Tabs
-// (Board oder Auslastung) in das Show-Mode-Overlay; in der Auslastungs-Ansicht
-// werden dabei Titel und Toolbar ausgeblendet. Kein Rückgabewert.
-function copyCurrentViewToShowMode(){
-  const content = document.getElementById('showModeContent');
-  const sourceId = currentTab === 'load' ? 'load' : 'board';
-  const source = document.getElementById(sourceId);
-  if(content && source){
-    content.innerHTML = source.innerHTML;
-    // Im Show Mode sollen in der Auslastung Überschrift und Steuerelemente ausgeblendet werden
-    if(currentTab === 'load'){
-      content.querySelectorAll('.section-title, .toolbar').forEach(el => el.remove());
-    }
-  }
-}
-
-// ESC-Taste beendet den Show Mode (globaler Keydown-Listener).
-document.addEventListener('keydown', function(e){
-  if(showModeActive && e.key === 'Escape'){
-    stopShowMode();
-  }
-});
\ No newline at end of file
diff --git a/public/js/store.js b/public/js/store.js
index c077d03..51fc482 100644
--- a/public/js/store.js
+++ b/public/js/store.js
@@ -1,36 +1,47 @@
 // -----------------------------
-// Projektübersicht — Daten laden, Speichern, Abteilung wechseln
+// Projektübersicht — Daten laden, Speichern
 // -----------------------------
-// Diese Datei bildet die Schnittstelle zum Server: Sie lädt alle Sitzungen
-// beim Start, speichert den kompletten Datenbestand (alle Wochen + globale
-// Personenliste) und verwaltet den Wechsel zwischen Abteilungen (ELT/HLS/ARCH).
-// Die Daten liegen serverseitig in einer SQLite-Datenbank und werden als
-// strukturierte JSON-Objekte über die API ausgetauscht (keine CSV-Strings).
-// Sie wird von `Test.html` nach `js/date-picker.js` und `js/server.js` geladen und stellt
-// die globalen Funktionen `save()`, `syncAllToServer()`, `switchDepartment()`,
-// `load()`, `seed()` und `demoProj()` bereit. Aufrufer sind u.a. `js/weeks.js`,
-// `js/board/board.js`, `js/people/people.js`, `js/projects/projects.js` und `js/load/load.js`; das Speichern
-// ist über `saveSyncTimer` (in `js/globals.js` deklariert) um 500 ms debounced.
+// Diese Datei bildet die Schnittstelle zum Server: Sie lädt beim Start alle
+// (firmenweit globalen, nicht mehr abteilungsgetrennten) Sitzungen und speichert
+// den kompletten Datenbestand (alle Wochen + globale Personenliste). Die Daten
+// liegen serverseitig in einer SQLite-Datenbank und werden als strukturierte
+// JSON-Objekte über die API ausgetauscht (keine CSV-Strings). Sie wird von
+// `App.html` nach `js/date-picker.js` und `js/server.js` geladen und stellt
+// die globalen Funktionen `save()`, `syncAllToServer()`, `load()`, `seed()`
+// und `demoProj()` bereit. Aufrufer sind u.a. `js/weeks.js`, `js/board/board.js`,
+// `js/people/people.js`, `js/projects/projects.js` und `js/load/load.js`; das
+// Speichern ist über `saveSyncTimer` (in `js/globals.js` deklariert) um 500 ms
+// debounced.
 
 // save: plant einen (debounced) Sync. Standardmäßig wird die aktuell gewählte
 // Woche als geändert markiert, da sich die meisten Bearbeitungen auf die
 // aktuelle Sitzung beziehen. Optionen:
 //   { week:false }  – aktuelle Woche NICHT markieren (z. B. reine Personen-Aktionen)
-//   { people:true } – zusätzlich die globale Personenliste als geändert markieren
 function save(opts = {}){
   if(opts.week !== false){
     const w = currentWeek();
-    if(w) dirtyWeeks.add(w.label);
+    if(w) markWeekDirty(w.label);
   }
-  if(opts.people) dirtyPeople = true;
   scheduleSessionSync();
 }
 
-// Dirty-Tracking: merkt sich, welche Wochen bzw. ob die globale Personenliste
-// seit dem letzten Sync lokal geändert wurden. Gespeichert wird nur das, was
-// sich wirklich geändert hat (statt wie früher immer alle Wochen).
+// Dirty-Tracking: merkt sich, welche Wochen seit dem letzten Sync lokal
+// geändert wurden. Gespeichert wird nur das, was sich wirklich geändert hat
+// (statt wie früher immer alle Wochen). Die globale Personenliste hat seit der
+// Ablösung von people/person_roles/person_absences keinen eigenen Schreibpfad
+// mehr (Projektbeteiligte werden über die Benutzerverwaltung gepflegt).
 let dirtyWeeks = new Set();
-let dirtyPeople = false;
+
+// weekChangeCounter: zählt je Woche die Änderungen mit. syncAllToServer merkt
+// sich den Stand beim Absenden und räumt die Dirty-Markierung nur auf, wenn er
+// sich bis zur Antwort nicht verändert hat. Ohne diesen Zähler verlor eine
+// Änderung, die WÄHREND eines laufenden Speichervorgangs entsteht, ihre
+// Markierung: Der eingereihte Nachlauf-Sync fand dann nichts mehr zu senden,
+// und das Getippte stand nur noch im Browser.
+const weekChangeCounter = new Map();
+
+// syncProblemTimer: Wiederholungsversuch nach einem fehlgeschlagenen Speichern.
+let syncProblemTimer = null;
 
 // In-Flight-Schutz für syncAllToServer: läuft bereits ein Sync, wird kein
 // zweiter gestartet (sonst senden zwei Syncs dieselbe Woche mit gleicher
@@ -39,6 +50,37 @@ let dirtyPeople = false;
 let syncInFlight = false;
 let syncQueued = false;
 
+// showSyncProblem: blendet unten rechts ein Band ein, wenn das Speichern
+// fehlschlägt. Vorher stand der Fehler ausschließlich in der Browser-Konsole —
+// der Nutzer arbeitete ahnungslos weiter, während seit Stunden nichts mehr
+// gespeichert wurde. Parameter: message (Text) oder null zum Ausblenden.
+function showSyncProblem(message){
+  let el = document.getElementById('syncProblemBar');
+  if(!message){
+    if(el) el.style.display = 'none';
+    return;
+  }
+  if(!el){
+    el = document.createElement('div');
+    el.id = 'syncProblemBar';
+    el.className = 'sync-problem-bar';
+    document.body.appendChild(el);
+  }
+  el.textContent = message;
+  el.style.display = '';
+}
+
+// scheduleSyncRetry: versucht ein fehlgeschlagenes Speichern nach 20 Sekunden
+// erneut. Ohne das blieb eine Woche nach einem Netzaussetzer dauerhaft
+// ungespeichert, bis der Nutzer zufällig etwas anderes bearbeitete.
+function scheduleSyncRetry(){
+  if(syncProblemTimer || dirtyWeeks.size === 0) return;
+  syncProblemTimer = setTimeout(() => {
+    syncProblemTimer = null;
+    if(dirtyWeeks.size > 0) syncAllToServer();
+  }, 20000);
+}
+
 // scheduleSessionSync: plant den Speichervorgang für alle Wochen und Personen
 // über einen 500-ms-Timer (Debounce). Bei erneutem Aufruf wird ein laufender
 // Timer zurückgesetzt, damit aufeinanderfolgende Änderungen in einem Sync enden.
@@ -48,22 +90,28 @@ function scheduleSessionSync(){
 }
 
 // syncAllToServer: schreibt nur die seit dem letzten Sync geänderten Wochen
-// plus – falls markiert – die globale Personenliste zum Server. Konflikte
-// (409) auf einer Woche werden über handleWeekConflict() gemeldet. Fehlerhaft
-// gespeicherte Wochen bleiben dirty, damit der nächste Sync sie erneut
-// versucht; nur erfolgreich gespeicherte werden aus dem Dirty-Satz entfernt.
+// zum Server. Konflikte (409) auf einer Woche werden über
+// handleWeekConflict() gemeldet. Fehlerhaft gespeicherte Wochen bleiben dirty,
+// damit der nächste Sync sie erneut versucht; nur erfolgreich gespeicherte
+// werden aus dem Dirty-Satz entfernt.
 function syncAllToServer(){
   if(syncInFlight){ syncQueued = true; return; }
   syncInFlight = true;
 
-  // Zuerst globale Personenliste speichern, falls geändert
   const jobs = [];
-  if(dirtyPeople) jobs.push(saveGlobalPeopleToServer());
-
   const weekLabels = Array.from(dirtyWeeks);
+  let problem = '';
   weekLabels.forEach(label => {
-    const w = db.weeks.find(x => x.label === label);
+    // Die Planung-Sandbox steckt bewusst nicht in db.weeks (siehe
+    // db.sandboxWeek, oben in load()) — ohne diesen Zweig würde jede
+    // Sandbox-Änderung hier lautlos verworfen (dirtyWeeks.delete ohne
+    // jemals zu speichern), weil db.weeks.find() sie nie findet.
+    const w = label === SANDBOX_WEEK_LABEL ? db.sandboxWeek : db.weeks.find(x => x.label === label);
     if(!w){ dirtyWeeks.delete(label); return; }
+    // Stand der Änderungen zum Zeitpunkt des Absendens merken (siehe
+    // weekChangeCounter): Nur wenn er bei der Antwort unverändert ist, sind
+    // wirklich alle Änderungen dieser Woche beim Server angekommen.
+    const sentGeneration = weekChangeCounter.get(label) || 0;
     jobs.push(sendWeekToServer(w)
       .then(res => {
         if(res && res.ok){
@@ -71,8 +119,9 @@ function syncAllToServer(){
           // Lokale Revisions-Basis aktualisieren, damit spätere eigene Saves
           // nicht fälschlich als Konflikt gemeldet werden.
           if(res.updatedAt) w.updatedAt = res.updatedAt;
-          dirtyWeeks.delete(label);
+          if((weekChangeCounter.get(label) || 0) === sentGeneration) dirtyWeeks.delete(label);
         } else {
+          problem = 'Sitzung "' + w.label + '" konnte nicht gespeichert werden.';
           console.error('Sitzung konnte nicht gespeichert werden:', w.label, res && res.error ? res.error : 'unbekannter Fehler');
         }
       })
@@ -80,8 +129,15 @@ function syncAllToServer(){
         if(err && err.conflict){
           dirtyWeeks.delete(label);
           handleWeekConflict(w, err);
+        } else if(err && err.status === 401){
+          // Sitzung am Server abgelaufen: Anmeldefenster zeigen, statt still
+          // weiterzuarbeiten und alles Weitere zu verlieren.
+          problem = 'Nicht mehr angemeldet — bitte neu anmelden, sonst gehen Änderungen verloren.';
+          if(typeof showLoginOverlay === 'function') showLoginOverlay();
+          console.error('Speichern abgelehnt (nicht angemeldet):', w.label);
         } else {
-          console.error('Sitzung konnte nicht gespeichert werden:', w.label, err.message || err);
+          problem = 'Speichern fehlgeschlagen (' + (err && err.message ? err.message : 'unbekannt') + ') — neuer Versuch in 20 Sekunden.';
+          console.error('Sitzung konnte nicht gespeichert werden:', w.label, (err && err.message) || err);
           // Label bleibt dirty -> der nächste Sync versucht es erneut.
         }
       }));
@@ -89,6 +145,8 @@ function syncAllToServer(){
 
   Promise.all(jobs).then(() => {
     syncInFlight = false;
+    showSyncProblem(problem || null);
+    if(problem) scheduleSyncRetry();
     if(syncQueued){ syncQueued = false; syncAllToServer(); }
   });
 }
@@ -96,12 +154,9 @@ function syncAllToServer(){
 // markWeekDirty: markiert eine bestimmte Woche (label) als geändert – für
 // Aktionen, die Wochen AUFßER der aktuellen betreffen (z. B. Auto-Lock).
 function markWeekDirty(label){
-  if(typeof label === 'string' && label) dirtyWeeks.add(label);
-}
-
-// markPeopleDirty: markiert die globale Personenliste als geändert.
-function markPeopleDirty(){
-  dirtyPeople = true;
+  if(typeof label !== 'string' || !label) return;
+  dirtyWeeks.add(label);
+  weekChangeCounter.set(label, (weekChangeCounter.get(label) || 0) + 1);
 }
 
 // handleWeekConflict: wird aufgerufen, wenn der Server eine zwischenzeitlich
@@ -117,16 +172,14 @@ function handleWeekConflict(week, err){
   else load();
 }
 
-// reloadWeekFromServer: lädt die aktuelle Abteilung neu und ersetzt NUR die
+// reloadWeekFromServer: lädt alle Sitzungen neu und ersetzt NUR die
 // übergebene Woche (bzw. entfernt sie, falls sie am Server gelöscht wurde).
 // Der Dirty-Zustand der konfliktbehafteten Woche wurde bereits von
 // syncAllToServer entfernt; alle anderen Dirty-Änderungen bleiben erhalten.
 function reloadWeekFromServer(label){
-  const requestedDepartment = currentDepartment;
-  fetch(baseUrl() + '/load-all' + departmentParam())
+  fetch(baseUrl() + '/load-all')
     .then(r => { if(!r.ok) throw new Error('Server HTTP '+r.status); return r.json(); })
     .then(data => {
-      if(currentDepartment !== requestedDepartment) return;
       const fresh = (Array.isArray(data.weeks) ? data.weeks : [])
         .find(w => w && w.label === label);
       const idx = db.weeks.findIndex(w => w.label === label);
@@ -149,93 +202,102 @@ function reloadWeekFromServer(label){
       showTab(currentTab);
     })
     .catch(err => {
+      // KEIN load() als Rückfall: Das leert dirtyWeeks und ersetzt alle Wochen,
+      // also gingen auch die noch ungespeicherten Änderungen an ANDEREN
+      // Sitzungen verloren — genau das, was diese Funktion vermeiden soll.
       console.error('Neu laden der Sitzung fehlgeschlagen:', err);
-      load();
+      showSyncProblem('Die Sitzung "' + label + '" konnte nicht neu geladen werden. Bitte die Seite neu laden.');
     });
 }
 
-// saveGlobalPeopleToServer: speichert die globale Personenliste der aktuellen
-// Abteilung über `sendPeopleToServer()` (JSON-Array). Auch eine leere Liste
-// wird gespeichert, damit das Löschen der letzten Person erhalten bleibt. Bei
-// Erfolg wird der Dirty-Status für Personen zurückgesetzt, bei Fehler bleibt
-// er erhalten (Retry beim nächsten Sync). Rückgabe: Promise.
-function saveGlobalPeopleToServer(){
-  const people = db.globalPeople[currentDepartment] || [];
-  return sendPeopleToServer(people)
-    .then(res => {
-      if(res && res.ok){
-        dirtyPeople = false;
-        console.log('Globale Personenliste gespeichert');
-      } else {
-        console.error('Globale Personenliste konnte nicht gespeichert werden:', res && res.error ? res.error : 'unbekannter Fehler');
-      }
+// load: liest alle Sitzungen und die globale Personenliste über `/load-all`
+// als JSON vom Server und baut daraus `db.weeks` auf. Sortiert nach
+// `weekSortKey()`, wendet `applyAutoLock()` an und rendert die Ansicht. Kein
+// Parameter, keine Rückgabe; bei Fehlern oder fehlenden Daten werden
+// Beispieldaten über `seed()` geladen.
+// loadAppSettings: holt die firmenweiten Einstellungen (GET /app-settings)
+// und die Feiertage (GET /holidays) und legt sie in APP_SETTINGS/HOLIDAYS ab
+// (js/globals.js). Beides wird zum RECHNEN gebraucht — Auslastung, Ampel,
+// Terminplan aus dem Honorar —, deshalb sind die Routen für jedes angemeldete
+// Konto lesbar; nur das Ändern ist Administratoren vorbehalten.
+//
+// Scheitert der Abruf, bleiben die Vorgaben aus js/globals.js stehen. Das ist
+// Absicht: Die Anwendung rechnet dann wie vor dem Ausbau der Einstellungen
+// weiter, statt mit leeren Werten falsche Zahlen zu zeigen.
+// Rückgabe: Promise (wird nie abgelehnt).
+function loadAppSettings(){
+  const settings = fetch(baseUrl() + '/app-settings')
+    .then(r => { if(!r.ok) throw new Error('Server HTTP ' + r.status); return r.json(); })
+    .then(data => { if(data && data.settings) APP_SETTINGS = Object.assign({}, APP_SETTINGS, data.settings); })
+    .catch(err => { console.warn('Firmenweite Einstellungen konnten nicht geladen werden, es gelten die Vorgabewerte:', err); });
+
+  const holidays = fetch(baseUrl() + '/holidays')
+    .then(r => { if(!r.ok) throw new Error('Server HTTP ' + r.status); return r.json(); })
+    .then(data => {
+      const list = Array.isArray(data.holidays) ? data.holidays : [];
+      HOLIDAYS = new Set(list.map(h => h.date));
+      HOLIDAY_NAMES = {};
+      list.forEach(h => { HOLIDAY_NAMES[h.date] = h.name || ''; });
+      // Die Bundesländer liefert dieselbe Route mit (siehe server.js); die
+      // Pflege-Maske im Admin-Bereich baut daraus ihre Auswahl.
+      if(data.states) GERMAN_STATES = data.states;
     })
-    .catch(err => {
-      console.error('Globale Personenliste konnte nicht gespeichert werden:', err.message || err);
-      // dirtyPeople bleibt true -> der nächste Sync versucht es erneut.
-    });
+    .catch(err => { console.warn('Feiertage konnten nicht geladen werden:', err); });
+
+  // Honorar-Anteile je Leistungsphase: Die Auslastung rechnet den offenen
+  // Wert einer Phase in Stunden um und braucht dafür deren Anteil am
+  // Gesamthonorar. Zusammen mit den übrigen Vorgaben geladen, also VOR
+  // /load-all und damit vor dem ersten renderAll().
+  const honorar = fetch(baseUrl() + '/honorar-config')
+    .then(r => { if(!r.ok) throw new Error('Server HTTP ' + r.status); return r.json(); })
+    .then(data => { HONORAR_ANTEILE = (data && data.anteile) || {}; })
+    .catch(err => { console.warn('Honorar-Anteile konnten nicht geladen werden, die Auslastung weist sie als fehlend aus:', err); });
+
+  return Promise.all([settings, holidays, honorar]);
 }
 
-// switchDepartment: wechselt die aktive Abteilung (z.B. "ELT") und lädt deren
-// Daten neu. Parameter `dept` ist der Abteilungsschlüssel aus `DEPARTMENTS`.
-// Aktualisiert Tab-Markierung und Seitentitel und ruft anschließend `load()`.
-// Gibt nichts zurück.
-function switchDepartment(dept){
-  if(!DEPARTMENTS[dept]) return;
-  // Laufenden Speicher-Debounce der alten Abteilung verwerfen, damit dessen
-  // Sync nicht nach dem Reset mit dem neuen currentDepartment feuert und die
-  // Daten der falschen Abteilung schreibt.
-  if(saveSyncTimer){ clearTimeout(saveSyncTimer); saveSyncTimer = null; }
-  dirtyWeeks.clear();
-  dirtyPeople = false;
-  currentDepartment = dept;
-  saveUiState();
-  updateRouteUrl(dept, currentTab);
-
-  // UI-Status der Abteilungs-Tabs aktualisieren
-  document.querySelectorAll('.dept-tab').forEach(btn => {
-    btn.classList.toggle('active', btn.dataset.dept === dept);
-  });
-
-  // Seitentitel anpassen
-  const info = DEPARTMENTS[dept];
-  document.title = 'Projektübersicht ' + info.label;
-  const titleEl = document.getElementById('pageTitle');
-  if(titleEl) titleEl.textContent = info.icon + ' Projektübersicht ' + info.label;
-
-  // Datenbank leeren und neu laden
-  db = { weeks: [], currentWeek: null, globalPeople: db.globalPeople || {} };
-  load();
-}
-
-// load: liest alle Sitzungen und die globale Personenliste der aktuellen
-// Abteilung über `/load-all` als JSON vom Server und baut daraus `db.weeks`
-// auf. Sortiert nach `weekSortKey()`, wendet `applyAutoLock()` an und rendert
-// die Ansicht. Kein Parameter, keine Rückgabe; bei Fehlern oder fehlenden
-// Daten werden Beispieldaten über `seed()` geladen.
-function load(){
+// load: lädt die Sitzungsdaten vom Server neu. Parameter: silent (optional) —
+// true für eine stille Hintergrund-Aktualisierung (js/wand/wand.js, alle 60s):
+// ein Fehlschlag wird nur geloggt statt per alert() gemeldet, und der
+// bisherige Datenstand bleibt stehen statt geleert zu werden. Ohne diesen
+// Zweig stapelten sich auf einem unbeaufsichtigten Touch-Display bei jedem
+// Fehlschlag blockierende alert()-Dialoge übereinander.
+function load(silent){
   // Nach einem (Neu-)Load sind die lokalen Daten serverseitig aktuell:
   // laufenden Debounce abbrechen und Dirty-Zustand verwerfen.
   if(saveSyncTimer){ clearTimeout(saveSyncTimer); saveSyncTimer = null; }
   dirtyWeeks.clear();
-  dirtyPeople = false;
   if(!window.fetch){
     alert('Ihr Browser unterstützt keine Netzwerk-Anfragen. Bitte verwenden Sie einen aktuellen Browser.');
-    seed(); return;
+    return;
   }
-  // Abteilung einfrieren, für die diese Anfrage gestartet wurde. Antworten,
-  // die nach einem zwischenzeitlichen Abteilungswechsel eintreffen, werden
-  // verworfen (Stale-Response), sonst würden Daten der alten Abteilung unter
-  // der neuen Abteilung angezeigt und gespeichert.
-  const requestedDepartment = currentDepartment;
-  const url = baseUrl() + '/load-all' + departmentParam();
+  const url = baseUrl() + '/load-all';
   console.log('Loading from', url);
-  fetch(url)
+  // Erst die firmenweiten Einstellungen und Feiertage, dann die Sitzungen:
+  // renderAll() am Ende rechnet bereits damit (Ampel-Schwellen, Balkenskala,
+  // Aufwandsvorlage, Arbeitstage). loadAppSettings() lehnt nie ab, ein
+  // Fehlschlag lässt also nur die Vorgabewerte stehen.
+  loadAppSettings().then(() => fetch(url)
     .then(r => { if(!r.ok) throw new Error('Server HTTP '+r.status); return r.json(); })
     .then(data => {
-      if(currentDepartment !== requestedDepartment) return;
-      // Globale Personenliste laden
-      db.globalPeople[currentDepartment] = Array.isArray(data.people) ? data.people : [];
+      // Globale Personenliste laden (flaches Array, keine Abteilungstrennung)
+      db.globalPeople = Array.isArray(data.people) ? data.people : [];
+
+      // db.sandboxWeek: die Planung-Sandbox (SANDBOX_WEEK_LABEL) — bewusst
+      // NICHT Teil von db.weeks (siehe /load-all, server.js), sondern ein
+      // eigenes, synthetisches Wochen-ähnliches Objekt, hier und nur hier
+      // aufgebaut. Damit sehen renderBoard()/berichtProjekte()/
+      // berechneAuslastung()/die Sitzungs-PDFs/Admin→Sitzungen sie nie —
+      // sie iterieren alle ausschließlich db.weeks. people wird aus der
+      // globalen Personenliste abgeleitet (dieselbe Form wie week.people),
+      // damit die Beteiligten-Matrix im Projektbereich auch für einen
+      // Sandbox-Plan Kandidaten zur Auswahl hat.
+      db.sandboxWeek = {
+        id: 'sandbox', label: SANDBOX_WEEK_LABEL, date: '',
+        people: db.globalPeople.map(p => ({ id: p.id, name: p.name, fullName: p.fullName })),
+        projects: Array.isArray(data.sandboxPlans) ? data.sandboxPlans : [],
+        attendance: {}, locked: false, updatedAt: data.sandboxUpdatedAt || ''
+      };
 
       db.weeks = (Array.isArray(data.weeks) ? data.weeks : [])
         .filter(w => w && typeof w.label === 'string')
@@ -262,23 +324,29 @@ function load(){
       }
       // Geschützte Tabs ('projects'/'people') dürfen nur mit Passwort angezeigt
       // werden. showTab() öffnet dafür automatisch das Passwort-Modal – auch
-      // wenn der Tab per Deep-Link-URL (z. B. "/ELT/Projekte") gewählt wurde.
+      // wenn der Tab per Deep-Link-URL (z. B. "/Projekte") gewählt wurde.
       renderAll();
       showTab(currentTab);
   })
   .catch(err => {
-    if(currentDepartment !== requestedDepartment) return;
     console.error('Laden vom Server fehlgeschlagen:', err);
+    if(silent) return;
     const serverUrl = baseUrl();
     const msg = 'Server unter ' + serverUrl + ' nicht erreichbar.\n\n' +
                 'Mögliche Ursachen:\n' +
                 '- Der Server wurde nicht gestartet\n' +
                 '- Der Server läuft auf einem anderen Port (Standard: 3003)\n' +
                 '- Firewall/Antivirus blockiert ' + serverUrl + '\n\n' +
-                'Es werden jetzt die Beispieldaten angezeigt.';
+                'Es werden keine Daten angezeigt. Bitte die Seite neu laden, sobald der Server wieder läuft.';
     alert(msg);
-    seed(); renderAll();
-  });
+    // BEWUSST KEIN seed(): Die Beispieldaten enthalten eine Woche "KW 30 / 2026"
+    // und wurden früher über save() an den Server geschickt, sobald die
+    // Verbindung zurückkam — sie überschrieben damit die echte gleichnamige
+    // Sitzung. Bei einem Ladefehler bleibt der Bestand jetzt einfach leer.
+    db.weeks = [];
+    db.currentWeek = null;
+    renderAll();
+  }));
 }
 
 // seed: initialisiert Beispiel-Daten (Personen + eine Woche mit Projekten).
@@ -299,7 +367,7 @@ function seed(){
     {id:personIdForName('MK'), name:"MK", fullName:"Martin Kluge", role:["Bauüberwachung"]},
     {id:personIdForName('HR'), name:"HR", fullName:"Hartwig Rauch", role:["Bauüberwachung"]},
   ];
-  db.globalPeople[currentDepartment] = JSON.parse(JSON.stringify(people));
+  db.globalPeople = JSON.parse(JSON.stringify(people));
 
   const wid = uid();
   db.weeks = [{
@@ -315,7 +383,9 @@ function seed(){
   save();
 }
 
-// demoProj: Helfer zum Erzeugen eines Projekt-Objekts (für seed/Tests)
+// demoProj: Helfer zum Erzeugen eines Projekt-Objekts (für seed/Tests).
+// projectUid: dauerhafte, wochenunabhängige Identität (siehe saveNewProj()
+// in js/load/load.js für die Erklärung, warum sie sich von id unterscheidet).
 function demoProj(nr,name,group,status,lph){
-  return {id:uid(), nr, name, group, status, lph: {...lph}, assign:{}, plan: null, aufwandProLP: undefined, aktuelleLP: undefined};
+  return {id:uid(), projectUid: uid(), nr, name, group, status, lph: {...lph}, assign:{}, plan: null, aufwandProLP: undefined, aktuelleLP: undefined};
 }
\ No newline at end of file
diff --git a/public/js/tabs-auth.js b/public/js/tabs-auth.js
index 35407dc..4afbd57 100644
--- a/public/js/tabs-auth.js
+++ b/public/js/tabs-auth.js
@@ -1,76 +1,109 @@
 // -----------------------------
-// Projektübersicht — Tabs (Navigation) & Passwort-Schutz
+// Projektübersicht — Tabs (Navigation)
 // -----------------------------
-// Modul für die Tab-Navigation und den Passwortschutz der Hauptseite (nur von
-// Test.html geladen, nach js/showmode.js, vor js/pdf.js). showTab() wechselt
-// zwischen Board, Auslastung, Projekte und Projektbeteiligte und fordert für
-// die geschützten Tabs 'projects'/'people' das Passwort an; confirmPassword()
-// prüft den SHA256-Hash gegen PROTECTED_PASSWORD_HASH (js/globals.js). Die
-// ausstehende Aktion wird in requestedAction (js/globals.js) gemerkt – davon
-// profitieren auch die Passwort-Gates in js/weeks.js (Löschen/Entsperren von
-// Sitzungen). Gerendert werden beim Tab-Wechsel renderBoard()/renderLoad()/
-// renderProjects()/renderPeople() aus js/board/board.js, js/load/load.js, js/projects/projects.js,
-// js/people/people.js.
+// Modul für die Tab-Navigation der Hauptseite (nur von App.html geladen, nach
+// js/wand/wand.js, vor js/pdf.js). showTab() wechselt zwischen Board,
+// Wochenbericht, Auslastung, Projekte, Projektbeteiligte, Meine Aufgaben,
+// Wandtafel, Einstellungen, Admin und dem Projektbereich eines einzelnen
+// Projekts ('plan', siehe TAB_PANELS).
+// Einstellungen und Admin sind keine eigenen Tabs mehr, sondern aufklappbare
+// Bereiche direkt in der Seitenleiste (siehe toggleSidebarAccordion() in
+// js/ui.js). Gerendert werden beim Tab-Wechsel renderBoard()/
+// renderWochenbericht()/renderLoad()/renderProjects()/renderPeople()/
+// renderDashboard()/renderWandboard() aus js/board/board.js,
+// js/wochenbericht/wochenbericht.js, js/load/load.js, js/projects/projects.js,
+// js/people/people.js, js/dashboard/dashboard.js, js/wand/wand.js. Der
+// frühere clientseitige Passwortschutz für die Tabs 'projects'/'people' wurde
+// entfernt — der Zugriffsschutz läuft jetzt serverseitig über die Session
+// (siehe js/auth.js, server.js).
+//
+// TAB_PANELS: alle Bereiche der Hauptseite. 'plan' ist der Projektbereich
+// EINES Projekts (#plan) — früher die eigenständige Seite project-plan.html,
+// die in einem eigenen Dokument geöffnet wurde. Seit dem Umbau ist er ein
+// Bereich wie jeder andere: Menüband und Seitenleiste bleiben stehen, der
+// Wechsel dorthin läuft über denselben showTab()-Weg wie der Wechsel vom
+// Dashboard ins Projektboard.
+const TAB_PANELS = ['board','wochenbericht','load','people','planung','dashboard','wand','settings','admin','plan'];
 
-// showTab: wechselt zwischen Ansichten; für sensible Tabs wird ein Passwort verlangt
-function showTab(t, skipAuth = false){
-  // Für die Tabs 'projects' und 'people' ist ein Passwortschutz vorgesehen
-  if((t==='projects' || t==='people') && !skipAuth && !isAuthenticated){
-    requestedAction = { type: 'tab', tab: t };
-    document.getElementById('passwordModal').style.display='flex';
-    document.getElementById('passwordInput').value='';
-    document.getElementById('passwordInput').focus();
-    return;
-  }
+function showTab(t){
+  // Der Bereich „Admin" steht nur Administratoren offen. Ohne diese Weiche
+  // zeigte ein weitergereichter Deep-Link „/Admin" einem Mitglied eine leere
+  // Seite — die Karten darin rendert renderAdminArea() für Nicht-Admins gar
+  // nicht erst. (Ein UI-Gate, mehr nicht: Die Routen dahinter sind
+  // serverseitig mit requireRole('admin') abgesichert.)
+  if(t === 'admin' && !(currentUser && currentUser.role === 'admin')) t = DEFAULT_TAB;
+  if(t !== currentTab) previousTab = currentTab;
   currentTab = t;
   saveUiState();
-  updateRouteUrl(currentDepartment, t);
+  updateRouteUrl(t);
 
-  ['board','projects','load','people'].forEach(x=>{
+  TAB_PANELS.forEach(x=>{
     const el = document.getElementById(x);
     if(el) el.style.display=(x===t?'block':'none');
   });
+  // Der Projektbereich steht als einziger Bereich AUSSERHALB von .container
+  // (er bringt eigene Kopfzeile und Innenabstände mit). Der leere Container
+  // hinterließe sonst seinen Innenabstand als blinden Streifen über der
+  // Kopfzeile des Projektbereichs.
+  const containerEl = document.querySelector('.app-main > .container');
+  if(containerEl) containerEl.style.display = (t === 'plan') ? 'none' : '';
+  // Wandtafel: Seitenleiste und Kopfzeile ausblenden (body.wandtafel-aktiv,
+  // styles.css) — das Kiosk-Konto hat echte Schreibrechte, eine zufällige
+  // Berührung der Navigation soll nicht in einen bearbeitbaren Bereich
+  // führen. startWandboard()/stopWandboard() (js/wand/wand.js) starten bzw.
+  // beenden dabei die Hintergrund-Aktualisierung und die Kachel-Rotation.
+  document.body.classList.toggle('wandtafel-aktiv', t === 'wand');
+  if(t === 'wand') startWandboard(); else stopWandboard();
   document.querySelectorAll('.tab').forEach(el=>el.classList.toggle('active',el.dataset.tab===t));
   if(t==='board' && currentWeek())   renderBoard();
-  if(t==='projects') renderProjects();
+  if(t==='wochenbericht') renderWochenbericht();
   if(t==='load')    renderLoad();
   if(t==='people')  renderPeople();
+  if(t==='planung') renderPlanung();
+  if(t==='dashboard') renderDashboard();
+  if(t==='wand')    renderWandboard();
+  if(t==='settings') renderSettings();
+  if(t==='admin')    renderAdminArea();
+  syncAdminNavState(t);
+  // Der Projektbereich wird erst NACH dem Einblenden gerendert: das GANTT
+  // rechnet mit der Containerbreite, die in einem ausgeblendeten Bereich 0
+  // wäre. Das Ziel (Sitzung + Projekt) steht vorher über setPlanTarget().
+  if(t==='plan')    openPlanView();
+  syncPlanNavItem();
 }
 
-// ---------- Passwort-Schutz Implementierung ----------
-
-// confirmPassword: prüft das eingegebene Passwort gegen den gespeicherten Hash
-function confirmPassword(){
-  const pwd = document.getElementById('passwordInput').value;
-  if(!pwd) { alert("Bitte Passwort eingeben!"); return; }
-
-  const pwdHash = CryptoJS.SHA256(pwd).toString();
-
-  if(pwdHash === PROTECTED_PASSWORD_HASH){
-    // Sitzungs-Authentifizierung merken, damit Tab-Wechsel und Abteilungs-
-    // wechsel innerhalb dieser Sitzung kein erneutes Passwort verlangen.
-    isAuthenticated = true;
-    // Nur die zuletzt angeforderte Aktion ausführen (nicht eine evtl. bereits
-    // durch closePasswordModal verworfenen Aktion erneut starten) – daher die
-    // Aktion hier erneut über requestedAction prüfen statt sie festzuhalten.
-    setTimeout(() => {
-      const action = requestedAction;
-      requestedAction = null;
-      if(action?.type==='tab') showTab(action.tab, true);
-      else if(action?.type==='deleteWeek') deleteWeek(true);
-      else if(action?.type==='unlockWeek') unlockCurrentWeek(true);
-      else if(action?.type==='importDb') importDb(true);
-    }, 100);
-    document.getElementById('passwordModal').style.display='none';
-  } else {
-    alert("Falsches Passwort!");
-    document.getElementById('passwordInput').value='';
-    document.getElementById('passwordInput').focus();
+// syncAdminNavState: „Admin" ist in der Seitenleiste kein .tab-Knopf,
+// sondern der Kopf einer aufklappbaren Gruppe — die allgemeine
+// .tab-Hervorhebung oben greift dort also nicht. Diese Funktion markiert ihn
+// stattdessen, solange der Bereich offen ist, und klappt die Gruppe dabei
+// auf, damit der gewählte Abschnitt sichtbar wird.
+// Parameter: t (aktiver Bereich). Keine Rückgabe.
+function syncAdminNavState(t){
+  const toggle = document.getElementById('adminAccordionToggle');
+  const subnav = document.getElementById('adminSubnav');
+  if(!toggle || !subnav) return;
+  const aktiv = (t === 'admin');
+  toggle.classList.toggle('active', aktiv);
+  if(aktiv && !subnav.classList.contains('open')){
+    subnav.classList.add('open');
+    toggle.classList.add('expanded');
+    toggle.setAttribute('aria-expanded', 'true');
   }
 }
-// closePasswordModal: schließt das Passwort-Modal ohne Ausführung und
-// verwirft die gemerkte Aktion (requestedAction = null).
-function closePasswordModal(){
-  document.getElementById('passwordModal').style.display='none';
-  requestedAction = null;
-}
\ No newline at end of file
+
+// syncPlanNavItem: hält den Eintrag des Projektbereichs in der Seitenleiste
+// aktuell. Er ist der einzige Navigationspunkt, der nicht immer da ist — er
+// erscheint erst, wenn ein Projekt geöffnet wurde, und trägt dann dessen
+// Bezeichnung. Damit zeigt die Seitenleiste auch im Projektbereich, wo man
+// gerade ist, statt (wie es ohne ihn wäre) gar keinen Punkt hervorzuheben.
+// Keine Parameter, keine Rückgabe.
+function syncPlanNavItem(){
+  const item = document.getElementById('planNavItem');
+  if(!item) return;
+  const app = window.PlanApp;
+  const name = app && app.projName ? app.projName : '';
+  item.style.display = name ? '' : 'none';
+  const label = document.getElementById('planNavItemLabel');
+  if(label) label.textContent = name || 'Projektbereich';
+  item.title = name ? ('Projektbereich: ' + name) : 'Projektbereich';
+}
diff --git a/public/js/ui.js b/public/js/ui.js
index 6c5868f..cb851c5 100644
--- a/public/js/ui.js
+++ b/public/js/ui.js
@@ -3,12 +3,12 @@
 // -----------------------------
 // Diese Datei verwaltet den reinen UI-Zustand: den kollabierbaren Header sowie
 // das Light/Dark-Theme. Sie wird nach js/globals.js von beiden HTML-
-// Einstiegspunkt Test.html geladen. Die
+// Einstiegspunkt App.html geladen. Die
 // bereitgestellten Funktionen werden von js/init.js beim Start sowie von
 // js/tabs-auth.js (Tab-Wechsel, showTab) aufgerufen; im Theme-Umschalter der
 // Seite werden toggleTheme/applyTheme direkt eingebunden.
 // Seit der Projektbereich eines Projekts kein eigenes Dokument mehr ist,
-// sondern der Bereich #plan von Test.html, kennen applyUrlRoute() und
+// sondern der Bereich #plan von App.html, kennen applyUrlRoute() und
 // updateRouteUrl() auch dessen Adresse "/Projektplan/<Projektname>".
 
 // saveUiState: speichert den aktiven Tab in den LocalStorage
@@ -258,7 +258,7 @@ function toggleSidebarCollapse(){
 // toggleSidebarAccordion: klappt einen der beiden Aktions-Bereiche in der
 // Seitenleiste (Einstellungen/Admin) auf oder zu. Erwartet die zugehörigen
 // Elemente unter den IDs "<key>AccordionToggle" (Kopf-Button) und
-// "<key>Subnav" (Liste der Aktionen), siehe Test.html. Kein Persistieren des
+// "<key>Subnav" (Liste der Aktionen), siehe App.html. Kein Persistieren des
 // Zustands — jeder Bereich startet beim Neuladen zugeklappt.
 // Parameter: key ('settings'|'admin'). Rückgabe: keine.
 function toggleSidebarAccordion(key){
diff --git a/public/js/utils.js b/public/js/utils.js
index 962e2a9..9b6a90a 100644
--- a/public/js/utils.js
+++ b/public/js/utils.js
@@ -246,7 +246,7 @@ function getWeekNumber(d){
 // Fett, Farben, Absätze) wird sowohl im Projektboard (js/board/board.js,
 // Detailpanel) als auch auf der Projektplan-Seite (js/plan/plan-info.js)
 // verwendet — deshalb liegen die reinen Hilfsfunktionen hier im gemeinsamen
-// Modul. Nur statusBlur() (board.js, ruft editProj() auf) bzw. der
+// Modul. Nur der
 // Plan-Gegenpart (planStatusBlur() in plan-info.js) bleiben modul-eigen, da
 // sie unterschiedliche Speicherpfade ansteuern.
 
@@ -289,10 +289,27 @@ function formatStatus(command, value){
 // eingeschleust werden können; im style-Attribut sind nur color/font-weight
 // erlaubt. Parameter: `html` (String). Rückgabe: bereinigter HTML-String ('' bei
 // leerem Eingabewert).
+//
+// DOMParser statt `div.innerHTML = html` — das ist der GANZE Sicherheitsgewinn
+// dieser Funktion, nicht bloß Geschmackssache: innerHTML lädt eingebettete
+// Ressourcen und führt deren Fehler-Handler aus, AUCH wenn das Element gar
+// nicht im Dokument hängt. Ein `<img src=x onerror=…>` lief damit schon
+// WÄHREND des Bereinigens — also auf jedem Anzeigepfad, der hier
+// durchkommt, obwohl das Bild danach korrekt entfernt wurde. Der Server
+// speichert Kommentare und Protokolltexte unverändert, ein angemeldetes
+// Konto konnte solches HTML also über die API hinterlegen und damit Code in
+// der Sitzung aller anderen ausführen. parseFromString() erzeugt dagegen ein
+// inertes Dokument: kein Laden, kein Handler. Nachgemessen — mit innerHTML
+// feuerte der Handler, mit DOMParser nicht, bei identischem Ergebnisbaum.
 function sanitizeStatusHtml(html){
   if(!html) return '';
-  const div = document.createElement('div');
-  div.innerHTML = html;
+  // Die Bereinigung läuft vollständig IM inerten Dokument ab: Würden die
+  // Knoten vorher in ein Element des Hauptdokuments übernommen, zöge
+  // appendChild() ein adoptNode() nach sich — und ein dabei übernommenes
+  // <img src=…> begänne wieder zu laden, also genau das, was hier
+  // verhindert werden soll.
+  const inert = new DOMParser().parseFromString(String(html), 'text/html');
+  const div = inert.body;
   const allowedTags = new Set(['B','STRONG','I','EM','U','P','BR','DIV','SPAN','FONT']);
   const allowedAttrs = new Set(['style']);
   // Elemente, deren INHALT mit verschwindet, statt ausgepackt zu werden:
@@ -345,26 +362,27 @@ function sanitizeStatusHtml(html){
   return div.innerHTML;
 }
 
-// statusHtmlToEditText: wandelt einen gespeicherten Kommentar (HTML) in den
-// Klartext, der im Textfeld des Kommentar-Editors steht. Fettschrift wird zu
-// **Sternchen**, Absätze und <br> werden zu Zeilenumbrüchen, alles andere
-// fällt weg. Gegenstück zu statusEditTextToHtml(). Nötig, weil der Editor im
-// Board seit der Kommentar-Überarbeitung ein normales <textarea> ist und kein
-// contenteditable mehr (document.execCommand ist abgekündigt) — gespeichert
-// wird aber weiterhin HTML, damit alle vorhandenen Anzeigepfade (Board-
-// Vorschau, Wochenbericht, PDF-Export, Show-Mode, Verlauf) unverändert
-// funktionieren und Altbestände lesbar bleiben.
+// statusTextMitZeilen: wandelt Kommentar-HTML in reinen Text und erhält dabei
+// die Zeilenumbrüche (<br> und Blockgrenzen werden zu \n). Gegenstück zu
+// statusPlainText() weiter unten, das Umbrüche bewusst zu Leerzeichen
+// einebnet — hier werden sie gebraucht, weil der einzige Aufrufer die ERSTE
+// ZEILE will: openTodoAusKommentar() (js/wochenbericht/wochenbericht.js)
+// schlägt daraus den Titel einer neuen Aufgabe vor.
+//
+// Hieß bis zur Umstellung auf contenteditable statusHtmlToEditText() und gab
+// Fett als **Sternchen**, Kursiv als *Sternchen* und Farbe als
+// [[c:…]]…[[/c]] zurück — die Rückrichtung zum damaligen Markup-Editor.
+// Seit der Editor echtes HTML führt (richtextWickeln() unten), hat dieses
+// Markup keinen Leser mehr; übrig blieben Sternchen, die unvermittelt im
+// vorgeschlagenen Aufgabentitel standen, obwohl sie nie jemand getippt hat.
+// Deshalb liefert die Funktion jetzt schlichten Text.
 // Parameter: html (String). Rückgabe: String.
-function statusHtmlToEditText(html){
+function statusTextMitZeilen(html){
   if(!html) return '';
   const div = document.createElement('div');
   div.innerHTML = sanitizeStatusHtml(html);
-  // Fett-Auszeichnungen vor dem Auflösen in Sternchen überführen
-  div.querySelectorAll('b, strong').forEach(el => {
-    const inner = (el.textContent || '').trim();
-    el.replaceWith(document.createTextNode(inner ? '**' + inner + '**' : ''));
-  });
-  // Block-Grenzen zu Zeilenumbrüchen
+  // Block-Grenzen zu Zeilenumbrüchen; alle Auszeichnungen fallen durch
+  // textContent ohnehin weg.
   div.querySelectorAll('br').forEach(el => el.replaceWith(document.createTextNode('\n')));
   div.querySelectorAll('p, div').forEach(el => el.append(document.createTextNode('\n')));
   return (div.textContent || '')
@@ -373,19 +391,192 @@ function statusHtmlToEditText(html){
     .trim();
 }
 
-// statusEditTextToHtml: wandelt den Klartext aus dem Kommentar-Editor in das
-// gespeicherte HTML. Escapt zuerst vollständig (esc()), sodass eingetippte
-// spitze Klammern niemals als Markup ankommen, und setzt danach die einzige
-// erlaubte Auszeichnung **fett** sowie Zeilenumbrüche. Gegenstück zu
-// statusHtmlToEditText(). Leerer oder reiner Leerraum-Text ergibt '' — die
-// bisherige Bedeutung von "kein Kommentar" bleibt damit erhalten.
-// Parameter: text (String). Rückgabe: String (HTML).
-function statusEditTextToHtml(text){
-  const clean = String(text || '').trim();
-  if(clean === '') return '';
-  return esc(clean)
-    .replace(/\*\*([^*\n]+)\*\*/g, '<b>$1</b>')
-    .replace(/\n/g, '<br>');
+// ---------- Formatierbare Textfelder: contenteditable statt Markup-Zeichen ----------
+//
+// Erster Anlauf (Markup-Zeichen **fett**/*kursiv*/[[c:…]] in einem normalen
+// <textarea>, inzwischen vollständig entfernt) zeigte während des
+// Tippens sichtbare Stern-/Klammer-Zeichen (**fett**, [[c:…]]) statt echter
+// Formatierung — Eriks Rückmeldung: "statt den zwei Sternchen... den Text
+// richtig fett machen". Diese Felder sind jetzt contenteditable statt
+// <textarea>, und richtextWickeln()/richtextFett()/richtextKursiv()/
+// richtextFarbe() wenden die Auszeichnung direkt auf die Markierung an — über
+// die Selection/Range-API (range.extractContents()/insertNode()), bewusst
+// KEIN document.execCommand (abgekündigt, derselbe Grund, der die vorige
+// contenteditable-Fassung dieser Felder schon einmal verworfen hatte — nur
+// diesmal ohne execCommand). Der Nutzer sieht dadurch sofort echten fetten/
+// kursiven/farbigen Text, keine Markup-Zeichen mehr.
+// richtextToolbarHtml() liefert die dazugehörige, überall wiederverwendbare
+// Werkzeugleiste; sie erwartet, dass das Zielfeld im selben .richtext-wrap
+// steht (per closest()+querySelector() gefunden), damit mehrere Instanzen
+// auf einer Seite (z. B. je Protokoll-Punkt) einander nicht in die Quere
+// kommen. onmousedown mit preventDefault() verhindert, dass der Knopf-Klick
+// dem Feld vorher den Fokus (und damit die Markierung) stiehlt.
+
+function richtextWickeln(feld, tagName, styleAttr){
+  if(!feld) return;
+  const sel = window.getSelection();
+  if(!sel || sel.rangeCount === 0) return;
+  const range = sel.getRangeAt(0);
+  if(range.collapsed || !feld.contains(range.commonAncestorContainer)) return;
+  const wrapper = document.createElement(tagName);
+  if(styleAttr) wrapper.setAttribute('style', styleAttr);
+  wrapper.appendChild(range.extractContents());
+  range.insertNode(wrapper);
+  // Markierung auf den neu eingefügten Inhalt setzen — ein zweiter Klick auf
+  // eine andere Auszeichnung wirkt dadurch sofort auf denselben Text weiter.
+  sel.removeAllRanges();
+  const neueRange = document.createRange();
+  neueRange.selectNodeContents(wrapper);
+  sel.addRange(neueRange);
+  feld.dispatchEvent(new Event('input', { bubbles: true }));
+}
+function richtextFett(feld){ richtextWickeln(feld, 'b'); }
+function richtextKursiv(feld){ richtextWickeln(feld, 'i'); }
+function richtextFarbe(feld, farbe){ richtextWickeln(feld, 'span', 'color:' + farbe); }
+
+// richtextFeldHtml: liefert ein contenteditable-Feld mit Platzhaltertext
+// (:empty:before + data-placeholder, siehe styles.css) als Ersatz für ein
+// <textarea>. html MUSS bereits sanitizeStatusHtml()-bereinigt sein (niemals
+// escapter Klartext — der Inhalt soll als Markup interpretiert werden, nicht
+// als Zeichenkette). extraAttrs hängt aufruferspezifische Event-Handler an.
+// editable=false (gesperrte Sitzung) setzt contenteditable="false" statt das
+// Feld ganz durch reinen Text zu ersetzen — Auswahl/Kopieren bleibt möglich.
+// Parameter: cssClass, html, placeholder, extraAttrs (Strings), editable
+// (Boolean, optional, Default true). Rückgabe: HTML-String.
+function richtextFeldHtml(cssClass, html, placeholder, extraAttrs, editable){
+  const bearbeitbar = editable === false ? 'false' : 'true';
+  return `<div class="${cssClass}" contenteditable="${bearbeitbar}" data-placeholder="${esc(placeholder || '')}" ${extraAttrs || ''}>${html || ''}</div>`;
+}
+
+// richtextCursorAnsEnde: setzt den Fokus in ein contenteditable-Feld und den
+// Cursor ans Textende — das Gegenstück zu textarea.setSelectionRange(), das
+// es für contenteditable nicht gibt. Parameter: feld (Element). Keine
+// Rückgabe.
+function richtextCursorAnsEnde(feld){
+  if(!feld) return;
+  feld.focus();
+  const range = document.createRange();
+  range.selectNodeContents(feld);
+  range.collapse(false);
+  const sel = window.getSelection();
+  sel.removeAllRanges();
+  sel.addRange(range);
+}
+
+// Einfügen bereinigen: Ohne diesen Lauscher übernimmt ein contenteditable-Feld
+// beim Einfügen aus Word, einer Webseite oder einer Mail deren vollständige
+// Formatierung — Schriftarten, Größen, Tabellen, Bilder. Sichtbar blieb das
+// bis zum Speichern; erst dort lief sanitizeStatusHtml() und der Text sprang
+// unvermittelt in eine andere Gestalt. Jetzt wird schon beim Einfügen auf
+// dieselbe Positivliste reduziert, die auch gespeichert wird — was man sieht,
+// ist, was bleibt.
+//
+// EIN Lauscher am Dokument für alle Felder (gleiche Begründung wie beim
+// selectionchange-Lauscher in js/plan/plan-protokoll.js): Die Felder werden
+// beim Rendern ständig neu erzeugt, ein Lauscher je Feld müsste bei jedem
+// Neuaufbau erneut gesetzt werden.
+document.addEventListener('paste', function(e){
+  const feld = e.target && e.target.closest ? e.target.closest('[contenteditable="true"]') : null;
+  if(!feld || !e.clipboardData) return;
+  e.preventDefault();
+  // text/html nur, wenn vorhanden — reiner Text wird escaped eingesetzt,
+  // damit darin enthaltene spitze Klammern Zeichen bleiben und nicht als
+  // Markup ankommen.
+  const html = e.clipboardData.getData('text/html');
+  const sauber = html
+    ? sanitizeStatusHtml(html)
+    : esc(e.clipboardData.getData('text/plain')).replace(/\r\n|\r|\n/g, '<br>');
+  if(!sauber) return;
+  const sel = window.getSelection();
+  if(!sel || sel.rangeCount === 0) return;
+  const range = sel.getRangeAt(0);
+  range.deleteContents();
+  // Über ein <template> in Knoten verwandeln: dessen Inhalt liegt in einem
+  // eigenen, inerten Dokumentfragment. `sauber` ist zwar bereits geprüft,
+  // aber so bleibt auch dieser Schritt frei von Ressourcen-Ladevorgängen.
+  const vorlage = document.createElement('template');
+  vorlage.innerHTML = sauber;
+  const fragment = vorlage.content;
+  const letzter = fragment.lastChild;
+  range.insertNode(fragment);
+  // Schreibmarke hinter das Eingefügte setzen, sonst stünde sie davor.
+  if(letzter){
+    const nach = document.createRange();
+    nach.setStartAfter(letzter);
+    nach.collapse(true);
+    sel.removeAllRanges();
+    sel.addRange(nach);
+  }
+  feld.dispatchEvent(new Event('input', { bubbles: true }));
+});
+
+// Rückmeldung der Formatierungsleiste: Fett/Kursiv/Farbe wirken nur auf
+// MARKIERTEN Text — ohne Markierung passiert beim Klick nichts, und zwar ohne
+// jeden Hinweis warum. Die Leiste hebt sich deshalb sichtbar hervor, sobald im
+// zugehörigen Feld etwas markiert ist, und trägt daneben einen Hinweis, der
+// von "Erst Text markieren" auf die Bestätigung umspringt.
+//
+// EIN dokumentweiter Lauscher für JEDES Vorkommen von .richtext-wrap, nicht
+// nur für den Protokoll-Schreibbereich (wo diese Funktion ursprünglich nur
+// dort lebte): der Board-Kommentar nutzt dieselbe Leiste
+// (richtextToolbarHtml(), renderCommentEditor() in js/board/board.js), zeigte
+// die Markierung aber nie an — die Leiste blieb dort dauerhaft blass, egal ob
+// Text markiert war. Anders als im Protokoll (immer höchstens EIN
+// Schreibbereich) können im Projektboard mehrere Zeilen gleichzeitig
+// aufgeklappt sein, jede mit eigenem Kommentarfeld — der Lauscher geht
+// deshalb jedes .richtext-wrap einzeln durch statt nur eines anzunehmen.
+document.addEventListener('selectionchange', function(){
+  const sel = window.getSelection();
+  const bereich = (sel && sel.rangeCount > 0 && !sel.isCollapsed) ? sel.getRangeAt(0) : null;
+  document.querySelectorAll('.richtext-wrap').forEach(wrap => {
+    const leiste = wrap.querySelector('.richtext-toolbar');
+    const feld = wrap.querySelector('[contenteditable="true"]');
+    if(!leiste || !feld) return;
+    const markiert = !!(bereich && feld.contains(bereich.commonAncestorContainer));
+    leiste.classList.toggle('hat-auswahl', markiert);
+    const hinweis = leiste.querySelector('.richtext-hinweis');
+    if(hinweis) hinweis.textContent = markiert ? '✓ Markiert — jetzt formatieren' : 'Erst Text markieren';
+  });
+});
+
+// RICHTEXT_FARBEN: die Palette der Farbknöpfe — bewusst dieselben Werte wie
+// --red/--green/--accent/--amber (styles.css), damit eine im Text gewählte
+// Farbe dieselbe Bedeutung trägt wie anderswo in der Anwendung (Rot = Achtung,
+// Grün = erledigt/positiv, Blau = Hinweis, Orange = offen/Warnung).
+const RICHTEXT_FARBEN = [
+  { farbe: '#d70015', titel: 'Rot' },
+  { farbe: '#248a3d', titel: 'Grün' },
+  { farbe: '#0071e3', titel: 'Blau' },
+  { farbe: '#b25000', titel: 'Orange' }
+];
+
+// richtextToolbarHtml: liefert die Werkzeugleiste (Fett/Kursiv/Farben) für ein
+// contenteditable-Feld (richtextFeldHtml()), das im selben .richtext-wrap-
+// Container steht. targetSelector wählt das Zielfeld innerhalb dieses
+// Containers aus — jeder Aufrufer übergibt seine eigene Feldklasse (z. B.
+// '.comment-field'), der Default greift nur, falls das je vergessen wird.
+// Parameter: targetSelector (String, optional). Rückgabe: HTML-String.
+function richtextToolbarHtml(targetSelector){
+  const sel = targetSelector || '[contenteditable]';
+  const ziel = `this.closest('.richtext-wrap').querySelector('${sel}')`;
+  const farbButtons = RICHTEXT_FARBEN.map(f =>
+    `<button type="button" class="richtext-farbe-btn" style="background:${f.farbe}" title="${f.titel}"
+       onmousedown="event.preventDefault()" onclick="richtextFarbe(${ziel}, '${f.farbe}')"></button>`).join('');
+  // .richtext-hinweis: Fett/Kursiv/Farbe wirken nur auf MARKIERTEN Text —
+  // ohne Markierung tut ein Klick nichts, und das war bisher nirgends
+  // ablesbar. Der Hinweis steht deshalb fest in der Leiste; wer ihn
+  // aktualisieren will, wenn tatsächlich etwas markiert ist, hängt sich an
+  // selectionchange (so macht es der Protokoll-Schreibbereich,
+  // js/plan/plan-protokoll.js).
+  return `<div class="richtext-toolbar">
+      <span class="richtext-btn-group">
+        <button type="button" class="richtext-btn" title="Fett" onmousedown="event.preventDefault()" onclick="richtextFett(${ziel})"><b>F</b></button>
+        <button type="button" class="richtext-btn" title="Kursiv" onmousedown="event.preventDefault()" onclick="richtextKursiv(${ziel})"><i>K</i></button>
+      </span>
+      <span class="richtext-divider"></span>
+      <span class="richtext-farben">${farbButtons}</span>
+      <span class="richtext-hinweis">Erst Text markieren</span>
+    </div>`;
 }
 
 // -------- Projekt-Verlauf über mehrere Sitzungen --------
diff --git a/public/js/wand/wand.js b/public/js/wand/wand.js
new file mode 100644
index 0000000..6ff4f57
--- /dev/null
+++ b/public/js/wand/wand.js
@@ -0,0 +1,836 @@
+// -----------------------------
+// Projektübersicht — Wandtafel (Touch-Dashboard)
+// -----------------------------
+// Modul für den Tab "Wandtafel" (App.html, Ladereihenfolge: ... → load →
+// dashboard → wand → settings → ...). Ersetzt den früheren Show Mode: der
+// klonte nur die gerade gerenderte Board- bzw. Auslastungs-Ansicht der EINEN
+// angemeldeten Sitzung (kein eigener Datenpfad, keine Aggregation über
+// Gewerke oder Nutzer hinweg). Gedacht für ein dauerhaft laufendes
+// Touch-Display mit einem eigens dafür angelegten Kiosk-Konto — siehe
+// CLAUDE.md "Wandtafel".
+//
+// Zweispaltig (Eriks Wahl "Variante C" aus dem Layout-Vergleich): links drei
+// kompakte Kennzahl-Kacheln, rechts der Ereignis-Feed — seit einem zweiten,
+// eigenen Vergleich (Feed-Vergleich) nach Art in drei Spalten gruppiert
+// (Neu/Überfällig/Termine) statt chronologisch gemischt, siehe
+// wandFeedHtml(). Die Kacheln selbst sind NICHT antippbar (kein Auf-/Zuklappen
+// mehr, auf Eriks Wunsch) — stattdessen ist jedes einzelne darin dargestellte
+// Element für sich antippbar (eine Gewerk-Zeile, eine Kennzahl, ein Kürzel,
+// ein Feed-Eintrag) und führt in eine Vollbild-Übersicht bzw. direkt ins
+// betroffene Projekt. Jede Kachel/jedes Ereignis ist eine reine Projektion
+// bereits geladener Daten (dasselbe db aus GET /load-all, das jeder andere
+// Tab auch nutzt) — keine eigene Server-Route, keine schreibenden Aktionen.
+// Wiederverwendet werden berechneAuslastung()/loadAmpelColor()/
+// kapazitaetsFaktor()/stundenFormat()/lpActiveList() aus js/load/load.js,
+// classifyProjectChange()/findPreviousWeek()/springZumWochenbericht() aus
+// js/wochenbericht/wochenbericht.js bzw. js/plan/plan-info.js,
+// statusPreviewText()/renderBoardRow()/renderBoardDrawer()/BOARD_OPTS aus
+// js/board/board.js, relativerTag()/tageBis()/initialsFor()/
+// formatWeekDate() aus js/dashboard/dashboard.js bzw. js/utils.js,
+// GROUP_ORDER/ROLES aus js/globals.js, sortGroups()/peopleByRole() aus
+// js/utils.js, esc()/heuteIso() aus js/utils.js, currentWeek() aus
+// js/weeks.js, load()/baseUrl() aus js/store.js/js/server.js,
+// showLoginOverlay() aus js/auth.js, openProjectPlan() aus js/gantt.js
+// (jeder Sprung ins Projekt verlässt die Wandtafel bewusst in den normalen
+// Projektbereich, Seitenleiste und Kopfzeile kommen dabei zurück — wie bei
+// jedem anderen Tab-Wechsel auch).
+//
+// Die Normalansicht ist höher als ein Bildschirm: unterhalb der zwei
+// Kennzahl-Spalten folgt die vollständige Projektliste
+// (wandProjektlisteHtml()) — auf Eriks ausdrücklichen Wunsch optisch
+// identisch mit der echten Projektliste (Tab "Projekte"), nicht eine eigene,
+// vereinfachte Zeilenform: Jede Gruppe/Zeile entsteht über denselben
+// renderBoardRow()/BOARD_OPTS wie dort, nur mit locked FEST auf true (siehe
+// wandProjektlisteHtml()) — die Wandtafel schreibt nie, also gibt es hier
+// nie Ziehgriffe oder einen Löschen-Knopf, unabhängig vom echten Sperrstatus
+// der Sitzung. Das Display ist ein echter Touch-Monitor — Erik kann
+// davortreten und darin scrollen; ohne Berührung kehrt die Ansicht nach
+// WAND_IDLE_MS von selbst an den Anfang zurück (wandAktivitaetErkannt()/
+// wandBeiUntaetigkeitZuruecksetzen()), damit ein unbeaufsichtigtes Display
+// nicht dauerhaft im Zustand der letzten vorbeigehenden Person hängen
+// bleibt. Erik wollte diesen Rücksprung nicht nur erleben, sondern vorher
+// sehen können: #wandIdleCountdown (neben "← Zur Übersicht", App.html) zeigt
+// laufend die verbleibende Zeit (wandCountdownTick(), ein eigenes
+// 1-Sekunden-Intervall, siehe startWandboard()/stopWandboard()).
+// Dasselbe gilt auch AUSSERHALB der Wandtafel: Ein Klick auf eine
+// Projekt-/Gewerk-Fläche verlässt sie ja absichtlich (Projektbereich bzw.
+// Wochenbericht) — ein document-weiter, capturing Klick-Lauscher auf
+// #wandContent setzt dabei wandUnterwegs, worüber dieselbe globale
+// Aktivitätserkennung (wandAktivitaetErkannt()) statt der Untätigkeits- die
+// Rückkehr-Uhr bedient; nach WAND_IDLE_MS ohne Berührung dort kehrt
+// wandKehreZurueck() von selbst auf die Wandtafel zurück. Der bewusste
+// Ausstieg über "← Zur Übersicht" (außerhalb von #wandContent) setzt
+// wandUnterwegs NICHT — eine Vorschau durch Personal soll nicht nach einer
+// Minute unterbrochen werden.
+
+// WAND_GEWERKE: die drei Fachrichtungen, in dieser Reihenfolge überall auf
+// der Wandtafel. Dieselben Werte wie VALID_DEPARTMENTS/project_gewerke.
+const WAND_GEWERKE = ['ELT', 'HLS', 'ARCH'];
+
+const WAND_REFRESH_MS = 60000; // Hintergrund-Aktualisierung
+const WAND_FEED_MAX = 5;       // Höchstzahl Einträge JE SPALTE im Ereignis-Feed (Neu/Überfällig/Termine)
+// WAND_IDLE_MS: Erik hat einen echten Touch-Monitor — er darf davortreten und
+// in der Projektliste unterhalb der Kacheln scrollen ("ich kann mich vor die
+// Tafel stellen und scrollen"). Nach dieser Zeit ohne jede Berührung kehrt
+// die Ansicht von selbst in den Normalzustand zurück (oben, keine offene
+// Übersicht) — ein unbeaufsichtigtes Display darf nicht dauerhaft in einem
+// Zustand hängen bleiben, den zufällig die letzte vorbeigehende Person
+// hinterlassen hat.
+const WAND_IDLE_MS = 60000;
+
+let wandRefreshTimer = null;
+let wandIdleTimer = null;
+let wandCountdownTimer = null;
+let wandIdleDeadline = 0; // Date.now()-Zeitpunkt, zu dem die Untätigkeits-Uhr auslöst
+let wandRueckkehrTimer = null;
+// wandUnterwegs: true zwischen einem Klick auf eine Projekt-/Gewerk-Fläche
+// DER WANDTAFEL (gesetzt vom Klick-Lauscher auf #wandContent weiter unten)
+// und der Rückkehr dorthin — nicht beim Verlassen über "← Zur Übersicht"
+// (ein bewusster Ausstieg für eine Vorschau, kein versehentliches Antippen,
+// und außerhalb von #wandContent). Nur während dieser Zeit treibt
+// wandAktivitaetErkannt() die Rückkehr-Uhr statt der Untätigkeits-Uhr.
+let wandUnterwegs = false;
+let wandAktuelleWoche = null; // für Übersicht-Klicks gemerkt (re-render ohne erneutes Laden)
+// wandUebersicht: null (zweispaltige Normalansicht) oder {typ, gewerk?} —
+// welche Vollbild-Übersicht gerade anstelle der Normalansicht steht. gewerk
+// ist nur bei typ 'auslastung'/'besprochen' gesetzt (eine Übersicht je
+// Gewerk).
+let wandUebersicht = null;
+
+// startWandboard: startet die Hintergrund-Aktualisierung, falls nicht schon
+// aktiv. Der Schon-aktiv-Schutz ist kein Komfort, sondern notwendig: load()
+// ruft an seinem Ende selbst showTab(currentTab) auf — showTab('wand') riefe
+// ohne diesen Schutz bei JEDEM eigenen 60s-Takt erneut startWandboard() auf
+// und setzte damit sofort einen weiteren, ungeduldigen Takt in Gang (eine
+// Rückkopplungsschleife, die praktisch ohne Pause neu lädt). Nach einer
+// erneuten Anmeldung (stopWandboard() setzt wandRefreshTimer zuvor auf null,
+// siehe wandRefreshTick()) greift der Schutz dagegen nicht und die
+// Aktualisierung startet korrekt neu. Keine Parameter, keine Rückgabe.
+function startWandboard(){
+  if(wandRefreshTimer) return;
+  // Ein frisches Betreten beginnt immer bei der normalen Ansicht, nie in
+  // einer Übersicht hängen — die läuft nur innerhalb EINES Aufenthalts auf
+  // der Wandtafel weiter (der 60s-Hintergrund-Takt ruft startWandboard()
+  // zwar erneut auf, der Schutz oben greift dann aber schon vorher, sodass
+  // dieser Reset NICHT bei jedem Takt läuft). Eine evtl. noch laufende
+  // Rückkehr-Uhr endet hier ebenfalls — sie ist erfüllt, sobald die
+  // Wandtafel wieder aktiv ist, egal ob durch sie selbst ausgelöst oder
+  // durch eine andere Navigation dorthin.
+  wandUebersicht = null;
+  wandUnterwegs = false;
+  clearTimeout(wandRueckkehrTimer); wandRueckkehrTimer = null;
+  wandRefreshTick();
+  wandRefreshTimer = setInterval(wandRefreshTick, WAND_REFRESH_MS);
+  wandAktivitaetErkannt(); // startet die Untätigkeits-Uhr für diesen Aufenthalt
+  wandCountdownTick();
+  wandCountdownTimer = setInterval(wandCountdownTick, 1000);
+}
+
+// stopWandboard: beendet den Hintergrund-Takt der Wandtafel. Wird von
+// showTab() beim Verlassen des Tabs aufgerufen (NACH dem Entfernen von
+// body.wandtafel-aktiv, siehe tabs-auth.js). Wenn das Verlassen durch einen
+// Klick INNERHALB von #wandContent ausgelöst wurde (wandUnterwegs, siehe der
+// document-weite Klick-Lauscher unten), wird hier sofort die Rückkehr-Uhr
+// scharf gestellt — wandAktivitaetErkannt() nimmt wegen des bereits
+// entfernten wandtafel-aktiv automatisch den passenden Zweig. Ein Verlassen
+// OHNE vorherigen Klick (etwa stopWandboard() aus wandRefreshTick() bei
+// abgelaufener Sitzung) lässt wandUnterwegs unberührt — dort gibt es nichts,
+// wohin zurückzukehren wäre. Keine Parameter, keine Rückgabe.
+function stopWandboard(){
+  clearInterval(wandRefreshTimer); wandRefreshTimer = null;
+  clearTimeout(wandIdleTimer); wandIdleTimer = null;
+  clearInterval(wandCountdownTimer); wandCountdownTimer = null;
+  const el = document.getElementById('wandIdleCountdown');
+  if(el) el.textContent = '';
+  if(wandUnterwegs) wandAktivitaetErkannt();
+}
+
+// wandAktivitaetErkannt: setzt je nach Lage entweder die Untätigkeits-Uhr
+// (auf der Wandtafel selbst) oder die Rückkehr-Uhr (unterwegs, siehe
+// wandUnterwegs) zurück. Horcht global auf Berührung/Maus/Tastatur/Scroll —
+// so kann der Listener einmalig beim Laden des Skripts registriert werden,
+// statt bei jedem Betreten/Verlassen an- und abgemeldet zu werden, und ist
+// überall sonst (kein wandtafel-aktiv, nicht wandUnterwegs) ein reines
+// No-op. Keine Parameter, keine Rückgabe.
+function wandAktivitaetErkannt(){
+  if(document.body.classList.contains('wandtafel-aktiv')){
+    clearTimeout(wandIdleTimer);
+    wandIdleTimer = setTimeout(wandBeiUntaetigkeitZuruecksetzen, WAND_IDLE_MS);
+    wandIdleDeadline = Date.now() + WAND_IDLE_MS;
+    wandCountdownTick();
+  } else if(wandUnterwegs){
+    clearTimeout(wandRueckkehrTimer);
+    wandRueckkehrTimer = setTimeout(wandKehreZurueck, WAND_IDLE_MS);
+  }
+}
+
+// wandKehreZurueck: nach WAND_IDLE_MS ohne Berührung AUSSERHALB der
+// Wandtafel — ausgelöst durch einen Klick auf eine ihrer eigenen
+// Projekt-/Gewerk-Flächen (wandUnterwegs, siehe dort) — zurück zur
+// Wandtafel. Erik: "auch wenn ich eine der Flächen/Projekte auf der Tafel
+// anklicke soll nach 1 min das Bild wieder zurückspringen" — ein kurzer
+// Blick ins Projekt darf das unbeaufsichtigte Display nicht dauerhaft
+// woanders hinterlassen. Keine Parameter, keine Rückgabe.
+function wandKehreZurueck(){
+  wandRueckkehrTimer = null;
+  showTab('wand');
+}
+
+// wandCountdownTick: schreibt die verbleibende Zeit bis zum automatischen
+// Rücksprung in #wandIdleCountdown (Kopfzeile neben "← Zur Übersicht", siehe
+// App.html) — Erik wollte sehen können, wann das passiert, statt vom Sprung
+// überrascht zu werden. Läuft über ein eigenes 1-Sekunden-Intervall statt
+// über wandIdleTimer selbst, da der nur EIN MAL (beim Auslösen) feuert.
+// Keine Parameter, keine Rückgabe.
+function wandCountdownTick(){
+  const el = document.getElementById('wandIdleCountdown');
+  if(!el) return;
+  const rest = Math.max(0, Math.ceil((wandIdleDeadline - Date.now()) / 1000));
+  el.textContent = rest > 0 ? ('Rücksprung in ' + rest + ' s') : '';
+}
+
+// wandBeiUntaetigkeitZuruecksetzen: nach WAND_IDLE_MS ohne Berührung zurück in
+// den Normalzustand — eine offene Übersicht schließt sich, und die
+// Projektliste scrollt an den Anfang zurück. Unbedingt (nicht nur wenn gerade
+// eine Übersicht offen war): Auch ein bloßes Herunterscrollen in der
+// Projektliste soll sich nach einer Minute von selbst zurücksetzen.
+// Startet die Uhr am Ende selbst neu (wandAktivitaetErkannt()), statt sie
+// auslaufen zu lassen — die Anzeige in #wandIdleCountdown soll durchgehend
+// laufen, nicht nach dem ersten Rücksprung stehen bleiben, solange niemand
+// die Tafel berührt. Keine Parameter, keine Rückgabe.
+function wandBeiUntaetigkeitZuruecksetzen(){
+  wandUebersicht = null;
+  renderWandboard({ resetScroll: true });
+  wandAktivitaetErkannt();
+}
+
+['pointerdown', 'touchstart', 'wheel', 'keydown'].forEach(evt =>
+  document.addEventListener(evt, wandAktivitaetErkannt, { passive: true }));
+// 'scroll' bubbelt bei Elementen (anders als bei window/document) nicht —
+// ein Listener in der CAPTURING-Phase an document bekommt ihn trotzdem mit,
+// da die Capturing-Phase unabhängig vom Bubbling jedes Element auf dem Weg
+// zum Ziel durchläuft.
+document.addEventListener('scroll', wandAktivitaetErkannt, { passive: true, capture: true });
+
+// Jeder Klick INNERHALB von #wandContent markiert "unterwegs" — unabhängig
+// davon, über welche konkrete Funktion er die Wandtafel verlässt
+// (openProjectPlan() direkt aus renderBoardRow() in der Projektliste,
+// springZumWochenbericht() aus der Besprochen-Übersicht, wandSpringeZuProjekt()
+// aus den übrigen Übersichten/dem Feed). Ein einzelner, allgemeiner Lauscher
+// statt eigener Wrapper um jede dieser Navigationsfunktionen: Mehrere davon
+// werden auch von ganz anderen, nicht-Wandtafel-Stellen der App aufgerufen
+// (board.js, plan-info.js) und dürfen dort keine Rückkehr auslösen — hier
+// entscheidet allein, WO der Klick stattfand, nicht WELCHE Funktion er
+// aufruft. Läuft in der CAPTURING-Phase: Mehrere Klick-Handler in der
+// Projektliste rufen event.stopPropagation() auf (z. B. der Projektname in
+// renderBoardRow()), was einen Lauscher in der normalen Bubbling-Phase an
+// #wandContent gar nicht erst erreichen würde — die Capturing-Phase läuft
+// davon unabhängig schon auf dem Weg zum eigentlichen Ziel. Das bewusste
+// Verlassen über "← Zur Übersicht" (außerhalb von #wandContent, siehe
+// App.html) setzt wandUnterwegs ABSICHTLICH NICHT — eine Vorschau durch
+// Personal soll nicht nach einer Minute unterbrochen werden. Die eigentliche
+// Uhr wird erst in stopWandboard() scharf gestellt, sobald die Navigation
+// tatsächlich stattgefunden hat.
+document.addEventListener('click', function(ev){
+  const wandContent = document.getElementById('wandContent');
+  if(wandContent && wandContent.contains(ev.target)) wandUnterwegs = true;
+}, { capture: true });
+
+// wandRefreshTick: der äußere Hintergrund-Takt. Prüft zuerst GET /whoami statt
+// blind load() aufzurufen: Ist die Sitzung abgelaufen, zeigt er das
+// bestehende Login-Overlay an Ort und Stelle (dasselbe Formular ist seit dem
+// ersten Seitenaufruf schon verdrahtet, siehe checkAuthAndInit(),
+// js/auth.js) — eine erneute Anmeldung setzt die Wandtafel über denselben
+// onAuthenticated()-Weg fort, ohne dass die Seite neu geladen werden muss.
+// Keine Parameter, keine Rückgabe.
+async function wandRefreshTick(){
+  let data;
+  try {
+    const res = await fetch(baseUrl() + '/whoami');
+    data = await res.json();
+  } catch(err){
+    console.error('Wandtafel: Anmeldestatus konnte nicht geprüft werden:', err);
+    return; // nächster Takt versucht es erneut
+  }
+  if(!data || !data.user){
+    stopWandboard();
+    showLoginOverlay();
+    return;
+  }
+  load(true); // silent — ruft am Ende renderAll()+showTab(currentTab) auf
+}
+
+// renderWandboard: baut entweder die zweispaltige Normalansicht (mit der
+// vollständigen Projektliste darunter) oder eine offene Vollbild-Übersicht
+// auf. Wird von showTab('wand') sowie nach jedem load() (über
+// showTab(currentTab)) aufgerufen.
+//
+// Die Normalansicht ist höher als ein Bildschirm — Erik hat einen echten
+// Touch-Monitor und wollte "unterhalb der Wandtafel... weitere Informationen
+// verstauen, z. B. die gesamte Projektliste". Nur dieser Teil scrollt
+// (`.wand-scrollable` auf #wandContent); eine offene Übersicht bleibt wie
+// zuvor genau einen Bildschirm hoch mit ihrer eigenen inneren Liste. Der
+// Scroll-Stand bleibt über den 60-Sekunden-Hintergrund-Takt hinweg erhalten
+// (sonst risse ein laufender Refresh jemanden, der gerade in der Liste
+// scrollt, zurück an den Anfang) — nur wandBeiUntaetigkeitZuruecksetzen()
+// verlangt ausdrücklich resetScroll:true. Parameter: opts.resetScroll
+// (optional). Keine Rückgabe.
+function renderWandboard(opts){
+  const resetScroll = !!(opts && opts.resetScroll);
+  const container = document.getElementById('wandContent');
+  if(!container) return;
+  const w = currentWeek();
+  if(!w){
+    container.innerHTML = '<div class="hint">Keine Sitzung vorhanden.</div>';
+    return;
+  }
+  wandAktuelleWoche = w;
+
+  const vorherigerScroll = resetScroll ? 0 : container.scrollTop;
+
+  if(wandUebersicht){
+    container.classList.remove('wand-scrollable');
+    container.innerHTML = wandUebersichtHtml(w);
+    return;
+  }
+
+  container.classList.add('wand-scrollable');
+  container.innerHTML = '<div class="wand-ambient"><div class="wand-c-layout">'
+    + '<div class="wand-c-links">' + wandLinkeSpalteHtml(w) + '</div>'
+    + '<div class="wand-c-rechts">'
+    +   '<h3 class="wand-kachel-titel">Aktuell diese Woche</h3>'
+    +   '<div class="wand-feed-wrap">' + wandFeedHtml(w) + '</div>'
+    +   renderWandStand()
+    + '</div>'
+    + '</div></div>'
+    + wandProjektlisteHtml(w);
+  container.scrollTop = vorherigerScroll;
+}
+
+// wandProjektlisteHtml: die vollständige Projektliste unterhalb der
+// Kennzahl-Kacheln — auf Eriks ausdrücklichen Wunsch ("Die Projektliste soll
+// so aussehen wie die Originale") keine eigene, vereinfachte Darstellung,
+// sondern dieselbe Zeile wie im echten Tab "Projekte": gleiche Gruppen
+// (GROUP_ORDER/sortGroups()), gleiche Sortierung (p.order) und jede Zeile
+// über denselben renderBoardRow()+BOARD_OPTS wie renderBoard() selbst
+// (js/board/board.js) — Nr., Name, Auftragsstatus-Kennzeichen, Status-
+// Vorschau, Avatar-Stapel und Phasen-Badge, aufklappbar zum selben
+// Detailpanel (renderBoardDrawer()). Anders als die Auslastung/Besprochen-
+// Kacheln zählt hier bewusst auch "In Anbahnung" mit, da es um
+// Vollständigkeit geht, nicht um bewertbare Arbeitslast.
+//
+// `locked` wird FEST auf true übergeben, unabhängig vom tatsächlichen
+// Sperrstatus der Sitzung: Die Wandtafel schreibt nie (siehe Dateikopf), und
+// renderBoardRow()/renderBoardDrawer() blenden bei locked=true genau die
+// Bedienelemente aus, die einen Schreibzugriff auslösen würden (Ziehgriff,
+// "Löschen", editierbarer Kommentar) — ein Projekt antippen bleibt möglich
+// (öffnet/schließt die Zeile, "Öffnen" springt ins Projekt), ein Kiosk-Konto
+// bekäme auf jeden Schreibversuch ohnehin ein serverseitiges 403.
+// toggleBoardRow() (board.js) ruft nach jedem Auf-/Zuklappen zusätzlich
+// renderWandboard() auf, damit eine hier aufgeklappte Zeile sofort sichtbar
+// wird, genau wie es das für renderBoard()/renderWochenbericht() schon tut.
+// Parameter: w. Rückgabe: HTML-String.
+function wandProjektlisteHtml(w){
+  const locked = true;
+  const grouped = peopleByRole(w);
+  const allPeople = [];
+  ROLES.forEach(r => grouped[r].forEach(entry => allPeople.push(entry)));
+
+  const groups = {};
+  GROUP_ORDER.forEach(g => { groups[g] = []; });
+  (Array.isArray(w.projects) ? w.projects : []).forEach(p => {
+    (groups[p.group] || (groups[p.group] = [])).push(p);
+  });
+  Object.keys(groups).forEach(g => groups[g].sort((a, b) => (a.order || 0) - (b.order || 0)));
+
+  const abschnitte = sortGroups(Object.keys(groups)).map(g => {
+    if(groups[g].length === 0) return '';
+    const zeilen = groups[g].map(p => renderBoardRow(p, allPeople, locked, w.label, BOARD_OPTS)).join('');
+    return '<div class="section-title">' + esc(g) + '</div><div class="board-list">' + zeilen + '</div>';
+  }).join('');
+
+  return '<div class="wand-projektliste">'
+    + '<h3 class="wand-kachel-titel">Alle Projekte</h3>'
+    + abschnitte
+    + '</div>';
+}
+
+// wandLinkeSpalteHtml: die drei Kennzahl-Kacheln (nicht mehr antippbar —
+// nur die Elemente darin sind es). Parameter: w. Rückgabe: HTML-String.
+function wandLinkeSpalteHtml(w){
+  return wandTileAuslastung(w) + wandTileBesprochen(w) + wandTileHeute(w);
+}
+
+// wandKachel: die gemeinsame, nicht-interaktive Kachel-Umrahmung. Parameter:
+// titel, inhalt (HTML). Rückgabe: HTML-String.
+function wandKachel(titel, inhalt){
+  return '<section class="wand-kachel">'
+    + '<h3 class="wand-kachel-titel">' + esc(titel) + '</h3>'
+    + '<div class="wand-kachel-body">' + inhalt + '</div>'
+    + '</section>';
+}
+
+// wandSpringeZuProjekt: verlässt die Wandtafel und öffnet den Projektbereich
+// eines Projekts, optional direkt in einem bestimmten Abschnitt — derselbe
+// Weg (Hash VOR dem Tab-Wechsel setzen, showTab('plan') übernimmt ihn über
+// updateRouteUrl()) wie die Termin-Links im Dashboard
+// (js/dashboard/dashboard.js), nur als unmittelbarer Bereichswechsel statt
+// eines neuen Tabs — die Wandtafel hat nur die eine Ansicht. Der Hash wird
+// IMMER gesetzt (auch leer->'dashboard'), damit ein von einem früheren Sprung
+// übrig gebliebener Hash nicht fälschlich übernommen wird. (Die Rückkehr zur
+// Wandtafel nach einer Minute Untätigkeit — wandUnterwegs — wird nicht hier,
+// sondern generisch über den Klick-Lauscher auf #wandContent ausgelöst, da
+// die Projektliste über renderBoardRow() auch ganz ohne diese Funktion direkt
+// openProjectPlan() aufruft; siehe dort.) Parameter: pid (Projekt-ID),
+// abschnitt (Bereichs-Schlüssel, z. B. 'aufgaben'). Keine Rückgabe.
+function wandSpringeZuProjekt(pid, abschnitt){
+  location.hash = abschnitt || 'dashboard';
+  openProjectPlan(pid);
+}
+
+// ---------- Vollbild-Übersichten (gemeinsamer Rahmen) ----------
+
+// wandUebersichtRahmen: Kopfzeile (Titel + Schließen) plus Inhalt — von
+// jeder Übersicht genutzt. Parameter: titel, inhalt (HTML). Rückgabe:
+// HTML-String.
+function wandUebersichtRahmen(titel, inhalt){
+  return '<div class="wand-uebersicht">'
+    + '<div class="wand-uebersicht-kopf"><h2>' + esc(titel) + '</h2>'
+    +   '<button type="button" class="secondary small" onclick="wandSchliesseUebersicht()">← Zurück zur Wandtafel</button></div>'
+    + inhalt
+    + '</div>';
+}
+
+// wandUebersichtZeile: eine Zeile im gemeinsamen Dreispalten-Format
+// (links/mitte/rechts). onclick ist ein fertiger JS-Ausdruck als String oder
+// null für eine nicht anklickbare Zeile (z. B. eine Abwesenheit, die auf kein
+// Projekt verweist). Parameter: links, mitte, rechts (bereits escapte
+// HTML-Strings), onclick, rechtsKlasse (optional, z. B. 'ist-rot').
+// Rückgabe: HTML-String.
+function wandUebersichtZeile(links, mitte, rechts, onclick, rechtsKlasse){
+  return '<div class="wand-uebersicht-zeile' + (onclick ? ' ist-klickbar' : '') + '"'
+    + (onclick ? ' onclick="' + onclick + '"' : '') + '>'
+    + '<span class="wand-uebersicht-projekt">' + links + '</span>'
+    + '<span class="wand-uebersicht-titel">' + mitte + '</span>'
+    + '<span class="wand-uebersicht-seit' + (rechtsKlasse ? ' ' + rechtsKlasse : '') + '">' + rechts + '</span>'
+    + '</div>';
+}
+
+// wandZeigeUebersicht: öffnet eine Vollbild-Übersicht anstelle der
+// zweispaltigen Ansicht. Parameter: typ (String), gewerk (optional, nur für
+// 'auslastung'/'besprochen'). Keine Rückgabe.
+function wandZeigeUebersicht(typ, gewerk){
+  wandUebersicht = { typ, gewerk: gewerk || null };
+  renderWandboard();
+}
+
+// wandSchliesseUebersicht: zurück zur zweispaltigen Ansicht. Keine
+// Parameter, keine Rückgabe.
+function wandSchliesseUebersicht(){
+  wandUebersicht = null;
+  renderWandboard();
+}
+
+// wandUebersichtHtml: baut die gerade angeforderte Übersicht. Parameter: w.
+// Rückgabe: HTML-String.
+function wandUebersichtHtml(w){
+  const u = wandUebersicht;
+  if(u.typ === 'ueberfaellig') return wandUebersichtUeberfaellig(w);
+  if(u.typ === 'offen') return wandUebersichtOffeneAufgaben(w);
+  if(u.typ === 'abwesend') return wandUebersichtAbwesend(w);
+  if(u.typ === 'auslastung') return wandUebersichtAuslastung(w, u.gewerk);
+  if(u.typ === 'besprochen') return wandUebersichtBesprochen(w, u.gewerk);
+  return '';
+}
+
+// ---------- Kachel 1: Auslastung je Gewerk ----------
+
+// wandAuslastungJeGewerk: Wochenstunden, Kapazität UND die beitragenden
+// Projekte je Gewerk der aktuellen Sitzung. Rechnet mit denselben Funktionen
+// wie renderLoad() (js/load/load.js), nur nach Gewerk statt nach Person
+// summiert — dieselbe Stelle im Projekt-Durchlauf, an der auch renderLoad()
+// aggregiert. Die Projektliste je Gewerk ist der Rohstoff für die
+// Gewerk-Übersicht (wandUebersichtAuslastung()).
+//
+// Ein Projekt mit MEHREREN Gewerken zählt seinen vollen Beitrag bei JEDEM
+// seiner Gewerke — eine bewusste Dopplung, keine Aufteilung: Es gibt keine
+// Regel, wie die Stunden zwischen den Gewerken aufzuteilen wären, und eine
+// erfundene Aufteilung wäre irreführender als eine offen sichtbare Dopplung.
+// Parameter: w (Wochen-Objekt). Rückgabe: { GEWERK: {stunden, kapazitaet,
+// bewertbar, gesamt, projekte:[{id,name,nr,stunden}]} }.
+function wandAuslastungJeGewerk(w){
+  const ergebnis = {};
+  WAND_GEWERKE.forEach(g => { ergebnis[g] = { stunden: 0, kapazitaet: 0, bewertbar: 0, gesamt: 0, projekte: [] }; });
+
+  const vollzeit = Number(APP_SETTINGS.vollzeitStundenProWoche) || 40;
+  (Array.isArray(w.people) ? w.people : []).forEach(p => {
+    const global = (db.globalPeople || []).find(x => x.id === p.id)
+      || (p.fullName ? (db.globalPeople || []).find(x => x.fullName === p.fullName) : null);
+    const gewerk = global && global.gewerk;
+    if(!gewerk || !ergebnis[gewerk]) return;
+    ergebnis[gewerk].kapazitaet += kapazitaetsFaktor(p) * vollzeit;
+  });
+
+  (Array.isArray(w.projects) ? w.projects : []).forEach(pr => {
+    if(pr.group === 'In Anbahnung') return;
+    const gewerke = (Array.isArray(pr.gewerke) ? pr.gewerke : []).filter(g => ergebnis[g]);
+    if(gewerke.length === 0) return;
+    gewerke.forEach(g => { ergebnis[g].gesamt++; });
+
+    const aktivePhase = lpActiveList(pr)[0];
+    const probe = berechneAuslastung(null, pr, aktivePhase, ROLES[0], 1, null);
+    if(!probe.unbewertbar) gewerke.forEach(g => { ergebnis[g].bewertbar++; });
+
+    let projektStunden = 0;
+    Object.keys(pr.assign || {}).forEach(aKey => {
+      const rolle = aKey.slice(aKey.indexOf('|') + 1);
+      const al = berechneAuslastung(null, pr, aktivePhase, rolle, pr.assign[aKey], pr.assign);
+      if(al.stunden > 0) projektStunden += al.stunden;
+    });
+    gewerke.forEach(g => {
+      ergebnis[g].stunden += projektStunden;
+      if(projektStunden > 0) ergebnis[g].projekte.push({ id: pr.id, name: pr.name, nr: pr.nr, stunden: projektStunden });
+    });
+  });
+
+  return ergebnis;
+}
+
+// wandTileAuslastung: ein Meter je Gewerk, Ampelfarbe wie im Auslastungs-Tab.
+// Jede Zeile ist einzeln antippbar und öffnet die Projektliste dieses
+// Gewerks (wandZeigeUebersicht('auslastung', g)). Eine Null bekommt KEINE
+// grüne Farbe (dieselbe Regel wie in renderLoad()) — "keine Daten" statt
+// eines irreführend guten Balkens. Parameter: w. Rückgabe: HTML-String.
+function wandTileAuslastung(w){
+  const daten = wandAuslastungJeGewerk(w);
+  const inhalt = WAND_GEWERKE.map(g => {
+    const d = daten[g];
+    const label = (DEPARTMENTS[g] && DEPARTMENTS[g].label) || g;
+    const klick = ' onclick="wandZeigeUebersicht(\'auslastung\',\'' + g + '\')"';
+    if(d.bewertbar === 0 || d.kapazitaet <= 0){
+      return '<div class="wand-meter-zeile ist-klickbar"' + klick + '>'
+        + '<span class="wand-meter-label">' + esc(label) + '</span>'
+        + '<div class="wand-meter"><span class="wand-meter-leer">keine Daten</span></div>'
+        + '<span class="wand-meter-wert">—</span></div>';
+    }
+    const quote = d.stunden / d.kapazitaet;
+    const ampel = loadAmpelColor(quote);
+    const breite = Math.min(100, quote * 100);
+    return '<div class="wand-meter-zeile ist-klickbar"' + klick + '>'
+      + '<span class="wand-meter-label">' + esc(label) + '</span>'
+      + '<div class="wand-meter"><div class="wand-meter-fill" style="width:' + breite + '%;background:' + ampel + '"></div></div>'
+      + '<span class="wand-meter-wert" style="color:' + ampel + '">' + stundenFormat(d.stunden) + '<span class="wand-einheit">h</span></span></div>';
+  }).join('');
+  return wandKachel('Auslastung je Gewerk', inhalt);
+}
+
+// wandUebersichtAuslastung: alle Projekte, die zu einem Gewerk beitragen,
+// nach Stunden absteigend — Antippen springt ins Projekt (Abschnitt
+// "Leistung", der dort ohnehin schon errechnete Honorar/Fortschritt-Bezug
+// passt inhaltlich am ehesten zur Auslastungs-Frage). Parameter: w, gewerk.
+// Rückgabe: HTML-String.
+function wandUebersichtAuslastung(w, gewerk){
+  const daten = wandAuslastungJeGewerk(w)[gewerk];
+  const label = (DEPARTMENTS[gewerk] && DEPARTMENTS[gewerk].label) || gewerk;
+  if(!daten || daten.projekte.length === 0){
+    return wandUebersichtRahmen('Auslastung ' + label, '<div class="wand-leer">Keine Projekte mit Stunden in diesem Gewerk.</div>');
+  }
+  const sortiert = daten.projekte.slice().sort((a, b) => b.stunden - a.stunden);
+  const zeilen = sortiert.map(p =>
+    wandUebersichtZeile(esc(p.nr || ''), esc(p.name), stundenFormat(p.stunden) + ' h',
+      'wandSpringeZuProjekt(\'' + esc(p.id) + '\',\'leistung\')')
+  ).join('');
+  return wandUebersichtRahmen('Auslastung ' + label, '<div class="wand-uebersicht-liste">' + zeilen + '</div>');
+}
+
+// ---------- Kachel 2: Wochenbericht besprochen ----------
+
+// wandBesprochenDaten: "X von Y besprochen" je Gewerk plus die noch NICHT
+// besprochenen Projekte (Rohstoff der Gewerk-Übersicht). "In Anbahnung"
+// zählt nicht mit (dieselbe Ausnahme wie in renderLoad()). Parameter: w.
+// Rückgabe: { GEWERK: {besprochen, gesamt, offeneProjekte:
+// [{id,uid,name,nr}]} }.
+function wandBesprochenDaten(w){
+  const ergebnis = {};
+  WAND_GEWERKE.forEach(g => {
+    const relevante = (w.projects || []).filter(p =>
+      Array.isArray(p.gewerke) && p.gewerke.includes(g) && p.group !== 'In Anbahnung');
+    const offeneProjekte = relevante.filter(p => !p.besprochen);
+    ergebnis[g] = {
+      besprochen: relevante.length - offeneProjekte.length,
+      gesamt: relevante.length,
+      offeneProjekte: offeneProjekte.map(p => ({ id: p.id, uid: p.projectUid, name: p.name, nr: p.nr })),
+    };
+  });
+  return ergebnis;
+}
+
+// wandTileBesprochen: ein Meter je Gewerk ("X von Y"). Jede Zeile ist
+// einzeln antippbar und öffnet die Liste der noch offenen Projekte dieses
+// Gewerks (wandZeigeUebersicht('besprochen', g)). Parameter: w. Rückgabe:
+// HTML-String.
+function wandTileBesprochen(w){
+  const daten = wandBesprochenDaten(w);
+  const inhalt = WAND_GEWERKE.map(g => {
+    const d = daten[g];
+    const label = (DEPARTMENTS[g] && DEPARTMENTS[g].label) || g;
+    if(d.gesamt === 0){
+      return '<div class="wand-meter-zeile"><span class="wand-meter-label">' + esc(label) + '</span>'
+        + '<span class="wand-meter-leer">keine Projekte</span></div>';
+    }
+    const quote = d.besprochen / d.gesamt;
+    const klick = ' onclick="wandZeigeUebersicht(\'besprochen\',\'' + g + '\')"';
+    return '<div class="wand-meter-zeile ist-klickbar"' + klick + '>'
+      + '<span class="wand-meter-label">' + esc(label) + '</span>'
+      + '<div class="wand-meter"><div class="wand-meter-fill" style="width:' + (quote * 100) + '%;background:var(--accent)"></div></div>'
+      + '<span class="wand-meter-wert">' + d.besprochen + ' von ' + d.gesamt + '</span></div>';
+  }).join('');
+  return wandKachel('Wochenbericht besprochen', inhalt);
+}
+
+// wandUebersichtBesprochen: die noch nicht besprochenen Projekte eines
+// Gewerks — Antippen springt NICHT in den Projektbereich, sondern in den
+// Wochenbericht (springZumWochenbericht(), js/plan/plan-info.js): Der
+// Kommentar/besprochen-Haken wird ausschließlich dort gepflegt ("Ein Ort je
+// Angabe", CLAUDE.md), ein Sprung ins Projekt selbst würde nur auf den
+// Verweis-Hinweis dorthin treffen. Parameter: w, gewerk. Rückgabe:
+// HTML-String.
+function wandUebersichtBesprochen(w, gewerk){
+  const daten = wandBesprochenDaten(w)[gewerk];
+  const label = (DEPARTMENTS[gewerk] && DEPARTMENTS[gewerk].label) || gewerk;
+  if(!daten || daten.offeneProjekte.length === 0){
+    return wandUebersichtRahmen('Noch offen — ' + label, '<div class="wand-leer">Alle Projekte dieses Gewerks sind besprochen.</div>');
+  }
+  const zeilen = daten.offeneProjekte.map(p =>
+    wandUebersichtZeile(esc(p.nr || ''), esc(p.name), 'noch offen',
+      p.uid ? 'springZumWochenbericht(\'' + esc(p.uid) + '\')' : null)
+  ).join('');
+  return wandUebersichtRahmen('Noch offen — ' + label, '<div class="wand-uebersicht-liste">' + zeilen + '</div>');
+}
+
+// ---------- Kachel 3: Heute (Aufgaben + Abwesenheiten) ----------
+
+// wandHeuteDaten: offene/überfällige Aufgaben UND die heute abwesenden
+// Personen in einer Kachel — beides beantwortet dieselbe Frage ("was ist
+// heute los"), getrennte Kacheln dafür wären zwei dünne Kacheln nebeneinander
+// gewesen. Unternehmensweit über plan.todos ALLER Projekte, anders als GET
+// /my-dashboard (nur die eigenen Aufgaben); alle Personen, nicht "außer mir"
+// wie bei /my-dashboard — auf der Wandtafel gibt es kein "mich".
+// Parameter: w. Rückgabe: {offen, offeneListe:[{titel,projekt,pid,datum}],
+// ueberfaelligeListe:[{titel,projekt,pid,datum}],
+// abwesend:[{name,typ,bis}]}.
+function wandHeuteDaten(w){
+  const heute = heuteIso();
+  const offeneListe = [];
+  const ueberfaelligeListe = [];
+  (w.projects || []).forEach(pr => {
+    const todos = (pr.plan && Array.isArray(pr.plan.todos)) ? pr.plan.todos : [];
+    todos.forEach(t => {
+      if(t.done) return;
+      const eintrag = {
+        titel: t.title || 'Aufgabe',
+        projekt: (pr.nr ? pr.nr + ' ' : '') + pr.name,
+        datum: t.end || '',
+        pid: pr.id,
+      };
+      offeneListe.push(eintrag);
+      if(t.end && t.end < heute) ueberfaelligeListe.push(eintrag);
+    });
+  });
+  // Überfällig: am längsten überfällig zuerst. Offen: nächste Frist zuerst,
+  // Aufgaben ohne Termin ans Ende (dieselbe Reihenfolge wie "Meine Aufgaben"
+  // im Dashboard).
+  ueberfaelligeListe.sort((a, b) => a.datum.localeCompare(b.datum));
+  offeneListe.sort((a, b) => (a.datum || '9999') < (b.datum || '9999') ? -1 : (a.datum || '9999') > (b.datum || '9999') ? 1 : 0);
+
+  const abwesend = (db.globalPeople || []).filter(p =>
+    Array.isArray(p.absences) && p.absences.some(a => a.start <= heute && heute <= a.end)
+  ).map(p => {
+    const a = p.absences.find(a => a.start <= heute && heute <= a.end);
+    return { name: p.fullName || p.name, typ: (a && a.type) || 'Abwesend', bis: a && a.end };
+  });
+
+  return { offen: offeneListe.length, offeneListe, ueberfaelligeListe, abwesend };
+}
+
+// wandTileHeute: zwei Kennzahlen (offen/überfällig) plus Abwesenheits-Kürzel
+// — jede einzeln antippbar, kein Auf-/Zuklappen der Kachel mehr. Parameter:
+// w. Rückgabe: HTML-String.
+function wandTileHeute(w){
+  const d = wandHeuteDaten(w);
+
+  const offenStat = '<div class="wand-stat ist-klickbar" onclick="wandZeigeUebersicht(\'offen\')" title="Alle offenen Aufgaben anzeigen">'
+    + '<b>' + d.offen + '</b><span>offene Aufgaben</span></div>';
+  const ueberfaelligStat = '<div class="wand-stat' + (d.ueberfaelligeListe.length > 0 ? ' ist-rot' : '') + ' ist-klickbar"'
+    + ' onclick="wandZeigeUebersicht(\'ueberfaellig\')" title="Alle überfälligen Aufgaben anzeigen">'
+    + '<b>' + d.ueberfaelligeListe.length + '</b><span>überfällig</span></div>';
+
+  const namenHtml = d.abwesend.length
+    ? '<div class="wand-namen">' + d.abwesend.map(p =>
+        '<span class="wand-avatar ist-klickbar" title="' + esc(p.name) + ' — Alle Abwesenheiten anzeigen" onclick="wandZeigeUebersicht(\'abwesend\')">'
+        + esc(initialsFor(p.name)) + '</span>').join('') + '</div>'
+    : '<div class="wand-leer-klein">niemand abwesend</div>';
+
+  const inhalt = '<div class="wand-stat-reihe">' + offenStat + ueberfaelligStat + '</div>' + namenHtml;
+  return wandKachel('Heute', inhalt);
+}
+
+// wandUebersichtOffeneAufgaben: ALLE offenen Aufgaben (nicht nur
+// überfällige), nächste Frist zuerst. Parameter: w. Rückgabe: HTML-String.
+function wandUebersichtOffeneAufgaben(w){
+  const d = wandHeuteDaten(w);
+  if(d.offeneListe.length === 0){
+    return wandUebersichtRahmen('Offene Aufgaben', '<div class="wand-leer">Keine offenen Aufgaben.</div>');
+  }
+  const zeilen = d.offeneListe.map(t =>
+    wandUebersichtZeile(esc(t.projekt), '„' + esc(t.titel) + '"', t.datum ? esc(relativerTag(t.datum)) : 'ohne Termin',
+      'wandSpringeZuProjekt(\'' + esc(t.pid) + '\',\'aufgaben\')')
+  ).join('');
+  return wandUebersichtRahmen('Offene Aufgaben (' + d.offeneListe.length + ')', '<div class="wand-uebersicht-liste">' + zeilen + '</div>');
+}
+
+// wandUebersichtUeberfaellig: alle überfälligen Aufgaben, am längsten
+// überfällig zuerst — jede Zeile springt ins Projekt, Abschnitt "Aufgaben".
+// Parameter: w. Rückgabe: HTML-String.
+function wandUebersichtUeberfaellig(w){
+  const d = wandHeuteDaten(w);
+  if(d.ueberfaelligeListe.length === 0){
+    return wandUebersichtRahmen('Überfällige Aufgaben', '<div class="wand-leer">Keine überfälligen Aufgaben.</div>');
+  }
+  const zeilen = d.ueberfaelligeListe.map(t =>
+    wandUebersichtZeile(esc(t.projekt), '„' + esc(t.titel) + '"', esc(relativerTag(t.datum)),
+      'wandSpringeZuProjekt(\'' + esc(t.pid) + '\',\'aufgaben\')', 'ist-rot')
+  ).join('');
+  return wandUebersichtRahmen('Überfällige Aufgaben (' + d.ueberfaelligeListe.length + ')', '<div class="wand-uebersicht-liste">' + zeilen + '</div>');
+}
+
+// wandUebersichtAbwesend: alle heute abwesenden Personen mit Art und bis
+// wann — nicht anklickbar (eine Abwesenheit gehört zu keinem Projekt, in das
+// man springen könnte). Parameter: w. Rückgabe: HTML-String.
+function wandUebersichtAbwesend(w){
+  const d = wandHeuteDaten(w);
+  if(d.abwesend.length === 0){
+    return wandUebersichtRahmen('Abwesend heute', '<div class="wand-leer">Niemand abwesend.</div>');
+  }
+  const zeilen = d.abwesend.map(p =>
+    wandUebersichtZeile(esc(p.name), esc(p.typ), p.bis ? 'bis ' + esc(formatWeekDate(p.bis)) : '', null)
+  ).join('');
+  return wandUebersichtRahmen('Abwesend heute (' + d.abwesend.length + ')', '<div class="wand-uebersicht-liste">' + zeilen + '</div>');
+}
+
+// ---------- Ereignis-Feed (rechte Spalte) ----------
+
+// wandAktuelleEreignisse: sammelt drei Ereignisarten aus allen Projekten der
+// Sitzung — neue/aktualisierte Kommentare (classifyProjectChange()), frisch
+// überfällige Aufgaben und anstehende Meilensteine — als EINE Liste, nach
+// zeitlicher Nähe zu heute sortiert (|Tage bis Datum| aufsteigend, nicht nach
+// Datum selbst: Ein Ereignis von gestern und eines von morgen sind beide
+// "gerade jetzt relevant", eines von vor zwei Wochen oder in zwei Monaten ist
+// es nicht — unabhängig davon, ob es in der Vergangenheit oder Zukunft
+// liegt). wandFeedHtml() gruppiert diese EINE Liste anschließend nach `art`
+// in drei Spalten (Variante C aus dem Feed-Vergleich) — die Sortierung
+// bleibt deshalb unverändert, sie gilt nur jetzt INNERHALB jeder Spalte statt
+// über alle Arten hinweg. Jeder Eintrag trägt projekt/beschreibung getrennt
+// (statt einem fertigen Text) sowie pid/abschnitt für den Sprung ins
+// Projekt. Parameter: w. Rückgabe: Array aus {art, projekt (HTML, bereits
+// escaped), beschreibung (HTML, bereits escaped), zeit, pid, abschnitt}.
+function wandAktuelleEreignisse(w){
+  const heute = heuteIso();
+  const prevWeek = (typeof findPreviousWeek === 'function') ? findPreviousWeek(w) : null;
+  const ereignisse = [];
+
+  (Array.isArray(w.projects) ? w.projects : []).forEach(pr => {
+    if(pr.group === 'In Anbahnung') return;
+    const projekt = esc(pr.nr || '') + (pr.nr ? ' ' : '') + esc(pr.name || '');
+
+    if(typeof classifyProjectChange === 'function'){
+      const klass = classifyProjectChange(pr, prevWeek);
+      if(klass.bucket === 'status' || klass.bucket === 'new'){
+        const vorschauRoh = pr.status ? statusPreviewText(pr.status) : '';
+        const vorschau = vorschauRoh.slice(0, 70);
+        ereignisse.push({
+          art: 'neu',
+          datum: pr.statusAt || heute,
+          pid: pr.id, abschnitt: 'dashboard', projekt,
+          beschreibung: (klass.bucket === 'new' ? 'Neues Projekt' : 'Neuer Kommentar')
+            + (vorschau ? ': „' + esc(vorschau) + (vorschauRoh.length > 70 ? '…' : '') + '"' : ''),
+        });
+      }
+    }
+
+    const todos = (pr.plan && Array.isArray(pr.plan.todos)) ? pr.plan.todos : [];
+    todos.forEach(t => {
+      if(t.done || !t.end || t.end >= heute) return;
+      ereignisse.push({
+        art: 'ueberfaellig',
+        datum: t.end,
+        pid: pr.id, abschnitt: 'aufgaben', projekt,
+        beschreibung: '„' + esc(t.title || 'Aufgabe') + '" überfällig',
+      });
+    });
+
+    const meilensteine = (pr.plan && Array.isArray(pr.plan.milestones)) ? pr.plan.milestones : [];
+    meilensteine.forEach(m => {
+      if(!m.date || m.date < heute) return;
+      ereignisse.push({
+        art: 'termin',
+        datum: m.date,
+        pid: pr.id, abschnitt: 'terminplan', projekt,
+        beschreibung: 'Meilenstein „' + esc(m.name || 'Meilenstein') + '"',
+      });
+    });
+  });
+
+  ereignisse.forEach(e => { e.zeit = relativerTag(e.datum); });
+  ereignisse.sort((a, b) => Math.abs(tageBis(a.datum)) - Math.abs(tageBis(b.datum)));
+  return ereignisse;
+}
+
+// WAND_FEED_SPALTEN: Reihenfolge und Beschriftung der drei Feed-Spalten.
+const WAND_FEED_SPALTEN = [
+  { art: 'neu', label: 'Neu' },
+  { art: 'ueberfaellig', label: 'Überfällig' },
+  { art: 'termin', label: 'Termine' },
+];
+
+// wandFeedHtml: gruppiert wandAktuelleEreignisse() nach Art in drei Spalten
+// (Eriks Wahl "Variante C" aus dem Feed-Vergleich) — zeigt auf einen Blick,
+// wie viele Ereignisse welcher Art anstehen, statt sie chronologisch zu
+// mischen. Die Spaltenüberschrift nennt die TATSÄCHLICHE Gesamtzahl dieser
+// Art, auch wenn nur WAND_FEED_MAX Einträge angezeigt werden. Jeder Eintrag
+// bleibt für sich antippbar und springt direkt ins zugehörige Projekt.
+// Parameter: w. Rückgabe: HTML-String.
+function wandFeedHtml(w){
+  const ereignisse = wandAktuelleEreignisse(w);
+  const spalten = WAND_FEED_SPALTEN.map(s => {
+    const alle = ereignisse.filter(e => e.art === s.art);
+    const gezeigt = alle.slice(0, WAND_FEED_MAX);
+    const eintraegeHtml = gezeigt.length
+      ? gezeigt.map(e =>
+          '<div class="wand-feed-eintrag" onclick="wandSpringeZuProjekt(\'' + esc(e.pid) + '\',\'' + esc(e.abschnitt) + '\')">'
+          + '<b>' + e.projekt + '</b><span>' + e.beschreibung + '</span>'
+          + '<span class="wand-feed-zeit">' + esc(e.zeit) + '</span>'
+          + '</div>'
+        ).join('')
+      : '<div class="wand-leer-klein">keine</div>';
+    return '<div class="wand-feed-gruppe">'
+      + '<div class="wand-feed-gruppe-kopf">'
+      +   '<span class="wand-feed-gruppe-punkt ' + s.art + '"></span>'
+      +   '<span class="wand-feed-gruppe-titel">' + esc(s.label) + '</span>'
+      +   '<span class="wand-feed-gruppe-anzahl">' + alle.length + '</span>'
+      + '</div>'
+      + eintraegeHtml
+      + '</div>';
+  }).join('');
+  return '<div class="wand-feed-gruppen">' + spalten + '</div>';
+}
+
+// ---------- Stand ----------
+
+// renderWandStand: reiner Zeitstempel der letzten erfolgreichen
+// Aktualisierung — das einzige Lebenszeichen, dass das unbeaufsichtigte
+// Display nicht eingefroren ist. Keine Parameter. Rückgabe: HTML-String.
+function renderWandStand(){
+  const jetzt = new Date().toLocaleTimeString('de-DE', { hour: '2-digit', minute: '2-digit' });
+  return '<div class="wand-stand">Stand: ' + jetzt + ' Uhr</div>';
+}
diff --git a/public/js/weeks.js b/public/js/weeks.js
index 96c4987..f130edd 100644
--- a/public/js/weeks.js
+++ b/public/js/weeks.js
@@ -2,30 +2,19 @@
 // Projektübersicht — Sitzungs-/Wochen-Verwaltung
 // -----------------------------
 // Diese Datei verwaltet die Sitzungen (Wochen): Auswahl, Anzeige des Datums,
-// Erzeugung neuer Sitzungen, Duplizieren, Sperren (Auto-Lock) und Löschen.
-// Sie wird von `Test.html` nach `js/store.js` geladen und stellt globale
-// Funktionen wie `currentWeek()`, `switchWeek()`, `newWeek()`, `cloneWeek()`,
-// `applyAutoLock()`, `guardWeekLocked()` und `deleteWeek()` bereit. Genutzt wird
+// Sperren (Auto-Lock) und Löschen. Sie wird von `App.html` nach `js/store.js`
+// geladen und stellt globale Funktionen wie `currentWeek()`, `switchWeek()`,
+// `applyAutoLock()`, `guardWeekLocked()`, `unlockWeek()` und `deleteWeekById()`
+// bereit. Genutzt wird
 // sie u.a. von `js/board/board.js` (`renderBoard`, `isWeekLocked`), `js/store.js`
 // (`load`) und `js/tabs-auth.js` (Passwort-Aktionen für Entsperren/Löschen).
-
-// refreshWeekSelect: aktualisiert das Dropdown `weekSelect` mit allen Sitzungen
-// der aktuellen Abteilung und markiert die aktuell ausgewählte. Kein Parameter,
-// keine Rückgabe.
-function refreshWeekSelect(){
-  const sel = document.getElementById('weekSelect');
-  sel.innerHTML = db.weeks.map(w=>`<option value="${w.id}" ${w.id===db.currentWeek?'selected':''}>${w.label}</option>`).join('');
-}
-
-// updateWeekDate: zeigt das Datum der aktuellen Sitzung im Display
-// `weekDateDisplay` an (formatiert über `formatWeekDate()`). Kein Parameter,
-// keine Rückgabe; leer, wenn keine Woche gewählt ist.
-function updateWeekDate(){
-  const disp = document.getElementById('weekDateDisplay');
-  const w = currentWeek();
-  if(!disp) return;
-  disp.textContent = w?.date ? `Datum: ${formatWeekDate(w.date)}` : '';
-}
+//
+// Neue Sitzungen entstehen seit dem automatischen Sitzungswechsel NICHT MEHR
+// hier — `ensureCurrentWeekRollover()` (server.js) legt sie serverseitig an,
+// sobald der Kalender in eine neue ISO-Woche wechselt, unabhängig davon, ob
+// irgendjemand die Anwendung gerade geöffnet hat (siehe CLAUDE.md). Die
+// früheren Funktionen `newWeek()`/`cloneWeek()`/`validateWeekLabel()` sind
+// deshalb entfallen.
 
 // currentWeek: liefert das Woche-Objekt zur aktuellen Auswahl aus `db.weeks`.
 // Kein Parameter; Rückgabe: das gefundene Woche-Objekt oder undefined.
@@ -37,53 +26,30 @@ function currentWeek(){ return db.weeks.find(w=>w.id===db.currentWeek); }
 // Keine Rückgabe.
 function switchWeek(id){ db.currentWeek = id; renderAll(); }
 
-// newWeek: erzeugt über zwei prompt-Dialoge eine neue leere Sitzung (Bezeichnung
-// und Datum). Die neue Woche übernimmt die globale Personenliste der Abteilung,
-// wird angehängt, per `applyAutoLock()` gesperrt und als aktuelle Woche gesetzt.
-// Keine Parameter, keine Rückgabe.
-function newWeek(){
-  const label = prompt("Bezeichnung der neuen Sitzung (z.B. KW 31 / 2026):","KW  / 2026");
-  if(!label) return;
-  const date = prompt("Datum (JJJJ-MM-TT):", new Date().toISOString().slice(0,10)) || "";
-  // Neue Woche übernimmt die aktuell globale Personenliste
-  const people = JSON.parse(JSON.stringify(db.globalPeople[currentDepartment] || []));
-  const w = {id:uid(), label, date, people, projects:[], attendance:{}, locked:false};
-  db.weeks.push(w);
-  applyAutoLock();
-  db.currentWeek=w.id; save(); renderAll();
-}
-
-// cloneWeek: dupliziert die aktuelle Sitzung inkl. Projekten (Dialog für
-// Bezeichnung und Datum). Projekte erhalten neue IDs; Status-Markierungen
-// werden auf `statusState='duplicated'` gesetzt. Keine Parameter, keine Rückgabe.
-function cloneWeek(){
-  const cur = currentWeek(); if(!cur) return;
-  const label = prompt("Bezeichnung der duplizierten Sitzung:", cur.label+" (Kopie)");
-  if(!label) return;
-  const date = prompt("Datum (JJJJ-MM-TT):", new Date().toISOString().slice(0,10)) || "";
-  const w = JSON.parse(JSON.stringify(cur));
-  w.id=uid(); w.label=label; w.date=date; w.attendance={}; w.locked=false;
-  // Neue IDs für duplizierte Projekte und Kennzeichnung
-  w.projects.forEach(p=>{
-    p.id = uid();
-    if(p.status && p.status.trim() !== "") p.statusState = 'duplicated';
-    else delete p.statusState;
-  });
-  db.weeks.push(w);
-  applyAutoLock();
-  db.currentWeek=w.id; save(); renderAll();
-}
-
 // -------- Sperren (Auto-Lock) und Entsperren --------
 
 // applyAutoLock: sperrt alle Sitzungen bis auf die chronologisch
 // letzte (aktuellste). Wird beim Laden, Erstellen und Duplizieren verwendet,
 // damit historische Sitzungen nicht mehr unbeabsichtigt bearbeitet werden.
+//
+// Firmenweit abschaltbar (Einstellung 'autoLockAktiv'): In manchen Büros wird
+// an mehreren Sitzungen parallel gearbeitet, dort steht die automatische
+// Sperre im Weg. Ist sie aus, wird NICHT nachträglich entsperrt — bereits
+// gesperrte Sitzungen bleiben es, das Entsperren bleibt eine bewusste
+// Admin-Handlung (POST /unlock-week).
 function applyAutoLock(){
   if(db.weeks.length === 0) return;
-  const sorted = [...db.weeks].sort((a,b) => weekSortKey(a.label).localeCompare(weekSortKey(b.label)));
+  if(!Number(APP_SETTINGS.autoLockAktiv)) return;
+  // Die Planung-Sandbox (SANDBOX_WEEK_LABEL) landet nie in db.weeks (siehe
+  // load(), js/store.js) und ist von dieser Schleife also strukturell schon
+  // ausgenommen — dieser Filter ist ein reines Sicherheitsnetz, falls das
+  // je nicht mehr zuträfe: sie darf nie als "späteste Woche" zählen oder
+  // gesperrt werden, sie ist keine echte Sitzung.
+  const echteWochen = db.weeks.filter(w => w.label !== SANDBOX_WEEK_LABEL);
+  if(echteWochen.length === 0) return;
+  const sorted = [...echteWochen].sort((a,b) => weekSortKey(a.label).localeCompare(weekSortKey(b.label)));
   const latestId = sorted[sorted.length - 1].id;
-  db.weeks.forEach(w => {
+  echteWochen.forEach(w => {
     const wasLocked = !!w.locked;
     w.locked = (w.id !== latestId);
     // Nur tatsächlich geänderte Lock-Zustände übertragen (beim bloßen Laden
@@ -111,52 +77,93 @@ function guardWeekLocked(){
   return false;
 }
 
-// unlockCurrentWeek: Entsperrt die aktuelle Sitzung nach Passwortprüfung.
-// Parameter `skipAuth=true` überspringt die Passwortabfrage (Aufruf nach
-// erfolgreicher Authentifizierung). Keine Rückgabe.
-function unlockCurrentWeek(skipAuth = false){
-  const w = currentWeek();
+// unlockWeek: entsperrt EINE Sitzung serverseitig (POST /unlock-week,
+// admin-only) und übernimmt bei Erfolg den Sperr-Zustand sowie die neue
+// Revision (`updatedAt`) lokal.
+//
+// Verallgemeinert gegenüber der früheren Fassung, die nur `currentWeek()`
+// kannte: Seit die Sitzungsauswahl aus dem Menüband entfernt wurde
+// (Sitzungen dienen nur noch der Speicherung und dem Verlauf), muss sich
+// auch eine ANDERE als die gerade offene Sitzung entsperren lassen — die
+// Sitzungsliste im Admin-Bereich (renderAdminSitzungen(), js/admin/admin.js)
+// braucht genau das.
+// Parameter: w (Woche-Objekt aus db.weeks), nachRender (optionale Funktion
+// statt renderAll() — die Admin-Liste soll nur sich selbst neu zeichnen,
+// nicht die ganze Seite, die ohnehin die entsperrte Sitzung nicht zeigt).
+// Keine Rückgabe.
+function unlockWeek(w, nachRender){
   if(!w || !w.locked) return;
-  if(!skipAuth && !isAuthenticated){
-    requestedAction = { type: 'unlockWeek' };
-    document.getElementById('passwordModal').style.display='flex';
-    document.getElementById('passwordInput').value='';
-    document.getElementById('passwordInput').focus();
-    return;
-  }
-  w.locked = false;
-  save(); renderAll();
-  requestedAction = null;
+  fetch(baseUrl() + '/unlock-week', {
+    method: 'POST',
+    headers: {'Content-Type':'application/json'},
+    body: JSON.stringify({ label: w.label })
+  }).then(r => {
+    if(r.status === 403){ alert('Nur Administratoren dürfen Sitzungen entsperren.'); return null; }
+    return r.json().then(json => ({ status: r.status, json }));
+  }).then(result => {
+    if(!result) return;
+    const { status, json } = result;
+    if(status === 200 && json && json.ok){
+      w.locked = false;
+      if(json.updatedAt) w.updatedAt = json.updatedAt;
+      (nachRender || renderAll)();
+    } else {
+      alert('Entsperren fehlgeschlagen: ' + (json && json.error ? json.error : 'unbekannter Fehler'));
+    }
+  }).catch(err => {
+    alert('Entsperren fehlgeschlagen: ' + (err.message || err));
+  });
 }
 
-// deleteWeek: löscht die aktuell ausgewählte Sitzung (nur wenn mehr als 1
-// vorhanden) auf dem Server. Parameter `skipAuth=true` überspringt die
-// Passwortabfrage. Danach wird die letzte verbleibende Woche aktiviert und neu
-// gerendert. Keine Rückgabe.
-function deleteWeek(skipAuth = false){
+// unlockCurrentWeek: entsperrt die gerade offene Sitzung. Aufrufer ist
+// ausschließlich der Sperr-Hinweis auf dem Board/Wochenbericht
+// (renderBoard()/renderWochenbericht()), der nur erscheint, wenn
+// `currentWeek()` selbst gesperrt ist — im Normalbetrieb mit aktiver
+// Auto-Sperre kommt das praktisch nicht vor, da immer nur die jüngste
+// Sitzung offen bleibt. Dünner Wrapper um `unlockWeek()`.
+function unlockCurrentWeek(){ unlockWeek(currentWeek()); }
+
+// deleteWeekById: löscht EINE Sitzung (nicht zwingend die aktuell offene)
+// mitsamt allen Projekten, Zuordnungen und Plänen dieser Sitzung auf dem
+// Server (admin-only, POST /delete-week). Mindestens eine Sitzung muss
+// bestehen bleiben. Die lokale Woche wird erst nach erfolgreicher
+// Server-Antwort entfernt (sonst würde sie bei fehlender Berechtigung
+// lokal verschwinden, obwohl sie auf dem Server weiterhin existiert).
+//
+// Ersetzt die frühere `deleteWeek()`, die stillschweigend "die im Menüband
+// gewählte Sitzung" meinte — ohne diese Auswahl im Menüband ist eine
+// explizite Ziel-Sitzung nötig; Aufrufer ist jetzt ausschließlich die
+// Sitzungsliste im Admin-Bereich.
+// Parameter: weekId, nachDelete (optionale Zusatzfunktion, die NACH dem
+// üblichen renderAll() zusätzlich läuft — die Admin-Liste zeichnet sich
+// darüber selbst neu, weil renderAll() sie nicht kennt). Keine Rückgabe.
+function deleteWeekById(weekId, nachDelete){
   if(db.weeks.length<=1){ alert("Mindestens eine Sitzung muss bestehen bleiben."); return; }
-  if(!skipAuth && !isAuthenticated){
-    requestedAction = { type: 'deleteWeek' };
-    document.getElementById('passwordModal').style.display='flex';
-    document.getElementById('passwordInput').value='';
-    document.getElementById('passwordInput').focus();
-    return;
-  }
-  if(!confirm("Diese Sitzung wirklich löschen?")) { requestedAction = null; return; }
-  const current = currentWeek();
-  if(current){
-    const label = current.label;
-    console.log('Lösche Woche auf Server:', label);
-    deleteWeekFromServer(label).then(res=>{
-      if(res && res.ok){ console.log('Woche gelöscht:', label); }
-      else { alert('Wochen-Löschung fehlgeschlagen: ' + (res && res.error ? res.error : 'unbekannter Fehler')); }
-    }).catch(err=>{ alert('Wochen-Löschung fehlgeschlagen: ' + (err.message || err)); });
-  }
-  db.weeks = db.weeks.filter(w=>w.id!==db.currentWeek);
-  db.weeks.sort((a,b) => weekSortKey(a.label).localeCompare(weekSortKey(b.label)));
-  db.currentWeek = db.weeks[db.weeks.length - 1].id;
-  applyAutoLock();
-  save();
-  renderAll();
-  requestedAction = null;
+  const w = db.weeks.find(x => x.id === weekId);
+  if(!w) return;
+  if(!confirm('Sitzung "' + w.label + '" wirklich löschen?')) return;
+  console.log('Lösche Woche auf Server:', w.label);
+  deleteWeekFromServer(w.label).then(res=>{
+    if(!(res && res.ok)){
+      alert('Wochen-Löschung fehlgeschlagen: ' + (res && res.error ? res.error : 'unbekannter Fehler'));
+      return;
+    }
+    console.log('Woche gelöscht:', w.label);
+    const warAktuell = (weekId === db.currentWeek);
+    db.weeks = db.weeks.filter(x=>x.id!==weekId);
+    db.weeks.sort((a,b) => weekSortKey(a.label).localeCompare(weekSortKey(b.label)));
+    // Zeigte die Oberfläche gerade die gelöschte Sitzung (oder zeigt sie aus
+    // irgendeinem Grund gar keine mehr existierende), auf die jüngste
+    // verbleibende wechseln — sonst verwiese db.currentWeek ins Leere.
+    if(warAktuell || !db.weeks.some(x => x.id === db.currentWeek)){
+      db.currentWeek = db.weeks[db.weeks.length - 1].id;
+    }
+    applyAutoLock();
+    save();
+    renderAll();
+    if(typeof nachDelete === 'function') nachDelete();
+  }).catch(err=>{
+    if(err && err.status === 403){ alert('Nur Administratoren dürfen Sitzungen löschen.'); return; }
+    alert('Wochen-Löschung fehlgeschlagen: ' + (err.message || err));
+  });
 }
\ No newline at end of file
diff --git a/public/js/wochenbericht/wochenbericht.js b/public/js/wochenbericht/wochenbericht.js
index b8bbbcf..fb4fc44 100644
--- a/public/js/wochenbericht/wochenbericht.js
+++ b/public/js/wochenbericht/wochenbericht.js
@@ -18,7 +18,7 @@
 // Projekt-Identität, die project_id (wird bei jedem cloneWeek() neu
 // vergeben) nicht bieten konnte. Die Bearbeitung der Projekte selbst
 // (Kommentar-Editor, LPH, Beteiligte) läuft vollständig über die bestehenden
-// Funktionen aus js/board/board.js (editProj/editLph/cycleAssign/
+// Funktionen aus js/board/board.js (editLph/cycleAssign/
 // renderCommentEditor/renderBoardDrawer/renderBoardRow) — dieses Modul
 // ergänzt die Gruppierung/Diff-Logik, das Layout des Berichts und die
 // Anwesenheitserfassung am Seitenfuß (renderAttendance(), weiter unten).
@@ -26,7 +26,7 @@
 // diesem Tab die Sitzung abgearbeitet wird.
 //
 // Läuft wie board.js als klassisches globales Skript (kein Modul/IIFE), nur
-// von Test.html geladen (nach js/board/board.js).
+// von App.html geladen (nach js/board/board.js).
 
 // findPreviousWeek: liefert die chronologisch vorherige Sitzung zu `week`
 // (nach weekSortKey sortiert) oder null, wenn `week` die früheste ist.
@@ -89,11 +89,12 @@ function classifyProjectChange(p, prevWeek){
 }
 
 // BERICHT_OPTS: Darstellungs-Optionen, die dieser Tab an die gemeinsamen
-// Render-Funktionen aus js/board/board.js übergibt. Im Wochenbericht werden
-// nur die beauftragten Leistungsphasen gezeigt (p.beauftragteLP) — im
-// Projektboard bleibt es bei allen. Den Verlauf der Vorwochen hängt
-// renderBoardDrawer() inzwischen überall an (renderProjektVerlauf() in
-// js/utils.js), er braucht deshalb kein eigenes Kennzeichen mehr.
+// Render-Funktionen aus js/board/board.js übergibt. dicht ist das einzige,
+// was den Wochenbericht noch vom Projektboard unterscheidet (zwei statt drei
+// Spalten) — nurBeauftragteLph gilt inzwischen für beide (BOARD_OPTS,
+// js/board/board.js). Den Verlauf der Vorwochen hängt renderBoardDrawer()
+// überall an (renderProjektVerlauf() in js/utils.js), er braucht deshalb kein
+// eigenes Kennzeichen mehr.
 const BERICHT_OPTS = { nurBeauftragteLph: true, dicht: true };
 
 // renderReportCard: baut die immer aufgeklappte Karte eines Projekts im
@@ -120,27 +121,6 @@ function renderReportCard(p, reason, allPeople, locked, weekLabel, variant){
     </div>`;
 }
 
-// renderReportSection: baut einen Abschnitt des Berichts (Überschrift mit
-// Anzahl, Liste der zugehörigen Projekte). `expanded` steuert, ob die volle
-// Karte (renderReportCard) oder die normale einklappbare Board-Zeile
-// (renderBoardRow) genutzt wird. Parameter: title, entries (Array
-// {p, reason}), allPeople, locked, expanded (Boolean), emptyText. Rückgabe:
-// HTML-String.
-function renderReportSection(title, entries, allPeople, locked, expanded, emptyText, weekLabel, variant){
-  let html = `<div class="section-title">${esc(title)} (${entries.length})</div>`;
-  if(entries.length === 0){
-    html += `<div class="hint">${esc(emptyText)}</div>`;
-    return html;
-  }
-  html += `<div class="${expanded ? 'report-list' : 'board-list'}">`;
-  html += entries.map(({p, reason}) => expanded
-    ? renderReportCard(p, reason, allPeople, locked, weekLabel, variant)
-    : renderBoardRow(p, allPeople, locked, weekLabel, BERICHT_OPTS)
-  ).join('');
-  html += `</div>`;
-  return html;
-}
-
 // ---------- Anwesenheit der Sitzung ----------
 // Die Anwesenheit hing ursprünglich als Zweitfunktion an der Kürzel-Legende
 // unter dem Projektboard ("klick für Anwesenheit") — Namenserklärung und
@@ -672,8 +652,13 @@ function openTodoAusKommentar(pid){
   // Vorschlag aus dem gerade im Feld stehenden Text, nicht aus dem
   // gespeicherten: Im Meeting tippt man den Beschluss und legt sofort die
   // Aufgabe an, ohne vorher zu speichern.
+  // feld ist seit der Umstellung auf contenteditable (Eriks Wunsch nach
+  // echter Fett-/Kursiv-/Farbdarstellung statt sichtbarer Markup-Zeichen,
+  // js/utils.js) ein <div> ohne .value — statusTextMitZeilen() liefert
+  // daraus reinen Text mit erhaltenen Zeilenumbrüchen, aus dem unten die
+  // erste Zeile als Titelvorschlag gezogen wird.
   const feld = document.querySelector('#wochenbericht .comment-field');
-  const text = feld ? feld.value : statusPlainText(p.status);
+  const text = feld ? statusTextMitZeilen(feld.innerHTML) : statusPlainText(p.status);
   const ersteZeile = String(text || '').split('\n').map(z => z.replace(/^[-•*\s]+/, '').trim()).find(z => z) || '';
 
   document.getElementById('todoKommentarTitel').value = ersteZeile.slice(0, 120);
@@ -844,7 +829,11 @@ document.addEventListener('keydown', function(e){
   if(typeof currentTab === 'undefined' || currentTab !== 'wochenbericht') return;
   const w = currentWeek();
   if(!w) return;
-  const imFeld = e.target && e.target.matches && e.target.matches('input, textarea, select');
+  // isContentEditable erfasst das Kommentarfeld (seit der Umstellung auf
+  // contenteditable ein <div>, kein <textarea> mehr, siehe js/utils.js) —
+  // ohne diese Ergänzung griffen ↓/↑ dort als Projekt-Wechsel statt als
+  // normale Cursorbewegung im Text.
+  const imFeld = e.target && ((e.target.matches && e.target.matches('input, textarea, select')) || e.target.isContentEditable);
 
   if((e.key === 'Enter') && (e.ctrlKey || e.metaKey)){
     const feld = e.target && e.target.closest ? e.target.closest('.comment-field') : null;
diff --git a/public/dein_bild.ico b/public/logo.ico
similarity index 100%
rename from public/dein_bild.ico
rename to public/logo.ico
diff --git a/public/plan-styles.css b/public/plan-styles.css
index c942d42..7948b36 100644
--- a/public/plan-styles.css
+++ b/public/plan-styles.css
@@ -678,11 +678,20 @@ html[data-theme="dark"] { --seg-hover: rgba(255,255,255,.10); }
 /* === Bereich "Protokolle" (js/plan/plan-protokoll.js) ===
    Listenansicht (.protokoll-row je Protokoll) und Detailansicht
    (.protokoll-field-grid Kopf, Teilnehmer- und Punkte-Block). Der
-   Punkte-Block gruppiert in .protokoll-gruppe-Abschnitte (freier Text,
-   keine feste Liste, siehe CLAUDE.md "### Protokolle"); neue Punkte tragen
-   .is-neu (eigenes Gelb-Token --protokoll-neu-bg/-border, siehe styles.css —
-   bewusst nicht --band-neu, das im Wochenbericht schon blau "neu
-   kommentiert" bedeutet). */
+   Punkte-Block ist ZWEIGETEILT (.protokoll-split): links eine schmale
+   Liste aller Punkte nach Gruppen (.protokoll-liste), rechts der
+   Schreibbereich für den gerade ausgewählten (.protokoll-schreiben) —
+   Begründung bei .protokoll-split weiter unten. Gruppierung bleibt freier
+   Text, keine feste Liste, siehe CLAUDE.md "### Protokolle".
+
+   Das Neu-Kennzeichen ist seit dieser Umstellung ein schlichter Chip
+   (.protokoll-chip-neu, Gelb-Token --protokoll-neu-bg/-border — bewusst
+   nicht --band-neu, das im Wochenbericht schon blau "neu kommentiert"
+   bedeutet) statt einer Einfärbung ganzer Zeilen und Felder; der Status
+   eines Punkts erscheint als farbiger Punkt im Listeneintrag
+   (.protokoll-punkt-dot) und als Umschalter im Kopf des Schreibbereichs.
+   Damit entfällt das frühere Gegeneinander von Zeilen-Gelb und
+   Feldrahmen. */
 
 .protokoll-list-head { display: flex; align-items: center; justify-content: space-between; margin-bottom: 10px; }
 
@@ -727,7 +736,7 @@ html[data-theme="dark"] { --seg-hover: rgba(255,255,255,.10); }
 
 /* Ladehinweis im Import-Dialog (#protokollImportLoading, Test.html): ohne
    ihn wirkte der Dialog während eines länger laufenden KI-Aufrufs (bis zu
-   KI_TIMEOUT_MS_LOKAL = 5 Minuten bei einem eigenen Server, server.js) wie
+   KI_TIMEOUT_MS_LOKAL = 30 Minuten bei einem eigenen Server, server.js) wie
    hängengeblieben — Felder und Knöpfe werden während der Anfrage zusätzlich
    gesperrt (setzeProtokollImportLadezustand(), plan-protokoll.js), damit
    kein zweiter Import gleichzeitig losgeschickt wird.
@@ -754,7 +763,7 @@ html[data-theme="dark"] { --seg-hover: rgba(255,255,255,.10); }
 .protokoll-field label { font-size: 11.5px; color: var(--text-subtle); text-transform: uppercase; letter-spacing: .04em; }
 
 .protokoll-block { margin-top: 20px; }
-.protokoll-block-head { margin-bottom: 10px; }
+.protokoll-block-head { margin-bottom: 10px; display: flex; align-items: center; justify-content: space-between; }
 .protokoll-block-head h4 { margin: 0; font-size: 13.5px; font-weight: 650; }
 
 .protokoll-teilnehmer-row { display: grid; grid-template-columns: 1fr 160px 100px 24px; gap: 10px; align-items: center;
@@ -765,54 +774,232 @@ html[data-theme="dark"] { --seg-hover: rgba(255,255,255,.10); }
 .protokoll-row-remove { color: var(--text-subtle); text-align: center; cursor: pointer; opacity: .6; flex-shrink: 0; }
 .protokoll-row-remove:hover { opacity: 1; color: var(--red); }
 
-.protokoll-gruppe { margin-bottom: 18px; }
-.protokoll-gruppe:last-of-type { margin-bottom: 8px; }
-.protokoll-gruppe-head { display: flex; align-items: center; justify-content: space-between;
-  padding: 2px 2px 8px; border-bottom: 1px solid var(--line-soft); margin-bottom: 10px; }
-.protokoll-gruppe-name { font-size: 11px; font-weight: 700; text-transform: uppercase; letter-spacing: .06em;
-  color: var(--accent); background: var(--accent-soft); padding: 3px 9px; border-radius: var(--r-pill); }
-.protokoll-gruppe-name.is-leer { color: var(--text-subtle); background: var(--surface-sunk); }
-.protokoll-gruppe-add { font-size: 12px; color: var(--accent); font-weight: 600; cursor: pointer; }
-.protokoll-gruppe-add:hover { color: var(--accent-hover); }
-.protokoll-gruppe-move,
-.protokoll-punkt-move { display: inline-flex; gap: 4px; flex-shrink: 0; }
-.protokoll-gruppe-move button,
-.protokoll-punkt-move button { padding: 2px 7px; line-height: 1.4; }
-.protokoll-gruppe-move button:disabled,
-.protokoll-punkt-move button:disabled { opacity: .3; cursor: default; }
+/* ---------- Punkte: links Liste, rechts Schreibbereich ----------
+   Eriks Auswahl „Liste + Schreibbereich" aus dem Protokoll-schreiben-Mockup,
+   Ablösung der früheren durchgehenden Tabelle (eine Zeile je Punkt mit allen
+   Feldern nebeneinander). Begründung dort und im Kopf von
+   renderPunkteBlockHtml() (js/plan/plan-protokoll.js): ein Protokollpunkt ist
+   ein kleiner Fließtext, keine Tabellenzelle — in der Spalte blieb für den
+   Text weder Breite noch Höhe, Thema und Text klebten übereinander und die
+   Formatierungsleiste saß eingeklemmt dazwischen. */
+.protokoll-split { display: grid; grid-template-columns: 290px minmax(0, 1fr); gap: 14px; align-items: start; }
 
-.protokoll-punkt { position: relative; border: 1px solid var(--line-soft); border-radius: var(--r-md);
-  padding: 10px 12px; margin-bottom: 8px; background: var(--surface); }
-.protokoll-punkt:last-child { margin-bottom: 0; }
-.protokoll-punkt.is-neu { background: var(--protokoll-neu-bg); border-color: var(--protokoll-neu-border);
-  border-left: 3px solid var(--protokoll-neu-border); padding-left: 9px; }
-.protokoll-punkt.is-erledigt { opacity: .6; }
-.protokoll-punkt-top-row { display: flex; align-items: center; gap: 8px; margin-bottom: 6px; flex-wrap: wrap; }
-.protokoll-punkt-nr { display: inline-block; width: 46px; flex-shrink: 0; font-variant-numeric: tabular-nums;
-  font-weight: 650; font-size: 12.5px; text-align: center; padding: 5px 4px; color: var(--text-muted);
-  background: var(--surface-sunk); border-radius: var(--r-sm); }
-.protokoll-punkt.is-neu .protokoll-punkt-nr { background: rgba(0,0,0,.06); color: var(--text); }
-.protokoll-punkt-gruppe { width: 110px; flex-shrink: 0; font-size: 12px; }
-.protokoll-chip-neu { background: var(--protokoll-neu-border); color: #3d2e00; font-size: 10px; font-weight: 700;
-  letter-spacing: .03em; text-transform: uppercase; padding: 2px 7px; border-radius: var(--r-pill); flex-shrink: 0; }
-.protokoll-punkt-thema { flex: 1; min-width: 160px; font-weight: 600; font-size: 13px; }
-.protokoll-punkt-erledigt-toggle { display: flex; align-items: center; gap: 5px; font-size: 12px;
-  color: var(--text-muted); flex-shrink: 0; }
-.protokoll-punkt-text { width: 100%; resize: vertical; font: inherit; font-size: 12.5px; color: var(--text-muted);
-  margin: 0 0 8px; box-sizing: border-box; }
-.protokoll-punkt-foot { display: flex; gap: 18px; flex-wrap: wrap; font-size: 12px; color: var(--text-subtle); }
-.protokoll-punkt-foot label { display: flex; align-items: center; gap: 6px; }
-.protokoll-punkt-foot input[type=text] { font-size: 12px; padding: 5px 8px; }
-.protokoll-punkt-foot .range-picker-display { width: 100px; font-size: 12px; padding: 5px 8px; }
-/* Reines Anzeigefeld (kein Input) — erstellt_am ist serverseitig maßgeblich
-   und beim Fortschreiben unveränderlich, siehe legeProtokollAn()/PUT
-   .../:id in server.js; rechtsbündig, damit es nicht wie ein drittes
-   Eingabefeld neben Zuständig/Termin wirkt. */
-.protokoll-punkt-erstellt { margin-left: auto; align-self: center; white-space: nowrap; }
+.protokoll-liste {
+  background: var(--surface); border: 1px solid var(--line); border-radius: var(--r-md);
+  overflow: hidden; box-shadow: var(--sh-1);
+}
+.protokoll-liste-kopf {
+  padding: 9px 12px; background: var(--surface-alt); border-bottom: 1px solid var(--line);
+  font-size: 10.5px; font-weight: 700; text-transform: uppercase; letter-spacing: .05em; color: var(--text-subtle);
+}
+/* Gruppen-Kopfzeile: Farbbalken links aus dem Gruppennamen gehasht
+   (protokollGruppeFarbe(), plan-protokoll.js — dasselbe Prinzip wie
+   projektFarbe() in der Auslastung), damit eine Gruppe ihre Farbe behält,
+   egal an welcher Position sie steht. Der Name selbst ist das Eingabefeld:
+   umbenennen wirkt auf alle Punkte der Gruppe. */
+.protokoll-liste-gruppe {
+  display: flex; align-items: center; gap: 7px; padding: 8px 10px 8px 11px;
+  background: var(--surface-sunk); border-bottom: 1px solid var(--line-soft);
+  border-left: 3px solid var(--protokoll-gruppe-farbe, var(--accent));
+}
+.protokoll-liste-gruppe + .protokoll-liste-gruppe,
+.protokoll-liste-zeile + .protokoll-liste-gruppe,
+.protokoll-liste-neu + .protokoll-liste-gruppe { border-top: 1px solid var(--line); }
+/* Dieselbe !important-Begründung wie bei den übrigen randlosen Feldern
+   weiter unten: die Dark-Mode-Fassung von input[type=text] (styles.css)
+   hängt ein html-Element vor den Selektor und gewinnt sonst. */
+.protokoll-liste-gruppe input.protokoll-gruppe-heading {
+  flex: 1; min-width: 0; font-size: 12px; font-weight: 700; letter-spacing: .01em;
+  border: none !important; background: none !important; border-radius: 4px !important;
+  color: var(--text) !important; padding: 2px 3px !important;
+}
+.protokoll-liste-gruppe input.protokoll-gruppe-heading::placeholder { color: var(--text-subtle); font-weight: 550; }
+.protokoll-liste-gruppe input.protokoll-gruppe-heading:focus { outline: none; }
+.protokoll-liste-gruppe input.protokoll-gruppe-heading:focus-visible { box-shadow: 0 0 0 2px var(--accent-soft) inset; }
+.protokoll-liste-gruppe .count {
+  font-size: 10px; font-variant-numeric: tabular-nums; color: var(--text-subtle);
+  background: var(--surface); border: 1px solid var(--line); border-radius: 980px; padding: 0 6px; flex-shrink: 0;
+}
+
+.protokoll-liste-zeile {
+  display: grid; grid-template-columns: 30px minmax(0, 1fr) auto; gap: 2px 8px; align-items: baseline;
+  padding: 8px 11px; cursor: pointer; border-bottom: 1px solid var(--line-soft);
+  border-left: 3px solid transparent;
+}
+.protokoll-liste-zeile:hover { background: var(--surface-alt); }
+.protokoll-liste-zeile.ist-aktiv { background: var(--accent-soft); border-left-color: var(--accent); }
+/* Jedes Kind bekommt seinen Platz im Raster AUSDRÜCKLICH zugewiesen. Mit
+   bloßer Auto-Platzierung zog der Status-Punkt (der als einziger eine
+   grid-row trug) die erste Spalte an sich, Nummer und Titel rutschten je
+   eine Spalte weiter und der Titel landete rechtsbündig in der schmalen
+   auto-Spalte — die Unterzeile blieb dann auf zwei Zeichen abgeschnitten. */
+.protokoll-liste-zeile .nr {
+  grid-column: 1; grid-row: 1;
+  font-variant-numeric: tabular-nums; font-size: 11.5px; font-weight: 700; color: var(--text-muted);
+}
+.protokoll-liste-zeile.ist-aktiv .nr { color: var(--accent); }
+.protokoll-liste-zeile .titel {
+  grid-column: 2; grid-row: 1;
+  font-size: 12.5px; font-weight: 600; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+}
+.protokoll-liste-zeile .titel.ist-leer { font-weight: 500; font-style: italic; color: var(--text-subtle); }
+.protokoll-liste-zeile .sub {
+  grid-column: 2; grid-row: 2; font-size: 10.5px; color: var(--text-subtle);
+  overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+}
+/* Das Neu-Kennzeichen steht rechts unter dem Status-Punkt statt in einer
+   eigenen dritten Zeile — sonst wäre jeder Eintrag der Liste eine Zeile
+   höher, nur für einen Chip. */
+.protokoll-liste-zeile .protokoll-chip-neu { grid-column: 3; grid-row: 2; justify-self: end; }
+.protokoll-punkt-dot {
+  grid-column: 3; grid-row: 1; justify-self: end; align-self: center;
+  width: 7px; height: 7px; border-radius: 50%; flex-shrink: 0;
+}
+.protokoll-punkt-dot[data-status="offen"] { background: var(--status-offen); }
+.protokoll-punkt-dot[data-status="erledigt"] { background: var(--status-erledigt); }
+.protokoll-punkt-dot[data-status="info"] { background: var(--status-info); }
+
+.protokoll-liste-neu {
+  padding: 8px 11px 8px 14px; color: var(--accent); font-size: 12px; font-weight: 600; cursor: pointer;
+  border-bottom: 1px solid var(--line-soft);
+}
+.protokoll-liste-neu:hover { background: var(--surface-alt); color: var(--accent-hover); }
+.protokoll-liste-neu.ist-gruppe { border-bottom: none; border-top: 1px solid var(--line); }
+.protokoll-liste-leer { padding: 14px 12px; font-size: 12.5px; color: var(--text-subtle); }
+
+/* ---------- Schreibbereich ---------- */
+.protokoll-schreiben {
+  background: var(--surface); border: 1px solid var(--line); border-radius: var(--r-md);
+  overflow: hidden; box-shadow: var(--sh-1);
+}
+.protokoll-schreiben.ist-leer { padding: 28px 22px; color: var(--text-muted); font-size: 13px; }
+.protokoll-schreiben.ist-leer p { margin: 0 0 6px; }
+.protokoll-schreiben.ist-leer p:last-child { margin-bottom: 0; }
+
+.protokoll-schreiben-kopf {
+  display: flex; align-items: center; gap: 9px; flex-wrap: wrap;
+  padding: 9px 16px; background: var(--surface-alt); border-bottom: 1px solid var(--line-soft);
+}
+.protokoll-schreiben-kopf .nr { font-variant-numeric: tabular-nums; font-weight: 700; font-size: 13px; }
+.protokoll-schreiben-kopf .gruppe {
+  font-size: 10.5px; font-weight: 700; text-transform: uppercase; letter-spacing: .06em; color: var(--text-subtle);
+}
+.protokoll-schreiben-kopf .rechts { margin-left: auto; display: flex; align-items: center; gap: 9px; }
+
+.protokoll-feld-label {
+  display: block; font-size: 9.5px; font-weight: 700; text-transform: uppercase; letter-spacing: .07em;
+  color: var(--text-subtle); margin-bottom: 5px;
+}
+.protokoll-schreiben-feld { padding: 13px 16px; }
+.protokoll-schreiben-feld + .protokoll-schreiben-feld { border-top: 1px solid var(--line-soft); }
+
+/* Thema und Text sitzen randlos in ihrem beschrifteten Abschnitt — der
+   Abschnitt selbst (Linie + Label) sagt schon, wo man schreibt, ein
+   zusätzlicher Feldrahmen gäbe zwei Kästen umeinander. !important wie
+   überall hier gegen die Dark-Mode-Fassung von input[type=text]
+   (html:not([data-theme="light"]) …, styles.css), die sonst an Spezifität
+   gewinnt und ein abgerundetes Eingabefeld-Rechteck durchscheinen lässt. */
+.protokoll-schreiben-feld input.protokoll-punkt-thema {
+  font: inherit; font-size: 17px; font-weight: 650; letter-spacing: -.01em; width: 100%; line-height: 1.3;
+  border: none !important; background: none !important; border-radius: 4px !important;
+  color: var(--text) !important; padding: 1px 2px !important; display: block;
+}
+.protokoll-schreiben-feld input.protokoll-punkt-thema::placeholder { font-weight: 500; color: var(--text-subtle); }
+.protokoll-schreiben-feld .protokoll-punkt-text {
+  font: inherit; font-size: 13.5px; line-height: 1.65; color: var(--text);
+  min-height: 130px; max-width: 66ch; padding: 1px 2px; border-radius: 4px;
+}
+.protokoll-schreiben-feld .protokoll-punkt-text:empty::before { content: attr(data-placeholder); color: var(--text-subtle); }
+.protokoll-schreiben-feld input.protokoll-punkt-thema:focus,
+.protokoll-schreiben-feld .protokoll-punkt-text:focus { outline: none; }
+.protokoll-schreiben-feld input.protokoll-punkt-thema:focus-visible,
+.protokoll-schreiben-feld .protokoll-punkt-text:focus-visible { box-shadow: 0 0 0 2px var(--accent-soft) inset; }
+/* ist-geaendert: NUR das geänderte Feld eines fortgeschriebenen Punkts gelb
+   markiert (Eriks Wunsch) — derselbe Gelb-Ton wie das Neu-Kennzeichen, hier
+   aber feldweise, weil der Punkt selbst ja derselbe geblieben ist, nur sein
+   Inhalt nicht. */
+.protokoll-schreiben-feld input.protokoll-punkt-thema.ist-geaendert,
+.protokoll-schreiben-feld .protokoll-punkt-text.ist-geaendert {
+  background: var(--protokoll-neu-bg) !important; padding: 3px 6px !important; margin: 0 -4px;
+}
+
+/* Die Formatierungsleiste sitzt zwischen Thema und Text — sie gehört zum
+   Textfeld darunter, nicht zum Thema darüber (Thema ist reiner Text ohne
+   Auszeichnung). */
+.protokoll-schreiben .richtext-toolbar { border-top: 1px solid var(--line-soft); }
+
+.protokoll-schreiben-raster {
+  display: grid; grid-template-columns: 1fr 1fr; gap: 14px;
+  padding: 13px 16px; border-top: 1px solid var(--line-soft);
+}
+.protokoll-schreiben-raster input {
+  font: inherit !important; font-size: 13px !important; width: 100%; min-width: 0 !important;
+  color: var(--text) !important; background: var(--surface) !important;
+  border: 1px solid var(--line) !important; border-radius: var(--r-sm) !important; padding: 6px 9px !important;
+}
+.protokoll-schreiben-raster input:focus {
+  outline: none; border-color: var(--accent) !important; box-shadow: 0 0 0 3px var(--accent-soft);
+}
+.protokoll-schreiben-fuss {
+  padding: 9px 16px; border-top: 1px solid var(--line-soft); background: var(--surface-alt);
+  font-size: 11px; color: var(--text-subtle);
+}
+.protokoll-schreiben-fuss .hint { font-size: 11px; }
+
+/* ---------- Chips, Verschieben, Entfernen ---------- */
+.protokoll-chip-neu {
+  display: inline-block; width: fit-content; background: var(--protokoll-neu-border); color: #3d2e00;
+  font-size: 9.5px; font-weight: 700; letter-spacing: .03em; text-transform: uppercase; padding: 1px 6px;
+  border-radius: var(--r-pill);
+}
+/* Gnadenrunde eines erledigten Punkts — bewusst Fließtext statt
+   Großbuchstaben-Pille: der Hinweistext ist zu lang dafür. */
+.protokoll-chip-entfaellt {
+  display: inline-block; max-width: 100%;
+  background: color-mix(in srgb, var(--red) 15%, transparent); color: var(--red);
+  font-size: 9.5px; font-weight: 700; line-height: 1.3; padding: 2px 7px; border-radius: var(--r-sm);
+}
+.protokoll-gruppe-move, .protokoll-punkt-move { display: inline-flex; gap: 4px; flex-shrink: 0; }
+/* button.secondary (styles.css) bringt eine eigene, leicht deckende Fläche
+   mit, die hier wie ein grauer Fleck wirkte. !important nötig: die
+   Dark-Mode-Fassung von button.secondary hängt ein html-Element vor den
+   Selektor und gewinnt sonst an Spezifität. */
+.protokoll-gruppe-move button, .protokoll-punkt-move button {
+  padding: 1px 6px; line-height: 1.4; font-size: 11px;
+  background: transparent !important; color: var(--text-subtle) !important;
+}
+.protokoll-gruppe-move button:hover:not(:disabled),
+.protokoll-punkt-move button:hover:not(:disabled) { color: var(--text) !important; }
+.protokoll-gruppe-move button:disabled, .protokoll-punkt-move button:disabled { opacity: .3; cursor: default; }
+
+/* ---------- Status-Umschalter ----------
+   Senkrecht gestapelt in der Grundform; im Kopf des Schreibbereichs ist
+   Platz, dort liegt er waagerecht. */
+.protokoll-status-switch {
+  display: flex; flex-direction: column; border: 1px solid var(--line); border-radius: 7px; padding: 2px;
+  background: var(--surface-sunk); gap: 1px; width: 56px;
+}
+.protokoll-status-switch.ist-waagerecht { flex-direction: row; width: auto; border-radius: 980px; }
+.protokoll-status-switch button {
+  appearance: none; border: none; background: none; font: inherit; font-size: 10.5px; font-weight: 700;
+  letter-spacing: .01em; padding: 4px 0; border-radius: 5px; cursor: pointer; color: var(--text-subtle);
+  text-align: center; transition: background .12s, color .12s;
+}
+.protokoll-status-switch.ist-waagerecht button { padding: 3px 11px; border-radius: 980px; }
+.protokoll-status-switch button:hover:not(.is-active) { color: var(--text); }
+.protokoll-status-switch button:disabled { cursor: default; }
+.protokoll-status-switch button:disabled:hover { color: var(--text-subtle); }
+.protokoll-status-switch button.offen.is-active { background: var(--status-offen); color: #fff; }
+.protokoll-status-switch button.erledigt.is-active { background: var(--status-erledigt); color: #fff; }
+.protokoll-status-switch button.info.is-active { background: var(--status-info); color: #fff; }
 
 @media (max-width: 900px){
   .protokoll-row { grid-template-columns: 1fr; gap: 4px; }
   .protokoll-field-grid { grid-template-columns: 1fr; }
+  /* Unter 900px stehen Liste und Schreibbereich untereinander — nebeneinander
+     bliebe für den Text keine lesbare Zeilenlänge mehr. */
+  .protokoll-split { grid-template-columns: minmax(0, 1fr); }
+  .protokoll-schreiben-raster { grid-template-columns: 1fr; }
 }
 
 .add-row-btn { display: flex; align-items: center; gap: 6px; color: var(--accent); font-size: 13px;
@@ -821,6 +1008,4 @@ html[data-theme="dark"] { --seg-hover: rgba(255,255,255,.10); }
 
 .legend-swatch { width: 13px; height: 13px; border-radius: 4px; flex-shrink: 0; display: inline-block; }
 .legend-swatch.neu { background: var(--protokoll-neu-bg); border: 1.5px solid var(--protokoll-neu-border); }
-.legend-swatch.fortgeschrieben,
-.legend-swatch.erledigt { background: var(--surface); border: 1.5px solid var(--line); }
-.legend-swatch.erledigt { opacity: .6; }
+.legend-swatch.info { background: var(--status-info-bg); border: 1.5px solid var(--status-info); }
diff --git a/public/project-plan.html b/public/project-plan.html
deleted file mode 100644
index ee1ac42..0000000
--- a/public/project-plan.html
+++ /dev/null
@@ -1,330 +0,0 @@
-<!DOCTYPE html>
-<!--
-  PROJEKTPLAN-ANSICHT: zeigt für ein einzelnes Projekt ein GANTT-Diagramm mit TODO- und
-  Meilenstein-Zeilen, Abhängigkeiten, Zoom, kritischem Pfad, Auto-Schedule, Ressourcen-
-  Auslastung und Abwesenheiten der Projektbeteiligten. Die Seite wird über openProjectPlan()
-  in js/gantt.js in einem neuen Tab geöffnet und per Deep-Link-Route
-  "/<Abteilung>/Projektplan/<Projektname>" adressiert; Woche und Projekt-Nr.
-  kommen als URL-Parameter (weekLabel, projNr). Sie lädt styles.css und ausschließlich die gemeinsamen
-  Module js/globals.js, js/utils.js, js/ui.js, js/date-picker.js, js/server.js
-  und js/gantt.js sowie danach die Plan-Module js/plan/plan-state.js,
-  js/plan/plan-build-gantt.js, js/plan/plan-gantt.js, js/plan/plan-drag.js,
-  js/plan/plan-modals.js und js/plan/plan-schedule.js. WICHTIG: store, weeks, board, people,
-  projects, load, showmode, tabs-auth, pdf und init dürfen hier NICHT geladen werden, da sie
-  Elemente der Hauptseite Test.html voraussetzen. Änderungen werden über savePlan() in
-  js/plan/plan-state.js nur für die aktuelle Woche direkt an den Server geschrieben.
--->
-<html lang="de">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>Projektplan</title>
-<link rel="stylesheet" href="/styles.css?v=3">
-<style>
-  .plan-page { min-height: 100vh; display: flex; flex-direction: column; }
-  .plan-header {
-    display: flex; align-items: center; justify-content: space-between;
-    padding: 12px 24px; background: var(--surface); border-bottom: 1px solid var(--line-soft);
-    position: sticky; top: 0; z-index: 20;
-  }
-  .plan-header h1 { font-size: 17px; margin: 0; font-weight: 600; }
-  .plan-header .subtitle { color: var(--text-muted); font-size: 13px; }
-  .plan-body { flex: 1; display: flex; gap: 0; overflow: hidden; }
-  .plan-main { flex: 1; display: flex; flex-direction: column; overflow: hidden; background: var(--bg); min-width: 0; }
-  .plan-main-header {
-    padding: 16px 20px 10px; display: flex; gap: 12px; align-items: center; flex-wrap: wrap;
-  }
-  .plan-main-content { flex: 1; overflow: auto; padding: 0 20px 20px; min-width: 0; }
-  .todo-item {
-    background: var(--surface-alt); border: 1px solid var(--line-soft); border-radius: var(--r-md);
-    padding: 10px 12px; margin-bottom: 10px;
-  }
-  .todo-item.done .todo-title { text-decoration: line-through; opacity: .6; }
-  .todo-row { display: flex; gap: 8px; align-items: center; margin-bottom: 6px; }
-  .todo-row:last-child { margin-bottom: 0; }
-  .todo-title { flex: 1; font-weight: 500; font-size: 13px; }
-  .todo-dates { display: flex; gap: 8px; flex-wrap: wrap; font-size: 12px; color: var(--text-muted); }
-  .todo-dates input[type=date] { padding: 4px 7px; font-size: 12px; }
-  .todo-assignee-list { display: flex; flex-wrap: wrap; gap: 5px; margin-top: 6px; }
-  .todo-assignee {
-    font-size: 11px; padding: 2px 8px; border-radius: var(--r-pill);
-    background: var(--surface-sunk); border: 1px solid var(--line-soft); color: var(--text-muted);
-  }
-  .todo-assignee.main { background: var(--green); color: #fff; border-color: transparent; }
-  .todo-assignee.optional { background: #d18b00; color: #fff; border-color: transparent; }
-  .empty-todos { color: var(--text-subtle); font-size: 13px; text-align: center; padding: 24px 0; }
-  .plan-people { margin-top: 14px; }
-  .plan-people-title { font-size: 12px; font-weight: 600; color: var(--text-muted); margin-bottom: 6px; }
-  .plan-people-list { display: flex; flex-wrap: wrap; gap: 6px; }
-  .plan-people-chip {
-    font-size: 12px; padding: 4px 10px; border-radius: var(--r-pill);
-    background: var(--accent-soft); color: var(--text); border: 1px solid var(--line-soft);
-  }
-  .milestone-list { display: flex; flex-direction: column; gap: 6px; }
-  .milestone-row { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
-  .milestone-row input[type=date] { padding: 4px 7px; font-size: 12px; }
-  .todo-list-main {
-    margin-top: 18px;
-    background: var(--surface);
-    border: 1px solid var(--line-soft);
-    border-radius: var(--r-lg);
-    padding: 14px 18px;
-  }
-  .todo-list-title {
-    font-size: 15px; font-weight: 600; margin: 0 0 10px;
-  }
-  .todo-list {
-    display: flex;
-    flex-direction: column;
-    gap: 8px;
-  }
-  .todo-row-item {
-    display: flex;
-    gap: 8px;
-    align-items: center;
-    flex-wrap: wrap;
-    padding: 8px 10px;
-    background: var(--surface-alt);
-    border: 1px solid var(--line-soft);
-    border-radius: var(--r-md);
-  }
-  .todo-row-item.done { opacity: .55; text-decoration: line-through; }
-  .todo-row-item input[type=text] { flex: 1 1 200px; min-width: 140px; }
-  .todo-row-item input[type=date] { padding: 4px 7px; font-size: 12px; }
-  .todo-add-row {
-    display: flex;
-    gap: 8px;
-    align-items: center;
-    flex-wrap: wrap;
-    margin-top: 10px;
-    padding-top: 10px;
-    border-top: 1px solid var(--line-soft);
-  }
-  .plan-toast {
-    position: fixed; bottom: 24px; left: 50%; transform: translateX(-50%) translateY(20px);
-    background: var(--text); color: #fff; padding: 10px 18px; border-radius: var(--r-pill);
-    font-size: 13px; opacity: 0; pointer-events: none; transition: opacity .25s, transform .25s;
-    z-index: 1000; box-shadow: var(--sh-3);
-  }
-  .plan-toast.show { opacity: 1; transform: translateX(-50%) translateY(0); }
-  .plan-resource-grid {
-    display: grid !important;
-    grid-template-columns: repeat(auto-fill, minmax(140px, max-content)) !important;
-    gap: 10px !important;
-    justify-content: start !important;
-  }
-  .plan-resource-card {
-    padding: 8px 10px !important;
-    min-height: 0 !important;
-    width: 140px !important;
-    max-width: 140px !important;
-  }
-  .plan-resource-card h3 {
-    font-size: 12px !important;
-    margin-bottom: 2px !important;
-  }
-  .plan-resource-clickable { cursor: pointer; transition: box-shadow .15s, transform .15s; }
-  .plan-resource-clickable:hover { box-shadow: var(--sh-2); transform: translateY(-1px); }
-  .todo-depends-list {
-    display: flex;
-    flex-direction: column;
-    gap: 4px;
-    max-height: 180px;
-    overflow-y: auto;
-    border: 1px solid var(--line-soft);
-    border-radius: var(--r-md);
-    padding: 8px;
-    background: var(--surface-alt);
-  }
-  .todo-depends-item {
-    display: flex;
-    align-items: center;
-    gap: 8px;
-    padding: 5px 6px;
-    border-radius: var(--r-sm);
-    cursor: pointer;
-    font-size: 12px;
-    transition: background .15s;
-  }
-  .todo-depends-item:hover { background: var(--surface-sunk); }
-  .todo-depends-item input { flex-shrink: 0; }
-  .todo-depends-group {
-    font-size: 11px;
-    color: var(--text-muted);
-    margin-top: 6px;
-    margin-bottom: 2px;
-    text-transform: uppercase;
-    letter-spacing: .03em;
-  }
-  .todo-depends-group:first-child { margin-top: 0; }
-
-  /* Drag-Handle für TODO- und Meilenstein-Zeilen direkt im GANTT */
-  .gantt-row.gantt-todo,
-  .gantt-row.gantt-milestone-row { cursor: default; }
-  .gantt-row.gantt-todo .gantt-label,
-  .gantt-row.gantt-milestone-row .gantt-label { display: flex; align-items: center; gap: 8px; }
-  .gantt-todo-drag {
-    color: var(--text-subtle); cursor: grab; font-size: 13px; line-height: 1;
-    user-select: none; flex-shrink: 0;
-  }
-  .gantt-row.gantt-todo.dragging,
-  .gantt-row.gantt-milestone-row.dragging { opacity: .5; }
-  .gantt-todo-drag:active { cursor: grabbing; }
-  .gantt-row.gantt-milestone-row .gantt-todo-drag { color: var(--text-subtle); }
-
-  @media (max-width: 900px) {
-    .plan-body { flex-direction: column; overflow: auto; }
-  }
-</style>
-</head>
-<body>
-<div class="plan-page">
-  <div class="plan-header">
-    <div>
-      <h1 id="planTitle">Projektplan</h1>
-      <div class="subtitle" id="planSubtitle"></div>
-    </div>
-    <div class="toolbar">
-      <button class="secondary" onclick="todoMail()">E-Mail erstellen</button>
-      <button class="secondary" onclick="window.close()">Schließen</button>
-    </div>
-  </div>
-
-  <div class="plan-body">
-    <div class="plan-main">
-      <div class="plan-main-header">
-        <label>Zeitraum:</label>
-        <input type="text" id="planGanttRange" class="range-picker-display" placeholder="Zeitraum wählen…" readonly
-          onclick="openRangePicker({ anchor: this, startInputId: 'planGanttStart', endInputId: 'planGanttEnd', displayId: 'planGanttRange', onApply: renderPlanGantt })">
-        <input type="hidden" id="planGanttStart">
-        <input type="hidden" id="planGanttEnd">
-        <button class="secondary" onclick="fitPlanGanttRange()">Zeitraum anpassen</button>
-        <label><input type="checkbox" id="planShowVacation" checked onchange="renderPlanGantt()"> Urlaub anzeigen</label>
-        <button class="secondary" onclick="zoomPlanGantt(-1)" title="Verkleinern">−</button>
-        <button class="secondary" onclick="zoomPlanGantt(1)" title="Vergrößern">+</button>
-        <button onclick="addPlanMilestone()" id="addMilestoneBtn">+ Meilenstein</button>
-        <button onclick="addTodo()" id="addTodoBtn">+ TODO</button>
-        <button onclick="autoScheduleTodos()" id="autoScheduleBtn" title="Aufgaben nach Abhängigkeiten automatisch anordnen">Auto-Schedule</button>
-        <button onclick="toggleCriticalPath()" id="criticalPathBtn" title="Kritischen Pfad ein-/ausblenden">Kritischer Pfad</button>
-      </div>
-      <div class="plan-main-content plan-main-content-full">
-        <div id="planGanttContainer" class="gantt-container"></div>
-        <div id="resourceLoadContainer" style="margin-top:16px"></div>
-      </div>
-    </div>
-  </div>
-</div>
-
-<!-- Meilenstein-Modal -->
-<div class="modal-bg" id="milestoneModal" style="display:none">
-  <div class="modal">
-    <h2>Meilenstein</h2>
-    <div class="form-row">
-      <label>Name</label>
-      <input type="text" id="milestoneEditName" placeholder="Name">
-    </div>
-    <div class="form-row">
-      <label>Datum</label>
-      <input type="text" id="milestoneEditDate" class="range-picker-display" placeholder="Datum wählen…" readonly onclick="openDatePicker({ anchor: this, inputId: 'milestoneEditDate' })">
-    </div>
-    <div class="form-row">
-      <label>Position</label>
-      <select id="milestoneEditPosition">
-        <option value="">Oben in der Projektzeile</option>
-      </select>
-    </div>
-    <div class="form-row">
-      <label>Vorgänger (mehrfach möglich)</label>
-      <div id="milestoneEditDependsOn" class="todo-depends-list"></div>
-    </div>
-    <div class="toolbar">
-      <button onclick="saveMilestoneEdit()">Speichern</button>
-      <button class="danger" onclick="deleteMilestoneEdit()">Löschen</button>
-      <button class="secondary" onclick="closeMilestoneModal()">Abbrechen</button>
-    </div>
-  </div>
-</div>
-
-<!-- TODO-Modal -->
-<div class="modal-bg" id="todoModal" style="display:none">
-  <div class="modal">
-    <h2>TODO</h2>
-    <div class="form-row">
-      <label>Titel</label>
-      <input type="text" id="todoEditTitle" placeholder="Titel">
-    </div>
-    <div class="form-row">
-      <label>Zeitraum</label>
-      <input type="text" id="todoEditRange" class="range-picker-display" placeholder="Start – Ende wählen…" readonly
-        onclick="openRangePicker({ anchor: this, startInputId: 'todoEditStart', endInputId: 'todoEditEnd', displayId: 'todoEditRange' })">
-      <input type="hidden" id="todoEditStart">
-      <input type="hidden" id="todoEditEnd">
-    </div>
-    <div class="form-row">
-      <label>Vorgänger (mehrfach möglich)</label>
-      <div id="todoEditDependsOn" class="todo-depends-list">
-        <label class="todo-depends-item">
-          <input type="checkbox" value="" checked> (Keine Abhängigkeit)
-        </label>
-      </div>
-    </div>
-    <div class="form-row">
-      <label>Zuständige</label>
-      <div id="todoEditAssignees" class="role-checkboxes"></div>
-    </div>
-    <div class="form-row">
-      <label>Fortschritt (%)</label>
-      <input type="range" id="todoEditProgress" min="0" max="100" value="0" oninput="document.getElementById('todoEditProgressVal').textContent=this.value+'%'"><span id="todoEditProgressVal">0%</span>
-    </div>
-    <div class="form-row">
-      <label><input type="checkbox" id="todoEditDone"> Erledigt</label>
-    </div>
-    <div class="toolbar">
-      <button onclick="saveTodoEdit()">Speichern</button>
-      <button class="danger" onclick="deleteTodoEdit()">Löschen</button>
-      <button class="secondary" onclick="closeTodoModal()">Abbrechen</button>
-    </div>
-  </div>
-</div>
-
-<!-- Abwesenheits-Modal (Urlaube der Projektbeteiligten) -->
-<div class="modal-bg" id="absenceModal" style="display:none">
-  <div class="modal">
-    <h2 id="absenceModalTitle">Abwesenheiten</h2>
-    <div class="form-row">
-      <div id="absenceModalList"></div>
-    </div>
-    <div class="absence-form" id="absenceModalForm">
-      <input type="text" id="absenceEditRange" class="range-picker-display" placeholder="Zeitraum wählen…" readonly
-        onclick="openRangePicker({ anchor: this, startInputId: 'absenceEditStart', endInputId: 'absenceEditEnd', displayId: 'absenceEditRange' })">
-      <input type="hidden" id="absenceEditStart">
-      <input type="hidden" id="absenceEditEnd">
-      <select id="absenceEditType">
-        <option>Urlaub</option>
-        <option>Krank</option>
-        <option>Fortbildung</option>
-        <option>Sonstiges</option>
-      </select>
-      <input type="text" id="absenceEditNote" placeholder="Notiz (optional)" style="width:140px">
-      <button class="secondary small" onclick="addPlanAbsence()">+ Abwesenheit</button>
-    </div>
-    <div class="toolbar" style="margin-top:12px">
-      <button class="secondary" onclick="closeAbsenceModal()">Schließen</button>
-    </div>
-  </div>
-</div>
-
-<script src="/js/globals.js?v=5"></script>
-<script src="/js/utils.js?v=5"></script>
-<script src="/js/ui.js?v=5"></script>
-<script src="/js/date-picker.js?v=5"></script>
-<script src="/js/server.js?v=5"></script>
-<script src="/js/gantt.js?v=5"></script>
-<script src="/js/plan/plan-state.js?v=5"></script>
-<script src="/js/plan/plan-build-gantt.js?v=5"></script>
-<script src="/js/plan/plan-gantt.js?v=5"></script>
-<script src="/js/plan/plan-drag.js?v=5"></script>
-<script src="/js/plan/plan-modals.js?v=5"></script>
-<script src="/js/plan/plan-schedule.js?v=5"></script>
-</body>
-</html>
diff --git a/public/styles.css b/public/styles.css
index 832c101..4a2c19d 100644
--- a/public/styles.css
+++ b/public/styles.css
@@ -20,6 +20,38 @@
   --green:         #248a3d;
   --amber:         #b25000;
   --red:           #d70015;
+  --red-hover:     #e8112d;
+  --red-active:    #b8000f;
+
+  /* Flächen des Anwesenheits-Kacheln im Zustand "anwesend" — eigene Tokens,
+     weil eine feste rgba-Grünfläche im Dark Mode nicht trägt. */
+  --attend-bg:       rgba(36,138,61,.10);
+  --attend-bg-hover: rgba(36,138,61,.16);
+
+  /* Kopfband der Wochenbericht-Karten je Änderungsart. Das Band trägt weiße
+     Schrift, deshalb etwas dunkler als --green (#248a3d käme nur auf
+     Kontrast 4,4 : 1 und bliebe damit unter den 4,5 : 1 für normalen Text). */
+  --band-neu:         #0071e3;
+  --band-fortschritt: #22823a;
+
+  /* Gelbe Markierung neu hinzugekommener Protokoll-Punkte — bewusst eigenes
+     Token statt --band-neu (dort blau, bedeutet "neu kommentiertes Projekt"
+     im Wochenbericht — eine andere Bedeutung, die hier kollidieren würde). */
+  --protokoll-neu-bg:     #fff6db;
+  --protokoll-neu-border: #e6b800;
+
+  /* Die drei Zustände eines Protokoll-Punkts (protokoll_punkte.status) —
+     eigene Bezeichner statt direkter --amber/--green/--accent-Nutzung an
+     jeder Stelle, damit sich die Farbzuordnung an einer Stelle ändern
+     ließe, ohne jede Verwendung einzeln anzufassen. Referenzieren andere
+     Tokens per var(), lösen sich also auch im Dark Mode korrekt auf, ohne
+     dort erneut definiert zu werden. --status-info-bg ist die Fläche einer
+     kompletten Info-Zeile in der Protokoll-Tabelle (color-mix statt fester
+     rgba-Werte, damit die Deckkraft in beiden Themes gleich wirkt). */
+  --status-offen:    var(--amber);
+  --status-erledigt: var(--green);
+  --status-info:     var(--accent);
+  --status-info-bg:  color-mix(in srgb, var(--accent) 8%, transparent);
 
   --r-sm:  6px;
   --r-md:  8px;
@@ -52,45 +84,75 @@ body {
 
 .container { padding: 20px 24px; }
 
-/* === Kopfzeile & Navigation === */
-header {
+/* === App-Shell: globales Menüband oben + linke Navigations-Sidebar +
+   Hauptbereich (OpenProject-Anordnung: ein durchgehendes globales Menüband
+   trägt Marke, aktuellen Kontext [Sitzung] und alle Aktionen/Konto rechts;
+   die Sidebar darunter ist reine Modul-Navigation, sonst nichts) === */
+.app-shell { display: flex; flex-direction: column; min-height: 100vh; }
+.app-body  { display: flex; flex: 1; min-height: 0; }
+.app-main  { flex: 1; min-width: 0; }
+
+/* Generisches Icon-System (js/icons.js): Icons skalieren wie ein Zeichen mit
+   der umgebenden Schriftgröße (1.1em), erben die Textfarbe über currentColor. */
+.icon { display: inline-flex; align-items: center; justify-content: center; flex-shrink: 0; }
+.icon svg { width: 1.1em; height: 1.1em; display: block; }
+
+/* === Globales Menüband (immer sichtbar, alle Breiten) === */
+.app-topbar {
+  position: sticky;
+  top: 0;
+  z-index: 140;
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  row-gap: 8px;
+  gap: 12px;
+  padding: 8px 20px;
   background: rgba(255,255,255,.82);
   -webkit-backdrop-filter: saturate(180%) blur(20px);
   backdrop-filter: saturate(180%) blur(20px);
   border-bottom: 1px solid var(--line-soft);
-  color: var(--text);
-  padding: 10px 24px;
 }
 
-.header-bar {
-  position: relative;
-  display: flex;
-  align-items: center;
-  gap: 16px;
-  min-height: 48px;
-}
+.mobile-nav-toggle { display: inline-flex; }
+@media (min-width: 769px) { .app-topbar .mobile-nav-toggle { display: none; } }
 
-header h1 {
-  font-size: 19px;
+.topbar-brand { display: flex; align-items: center; gap: 8px; flex-shrink: 0; }
+.topbar-logo  { height: 28px; width: auto; object-fit: contain; }
+.topbar-title {
+  font-size: 15px;
   font-weight: 600;
   margin: 0;
-  letter-spacing: -0.02em;
+  letter-spacing: -0.01em;
   white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  padding-right: 140px;
 }
 
-.header-logo {
-  position: absolute;
-  left: 50%;
-  top: 50%;
-  transform: translate(-50%, -50%);
-  height: 44px;
-  width: auto;
-  max-width: 120px;
-  object-fit: contain;
-  pointer-events: none;
+
+.app-topbar-actions {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  margin-left: auto;
+  flex-wrap: wrap;
+}
+
+.toolbar-group { display: flex; align-items: center; gap: 4px; }
+
+.toolbar-divider {
+  width: 1px;
+  height: 22px;
+  background: var(--line-soft);
+  flex-shrink: 0;
+}
+
+@media (max-width: 768px) {
+  .app-topbar-actions {
+    order: 4;
+    flex: 1 1 100%;
+    margin-left: 0;
+    overflow-x: auto;
+    padding-bottom: 2px;
+  }
 }
 
 .header-toggle {
@@ -103,20 +165,98 @@ header h1 {
   justify-content: center;
 }
 
-.header-toggle-icon { font-size: 16px; }
-
-@media (max-width: 520px) {
-  .header-logo { height: 36px; max-width: 80px; }
-  header h1 { font-size: 16px; padding-right: 100px; }
+.theme-toggle-circle {
+  width: 34px;
+  height: 34px;
+  border-radius: 50%;
+  padding: 0;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  background: var(--surface-sunk);
+  border: 1px solid var(--line-soft);
+  color: var(--text);
+  cursor: pointer;
+  flex-shrink: 0;
+  transition: background .2s var(--ease), color .2s var(--ease), transform .1s var(--ease);
 }
 
-/* === Seiten-Menü (links ausfahrend) === */
+.theme-toggle-circle:hover { background: var(--line-soft); }
+.theme-toggle-circle:active { transform: scale(.95); }
+
+.icon-btn-danger:hover { background: var(--red); color: #fff; }
+.icon-btn-danger:active { background: var(--red-active); }
+
+/* Konto-Menü (Avatar-Knopf rechts im Menüband + Dropdown) */
+.topbar-user { position: relative; }
+
+.user-menu-dropdown {
+  position: absolute;
+  top: calc(100% + 8px);
+  right: 0;
+  min-width: 220px;
+  background: var(--surface);
+  border: 1px solid var(--line-soft);
+  border-radius: var(--r-lg);
+  box-shadow: var(--sh-3);
+  padding: 8px;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  z-index: 150;
+  opacity: 0;
+  visibility: hidden;
+  transform: translateY(-4px);
+  transition: opacity .15s var(--ease), transform .15s var(--ease), visibility .15s var(--ease);
+}
+
+.user-menu-dropdown.open {
+  opacity: 1;
+  visibility: visible;
+  transform: translateY(0);
+}
+
+.user-menu-info {
+  padding: 8px 10px 10px;
+  margin-bottom: 2px;
+  border-bottom: 1px solid var(--line-soft);
+  font-size: 12px;
+  color: var(--text-muted);
+}
+
+/* .menu-item: generischer Zeilen-Knopf/-Link (Text + optionales Icon) —
+   genutzt im Konto-Dropdown (dort über .user-menu-dropdown volle Breite) UND
+   als Basis für die Sidebar-Unterpunkte (siehe .sidebar-subitem). */
+a.menu-item,
+button.menu-item {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  text-align: left;
+  background: transparent;
+  color: var(--text);
+  padding: 8px 10px;
+  border: none;
+  border-radius: var(--r-md);
+  font-size: 13px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background .15s var(--ease);
+}
+
+a.menu-item:hover,
+button.menu-item:hover { background: var(--surface-sunk); }
+
+.user-menu-dropdown a.menu-item,
+.user-menu-dropdown button.menu-item { display: flex; width: 100%; }
+
+/* === Seiten-Navigation (links, reine Modul-Navigation) === */
 .side-menu {
   position: fixed;
   top: 0;
   left: 0;
   bottom: 0;
-  width: 280px;
+  width: 260px;
   max-width: 80vw;
   background: var(--surface);
   border-right: 1px solid var(--line-soft);
@@ -132,251 +272,274 @@ header h1 {
   transform: translateX(0);
 }
 
-.side-menu-header {
+.side-menu-mobile-header {
   display: flex;
+  justify-content: flex-end;
+  padding: 8px 8px 0;
+}
+@media (min-width: 769px) { .side-menu-mobile-header { display: none; } }
+
+.sidebar-nav {
+  flex: 1;
+  min-height: 0;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  padding: 12px;
+}
+
+.sidebar-collapse-bar {
+  flex-shrink: 0;
+  display: none;
   align-items: center;
+  justify-content: center;
+  width: 100%;
+  padding: 12px;
+  background: transparent;
+  border: none;
+  border-top: 1px solid var(--line-soft);
+  border-radius: 0;
+  color: var(--text-muted);
+  cursor: pointer;
+  transition: background .2s var(--ease), color .2s var(--ease);
+}
+.sidebar-collapse-bar:hover { background: var(--surface-sunk); color: var(--text); }
+.sidebar-collapse-bar:active { transform: none; }
+
+#sidebarCollapseIcon { transition: transform .2s var(--ease); }
+
+/* === Wandtafel (js/wand/wand.js) ===
+   Zweispaltiges Touch-Dashboard für ein dauerhaft laufendes Display,
+   gewerke- und nutzerübergreifend — ersetzt den früheren Show Mode, der nur
+   die gerade angemeldete Sitzung großflächig klonte (keine Aggregation über
+   Gewerke oder Nutzer hinweg, siehe CLAUDE.md). Seitenleiste und Kopfzeile
+   blendet showTab() über body.wandtafel-aktiv aus: Das Kiosk-Konto ist ein
+   gewöhnliches Mitgliedskonto mit echten Schreibrechten — die Kachelfläche
+   soll die einzige Berührfläche sein, damit eine zufällige Berührung nicht
+   in einen bearbeitbaren Bereich wie "Projekte" führt.
+   Verhält sich zusätzlich wie ein fester Bildschirmausschnitt statt einer
+   normal scrollenden Seite (height:100vh + overflow:hidden auf dem Weg
+   .app-main → .container → #wand) — ein unbeaufsichtigtes Display soll von
+   selbst nie scrollen müssen; die zwei Spalten strecken sich über die volle
+   restliche Höhe.
+   AUSNAHME, auf Eriks Wunsch (echter Touch-Monitor, "ich kann mich vor die
+   Tafel stellen und scrollen"): unterhalb der zwei Spalten folgt die
+   vollständige Projektliste (wandProjektlisteHtml(), js/wand/wand.js), und
+   NUR dieser Bereich (#wandContent, Klasse .wand-scrollable, von
+   renderWandboard() gesetzt) scrollt — eine offene Übersicht bleibt weiter
+   exakt einen Bildschirm hoch, siehe .wand-uebersicht unten. Ohne Berührung
+   kehrt die Ansicht nach WAND_IDLE_MS von selbst an den Anfang zurück
+   (wandAktivitaetErkannt()/wandBeiUntaetigkeitZuruecksetzen()). */
+body.wandtafel-aktiv .app-topbar,
+body.wandtafel-aktiv .side-menu,
+body.wandtafel-aktiv .side-menu-backdrop { display: none !important; }
+body.wandtafel-aktiv .app-main { height: 100vh; overflow: hidden; }
+body.wandtafel-aktiv .container { height: 100%; overflow: hidden; display: flex; flex-direction: column; padding: 14px 20px; }
+body.wandtafel-aktiv #wand { display: flex !important; flex-direction: column; flex: 1; min-height: 0; }
+
+.wand-kopfzeile {
+  flex-shrink: 0;
+  display: flex;
+  align-items: baseline;
   justify-content: space-between;
-  padding: 14px 18px;
-  border-bottom: 1px solid var(--line-soft);
-  font-weight: 600;
-  font-size: 16px;
+  gap: 12px;
+  padding-bottom: 10px;
+}
+.wand-zurueck {
+  appearance: none;
+  border: none;
+  background: none;
+  color: var(--text-subtle);
+  font-size: 12px;
+  padding: 0;
+  cursor: pointer;
+}
+.wand-zurueck:hover { color: var(--text-muted); }
+
+/* wandIdleCountdown (js/wand/wand.js): die verbleibende Zeit bis zum
+   automatischen Rücksprung in den Normalzustand (WAND_IDLE_MS) — Erik wollte
+   sehen können, wann das passiert, statt davon überrascht zu werden. Sitzt
+   bewusst AUSSERHALB von #wandContent, damit sie von dessen Neu-Rendern
+   (jeder Datenabgleich, jedes Auf-/Zuklappen) unberührt bleibt. */
+.wand-idle-countdown { flex-shrink: 0; font-size: 11px; color: var(--text-subtle); font-variant-numeric: tabular-nums; }
+
+/* Normalzustand: #wandContent selbst bleibt genau ein Bildschirm hoch, kein
+   Scrollen (das ist der Zustand, den eine offene Übersicht ebenfalls nutzt —
+   siehe .wand-uebersicht). Erst .wand-scrollable (von renderWandboard()
+   gesetzt, wenn KEINE Übersicht offen ist) schaltet auf einen normalen
+   Block-Scrollcontainer um, dessen erstes Kind (.wand-ambient) weiterhin
+   genau einen Bildschirm hoch ist — die Projektliste danach verlängert den
+   Inhalt darüber hinaus und erzeugt dadurch den Scrollbalken. */
+.wand-grid-wrap { flex: 1; min-height: 0; display: flex; flex-direction: column; }
+.wand-grid-wrap.wand-scrollable { display: block; overflow-y: auto; }
+.wand-ambient { min-height: 100%; display: flex; flex-direction: column; }
+
+.wand-c-layout { flex: 1; min-height: 0; display: grid; grid-template-columns: 320px 1fr; gap: 16px; }
+.wand-c-links { display: flex; flex-direction: column; gap: 16px; min-height: 0; }
+.wand-c-links .wand-kachel { flex: 1; min-height: 0; }
+
+.wand-c-rechts {
+  background: var(--surface);
+  border: 1px solid var(--line-soft);
+  border-radius: var(--r-xl);
+  box-shadow: var(--sh-2);
+  padding: 18px 22px;
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
 }
 
-.side-menu-header-actions {
+.wand-kachel {
+  background: var(--surface);
+  border: 1px solid var(--line-soft);
+  border-radius: var(--r-xl);
+  box-shadow: var(--sh-2);
+  padding: 18px 20px;
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+}
+.wand-kachel-titel {
+  margin: 0 0 12px;
+  font-size: 13px;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: .05em;
+  color: var(--text-muted);
+  flex-shrink: 0;
+}
+/* Der Inhalt verteilt sich GLEICHMÄSSIG über die volle, gestreckte
+   Kachelhöhe (space-evenly) statt oben zu kleben und unten Leerraum zu
+   lassen — genau das ließ vorher dünn befüllte Kacheln neben vollen leer
+   wirken. */
+.wand-kachel-body { flex: 1; display: flex; flex-direction: column; justify-content: space-evenly; min-height: 0; overflow: hidden; }
+
+/* Meter-Zeilen: Auslastung je Gewerk, Wochenbericht-Fortschritt je Gewerk.
+   Nicht mehr die Kachel als Ganzes ist antippbar, sondern jede einzelne
+   Gewerk-Zeile für sich (wandZeigeUebersicht('auslastung'|'besprochen', g)) —
+   deshalb trägt .ist-klickbar hier die Zeile, nicht mehr .wand-kachel. */
+.wand-meter-zeile { display: flex; align-items: center; gap: 12px; }
+.wand-meter-zeile.ist-klickbar { cursor: pointer; border-radius: var(--r-md); margin: 0 -6px; padding: 3px 6px; transition: background .15s var(--ease); }
+.wand-meter-zeile.ist-klickbar:hover { background: var(--surface-sunk); }
+.wand-meter-label { flex: 0 0 90px; font-size: 13px; font-weight: 600; color: var(--text); }
+.wand-meter {
+  flex: 1;
+  height: 18px;
+  background: var(--surface-sunk);
+  border-radius: var(--r-pill);
+  overflow: hidden;
   display: flex;
   align-items: center;
-  gap: 8px;
 }
+.wand-meter-fill { height: 100%; border-radius: var(--r-pill); transition: width .3s var(--ease); }
+.wand-meter-leer { font-size: 12px; color: var(--text-subtle); padding-left: 4px; }
+.wand-meter-wert {
+  flex: 0 0 76px;
+  text-align: right;
+  font-size: 15px;
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+}
+.wand-einheit { font-size: 11px; font-weight: 400; color: var(--text-subtle); margin-left: 2px; }
+.wand-leer-klein { font-size: 11.5px; color: var(--text-subtle); }
 
-.theme-toggle-circle {
-  width: 34px;
-  height: 34px;
+/* Kennzahlen: Kachel "Heute" (offene/überfällige Aufgaben, Abwesend) — jede
+   Kennzahl und jedes Kürzel ist für sich antippbar (.ist-klickbar), öffnet
+   die passende Vollbild-Übersicht. */
+.wand-stat-reihe { display: flex; gap: 28px; }
+.wand-stat { display: flex; flex-direction: column; gap: 2px; }
+.wand-stat b { font-size: 30px; font-weight: 700; letter-spacing: -.02em; font-variant-numeric: tabular-nums; }
+.wand-stat span { font-size: 12px; color: var(--text-subtle); }
+.wand-stat.ist-rot b { color: var(--red); }
+.wand-stat.ist-klickbar { cursor: pointer; }
+.wand-stat.ist-klickbar:hover b { text-decoration: underline; }
+.wand-namen { display: flex; flex-wrap: wrap; gap: 6px; }
+.wand-avatar {
+  width: 28px;
+  height: 28px;
   border-radius: 50%;
-  padding: 0;
   display: inline-flex;
   align-items: center;
   justify-content: center;
-  background: var(--surface-sunk);
-  border: 1px solid var(--line-soft);
-  color: var(--text);
-  cursor: pointer;
-  transition: background .2s var(--ease), transform .1s var(--ease);
+  font-size: 10.5px;
+  font-weight: 700;
+  background: var(--accent-soft);
+  color: var(--accent);
 }
+.wand-avatar.ist-klickbar { cursor: pointer; }
+.wand-avatar.ist-klickbar:hover { box-shadow: 0 0 0 2px var(--accent); }
+.wand-leer { font-size: 13px; color: var(--text-subtle); }
 
-.theme-toggle-circle:hover { background: var(--line-soft); }
-.theme-toggle-circle:active { transform: scale(.95); }
-
-.side-menu-content {
-  padding: 16px;
-  display: flex;
-  flex-direction: column;
-  gap: 18px;
-  overflow-y: auto;
+/* Ereignis-Feed (rechte Spalte) — auf Eriks Wahl "Variante C" aus dem
+   Design-Vergleich: drei Spalten nach Art (Neu/Überfällig/Termine) statt
+   einer gemischten, chronologisch sortierten Liste. Zeigt auf einen Blick,
+   WIE VIELE Ereignisse welcher Art anstehen — kostet dafür die vorherige
+   "zeitlich am nächsten zuerst"-Durchmischung über die Arten hinweg;
+   innerhalb einer Spalte sortiert wandAktuelleEreignisse() unverändert nach
+   zeitlicher Nähe. Jeder Eintrag bleibt für sich antippbar und springt
+   direkt ins betroffene Projekt. */
+.wand-feed-wrap { flex: 1; min-height: 0; overflow: hidden; }
+.wand-feed-gruppen { display: flex; gap: 16px; height: 100%; }
+.wand-feed-gruppe { flex: 1; min-width: 0; display: flex; flex-direction: column; gap: 2px; overflow: hidden; }
+.wand-feed-gruppe-kopf { display: flex; align-items: center; gap: 6px; margin-bottom: 4px; flex-shrink: 0; }
+.wand-feed-gruppe-punkt { width: 7px; height: 7px; border-radius: 50%; flex-shrink: 0; }
+.wand-feed-gruppe-punkt.neu { background: var(--accent); }
+.wand-feed-gruppe-punkt.ueberfaellig { background: var(--red); }
+.wand-feed-gruppe-punkt.termin { background: var(--amber); }
+.wand-feed-gruppe-titel {
+  font-size: 10.5px; font-weight: 700; text-transform: uppercase; letter-spacing: .04em; color: var(--text-muted);
 }
-
-.menu-section {
-  display: flex;
-  flex-direction: column;
-  gap: 8px;
+.wand-feed-gruppe-anzahl { font-size: 10.5px; color: var(--text-subtle); margin-left: auto; }
+.wand-feed-eintrag {
+  font-size: 12px; line-height: 1.4; padding: 8px 0; border-top: 1px solid var(--line-soft);
+  cursor: pointer; border-radius: var(--r-md); transition: background .15s var(--ease);
 }
+.wand-feed-eintrag:first-of-type { border-top: none; padding-top: 0; }
+.wand-feed-eintrag:hover { background: var(--surface-sunk); }
+.wand-feed-eintrag b { display: block; font-weight: 600; color: var(--text); margin-bottom: 1px; }
+.wand-feed-eintrag span { color: var(--text-muted); }
+.wand-feed-zeit { display: block; font-size: 10.5px; color: var(--text-subtle); margin-top: 2px; }
 
-.menu-label {
-  font-size: 11px;
-  font-weight: 600;
-  text-transform: uppercase;
-  letter-spacing: .04em;
-  color: var(--text-muted);
-  margin-bottom: 2px;
+.wand-stand { text-align: center; font-size: 11px; color: var(--text-subtle); margin-top: 10px; flex-shrink: 0; }
+
+/* Vollbild-Übersichten (überfällige/offene Aufgaben, Auslastung/Besprochen
+   je Gewerk, Abwesenheiten) — ersetzen das zweispaltige Layout vorübergehend
+   vollständig (wandUebersicht). Die Liste ist die EINE bewusste Ausnahme vom
+   "kein Scrollen"-Grundsatz der Wandtafel: ein gezielter Einstieg mit
+   potenziell vielen Zeilen, kein passiver Dauerzustand. */
+.wand-uebersicht {
+  flex: 1; min-height: 0; display: flex; flex-direction: column;
+  background: var(--surface); border: 1px solid var(--line-soft); border-radius: var(--r-xl);
+  box-shadow: var(--sh-2); padding: 20px 24px;
 }
-
-.menu-section button { width: 100%; justify-content: center; }
-
-.menu-divider {
-  border: none;
-  border-top: 1px solid var(--line-soft);
-  margin: 0;
+.wand-uebersicht-kopf { display: flex; align-items: center; justify-content: space-between; margin-bottom: 14px; flex-shrink: 0; }
+.wand-uebersicht-kopf h2 { margin: 0; font-size: 19px; font-weight: 700; letter-spacing: -.01em; }
+.wand-uebersicht-liste { flex: 1; min-height: 0; overflow-y: auto; display: flex; flex-direction: column; }
+.wand-uebersicht-zeile {
+  display: flex; align-items: center; gap: 18px; padding: 13px 6px; border-top: 1px solid var(--line-soft);
+  transition: background .15s var(--ease);
 }
+.wand-uebersicht-zeile:first-child { border-top: none; }
+.wand-uebersicht-zeile.ist-klickbar { cursor: pointer; }
+.wand-uebersicht-zeile.ist-klickbar:hover { background: var(--surface-sunk); }
+.wand-uebersicht-projekt { flex: 0 0 280px; font-weight: 600; font-size: 14.5px; color: var(--text); }
+.wand-uebersicht-titel { flex: 1; font-size: 14.5px; color: var(--text); }
+/* Neutral, nicht mehr fest rot: eine Übersichts-Zeile kann auch eine
+   unauffällige Angabe zeigen (Stunden, "noch offen", Abwesenheitsende) —
+   .ist-rot markiert gezielt die wirklich überfälligen Zeilen. */
+.wand-uebersicht-seit { flex-shrink: 0; font-size: 13px; font-weight: 600; color: var(--text-muted); }
+.wand-uebersicht-seit.ist-rot { color: var(--red); }
 
-/* === Show Mode === */
-.show-mode-overlay {
-  position: fixed;
-  inset: 0;
-  background: var(--bg);
-  z-index: 1000;
-  display: flex;
-  flex-direction: column;
-}
-
-.show-mode-header {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  padding: 14px 24px;
-  background: var(--surface);
-  border-bottom: 1px solid var(--line-soft);
-  font-size: 18px;
-  font-weight: 600;
-}
-
-.show-mode-content {
-  flex: 1;
-  overflow: auto;
-  padding: 24px;
-}
-
-.show-mode-content .container {
-  padding: 0;
-  max-width: 1400px;
-  margin: 0 auto;
-}
-
-.show-mode-content .section-title {
-  margin-top: 0;
-}
-
-.show-mode-paused {
-  position: fixed;
-  bottom: 30px;
-  left: 50%;
-  transform: translateX(-50%);
-  background: var(--surface);
-  border: 1px solid var(--line-soft);
-  padding: 12px 24px;
-  border-radius: var(--r-pill);
-  box-shadow: var(--sh-3);
-  font-weight: 600;
-  z-index: 1001;
-  pointer-events: none;
-}
-
-/* Kompakte Darstellung im Show Mode */
-.show-mode-content {
-  font-size: 12px;
-}
-
-.show-mode-content .table-wrap {
-  max-height: none;
-  overflow: visible;
-}
-
-.show-mode-content table {
-  font-size: 10px !important;
-}
-
-.show-mode-content th,
-.show-mode-content td {
-  padding: 3px 4px !important;
-}
-
-.show-mode-content thead tr:nth-child(1) th,
-.show-mode-content thead tr:nth-child(2) th {
-  position: static;
-}
-
-.show-mode-content th.rot {
-  height: 60px !important;
-}
-
-.show-mode-content .proj-name {
-  min-width: 120px !important;
-}
-
-.show-mode-content .status {
-  min-width: 160px !important;
-}
-
-.show-mode-content .status-edit {
-  min-height: 24px !important;
-  padding: 3px 5px !important;
-  font-size: 10px !important;
-}
-
-.show-mode-content .person-cell {
-  width: 22px !important;
-}
-
-.show-mode-content .lph-cell {
-  width: 38px !important;
-}
-
-.show-mode-content .lph-cell input {
-  width: 30px !important;
-}
-
-.show-mode-content .bar {
-  height: 3px !important;
-  margin-top: 2px !important;
-}
-
-.show-mode-content .group-header td {
-  padding: 4px 6px !important;
-}
-
-.show-mode-content #boardLegend {
-  display: none;
-}
-
-.show-mode-content .load-grid {
-  gap: 12px;
-}
-
-.show-mode-content .load-row {
-  grid-template-columns: repeat(auto-fit, minmax(160px, 1fr)) !important;
-  gap: 10px !important;
-}
-
-.show-mode-content .load-card {
-  padding: 10px 12px !important;
-}
-
-.show-mode-content .load-card h3 {
-  font-size: 12px !important;
-}
-
-.show-mode-content .load-num {
-  font-size: 22px !important;
-}
-
-.show-mode-content .load-detail {
-  font-size: 10px !important;
-  margin-top: 6px !important;
-}
-
-.show-mode-loading {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  height: 100%;
-  font-size: 24px;
-  color: var(--text-muted);
-}
-
-/* Show Mode: Auslastungs-Steuerelemente und Überschrift ausblenden */
-.show-mode-overlay .show-mode-content #load .section-title,
-.show-mode-overlay .show-mode-content #load .toolbar {
-  display: none !important;
-}
-
-/* Show Mode: Bearbeitung deaktivieren */
-.show-mode-content .person-cell,
-.show-mode-content .lph-cell input,
-.show-mode-content .status-edit {
-  pointer-events: none !important;
-  cursor: default !important;
-}
-
-.show-mode-content .del-proj {
-  pointer-events: none !important;
-}
-
-.show-mode-content input[type=text].edit-name,
-.show-mode-content input[type=checkbox] {
-  pointer-events: none !important;
-}
-
-.show-mode-content button {
-  pointer-events: none !important;
-}
+/* Vollständige Projektliste unterhalb der zwei Spalten (wandProjektlisteHtml,
+   js/wand/wand.js) — nur sichtbar/erreichbar durch Herunterscrollen auf
+   einem echten Touch-Monitor. Auf Eriks Wunsch optisch identisch mit der
+   echten Projektliste: Gruppenüberschrift und Zeilen sind exakt
+   .section-title/.board-list/.board-row aus der Projektliste selbst (keine
+   eigene Zeilenform hier) — nur der äußere Abstand zu den Kacheln darüber
+   ist eine Wandtafel-eigene Ergänzung. */
+.wand-projektliste { margin-top: 22px; padding-bottom: 8px; }
+.wand-projektliste .section-title:first-child { margin-top: 0; }
 
 .side-menu-backdrop {
   position: fixed;
@@ -395,6 +558,66 @@ header h1 {
   visibility: visible;
 }
 
+/* Ab 769px: Sidebar dauerhaft sichtbar (kein Off-Canvas mehr nötig) */
+@media (min-width: 769px) {
+  #headerMenu.side-menu {
+    position: sticky;
+    /* top muss der tatsächlichen Höhe von .app-topbar entsprechen (beide
+       sticky, gleicher Scroll-Container) — sonst zieht die Sidebar bei
+       Seiten, die länger als ein Bildschirm sind, beim Herunterscrollen mit
+       top:0 unter das Menüband statt sich direkt darunter einzureihen, und
+       am unteren Rand bleibt eine sidebarlose Lücke in Höhe des Menübands
+       übrig (height: calc(100vh - 52px) reichte dann nicht bis nach unten). */
+    top: 52px;
+    height: calc(100vh - 52px);
+    transform: none;
+    box-shadow: none;
+    width: 260px;
+    flex: 0 0 260px;
+    border-right: 1px solid var(--line-soft);
+  }
+  #headerMenu.side-menu .header-toggle { display: none; }
+  .side-menu-backdrop { display: none; }
+
+  /* Umschalt-Leiste am unteren Sidebar-Rand nur auf Desktop-Breite sichtbar
+     (auf Mobile bleibt es beim reinen Off-Canvas-Menü ohne Zwischenzustand) */
+  .sidebar-collapse-bar { display: flex; }
+
+  /* Eingeklappte Sidebar: nur noch eine schmale Icon-Rail mit den 5
+     Navigationspunkten, alle Beschriftungen verschwinden */
+  #headerMenu.side-menu.collapsed {
+    width: 64px;
+    flex: 0 0 64px;
+  }
+
+  #headerMenu.side-menu.collapsed .sidebar-nav {
+    padding-left: 8px;
+    padding-right: 8px;
+  }
+
+  #headerMenu.side-menu.collapsed .nav-item .nav-label {
+    display: none;
+  }
+
+  #headerMenu.side-menu.collapsed .nav-item {
+    justify-content: center;
+    padding-left: 0;
+    padding-right: 0;
+  }
+
+  #headerMenu.side-menu.collapsed #sidebarCollapseIcon {
+    transform: rotate(180deg);
+  }
+
+  /* In der Icon-Rail ergeben aufgeklappte Unterlisten/Rubrik-Überschriften
+     ohne Textbeschriftung keinen Sinn — beides wird vollständig ausgeblendet. */
+  #headerMenu.side-menu.collapsed .nav-chevron,
+  #headerMenu.side-menu.collapsed .sidebar-section-label,
+  #headerMenu.side-menu.collapsed .sidebar-subnav {
+    display: none;
+  }
+}
+
 .toolbar {
   display: flex;
   gap: 8px;
@@ -408,36 +631,17 @@ button.active {
   border-color: var(--accent);
 }
 
-.week-date {
-  color: var(--text-muted);
-  font-size: 13px;
-  margin-left: 4px;
-}
-
-/* Abteilungs-Tabs: Segmented Control */
-.dept-tabs {
-  position: relative;
-  display: flex;
-  align-items: stretch;
-  justify-content: center;
-  min-height: 54px;
-  background: var(--bg);
-  padding: 0;
-}
-
+/* Hamburger-Knopf im globalen Menüband (nur < 769px sichtbar, öffnet die
+   Sidebar als Off-Canvas-Menü, siehe .mobile-nav-toggle weiter oben). */
 .menu-corner-btn {
-  position: absolute;
-  left: 0;
-  top: 0;
-  bottom: 0;
-  width: 54px;
   display: inline-flex;
   align-items: center;
   justify-content: center;
-  background: var(--bg);
-  border: none;
-  border-right: 1px solid var(--line-soft);
-  border-radius: 0;
+  width: 40px;
+  height: 40px;
+  background: var(--surface-sunk);
+  border: 1px solid var(--line-soft);
+  border-radius: var(--r-md);
   box-shadow: none;
   color: var(--text);
   cursor: pointer;
@@ -445,72 +649,122 @@ button.active {
   transition: background .2s var(--ease);
 }
 
-.menu-corner-btn:hover { background: var(--surface-sunk); }
+.menu-corner-btn:hover { background: var(--line-soft); }
 .menu-corner-btn:active { transform: none; }
 
-.dept-tabs-center {
+/* Hauptnavigation (Sidebar) — ersetzt die alte horizontale .tabs-Leiste */
+.sidebar-nav { gap: 2px; }
+
+.nav-item {
   display: flex;
   align-items: center;
-  gap: 2px;
-  flex-wrap: wrap;
-  padding: 12px 24px 0 24px;
-}
-
-.dept-tab {
+  gap: 8px;
+  width: 100%;
+  text-align: left;
+  text-decoration: none;
   background: transparent;
   color: var(--text-muted);
-  padding: 10px 22px;
+  padding: 9px 12px;
   cursor: pointer;
   border: none;
   border-radius: var(--r-md);
-  font-size: 15px;
+  font-size: 13px;
   font-weight: 500;
   transition: background .2s var(--ease), color .2s var(--ease);
 }
 
-.dept-tab:hover {
-  background: rgba(0,0,0,.045);
-  color: var(--text);
+.nav-icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 18px;
+  flex-shrink: 0;
+  font-size: 15px;
 }
 
-.dept-tab.active {
-  background: var(--surface);
-  color: var(--text);
-  font-weight: 600;
-  box-shadow: var(--sh-1);
+.nav-label {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
 }
 
-/* Unter-Tabs */
-.tabs {
-  display: flex;
-  gap: 2px;
-  background: var(--bg);
-  padding: 6px 24px 0 24px;
-  flex-wrap: wrap;
-  border-bottom: 1px solid var(--line-soft);
-}
+/* .nav-item kann ein echter <a href>-Link sein statt eines Buttons — ohne
+   diese Regel würde ein bereits besuchtes Ziel (echte Browser-Historie) mit
+   der UA-Standardfarbe für besuchte Links abweichen. */
+.nav-item:visited { color: var(--text-muted); }
+.nav-item:hover,
+.nav-item:visited:hover { background: var(--surface-sunk); color: var(--text); }
 
-.tab {
-  background: transparent;
-  color: var(--text-muted);
-  padding: 8px 14px;
-  cursor: pointer;
-  border: none;
-  border-radius: var(--r-sm) var(--r-sm) 0 0;
-  font-size: 13px;
-  font-weight: 500;
-  transition: color .2s var(--ease), box-shadow .2s var(--ease);
-}
-
-.tab:hover { color: var(--text); }
-
-.tab.active {
-  background: transparent;
+.nav-item.active {
+  background: var(--accent-soft);
   color: var(--accent);
   font-weight: 600;
-  box-shadow: inset 0 -2px 0 var(--accent);
 }
 
+/* .sidebar-section-label: kleine Rubrik-Überschrift oberhalb einer Gruppe von
+   Sidebar-Einträgen (z. B. "Dashboard", "Navigation"). */
+.sidebar-section-label {
+  padding: 10px 12px 2px;
+  font-size: 11px;
+  font-weight: 700;
+  letter-spacing: .04em;
+  text-transform: uppercase;
+  color: var(--text-muted);
+}
+
+/* .nav-group-toggle: Sidebar-Eintrag, der statt eines Tabs einen
+   auf-/zuklappbaren Unterbereich steuert (Einstellungen/Admin, siehe
+   toggleSidebarAccordion() in js/ui.js). */
+.nav-chevron {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 14px;
+  flex-shrink: 0;
+  margin-left: auto;
+  transition: transform .2s var(--ease);
+}
+
+.nav-group-toggle.expanded .nav-chevron { transform: rotate(180deg); }
+
+/* .sidebar-subnav: Liste der Aktionen unter einem aufgeklappten
+   .nav-group-toggle, per max-height animiert ein-/ausgeblendet. */
+.sidebar-subnav {
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+  padding-left: 8px;
+  max-height: 0;
+  opacity: 0;
+  overflow: hidden;
+  transition: max-height .25s var(--ease), opacity .2s var(--ease);
+}
+
+.sidebar-subnav.open {
+  /* Reicht für die längste Gruppe („Einstellungen", sieben Punkte); die
+     Animation läuft über max-height, deshalb steht hier eine feste Zahl. */
+  max-height: 360px;
+  opacity: 1;
+}
+
+.sidebar-subitem {
+  width: 100%;
+  padding-left: 34px;
+  font-size: 12.5px;
+  color: var(--text-muted);
+}
+.sidebar-subitem:hover { color: var(--text); }
+/* .is-active: der gerade gezeigte Abschnitt der Gruppe „Einstellungen"
+   (showSettingsSection() in js/settings/settings.js). Die übrigen Gruppen
+   lösen Aktionen aus und kennen deshalb keinen dauerhaft aktiven Punkt. */
+.sidebar-subitem.is-active {
+  color: var(--accent);
+  font-weight: 600;
+  background: var(--accent-soft);
+}
+.sidebar-subitem.danger { color: var(--red); }
+.sidebar-subitem.danger:hover { background: var(--red); color: #fff; }
+
 /* === Buttons & Formulare === */
 button {
   cursor: pointer;
@@ -543,8 +797,8 @@ button.secondary:hover  { background: rgba(0,0,0,.10); }
 button.secondary:active { background: rgba(0,0,0,.14); }
 
 button.danger  { background: var(--red); }
-button.danger:hover  { background: #e8112d; }
-button.danger:active { background: #b8000f; }
+button.danger:hover  { background: var(--red-hover); }
+button.danger:active { background: var(--red-active); }
 
 button.small {
   padding: 3px 10px;
@@ -553,6 +807,7 @@ button.small {
 
 select,
 input[type=text],
+input[type=email],
 input[type=date] {
   padding: 7px 10px;
   border: 1px solid var(--line);
@@ -566,6 +821,7 @@ input[type=date] {
 
 select:focus,
 input[type=text]:focus,
+input[type=email]:focus,
 input[type=date]:focus {
   outline: none;
   border-color: var(--accent);
@@ -627,46 +883,8 @@ thead tr:nth-child(1) th {
   z-index: 10;
 }
 
-thead tr:nth-child(2) th {
-  background: var(--surface-alt);
-  color: var(--text);
-  font-weight: 500;
-  border: 1px solid var(--line);
-  position: sticky;
-  top: 0; /* Wird von adjustStickyOffsets() dynamisch überschrieben */
-  z-index: 6;
-}
-
-th.rot {
-  background: var(--surface);
-  writing-mode: vertical-rl;
-  transform: rotate(180deg);
-  height: 90px;
-  padding: 4px 2px;
-  font-weight: 500;
-}
-
-td.left {
-  text-align: left;
-  min-width: 80px;
-}
-
 tr:nth-child(even) td { background: var(--surface-alt); }
 
-.proj-name {
-  font-weight: 600;
-  min-width: 160px;
-  letter-spacing: -0.01em;
-}
-
-.group-header td {
-  background: var(--surface-sunk) !important;
-  font-weight: 600;
-  text-align: left;
-  color: var(--text);
-  letter-spacing: -0.01em;
-}
-
 /* === Status-Felder in der Projektzeile === */
 .status {
   min-width: 240px;
@@ -704,6 +922,202 @@ tr:nth-child(even) td { background: var(--surface-alt); }
 .status-edit b,
 .status-edit strong { font-weight: 600; }
 
+/* === Kommentar-Editor im Board und im Wochenbericht ======================
+   Ersetzt das frühere contenteditable-Feld samt execCommand-Leiste: Textfeld
+   mit Verfasser-Kopfzeile, ausdrücklichem Speichern und dem eingeklappten,
+   scrollbaren Verlauf der früheren Sitzungen. Aufgebaut von
+   renderCommentEditor() in js/board/board.js. */
+
+.comment-block { display: flex; flex-direction: column; gap: 10px; }
+
+.comment-editor {
+  border: 1px solid var(--line);
+  border-radius: var(--r-md);
+  background: var(--surface);
+  overflow: hidden;
+}
+.comment-editor-head,
+.comment-head-line {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+  padding: 6px 10px;
+  font-size: 11px;
+  color: var(--text-muted);
+  background: var(--surface-alt);
+  border-bottom: 1px solid var(--line-soft);
+}
+.comment-head-line { border: 1px solid var(--line-soft); border-radius: var(--r-md); }
+.comment-who { display: flex; align-items: center; gap: 6px; color: var(--text); font-weight: 500; }
+.comment-unknown { color: var(--text-subtle); font-weight: 400; font-style: italic; }
+.comment-sep { color: var(--text-subtle); }
+.comment-av {
+  width: 19px; height: 19px; border-radius: 50%;
+  background: var(--accent); color: #fff;
+  display: flex; align-items: center; justify-content: center;
+  font-size: 9px; font-weight: 600; flex-shrink: 0;
+}
+.comment-kbd { margin-left: auto; font-size: 10px; color: var(--text-subtle); white-space: nowrap; }
+
+/* .comment-field ist seit der Umstellung auf contenteditable (Eriks Wunsch
+   nach echter statt mit Sternchen markierter Fett-/Kursiv-/Farbschrift,
+   public/js/utils.js) ein <div>, kein <textarea> mehr — Selektor deshalb
+   klassenbasiert statt elementbasiert, resize entfällt (kein Äquivalent für
+   contenteditable), Platzhalter über :empty:before + data-placeholder statt
+   ::placeholder (das Pseudo-Element gibt es nur für echte Formularfelder). */
+.comment-editor .comment-field {
+  width: 100%;
+  display: block;
+  padding: 8px 10px;
+  font-family: inherit;
+  font-size: 12px;
+  line-height: 1.5;
+  color: var(--text);
+  background: var(--surface);
+  min-height: 62px;
+}
+.comment-editor .comment-field:focus { outline: none; box-shadow: none; }
+.comment-editor .comment-field:empty::before { content: attr(data-placeholder); color: var(--text-subtle); }
+
+/* .richtext-toolbar (js/utils.js, richtextToolbarHtml()): gemeinsame
+   Fett/Kursiv/Farbe-Werkzeugleiste für jedes Textfeld, das Eriks Wunsch nach
+   formatierbarem Text bedient (Board-Kommentar, Protokoll-Punkt-Text — siehe
+   .richtext-wrap dort). "Angedockte" Darstellung (Eriks Auswahl C aus dem
+   Formatierungsleiste-Mockup): eine schattierte Leiste, die direkt auf dem
+   Textfeld aufsitzt — eigene Fläche + untere Trennkante statt einzeln
+   umrandeter Knöpfe, damit Leiste und Feld wie EIN Kasten statt zwei lose
+   übereinanderstehende Elemente wirken. Bewusst KEIN zusätzlicher Rahmen um
+   den ganzen .richtext-wrap: das Protokoll-Textfeld soll weiterhin randlos in
+   seiner Tabellenzelle sitzen (siehe Kommentar bei .protokoll-thema-cell
+   weiter unten), der Board-Kommentar steckt ohnehin schon in der
+   umrandeten .comment-editor-Karte — die Leiste muss daher in beiden
+   Zusammenhängen funktionieren, ohne selbst Ecken abzurunden (mal steht sie
+   ganz oben in ihrer Karte, mal nicht). */
+.richtext-toolbar {
+  display: flex; align-items: center; gap: 8px; padding: 5px 8px;
+  background: var(--surface-sunk); border-bottom: 1px solid var(--line-soft);
+}
+.richtext-btn-group { display: inline-flex; gap: 2px; }
+.richtext-btn {
+  appearance: none; border: none; background: none; color: var(--text-muted);
+  width: 22px; height: 20px; border-radius: 4px; font-size: 11px; font-weight: 700; cursor: pointer; line-height: 1;
+}
+.richtext-btn:hover { background: var(--surface-alt); color: var(--text); }
+.richtext-divider { width: 1px; height: 14px; background: var(--line); flex-shrink: 0; }
+.richtext-farben { display: inline-flex; gap: 6px; }
+.richtext-farbe-btn {
+  appearance: none; border: none; width: 14px; height: 14px; border-radius: 50%; cursor: pointer; padding: 0;
+  box-shadow: 0 0 0 1px rgba(0,0,0,.08) inset;
+}
+.richtext-farbe-btn:hover { outline: 2px solid var(--line); outline-offset: 1px; }
+/* .richtext-hinweis: Fett/Kursiv/Farbe wirken nur auf MARKIERTEN Text — ohne
+   Markierung tut ein Klick nichts, und das war bisher nirgends ablesbar.
+   Solange nichts markiert ist, bleiben die Knöpfe blass und der Hinweis
+   fordert zum Markieren auf; .hat-auswahl (von einem selectionchange-
+   Lauscher gesetzt, siehe js/plan/plan-protokoll.js) dreht beides um. */
+.richtext-hinweis { margin-left: auto; font-size: 10px; color: var(--text-subtle); white-space: nowrap; }
+.richtext-toolbar:not(.hat-auswahl) .richtext-btn,
+.richtext-toolbar:not(.hat-auswahl) .richtext-farbe-btn { opacity: .45; }
+.richtext-toolbar.hat-auswahl { background: var(--accent-soft); }
+.richtext-toolbar.hat-auswahl .richtext-hinweis { color: var(--accent); font-weight: 600; }
+
+.comment-editor-foot {
+  display: flex;
+  align-items: center;
+  gap: 7px;
+  padding: 7px 10px;
+  border-top: 1px solid var(--line-soft);
+  background: var(--surface-alt);
+}
+.comment-foot-spacer { margin-left: auto; }
+.comment-dirty { font-size: 10.5px; color: var(--amber); white-space: nowrap; }
+
+.comment-readonly {
+  border: 1px solid var(--line-soft);
+  border-radius: var(--r-md);
+  padding: 7px 9px;
+  font-size: 11.5px;
+  line-height: 1.45;
+  background: var(--surface);
+}
+
+/* Verlauf: eingeklappt, mit Anzahl im Kopf; die Liste selbst scrollt */
+.comment-history {
+  border: 1px solid var(--line-soft);
+  border-radius: var(--r-md);
+  background: var(--surface);
+  overflow: hidden;
+}
+.comment-history > summary {
+  cursor: pointer;
+  list-style: none;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 7px 10px;
+  font-size: 11.5px;
+  color: var(--text);
+  user-select: none;
+}
+.comment-history > summary::-webkit-details-marker { display: none; }
+.comment-history > summary:hover { background: var(--surface-alt); }
+.comment-history-caret {
+  color: var(--text-subtle);
+  font-size: 9px;
+  transition: transform .18s var(--ease);
+}
+.comment-history[open] > summary .comment-history-caret { transform: rotate(90deg); }
+.comment-history-count {
+  margin-left: auto;
+  font-size: 10.5px;
+  font-weight: 600;
+  background: var(--accent-soft);
+  color: var(--accent);
+  border-radius: var(--r-pill);
+  padding: 1px 8px;
+  font-variant-numeric: tabular-nums;
+}
+.comment-history-count.zero { background: var(--surface-sunk); color: var(--text-subtle); }
+.comment-history-body { border-top: 1px solid var(--line-soft); padding: 4px 10px 8px; }
+
+.comment-history-list {
+  max-height: 220px;
+  overflow-y: auto;
+  overscroll-behavior: contain;
+}
+.comment-history-entry { padding: 8px 0; }
+.comment-history-entry + .comment-history-entry { border-top: 1px solid var(--line-soft); }
+.comment-history-head {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-bottom: 3px;
+  font-size: 10.5px;
+}
+.comment-history-week {
+  font-weight: 600;
+  color: var(--text);
+  white-space: nowrap;
+  font-variant-numeric: tabular-nums;
+}
+.comment-history-meta { color: var(--text-subtle); }
+.comment-history-text { font-size: 11.5px; line-height: 1.45; color: var(--text-muted); }
+.comment-history-text b,
+.comment-history-text strong { font-weight: 600; color: var(--text); }
+
+.comment-take {
+  margin-left: auto;
+  padding: 2px 9px;
+  font-size: 10px;
+  border-radius: var(--r-pill);
+  background: transparent;
+  color: var(--text-muted);
+  border: 1px solid var(--line);
+  flex-shrink: 0;
+}
+.comment-take:hover { background: var(--surface-sunk); color: var(--text); }
+
 .status-toolbar {
   display: none;
   position: absolute;
@@ -745,26 +1159,6 @@ tr:nth-child(even) td { background: var(--surface-alt); }
   font-weight: 600;
 }
 
-/* === Personen-Zuweisungszellen === */
-.person-cell {
-  cursor: pointer;
-  user-select: none;
-  width: 26px;
-  transition: background .12s var(--ease);
-}
-
-.person-cell.on {
-  background: var(--green) !important;
-  color: #fff;
-  font-weight: 600;
-}
-
-.person-cell.optional {
-  background: #d18b00 !important;
-  color: #fff;
-  font-weight: 600;
-}
-
 .locked-cell {
   cursor: not-allowed !important;
   background: var(--surface-sunk) !important;
@@ -777,70 +1171,6 @@ tr:nth-child(even) td { background: var(--surface-alt); }
   border-color: var(--line-soft) !important;
 }
 
-/* Gesperrte Zellen immer grau, auch wenn X/(X) gesetzt ist */
-.person-cell.locked-cell.on,
-.person-cell.locked-cell.optional {
-  background: var(--surface-sunk) !important;
-  color: var(--text-muted) !important;
-}
-
-/* === Rollenfarben === */
-.person-cell.role-planung {
-  background: linear-gradient(rgba(255,255,255,.55), rgba(255,255,255,.55)),
-              rgb(212, 245, 224);
-  background-attachment: fixed;
-}
-
-.person-cell.role-projektleitung {
-  background: linear-gradient(rgba(255,255,255,.55), rgba(255,255,255,.55)),
-              rgb(255, 219, 219);
-  background-attachment: fixed;
-}
-
-.person-cell.role-bauüberwachung {
-  background: linear-gradient(rgba(255,255,255,.55), rgba(255,255,255,.55)),
-              rgb(203, 238, 255);
-  background-attachment: fixed;
-}
-
-.role-planung,
-.role-planung.rot {
-  background: linear-gradient(rgba(255,255,255,.55), rgba(255,255,255,.55)),
-              rgb(212, 245, 224);
-  background-attachment: fixed;
-}
-
-.role-projektleitung,
-.role-projektleitung.rot {
-  background: linear-gradient(rgba(255,255,255,.55), rgba(255,255,255,.55)),
-              rgb(255, 219, 219);
-  background-attachment: fixed;
-}
-
-.role-bauüberwachung,
-.role-bauüberwachung.rot {
-  background: linear-gradient(rgba(255,255,255,.55), rgba(255,255,255,.55)),
-              rgb(203, 238, 255);
-  background-attachment: fixed;
-}
-
-th.role-planung,
-th.role-projektleitung,
-th.role-bauüberwachung { color: var(--text); }
-
-/* === LPH / Balken / Überschriften === */
-.lph-cell { width: 50px; }
-
-.lph-cell input {
-  width: 38px;
-  border: 1px solid var(--line-soft);
-  border-radius: var(--r-sm);
-  padding: 3px;
-  text-align: center;
-  font-size: 11px;
-  font-family: inherit;
-}
-
 .bar {
   height: 5px;
   border-radius: var(--r-pill);
@@ -856,16 +1186,450 @@ th.role-bauüberwachung { color: var(--text); }
   transition: width .3s var(--ease);
 }
 
-/* Markierung der amtierenden Leistungsphase (gesetzt im Tab "Projekte") */
-.lph-cell.lp-aktiv {
-  background: var(--accent-soft);
-  box-shadow: inset 0 2px 0 var(--accent);
+/* === Projektboard (Listenansicht) ===
+   Eine Bubble-Card je Projektgruppe (.board-list) mit den Projekten als
+   Listenzeilen (.board-row) — ersetzt die frühere breite Matrix (eine Spalte
+   je Person/Leistungsphase). Jede Zeile zeigt nur das Nötigste auf einen
+   Blick (Kürzel-Avatare der Zugeordneten, aktive Phase, Status-Vorschau);
+   Klick auf die Zeile klappt darunter das Detailpanel (.board-drawer) mit
+   Status-Editor, vollständiger Rollen-Zuordnung und allen LPH-Balken auf. */
+.board-list {
+  display: flex;
+  flex-direction: column;
+  background: var(--surface);
+  border: 1px solid var(--line-soft);
+  border-radius: var(--r-xl);
+  box-shadow: var(--sh-2);
+  overflow: hidden;
 }
 
-.lph-cell.lp-aktiv input {
-  border-color: var(--accent);
-  font-weight: 600;
+.board-row { border-bottom: 1px solid var(--line-soft); }
+.board-row:last-child { border-bottom: none; }
+
+.board-row-main {
+  display: flex;
+  align-items: center;
+  gap: 14px;
+  padding: 12px 16px;
+  cursor: pointer;
+  transition: background .15s var(--ease);
 }
+.board-row-main:hover { background: var(--surface-sunk); }
+
+.board-chev {
+  flex-shrink: 0;
+  color: var(--text-subtle);
+  display: inline-flex;
+  transition: transform .2s var(--ease);
+}
+.board-row.open .board-chev { transform: rotate(90deg); }
+
+.board-nr {
+  flex-shrink: 0;
+  width: 64px;
+  font-size: 11.5px;
+  color: var(--text-muted);
+  font-family: ui-monospace, 'SF Mono', monospace;
+}
+
+.board-name-wrap { flex: 1 1 260px; min-width: 0; }
+.board-name {
+  font-weight: 600;
+  letter-spacing: -0.01em;
+  cursor: pointer;
+}
+.board-name:hover { color: var(--accent); text-decoration: underline; }
+
+.board-status-line {
+  margin-top: 3px;
+  font-size: 12px;
+  color: var(--text-muted);
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.board-newdot {
+  flex-shrink: 0;
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: var(--green);
+}
+
+.board-avatar-stack {
+  flex-shrink: 0;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  max-width: 220px;
+}
+
+.board-avatar {
+  flex-shrink: 0;
+  width: 26px;
+  height: 26px;
+  border-radius: 50%;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 10px;
+  font-weight: 700;
+  letter-spacing: -0.02em;
+  color: var(--text-muted);
+  background: var(--surface-sunk);
+  border: 1px solid var(--line-soft);
+  cursor: pointer;
+  user-select: none;
+  transition: background .15s var(--ease), color .15s var(--ease), box-shadow .15s var(--ease);
+}
+
+.board-avatar.role-planung.state-1 { background: var(--green); border-color: var(--green); color: #fff; }
+.board-avatar.role-projektleitung.state-1 { background: var(--red); border-color: var(--red); color: #fff; }
+.board-avatar.role-bauüberwachung.state-1 { background: var(--accent); border-color: var(--accent); color: #fff; }
+
+.board-avatar.role-planung.state-2 { background: transparent; color: var(--green); border-color: var(--green); }
+.board-avatar.role-projektleitung.state-2 { background: transparent; color: var(--red); border-color: var(--red); }
+.board-avatar.role-bauüberwachung.state-2 { background: transparent; color: var(--accent); border-color: var(--accent); }
+
+.phase-pill {
+  flex-shrink: 0;
+  font-size: 11px;
+  font-weight: 600;
+  font-family: ui-monospace, 'SF Mono', monospace;
+  padding: 4px 10px;
+  border-radius: var(--r-pill);
+  background: var(--accent-soft);
+  color: var(--accent);
+  white-space: nowrap;
+}
+.phase-pill.muted { background: var(--surface-sunk); color: var(--text-subtle); font-family: inherit; font-weight: 500; }
+
+/* --- Detailpanel (.board-drawer) --- */
+.board-drawer {
+  padding: 18px 24px 22px;
+  background: var(--surface-alt);
+  border-top: 1px solid var(--line-soft);
+}
+
+.board-drawer h4 {
+  margin: 0 0 8px;
+  font-size: 11px;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: .05em;
+  color: var(--text-muted);
+}
+
+/* Die Schublade liefert drei gleichrangige Blöcke (Kommentar, Leistungsphasen,
+   Beteiligte, siehe renderBoardDrawer() in js/board/board.js). Im Projektboard
+   stehen alle drei übereinander: Kommentar über die volle Breite (er teilte
+   sich zuvor eine schmale Spalte mit den gestapelten LPH-Zeilen, die ihn auf
+   wenig Höhe drückten — Eriks Rückmeldung "Darstellung der Kommentare ist zu
+   klein"), darunter die Leistungsphasen als EIN schmaler Streifen
+   (board-lph-leiste, dasselbe Muster wie in der dichten Wochenbericht-Karte)
+   statt als Liste, darunter die Beteiligten. */
+.board-drawer-grid {
+  display: grid;
+  grid-template-columns: 1fr;
+  grid-template-areas: "kommentar" "lph" "beteiligte";
+  align-content: start;
+  gap: 18px;
+}
+.drawer-col-comment { grid-area: kommentar; }
+.drawer-col-lph     { grid-area: lph; }
+.drawer-col-people  { grid-area: beteiligte; }
+
+/* Auswahl der beauftragten Leistungsphasen. Genutzt vom Honorar-Dialog der
+   Projektplan-Seite (renderHonorarEingaben(), js/plan/plan-honorar.js) und
+   vom Neues-Projekt-Modal (openNewProjModal(), js/load/load.js) — deshalb
+   hier im gemeinsamen Stylesheet statt inline in einer der beiden Seiten. */
+.beauftragte-lp-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(84px, 1fr));
+  gap: 4px 10px;
+}
+.beauftragte-lp-item {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  font-size: 12px;
+  color: var(--text);
+  white-space: nowrap;
+}
+
+/* --- Wochenbericht: immer aufgeklappte Projekt-Karten ("Neu kommentiert",
+   "Fortschritt aktualisiert") — im Unterschied zu .board-list/.board-row
+   (Akkordeon der "Unverändert"-Gruppe) ist hier jede Karte ein eigenständiger
+   Kasten, kein Container mit Trennlinien. */
+.report-list {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+.report-card {
+  background: var(--surface);
+  border: 1px solid var(--line-soft);
+  border-radius: var(--r-md);
+  box-shadow: var(--sh-1);
+  overflow: hidden;
+}
+
+/* Kopfband: durchgefärbt in der Farbe der Änderungsart, damit beim Scrollen
+   ohne Blick auf die Abschnitts-Überschrift erkennbar ist, worum es geht.
+   Die Farbe kommt aus --band-neu/--band-fortschritt und lässt sich dort in
+   einem Zug abschwächen, falls die Leiste zu kräftig wirkt. */
+.report-card-head {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  flex-wrap: wrap;
+  padding: 9px 14px;
+  background: var(--surface-alt);
+  border-bottom: 1px solid var(--line-soft);
+}
+.report-card-head .board-name { cursor: pointer; }
+
+.report-card-neu         > .report-band { background: var(--band-neu); }
+.report-card-fortschritt > .report-band { background: var(--band-fortschritt); }
+
+.report-band {
+  border-bottom: none;
+  color: #fff;
+}
+.report-band .board-nr { color: rgba(255,255,255,.75); }
+.report-band .board-name { color: #fff; font-weight: 600; }
+.report-band .board-name:hover { text-decoration: underline; }
+.report-band .tag-chip {
+  background: rgba(255,255,255,.22);
+  color: #fff;
+  border-color: transparent;
+}
+.report-band .report-reason-badge {
+  background: rgba(255,255,255,.22);
+  color: #fff;
+}
+
+/* Drei Spalten statt zwei: im Bericht stehen Leistungsphasen und Beteiligte
+   nebeneinander, wodurch die Karte flacher wird. Dasselbe Markup wie im
+   Projektboard, nur anders angeordnet. */
+.report-card .board-drawer {
+  padding: 14px 16px 16px;
+  border-top: none;
+  background: var(--surface);
+}
+.report-card .board-drawer-grid {
+  grid-template-columns: 1.7fr 1fr 1fr;
+  grid-template-areas: "kommentar lph beteiligte";
+  gap: 22px;
+}
+.report-card .board-role-label { width: 58px; }
+
+@media (max-width: 860px) {
+  .report-card .board-drawer-grid {
+    grid-template-columns: 1fr;
+    grid-template-areas: "kommentar" "lph" "beteiligte";
+    gap: 16px;
+  }
+}
+
+/* === Dichte Fassung der Karte (.board-drawer-dicht, Wochenbericht) ===
+   Gleiche Angaben, gleiche Bedienelemente, enger gesetzt. Den Ausschlag gibt
+   die Leistungsphasen-Leiste: als Zeilen untereinander bestimmten bis zu zehn
+   Phasen die Höhe der ganzen Karte — bei 29 Projekten wurde der Bericht damit
+   rund 17 Bildschirmseiten lang. Nebeneinander braucht dieselbe Information
+   eine Zeile. */
+.board-drawer-dicht .board-drawer-grid {
+  /* Die Beteiligten brauchen so viel Breite wie der Kommentar: Sobald ihre
+     Kürzel umbrechen, bestimmt ihre Spalte die Höhe der ganzen Karte. Mit
+     1.45/1.15/1 waren es 14,2 Bildschirmseiten, mit gleich breiter
+     Beteiligten-Spalte 11,6 — mehr Breite bringt darüber hinaus nichts,
+     weil dann ohnehin nichts mehr umbricht. */
+  /* Die rechte Spalte bekommt eine MINDESTBREITE: Zehn Phasenfelder in einer
+     reinen fr-Spalte wurden 27 px schmal, und "100" passte nicht mehr ins
+     Eingabefeld — 79 Werte waren abgeschnitten. Unter 620 px Containerbreite
+     gibt die Mindestbreite nach und die Spalten rutschen untereinander. */
+  grid-template-columns: minmax(0, 1fr) minmax(340px, 1fr);
+  grid-template-areas: "kommentar kompakt";
+  gap: 18px;
+}
+@media (max-width: 860px) {
+  .board-drawer-dicht .board-drawer-grid {
+    grid-template-columns: 1fr;
+    grid-template-areas: "kommentar" "kompakt";
+    gap: 14px;
+  }
+}
+.drawer-col-kompakt { grid-area: kompakt; min-width: 0; }
+/* Die zweite Überschrift in derselben Spalte braucht Abstand nach oben, den
+   die erste (am Spaltenanfang) nicht haben darf. */
+.drawer-h4-zweit { margin-top: 12px; }
+
+.board-lph-leiste {
+  display: flex;
+  gap: 3px;
+  align-items: stretch;
+}
+.board-lph-cell {
+  flex: 1 1 0;
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 1px;
+  padding: 3px 2px 4px;
+  border: 1px solid var(--line-soft);
+  border-radius: var(--r-sm);
+  background: var(--surface-sunk);
+  /* Der Füllstand kommt als senkrechter Verlauf aus dem Inline-Stil
+     (renderBoardDrawer in js/board/board.js) — so bleibt der Balken erhalten,
+     den die Zeilenform als eigenes Element hatte. */
+  background-repeat: no-repeat;
+}
+.board-lph-cell-label {
+  font-size: 10px;
+  font-weight: 600;
+  color: var(--text-muted);
+  line-height: 1.2;
+}
+.board-lph-cell input {
+  width: 100%;
+  min-width: 0;
+  padding: 1px 2px;
+  border: none;
+  background: transparent;
+  text-align: center;
+  font-size: 11.5px;
+  font-variant-numeric: tabular-nums;
+  color: var(--text);
+  font-family: inherit;
+}
+.board-lph-cell input:focus {
+  outline: 1.5px solid var(--accent);
+  outline-offset: -1px;
+  border-radius: 3px;
+}
+.board-lph-cell.lp-aktiv {
+  border-color: var(--accent);
+}
+.board-lph-cell.lp-aktiv .board-lph-cell-label,
+.board-lph-cell.lp-aktiv input { color: var(--accent); }
+.board-lph-cell.locked-cell input { cursor: default; }
+
+/* Das Rollen-Label steht NEBEN seinen Kürzeln. Über ihnen kostete es drei
+   zusätzliche Zeilen, und damit bestimmte die Beteiligten-Spalte die Höhe der
+   ganzen Karte (189 px gegenüber 130 für den Kommentar). Die feste Breite ist
+   so bemessen, dass "Bauüberwachung" hineinpasst — bei 52 px lief die
+   Beschriftung über die Kürzel.
+
+   Die Regeln hängen am Merkmal .board-drawer-dicht, nicht am Ort: Sie
+   standen zunächst unter .report-card, und mit dem Umbau des Wochenberichts
+   auf die Tagesordnung gab es diesen Container nicht mehr — die dichte
+   Karte fiel still auf die Board-Darstellung zurück. Das zusätzliche
+   .board-role-mini liefert die Spezifität, die nötig ist, um die dortige
+   Regel für .board-role-row zu schlagen. */
+.board-drawer-dicht .board-role-mini .board-role-row {
+  display: flex;
+  align-items: flex-start;
+  gap: 7px;
+  margin-bottom: 4px;
+}
+.board-drawer-dicht .board-role-mini .board-role-label {
+  flex: 0 0 auto;
+  /* Bemessen am längsten Rollennamen: "BAUÜBERWACHUNG" braucht bei 10 px in
+     Versalien diese Breite — bei 88 px fehlte der letzte Buchstabe. */
+  width: 104px;
+  padding-top: 4px;
+  font-size: 10px;
+  line-height: 1.25;
+  letter-spacing: .02em;
+  text-transform: uppercase;
+}
+
+/* Schmale Fenster: Dort reicht die Breite für Label UND Kürzel nicht mehr,
+   also wieder übereinander — lieber drei Zeilen mehr als abgeschnittene
+   Beschriftungen. */
+@media (max-width: 1100px) {
+  .board-drawer-dicht .board-role-mini .board-role-row { display: block; }
+  .board-drawer-dicht .board-role-mini .board-role-label {
+    width: auto;
+    padding-top: 0;
+    margin-bottom: 2px;
+  }
+}
+
+.report-reason-badge {
+  margin-left: auto;
+  font-size: 11px;
+  font-weight: 600;
+  padding: 3px 10px;
+  border-radius: var(--r-pill);
+  background: var(--accent-soft);
+  color: var(--accent);
+  white-space: nowrap;
+}
+/* Innerhalb einer Report-Karte braucht das Detailpanel nicht den
+   Zeilen-Einzug/die obere Trennlinie, die es im Board-Akkordeon ausrichtet. */
+.report-card .board-drawer {
+  padding: 16px 20px 20px;
+  border-top: none;
+}
+
+/* .board-lph-row/-list/-label/-wert: reine Anzeige-Zeile für Leistungsphasen,
+   seit Variante A (Board-Drawer) nicht mehr für den Drawer selbst gebraucht
+   (siehe .board-lph-leiste/-cell dort), aber weiterhin für die
+   Fortschrittsliste im Projektbereich-Dashboard (#planLphList,
+   renderPlanInfo() in js/plan/plan-info.js) — eine großzügig bemessene,
+   eigene Fläche statt einer schmalen Drawer-Spalte, wo die gestapelte Form
+   kein Platzproblem hat. */
+.board-lph-list {
+  display: flex;
+  flex-direction: column;
+  gap: 7px;
+  margin-top: 14px;
+}
+
+.board-lph-row {
+  display: grid;
+  grid-template-columns: 42px 1fr 50px;
+  align-items: center;
+  gap: 10px;
+}
+.board-lph-row.is-ansicht{ cursor: default; }
+
+.board-lph-row .bar { flex: 1; margin-top: 0; }
+
+.board-lph-label {
+  font-size: 11px;
+  font-family: ui-monospace, 'SF Mono', monospace;
+  color: var(--text-muted);
+}
+
+.board-lph-row.lp-aktiv .board-lph-label { color: var(--accent); font-weight: 600; }
+
+/* Der Prozentwert einer Leistungsphase an der Stelle des Eingabefeldes. Die
+   Breite entspricht dem Feld, damit die Balken aller Zeilen gleich weit
+   reichen; tabular-nums hält die Ziffern in einer Spalte. */
+.board-lph-wert{
+  min-width: 52px;
+  text-align: right;
+  font-size: 12px;
+  font-variant-numeric: tabular-nums;
+  color: var(--text-muted);
+}
+
+.board-role-mini { display: flex; flex-direction: column; gap: 10px; }
+.board-role-mini .board-role-row { display: flex; align-items: center; gap: 10px; }
+.board-role-mini .board-role-label {
+  width: 100px;
+  flex-shrink: 0;
+  font-size: 11.5px;
+  color: var(--text-muted);
+}
+.board-role-mini .board-role-chips { display: flex; flex-wrap: wrap; gap: 6px; }
 
 .section-title {
   font-size: 17px;
@@ -873,51 +1637,266 @@ th.role-bauüberwachung { color: var(--text); }
   margin: 24px 0 10px;
   color: var(--text);
   letter-spacing: -0.02em;
+  line-height: 1.2;
 }
 
 /* === Lade-/Auswertungsübersicht === */
 .load-grid {
   display: flex;
   flex-direction: column;
-  gap: 20px;
+  gap: 24px;
   width: 100%;
 }
 
 .load-row {
   display: grid;
   grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
-  gap: 14px;
+  gap: 16px;
   align-items: start;
   width: 100%;
 }
 
+/* === Auslastung: das Lastband ===
+   Eine Zeile je Person und Rolle; der Balken ist nach Projekten aufgeteilt.
+   Zuvor stand jede Person in einer eigenen .load-card mit ihrer Projektliste
+   klein darunter — man sah die Zahl, aber nicht, woraus sie besteht. Die
+   Frage nach einer Auslastung von 1,80 ist aber immer dieselbe: aus einem
+   großen Projekt oder aus fünf kleinen, und was davon lässt sich abgeben?
+   .load-card/.load-row/.load-num/.load-detail bleiben bestehen — das
+   Dashboard (js/dashboard/dashboard.js) und die Ressourcenansicht des
+   Projektbereichs (js/plan/plan-gantt.js) bauen darauf auf. */
+.load-rolle { width: 100%; }
+
+.load-rolle-titel {
+  font-size: 14px;
+  font-weight: 600;
+  margin: 0 0 6px;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: .04em;
+}
+
+.load-zeile {
+  display: flex;
+  align-items: center;
+  gap: 16px;
+  padding: 11px 4px;
+  border-bottom: 1px solid var(--line-soft);
+}
+.load-zeile:last-child { border-bottom: none; }
+.load-zeile:hover { background: var(--surface); }
+
+/* Wer — Name oben, Kürzel und Zusätze darunter. Feste Breite, damit die
+   Bänder aller Zeilen an derselben Stelle beginnen und vergleichbar sind. */
+.load-wer {
+  flex: 0 0 200px;
+  min-width: 0;
+}
+.load-wer-name {
+  font-size: 13px;
+  font-weight: 500;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.load-wer-meta {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  flex-wrap: wrap;
+  font-size: 11px;
+  color: var(--text-subtle);
+  margin-top: 1px;
+}
+
+/* Das Band. Die Segmente füllen es von links; was frei bleibt, ist die
+   Restkapazität bis zum Skalenende (Vorgabe 8, firmenweit einstellbar). */
+.load-band {
+  flex: 1;
+  display: flex;
+  align-items: center;
+  height: 22px;
+  min-width: 140px;
+  background: var(--surface-sunk);
+  border-radius: var(--r-sm);
+  overflow: hidden;
+}
+
+.load-seg {
+  display: flex;
+  align-items: center;
+  height: 100%;
+  padding: 0 7px;
+  min-width: 3px;
+  font-size: 10px;
+  font-weight: 600;
+  color: #fff;
+  white-space: nowrap;
+  overflow: hidden;
+  border-right: 1px solid rgba(255,255,255,.4);
+  transition: filter .15s var(--ease);
+}
+.load-seg:last-of-type { border-right: none; }
+.load-seg:hover { filter: brightness(1.12); }
+.load-seg span { overflow: hidden; }
+
+.load-band-leer {
+  font-size: 11px;
+  color: var(--text-subtle);
+  padding-left: 9px;
+}
+
+.load-wert {
+  flex: 0 0 62px;
+  text-align: right;
+  font-size: 19px;
+  font-weight: 600;
+  letter-spacing: -.02em;
+  font-variant-numeric: tabular-nums;
+}
+
+.load-anbahnung {
+  font-size: 10px;
+  padding: 1px 7px;
+  border-radius: var(--r-pill);
+  background: var(--surface-sunk);
+  color: var(--text-muted);
+  white-space: nowrap;
+}
+
+/* Kopfzeile: was die Zahlen abdecken. Sie steht oben, weil die Aussagekraft
+   der ganzen Seite daran hängt — eine Auslastung aus drei von 29 Projekten
+   ist etwas anderes als eine aus 29. */
+.load-kopf {
+  display: flex;
+  align-items: center;
+  gap: 16px;
+  flex-wrap: wrap;
+  padding: 12px 14px;
+  background: var(--surface-sunk);
+  border-radius: var(--r-lg);
+  font-size: 13px;
+}
+.load-kopf-zahl strong {
+  font-size: 17px;
+  font-variant-numeric: tabular-nums;
+}
+.load-kopf-warnung {
+  color: var(--red);
+  font-weight: 600;
+}
+.load-kopf-warnung::before {
+  content: '';
+  display: inline-block;
+  width: 7px; height: 7px;
+  border-radius: 50%;
+  background: var(--red);
+  margin-right: 7px;
+  vertical-align: middle;
+}
+
+.load-luecken {
+  padding: 12px 14px;
+  border: 1px dashed var(--line);
+  border-radius: var(--r-lg);
+  font-size: 12px;
+}
+.load-luecke {
+  display: flex;
+  justify-content: space-between;
+  gap: 16px;
+  padding: 4px 0;
+  border-bottom: 1px solid var(--line-soft);
+}
+.load-luecke:last-child { border-bottom: none; }
+.load-luecke b { color: var(--text-muted); font-weight: 500; white-space: nowrap; }
+
+/* Summenzeile je Mensch: ein durchgehender Riegel statt der Projektsegmente.
+   Sie beantwortet die Frage, die die Rollenzeilen nicht beantworten können —
+   wer in drei Rollen arbeitet, hat trotzdem nur eine Arbeitswoche. */
+.load-zeile-summe .load-wer-name { font-weight: 600; }
+.load-seg-summe { border-right: none; }
+
+/* Marke der vollen Kapazität im Band. Sie sitzt am rechten Rand, weil das
+   volle Band genau die Wochenkapazität ist; ein Riegel, der sie erreicht,
+   stößt sichtbar an. */
+.load-kapazitaet {
+  position: absolute;
+  right: 0; top: 0; bottom: 0;
+  width: 2px;
+  background: var(--text-subtle);
+  opacity: .5;
+}
+.load-zeile-summe .load-band { position: relative; }
+
+.load-einheit {
+  font-size: 11px;
+  font-weight: 500;
+  color: var(--text-subtle);
+  margin-left: 2px;
+}
+
+.load-legende-item em {
+  font-style: normal;
+  color: var(--text-subtle);
+  margin-left: 3px;
+}
+
+/* Legende der Projektfarben, nur für die tatsächlich vorkommenden Projekte.
+   Nötig, weil in schmalen Segmenten die Projektnummer keinen Platz findet. */
+.load-legende {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px 16px;
+  padding-top: 14px;
+  border-top: 1px solid var(--line-soft);
+  font-size: 11px;
+  color: var(--text-muted);
+}
+.load-legende-item {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+}
+.load-legende-item i {
+  width: 9px;
+  height: 9px;
+  border-radius: 2px;
+  flex: 0 0 auto;
+}
+
+@media (max-width: 720px) {
+  .load-wer { flex-basis: 128px; }
+  .load-zeile { gap: 10px; }
+  .load-wert { flex-basis: 52px; font-size: 16px; }
+}
+
 .load-row-title {
   grid-column: 1 / -1;
   width: 100%;
-  font-size: 20px;
+  font-size: 14px;
   font-weight: 600;
   margin: 0 0 2px 0;
   padding-top: 4px;
   color: var(--text-muted);
   text-transform: uppercase;
   letter-spacing: .04em;
-  font-size: 14px;
 }
 
 .load-card {
   background: var(--surface);
   border: 1px solid var(--line-soft);
-  border-radius: var(--r-lg);
-  padding: 16px 18px;
+  border-radius: var(--r-xl);
+  padding: 20px 22px;
   min-width: 0;
   width: 100%;
-  box-shadow: var(--sh-1);
+  box-shadow: var(--sh-2);
   transition: box-shadow .2s var(--ease), transform .2s var(--ease);
 }
 
 .load-card:hover {
-  box-shadow: var(--sh-2);
-  transform: translateY(-1px);
+  box-shadow: var(--sh-3);
+  transform: translateY(-2px);
 }
 
 .load-card h3 {
@@ -925,6 +1904,7 @@ th.role-bauüberwachung { color: var(--text); }
   font-size: 14px;
   font-weight: 600;
   letter-spacing: -0.01em;
+  line-height: 1.25;
 }
 
 .load-num {
@@ -960,7 +1940,12 @@ th.role-bauüberwachung { color: var(--text); }
   display: none;
   align-items: center;
   justify-content: center;
-  z-index: 100;
+  /* Über Menüband (.app-topbar, 140) UND Seitenleiste (.side-menu, 200):
+     Mit dem früheren Wert 100 blieb die Navigation neben einem offenen Dialog
+     sichtbar und anklickbar — auch hinter dem "blockierenden" Login-Fenster —
+     und die Seitenleiste verdeckte bei mittleren Fensterbreiten die linke
+     Kante breiter Dialoge. */
+  z-index: 300;
 }
 
 .modal {
@@ -979,6 +1964,7 @@ th.role-bauüberwachung { color: var(--text); }
   font-size: 20px;
   font-weight: 600;
   letter-spacing: -0.02em;
+  line-height: 1.15;
 }
 
 .form-row {
@@ -994,6 +1980,59 @@ th.role-bauüberwachung { color: var(--text); }
   color: var(--text-muted);
 }
 
+/* Gesperrte Bedienelemente: Ohne eigene :disabled-Regeln schlagen die
+   Farbangaben oben die Browser-Voreinstellung, und ein deaktivierter Knopf
+   sieht exakt aus wie ein bedienbarer (z. B. in gesperrten Sitzungen oder
+   bei der eigenen Zeile in der Benutzerverwaltung). */
+button:disabled,
+input:disabled,
+select:disabled,
+textarea:disabled {
+  opacity: .45;
+  cursor: not-allowed;
+  box-shadow: none;
+}
+button:disabled:hover,
+select:disabled:hover {
+  filter: none;
+  transform: none;
+}
+
+/* Warnband unten rechts, wenn das Speichern fehlschlägt (showSyncProblem() in
+   js/store.js). Liegt über allem, damit es auch neben einem offenen Dialog
+   sichtbar bleibt. */
+.sync-problem-bar {
+  position: fixed;
+  right: 18px;
+  bottom: 18px;
+  z-index: 500;
+  max-width: 340px;
+  background: var(--red);
+  color: #fff;
+  font-size: 13px;
+  line-height: 1.45;
+  padding: 11px 15px;
+  border-radius: var(--r-md);
+  box-shadow: var(--sh-3);
+}
+
+/* Hinweisband gesperrter Sitzungen (renderBoard()/renderWochenbericht()).
+   Vorher standen die Farben als Inline-Angaben im Markup und waren damit im
+   Dunkelmodus grell weiß-rosa. */
+.lock-notice {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  flex-wrap: wrap;
+  background: var(--surface-alt);
+  border: 1px solid var(--red);
+  color: var(--red);
+  border-radius: var(--r-md);
+  padding: 9px 13px;
+  margin-bottom: 12px;
+  font-size: 13px;
+}
+
 /* === LP-Aufwand-Maske als Matrix-Tabelle ===
    Zeilen = Leistungsphasen, Spalten = Rollen + "amtierend" (Radio). */
 .lp-matrix {
@@ -1043,25 +2082,38 @@ th.role-bauüberwachung { color: var(--text); }
   max-width: 640px;
 }
 
+/* .bubble-card: gemeinsame "Bubble-Card"-Optik für Projekt- und
+   Personen-Karten (Projekte-/Projektbeteiligte-Tab) — gleicher Radius/
+   Schatten wie .load-card (Dashboard/Auslastung), aber ohne Hover-Anhebung,
+   weil die Projekt-Karten Formularelemente enthalten (eine Anhebung beim
+   Überfahren wäre dort irritierend). */
+.bubble-card {
+  background: var(--surface);
+  border: 1px solid var(--line-soft);
+  border-radius: var(--r-xl);
+  padding: 20px 22px;
+  box-shadow: var(--sh-2);
+  transition: box-shadow .2s var(--ease);
+}
+
+.bubble-card:hover {
+  box-shadow: var(--sh-3);
+}
+
 .person-list-item,
 .person-card {
   display: flex;
   flex-direction: column;
-  border-bottom: 1px solid var(--line-soft);
   width: 100%;
 }
 
 .person-list-item {
   align-items: center;
   gap: 8px;
-  padding: 8px 4px;
   overflow-x: auto;
   flex-direction: row;
 }
 
-.person-card:last-child,
-.person-list-item:last-child { border-bottom: none; }
-
 .person-header {
   display: flex;
   align-items: center;
@@ -1069,10 +2121,43 @@ th.role-bauüberwachung { color: var(--text); }
   padding: 8px 4px;
   cursor: pointer;
   overflow-x: auto;
+  transition: background .2s var(--ease);
 }
 
 .person-header:hover { background: var(--surface-sunk); }
 
+/* Schaltflächen-Optik auch für Links: Ein <a class="secondary"> in einer
+   Knopfleiste sah sonst aus wie ein blauer Standardlink, weil .secondary
+   ausschließlich für <button> definiert war. */
+a.secondary {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  background: var(--surface-alt);
+  color: var(--text);
+  border: 1px solid var(--line);
+  border-radius: var(--r-md);
+  padding: 6px 12px;
+  font-size: 13px;
+  font-weight: 500;
+  text-decoration: none;
+  transition: background .15s var(--ease), border-color .15s var(--ease);
+}
+a.secondary:hover { background: var(--surface-sunk); border-color: var(--text-subtle); }
+
+/* Trennzeichen in der Board-Legende (Rollenfarben | Art der Zuordnung) */
+.legend-sep { color: var(--text-subtle); }
+
+/* Zugehörigkeit zur aktuellen Sitzung + Schaltfläche rechts in der Zeile
+   (renderPeople(), js/people/people.js). */
+.person-week-state {
+  margin-left: auto;
+  font-size: 12px;
+  color: var(--green);
+  white-space: nowrap;
+}
+.person-header button { flex: 0 0 auto; }
+
 .person-toggle {
   flex: 0 0 auto;
   font-size: 11px;
@@ -1081,6 +2166,14 @@ th.role-bauüberwachung { color: var(--text); }
   text-align: center;
 }
 
+.person-toggle .icon {
+  transition: transform .2s var(--ease);
+}
+
+.person-card.open .person-toggle .icon {
+  transform: rotate(90deg);
+}
+
 .person-list-item span.drag-handle,
 .person-header span.drag-handle {
   flex: 0 0 auto;
@@ -1109,6 +2202,89 @@ th.role-bauüberwachung { color: var(--text); }
   white-space: nowrap;
 }
 
+/* .projects-sortable: Listen-Container je Projekt-Gruppe im Projekte-Tab
+   (projects.js) — eine Bubble-Card mit den Projekten als Listenzeilen
+   (kein Karten-Raster mehr, siehe .project-item). Der Container-Klassenname
+   bleibt unverändert, damit die Drag-and-Drop-Selektoren (handleDrop/
+   reorderProjects) weiter greifen. */
+.projects-sortable {
+  display: flex;
+  flex-direction: column;
+  background: var(--surface);
+  border: 1px solid var(--line-soft);
+  border-radius: var(--r-xl);
+  box-shadow: var(--sh-2);
+  overflow: hidden;
+}
+
+/* .people-readonly: Listen-Container im Projektbeteiligte-Tab (people.js) —
+   eine Bubble-Card mit den Personen als Listenzeilen (kein Karten-Raster
+   mehr, siehe .person-card). */
+.people-readonly {
+  display: flex;
+  flex-direction: column;
+  background: var(--surface);
+  border: 1px solid var(--line-soft);
+  border-radius: var(--r-xl);
+  box-shadow: var(--sh-2);
+  overflow: hidden;
+}
+
+/* .person-card: eine Listenzeile im Projektbeteiligte-Tab (ersetzt die
+   vormalige eigene Bubble-Card je Person) — der klickbare .person-header
+   bleibt die sichtbare Zeile, .person-absences klappt darunter auf. */
+.person-card {
+  border-bottom: 1px solid var(--line-soft);
+  padding: 0 16px;
+}
+.person-card:last-child { border-bottom: none; }
+
+/* .sidebar-nav-divider: trennt die Modul-Navigation von Einstellungen/Admin. */
+.sidebar-nav-divider {
+  border: none;
+  border-top: 1px solid var(--line-soft);
+  margin: 8px 6px;
+}
+
+/* .project-item: eine Listenzeile im Projekte-Tab (ersetzt die vormalige
+   eigene Bubble-Card je Projekt) — überschreibt die Zeilen-Basis von
+   .person-list-item mit einer umbrechenden Zeile plus rechtsbündigen
+   Aktionen (.project-card-footer); das Karten-Attribut (data-project-id) und
+   die Drag-Handler bleiben unverändert. */
+.project-item {
+  overflow-x: visible;
+  flex-wrap: wrap;
+  padding: 12px 16px;
+  border-bottom: 1px solid var(--line-soft);
+  border-radius: 0;
+  transition: background .15s var(--ease);
+}
+.project-item:last-child { border-bottom: none; }
+.project-item:hover { background: var(--surface-sunk); }
+
+.project-tags-row {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 6px;
+  flex: 1 1 200px;
+  min-width: 0;
+}
+
+.project-card-footer {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-left: auto;
+}
+/* Überschreibt die generische .person-list-item-button-Regel (margin-left:
+   auto auf jedem direkten Button), sonst würden sich die beiden Footer-
+   Buttons gegenseitig auseinanderschieben statt gruppiert zu bleiben — nur
+   der Footer als Ganzes soll rechtsbündig sein. */
+.project-card-footer button { margin-left: 0; }
+
+.tag-input { width: 110px; font-size: 12px; padding: 3px 8px; }
+
 /* === Hinweise & Hilfsklassen === */
 .legend {
   font-size: 11px;
@@ -1125,49 +2301,112 @@ th.role-bauüberwachung { color: var(--text); }
   gap: 5px;
 }
 
-.legend-list {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 10px;
-  padding-bottom: 4px;
-}
 
-.legend-item {
-  flex: 0 0 auto;
-  padding: 6px 10px;
+/* === Anwesenheitsblock der Sitzung ======================================
+   Eigener Block oben im Projektboard (renderAttendance(), js/board/board.js).
+   Zustände sind bewusst binär (anwesend / nicht anwesend, Tabelle attendance);
+   der Zähler in der Kopfzeile macht sichtbar, wenn noch niemand geklickt hat. */
+
+.attendance-block {
   background: var(--surface);
   border: 1px solid var(--line-soft);
-  border-radius: var(--r-sm);
-  color: var(--text);
-  user-select: none;
-  transition: opacity .2s var(--ease), background .2s var(--ease);
-  cursor: pointer;
+  border-radius: var(--r-lg);
+  box-shadow: var(--sh-1);
+  margin-top: 16px;
+  overflow: hidden;
+}
+.attendance-bar {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  flex-wrap: wrap;
+  padding: 9px 14px;
+  background: var(--surface-alt);
+  border-bottom: 1px solid var(--line-soft);
+}
+.attendance-title { font-weight: 600; font-size: 13px; }
+.attendance-count {
+  font-size: 11.5px;
+  color: var(--text-muted);
+  font-variant-numeric: tabular-nums;
   white-space: nowrap;
 }
+.attendance-spacer { margin-left: auto; }
 
-.legend-item:hover { opacity: .8; }
-
-.legend-item.present {
-  background: var(--green);
-  color: #fff;
-  border-color: transparent;
+.attendance-grid {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  padding: 12px 14px;
 }
 
-.legend-item span {
-  font-weight: 600;
-  color: inherit;
-}
-
-.legend-item.locked-legend-item { opacity: .7; }
-
-#boardLegend {
-  margin-top: 16px;
-  padding: 12px;
+.attendance-tile {
+  position: relative;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 4px;
+  width: 84px;
+  padding: 9px 5px 8px;
+  border: 1px solid var(--line);
+  border-radius: var(--r-md);
   background: var(--surface);
-  border: 1px solid var(--line-soft);
-  border-radius: 6px;
-  font-size: 12px;
+  color: var(--text-muted);
+  font-family: inherit;
+  font-weight: 400;
+  cursor: pointer;
+  transition: border-color .15s var(--ease), background .15s var(--ease), color .15s var(--ease);
 }
+.attendance-tile:hover { border-color: var(--text-subtle); background: var(--surface-alt); }
+.attendance-tile:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; }
+
+.attendance-av {
+  width: 30px; height: 30px;
+  border-radius: 50%;
+  background: var(--surface-sunk);
+  color: var(--text-muted);
+  display: flex; align-items: center; justify-content: center;
+  font-size: 11px; font-weight: 600;
+  transition: background .15s var(--ease), color .15s var(--ease);
+}
+.attendance-name {
+  font-size: 10.5px;
+  line-height: 1.25;
+  text-align: center;
+  word-break: break-word;
+}
+.attendance-note {
+  font-size: 9.5px;
+  color: var(--amber);
+  line-height: 1.2;
+  text-align: center;
+}
+/* Der Haken trägt den Zustand zusätzlich zur Farbe — nicht jede Person
+   unterscheidet Grün und Grau zuverlässig. */
+.attendance-mark {
+  position: absolute;
+  top: 4px; right: 6px;
+  font-size: 11px;
+  font-weight: 700;
+  color: var(--green);
+  line-height: 1;
+}
+
+.attendance-tile.present {
+  border-color: var(--green);
+  background: var(--attend-bg);
+  color: var(--green);
+  font-weight: 500;
+}
+.attendance-tile.present:hover { background: var(--attend-bg-hover); border-color: var(--green); }
+.attendance-tile.present .attendance-av { background: var(--green); color: #fff; }
+
+.attendance-tile.locked-cell { cursor: not-allowed; opacity: .7; }
+.attendance-tile.locked-cell:hover { border-color: var(--line); background: var(--surface); }
+.attendance-tile.present.locked-cell:hover { background: var(--attend-bg); border-color: var(--green); }
+
+/* Legende ist seit der Trennung reine Namenserklärung, nicht mehr klickbar */
+
 
 .swatch {
   width: 12px;
@@ -1186,6 +2425,10 @@ th.role-bauüberwachung { color: var(--text); }
   background: var(--surface);
 }
 
+/* Fehlermeldung direkt am Formularfeld (Passwort-Dialog, Aufgaben-Dialog)
+   statt als alert() — der Fehler steht dort, wo er entstanden ist. */
+.field-error { font-size: 11.5px; color: var(--red); }
+
 .hint {
   color: var(--text-subtle);
   font-size: 12px;
@@ -1200,10 +2443,6 @@ th.role-bauüberwachung { color: var(--text); }
 
 .lock-notice button { margin-left: 12px; }
 
-.locked-legend-item {
-  opacity: .7;
-  filter: grayscale(.35);
-}
 
 input[type=text].edit-name {
   border: 1px solid transparent;
@@ -1213,6 +2452,7 @@ input[type=text].edit-name {
   font-size: 12px;
   padding: 3px 5px;
   border-radius: var(--r-sm);
+  transition: background .15s var(--ease), border-color .15s var(--ease), box-shadow .15s var(--ease);
 }
 
 input[type=text].edit-name:hover { background: rgba(0,0,0,.03); }
@@ -1265,6 +2505,17 @@ input[type=text].edit-name:focus {
     --green:         #30d158;
     --amber:         #ff9f0a;
     --red:           #ff453a;
+    --red-hover:     #ff453a;
+    --red-active:    #a3000f;
+
+    --attend-bg:       rgba(48,209,88,.16);
+    --attend-bg-hover: rgba(48,209,88,.24);
+
+    --band-neu:         #0a6fd0;
+    --band-fortschritt: #1e7a38;
+
+    --protokoll-neu-bg:     rgba(255,214,10,.14);
+    --protokoll-neu-border: #ffd60a;
 
     --sh-1: 0 1px 2px rgba(0,0,0,.5), 0 1px 3px rgba(0,0,0,.4);
     --sh-2: 0 2px 10px rgba(0,0,0,.55), 0 1px 3px rgba(0,0,0,.4);
@@ -1295,6 +2546,17 @@ html[data-theme="dark"] {
   --green:         #30d158;
   --amber:         #ff9f0a;
   --red:           #ff453a;
+  --red-hover:     #ff453a;
+  --red-active:    #a3000f;
+
+  --attend-bg:       rgba(48,209,88,.16);
+  --attend-bg-hover: rgba(48,209,88,.24);
+
+  --band-neu:         #0a6fd0;
+  --band-fortschritt: #1e7a38;
+
+  --protokoll-neu-bg:     rgba(255,214,10,.14);
+  --protokoll-neu-border: #ffd60a;
 
   --sh-1: 0 1px 2px rgba(0,0,0,.5), 0 1px 3px rgba(0,0,0,.4);
   --sh-2: 0 2px 10px rgba(0,0,0,.55), 0 1px 3px rgba(0,0,0,.4);
@@ -1303,53 +2565,54 @@ html[data-theme="dark"] {
 
 /* Gemeinsame Dark-Style-Regeln (System oder manuell) */
 @media (prefers-color-scheme: dark) {
-  html:not([data-theme="light"]) header {
+  html:not([data-theme="light"]) .app-topbar {
     background: rgba(28,28,30,.75);
     border-bottom: 1px solid var(--line);
   }
+  html:not([data-theme="light"]) .toolbar-divider { background: var(--line); }
+  html:not([data-theme="light"]) .sidebar-nav-divider { border-top-color: var(--line); }
   html:not([data-theme="light"]) .side-menu {
     background: var(--surface);
     border-right-color: var(--line);
   }
-  html:not([data-theme="light"]) .side-menu-header,
-  html:not([data-theme="light"]) .menu-divider {
+  html:not([data-theme="light"]) .side-menu-mobile-header,
+  html:not([data-theme="light"]) .sidebar-collapse-bar {
     border-color: var(--line);
   }
-  html:not([data-theme="light"]) .show-mode-overlay { background: var(--bg); }
-  html:not([data-theme="light"]) .show-mode-header {
-    background: var(--surface);
-    border-bottom-color: var(--line);
-  }
-  html:not([data-theme="light"]) .show-mode-paused {
+  html:not([data-theme="light"]) .user-menu-dropdown {
     background: var(--surface);
     border-color: var(--line);
   }
+  html:not([data-theme="light"]) .user-menu-info { border-bottom-color: var(--line); }
+  html:not([data-theme="light"]) a.menu-item:hover,
+  html:not([data-theme="light"]) button.menu-item:hover { background: rgba(255,255,255,.08); }
+  html:not([data-theme="light"]) .sidebar-collapse-bar:hover { background: rgba(255,255,255,.08); }
   html:not([data-theme="light"]) .theme-toggle-circle {
     background: var(--surface-sunk);
     border-color: var(--line);
     color: var(--text);
   }
   html:not([data-theme="light"]) .menu-corner-btn {
-    background: var(--bg);
-    border-right-color: var(--line);
+    background: var(--surface-sunk);
+    border-color: var(--line);
     color: var(--text);
   }
-  html:not([data-theme="light"]) .menu-corner-btn:hover { background: var(--surface-sunk); }
-  html:not([data-theme="light"]) .header-logo { filter: brightness(.92); }
-  html:not([data-theme="light"]) .dept-tab:hover  { background: rgba(255,255,255,.08); }
-  html:not([data-theme="light"]) .dept-tab.active { background: var(--surface-sunk); }
-  html:not([data-theme="light"]) .tabs { border-bottom: 1px solid var(--line); }
+  html:not([data-theme="light"]) .menu-corner-btn:hover { background: var(--line); }
+  html:not([data-theme="light"]) .topbar-logo { filter: brightness(.92); }
+  html:not([data-theme="light"]) .nav-item:hover  { background: rgba(255,255,255,.08); }
+  html:not([data-theme="light"]) .nav-item.active { background: var(--accent-soft); }
 
   html:not([data-theme="light"]) button:focus-visible { box-shadow: 0 0 0 3px rgba(10,132,255,.45); }
   html:not([data-theme="light"]) button.secondary        { background: rgba(255,255,255,.10); color: var(--text); }
   html:not([data-theme="light"]) button.secondary:hover  { background: rgba(255,255,255,.15); }
   html:not([data-theme="light"]) button.secondary:active { background: rgba(255,255,255,.20); }
   html:not([data-theme="light"]) button.danger        { background: #d70015; }
-  html:not([data-theme="light"]) button.danger:hover  { background: #ff453a; }
-  html:not([data-theme="light"]) button.danger:active { background: #a3000f; }
+  html:not([data-theme="light"]) button.danger:hover  { background: var(--red-hover); }
+  html:not([data-theme="light"]) button.danger:active { background: var(--red-active); }
 
   html:not([data-theme="light"]) select,
   html:not([data-theme="light"]) input[type=text],
+  html:not([data-theme="light"]) input[type=email],
   html:not([data-theme="light"]) input[type=date] {
     background-color: var(--surface-sunk);
     border-color: var(--line);
@@ -1357,6 +2620,7 @@ html[data-theme="dark"] {
   }
   html:not([data-theme="light"]) select:focus,
   html:not([data-theme="light"]) input[type=text]:focus,
+  html:not([data-theme="light"]) input[type=email]:focus,
   html:not([data-theme="light"]) input[type=date]:focus {
     box-shadow: 0 0 0 3px rgba(10,132,255,.28);
   }
@@ -1365,8 +2629,6 @@ html[data-theme="dark"] {
   }
   html:not([data-theme="light"]) ::placeholder { color: var(--text-subtle); }
 
-  html:not([data-theme="light"]) th.rot { background: var(--surface); }
-
   html:not([data-theme="light"]) .status-edit {
     background: var(--surface-sunk);
     border-color: var(--line);
@@ -1380,53 +2642,21 @@ html[data-theme="dark"] {
   html:not([data-theme="light"]) .status-toolbar button:hover  { background: rgba(255,255,255,.10); }
   html:not([data-theme="light"]) .status-toolbar button:active { background: rgba(255,255,255,.16); }
 
-  html:not([data-theme="light"]) .person-cell.on { background: #1e7a38 !important; color: #fff; }
-  html:not([data-theme="light"]) .person-cell.optional { background: #9a6200 !important; color: #fff; }
   html:not([data-theme="light"]) .locked-cell { background: #38383a !important; opacity: .55; }
   html:not([data-theme="light"]) .locked-cell input {
     background: #38383a !important;
     border-color: var(--line) !important;
     color: var(--text-muted) !important;
   }
-  html:not([data-theme="light"]) .person-cell.locked-cell.on,
-  html:not([data-theme="light"]) .person-cell.locked-cell.optional {
-    background: #38383a !important;
-    color: var(--text-subtle) !important;
-  }
 
-  html:not([data-theme="light"]) .person-cell.role-planung,
-  html:not([data-theme="light"]) .role-planung,
-  html:not([data-theme="light"]) .role-planung.rot {
-    background: #1b3626;
-    background-attachment: scroll;
-    color: var(--text);
-  }
-  html:not([data-theme="light"]) .person-cell.role-projektleitung,
-  html:not([data-theme="light"]) .role-projektleitung,
-  html:not([data-theme="light"]) .role-projektleitung.rot {
-    background: #3d2224;
-    background-attachment: scroll;
-    color: var(--text);
-  }
-  html:not([data-theme="light"]) .person-cell.role-bauüberwachung,
-  html:not([data-theme="light"]) .role-bauüberwachung,
-  html:not([data-theme="light"]) .role-bauüberwachung.rot {
-    background: #17313f;
-    background-attachment: scroll;
-    color: var(--text);
-  }
-  html:not([data-theme="light"]) th.role-planung,
-  html:not([data-theme="light"]) th.role-projektleitung,
-  html:not([data-theme="light"]) th.role-bauüberwachung { color: var(--text); }
-
-  html:not([data-theme="light"]) .lph-cell input {
-    background: var(--surface-sunk);
-    border-color: var(--line);
-    color: var(--text);
-  }
   html:not([data-theme="light"]) .bar { background: #38383a; }
+  html:not([data-theme="light"]) .board-avatar { border-color: var(--line); }
 
   html:not([data-theme="light"]) .load-card { border-color: var(--line); }
+  html:not([data-theme="light"]) .bubble-card,
+  html:not([data-theme="light"]) .projects-sortable,
+  html:not([data-theme="light"]) .people-readonly,
+  html:not([data-theme="light"]) .board-list { border-color: var(--line); }
   html:not([data-theme="light"]) .modal-bg { background: rgba(0,0,0,.6); }
   html:not([data-theme="light"]) .modal    { border: 1px solid var(--line); }
 
@@ -1440,57 +2670,55 @@ html[data-theme="dark"] {
     border-color: var(--accent);
     box-shadow: 0 0 0 3px rgba(10,132,255,.28);
   }
-  html:not([data-theme="light"]) .locked-legend-item { opacity: .6; }
-  html:not([data-theme="light"]) .legend-item.present { color: #fff; }
 
   html:not([data-theme="light"]) ::-webkit-scrollbar-thumb { background: rgba(255,255,255,.22); background-clip: content-box; }
   html:not([data-theme="light"]) ::-webkit-scrollbar-thumb:hover { background: rgba(255,255,255,.34); background-clip: content-box; }
 }
 
-html[data-theme="dark"] header {
+html[data-theme="dark"] .app-topbar {
   background: rgba(28,28,30,.75);
   border-bottom: 1px solid var(--line);
 }
+html[data-theme="dark"] .toolbar-divider { background: var(--line); }
+html[data-theme="dark"] .sidebar-nav-divider { border-top-color: var(--line); }
 html[data-theme="dark"] .side-menu {
   background: var(--surface);
   border-right-color: var(--line);
 }
-html[data-theme="dark"] .side-menu-header,
-html[data-theme="dark"] .menu-divider {
+html[data-theme="dark"] .side-menu-mobile-header,
+html[data-theme="dark"] .sidebar-collapse-bar {
   border-color: var(--line);
 }
-html[data-theme="dark"] .show-mode-overlay { background: var(--bg); }
-html[data-theme="dark"] .show-mode-header {
-  background: var(--surface);
-  border-bottom-color: var(--line);
-}
-html[data-theme="dark"] .show-mode-paused {
+html[data-theme="dark"] .user-menu-dropdown {
   background: var(--surface);
   border-color: var(--line);
 }
+html[data-theme="dark"] .user-menu-info { border-bottom-color: var(--line); }
+html[data-theme="dark"] a.menu-item:hover,
+html[data-theme="dark"] button.menu-item:hover { background: rgba(255,255,255,.08); }
+html[data-theme="dark"] .sidebar-collapse-bar:hover { background: rgba(255,255,255,.08); }
 html[data-theme="dark"] .theme-toggle-circle {
   background: var(--surface-sunk);
   border-color: var(--line);
   color: var(--text);
 }
 html[data-theme="dark"] .menu-corner-btn {
-  background: var(--bg);
-  border-right-color: var(--line);
+  background: var(--surface-sunk);
+  border-color: var(--line);
   color: var(--text);
 }
-html[data-theme="dark"] .menu-corner-btn:hover { background: var(--surface-sunk); }
-html[data-theme="dark"] .header-logo { filter: brightness(.92); }
-html[data-theme="dark"] .dept-tab:hover  { background: rgba(255,255,255,.08); }
-html[data-theme="dark"] .dept-tab.active { background: var(--surface-sunk); }
-html[data-theme="dark"] .tabs { border-bottom: 1px solid var(--line); }
+html[data-theme="dark"] .menu-corner-btn:hover { background: var(--line); }
+html[data-theme="dark"] .topbar-logo { filter: brightness(.92); }
+html[data-theme="dark"] .nav-item:hover  { background: rgba(255,255,255,.08); }
+html[data-theme="dark"] .nav-item.active { background: var(--accent-soft); }
 
 html[data-theme="dark"] button:focus-visible { box-shadow: 0 0 0 3px rgba(10,132,255,.45); }
 html[data-theme="dark"] button.secondary        { background: rgba(255,255,255,.10); color: var(--text); }
 html[data-theme="dark"] button.secondary:hover  { background: rgba(255,255,255,.15); }
 html[data-theme="dark"] button.secondary:active { background: rgba(255,255,255,.20); }
 html[data-theme="dark"] button.danger        { background: #d70015; }
-html[data-theme="dark"] button.danger:hover  { background: #ff453a; }
-html[data-theme="dark"] button.danger:active { background: #a3000f; }
+html[data-theme="dark"] button.danger:hover  { background: var(--red-hover); }
+html[data-theme="dark"] button.danger:active { background: var(--red-active); }
 
 html[data-theme="dark"] select,
 html[data-theme="dark"] input[type=text],
@@ -1509,8 +2737,6 @@ html[data-theme="dark"] select {
 }
 html[data-theme="dark"] ::placeholder { color: var(--text-subtle); }
 
-html[data-theme="dark"] th.rot { background: var(--surface); }
-
 html[data-theme="dark"] .status-edit {
   background: var(--surface-sunk);
   border-color: var(--line);
@@ -1524,53 +2750,21 @@ html[data-theme="dark"] .status-toolbar {
 html[data-theme="dark"] .status-toolbar button:hover  { background: rgba(255,255,255,.10); }
 html[data-theme="dark"] .status-toolbar button:active { background: rgba(255,255,255,.16); }
 
-html[data-theme="dark"] .person-cell.on { background: #1e7a38 !important; color: #fff; }
-html[data-theme="dark"] .person-cell.optional { background: #9a6200 !important; color: #fff; }
 html[data-theme="dark"] .locked-cell { background: #38383a !important; opacity: .55; }
 html[data-theme="dark"] .locked-cell input {
   background: #38383a !important;
   border-color: var(--line) !important;
   color: var(--text-muted) !important;
 }
-html[data-theme="dark"] .person-cell.locked-cell.on,
-html[data-theme="dark"] .person-cell.locked-cell.optional {
-  background: #38383a !important;
-  color: var(--text-subtle) !important;
-}
 
-html[data-theme="dark"] .person-cell.role-planung,
-html[data-theme="dark"] .role-planung,
-html[data-theme="dark"] .role-planung.rot {
-  background: #1b3626;
-  background-attachment: scroll;
-  color: var(--text);
-}
-html[data-theme="dark"] .person-cell.role-projektleitung,
-html[data-theme="dark"] .role-projektleitung,
-html[data-theme="dark"] .role-projektleitung.rot {
-  background: #3d2224;
-  background-attachment: scroll;
-  color: var(--text);
-}
-html[data-theme="dark"] .person-cell.role-bauüberwachung,
-html[data-theme="dark"] .role-bauüberwachung,
-html[data-theme="dark"] .role-bauüberwachung.rot {
-  background: #17313f;
-  background-attachment: scroll;
-  color: var(--text);
-}
-html[data-theme="dark"] th.role-planung,
-html[data-theme="dark"] th.role-projektleitung,
-html[data-theme="dark"] th.role-bauüberwachung { color: var(--text); }
-
-html[data-theme="dark"] .lph-cell input {
-  background: var(--surface-sunk);
-  border-color: var(--line);
-  color: var(--text);
-}
 html[data-theme="dark"] .bar { background: #38383a; }
+html[data-theme="dark"] .board-avatar { border-color: var(--line); }
 
 html[data-theme="dark"] .load-card { border-color: var(--line); }
+html[data-theme="dark"] .bubble-card,
+html[data-theme="dark"] .projects-sortable,
+html[data-theme="dark"] .people-readonly,
+html[data-theme="dark"] .board-list { border-color: var(--line); }
 html[data-theme="dark"] .modal-bg { background: rgba(0,0,0,.6); }
 html[data-theme="dark"] .modal    { border: 1px solid var(--line); }
 
@@ -1584,8 +2778,6 @@ html[data-theme="dark"] input[type=text].edit-name:focus {
   border-color: var(--accent);
   box-shadow: 0 0 0 3px rgba(10,132,255,.28);
 }
-html[data-theme="dark"] .locked-legend-item { opacity: .6; }
-html[data-theme="dark"] .legend-item.present { color: #fff; }
 
 html[data-theme="dark"] ::-webkit-scrollbar-thumb { background: rgba(255,255,255,.22); background-clip: content-box; }
 html[data-theme="dark"] ::-webkit-scrollbar-thumb:hover { background: rgba(255,255,255,.34); background-clip: content-box; }
@@ -2089,6 +3281,7 @@ html[data-theme="dark"] ::-webkit-scrollbar-thumb:hover { background: rgba(255,2
   border-radius: var(--r-sm);
   cursor: pointer;
   user-select: none;
+  transition: background .15s var(--ease);
 }
 
 .range-picker-day:hover { background: var(--surface-sunk); }
@@ -2118,7 +3311,8 @@ html[data-theme="dark"] ::-webkit-scrollbar-thumb:hover { background: rgba(255,2
 
 .person-absences {
   padding: 8px 8px 8px 40px;
-  border-bottom: 1px solid var(--line-soft);
+  margin-top: 4px;
+  border-radius: var(--r-md);
   background: var(--surface-alt);
 }
 
@@ -2155,6 +3349,312 @@ html[data-theme="dark"] ::-webkit-scrollbar-thumb:hover { background: rgba(255,2
 .absence-form input[type=date] { width: 130px; }
 .absence-form select { min-width: 110px; }
 
+/* Tag-Chips: editierbar in der Projekte-Liste (projects.js), read-only auf
+   Board-Zeilen, Dashboard-Aufgabenkarten und der Projektplan-Kopfzeile.
+   Farben ausschließlich über CSS-Variablen, die in beiden Dark-Mode-Blöcken
+   bereits passend umdefiniert sind — keine zusätzlichen Dark-Overrides nötig. */
+.tag-chip-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+}
+
+.tag-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  background: var(--surface-sunk);
+  border: 1px solid var(--line-soft);
+  border-radius: var(--r-pill);
+  padding: 2px 8px;
+  font-size: 11px;
+  font-weight: 400;
+  color: var(--text-muted);
+}
+
+.tag-chip .tag-remove {
+  cursor: pointer;
+  font-weight: 600;
+  color: var(--text-subtle);
+  line-height: 1;
+  transition: color .15s var(--ease);
+}
+
+.tag-chip .tag-remove:hover { color: var(--red); }
+
+/* === Dashboard ("Meine Aufgaben"-Tab, js/dashboard/dashboard.js) ===
+   Aufbau: Kopf — Band — zwei Zonen. Die frühere Anordnung stellte die
+   Uhrzeit als größte Zahl heraus, zeigte vier gleich große Kennzahlkacheln
+   (meist drei davon mit einer Null) und legte alles untereinander, sodass
+   der Urlaub eines Kollegen gleichrangig unter den eigenen offenen Aufgaben
+   stand. */
+
+/* ---------- Kopf: Begrüßung links, Nebensachen rechts ---------- */
+.dash-kopf {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 20px;
+  flex-wrap: wrap;
+  margin-bottom: 20px;
+}
+.dash-gruss {
+  margin: 0;
+  font-size: 22px;
+  font-weight: 600;
+  letter-spacing: -.02em;
+}
+.dash-gruss em {
+  font-style: normal;
+  font-weight: 400;
+  color: var(--text-muted);
+}
+.dash-kopf-rechts {
+  display: flex;
+  align-items: baseline;
+  gap: 12px;
+}
+.dash-sitzung {
+  font-size: 11px;
+  font-weight: 600;
+  padding: 2px 9px;
+  border-radius: var(--r-pill);
+  background: var(--surface-sunk);
+  color: var(--text-muted);
+}
+.dash-uhr {
+  font-size: 13px;
+  color: var(--text-muted);
+  font-variant-numeric: tabular-nums;
+}
+
+/* ---------- Band: der Befund als Satz ---------- */
+.dash-band {
+  display: flex;
+  align-items: center;
+  gap: 22px;
+  flex-wrap: wrap;
+  padding: 16px 20px;
+  margin-bottom: 24px;
+  background: var(--surface-sunk);
+  border-radius: var(--r-lg);
+}
+/* Ohne Befund bleibt das Band farblos — eine Null in Alarmfarbe behauptet
+   ein Problem, das es nicht gibt. */
+.dash-band.ist-ruhig {
+  background: transparent;
+  border: 1px solid var(--line-soft);
+}
+.dash-befund {
+  margin: 0;
+  flex: 1 1 300px;
+  min-width: 0;
+  font-size: 17px;
+}
+/* Die Zahl größer als der Satz: Sie ist die Nachricht, und ab 19 px fett
+   gilt für den Kontrast die Schwelle für große Schrift — die Ampelfarbe
+   erreicht auf der abgesetzten Bandfläche sonst nur 4,1:1 im dunklen Thema. */
+.dash-befund b {
+  font-size: 1.15em;
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+}
+.dash-befund b.ist-rot { color: var(--red); }
+.dash-befund b.ist-ruhig { color: var(--green); }
+
+.dash-band-zahlen { display: flex; gap: 20px; flex-wrap: wrap; }
+.dash-zahl { display: flex; flex-direction: column; gap: 1px; min-width: 74px; }
+.dash-zahl b {
+  font-size: 19px;
+  font-weight: 600;
+  line-height: 1.15;
+  font-variant-numeric: tabular-nums;
+}
+.dash-zahl span { font-size: 11px; color: var(--text-subtle); white-space: nowrap; }
+.dash-zahl.ist-null b { color: var(--text-subtle); }
+
+/* ---------- Zwei Zonen: links der Arbeitsstrom, rechts der Rand ---------- */
+.dash-zonen {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) 300px;
+  gap: 24px;
+  align-items: start;
+}
+
+.dash-abschnitt { margin-bottom: 24px; }
+.dash-abschnitt:last-child { margin-bottom: 0; }
+.dash-abschnitt-kopf {
+  display: flex;
+  align-items: baseline;
+  gap: 10px;
+  margin-bottom: 8px;
+}
+.dash-abschnitt-titel {
+  margin: 0;
+  font-size: 11.5px;
+  font-weight: 600;
+  letter-spacing: .06em;
+  text-transform: uppercase;
+  color: var(--text-muted);
+}
+.dash-abschnitt-zahl {
+  font-size: 11px;
+  padding: 1px 7px;
+  border-radius: var(--r-pill);
+  background: var(--surface-sunk);
+  color: var(--text-muted);
+  font-variant-numeric: tabular-nums;
+}
+.dash-abschnitt-zusatz {
+  margin-left: auto;
+  font-size: 11px;
+  color: var(--text-subtle);
+}
+
+.dash-karte {
+  background: var(--surface);
+  border: 1px solid var(--line-soft);
+  border-radius: var(--r-lg);
+  box-shadow: var(--sh-1);
+  overflow: hidden;
+}
+.dash-leer { padding: 16px 18px; font-size: 13px; color: var(--text-subtle); }
+
+/* ---------- Meine Aufgaben: Zeilen statt halbseitiger Karten ---------- */
+.dash-auf {
+  display: flex;
+  align-items: center;
+  gap: 14px;
+  padding: 11px 16px;
+  border-bottom: 1px solid var(--line-soft);
+  text-decoration: none;
+  color: inherit;
+  transition: background .12s var(--ease);
+}
+.dash-auf:last-child { border-bottom: none; }
+.dash-auf:hover { background: var(--surface-sunk); }
+.dash-auf:focus-visible { outline: 2px solid var(--accent); outline-offset: -2px; }
+
+.dash-auf-text { flex: 1 1 auto; min-width: 0; }
+.dash-auf-titel {
+  display: block;
+  font-size: 13.5px;
+  font-weight: 500;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.dash-auf-meta {
+  display: flex;
+  align-items: center;
+  gap: 7px;
+  flex-wrap: wrap;
+  margin-top: 1px;
+  font-size: 11px;
+  color: var(--text-subtle);
+}
+.dash-auf-tag {
+  font-size: 10px;
+  padding: 0 6px;
+  border-radius: var(--r-sm);
+  background: var(--surface-sunk);
+  color: var(--text-muted);
+}
+
+.dash-auf-fortschritt { flex: 0 0 96px; display: flex; align-items: center; gap: 8px; }
+.dash-auf-bar {
+  flex: 1;
+  height: 5px;
+  background: var(--surface-sunk);
+  border-radius: var(--r-pill);
+  overflow: hidden;
+}
+.dash-auf-bar i { display: block; height: 100%; background: var(--accent); border-radius: var(--r-pill); }
+.dash-auf-pct {
+  min-width: 30px;
+  text-align: right;
+  font-size: 11px;
+  color: var(--text-subtle);
+  font-variant-numeric: tabular-nums;
+}
+
+.dash-auf-frist {
+  flex: 0 0 118px;
+  text-align: right;
+  font-size: 12px;
+  line-height: 1.3;
+  font-variant-numeric: tabular-nums;
+}
+.dash-auf-frist em { display: block; font-style: normal; font-size: 10.5px; color: var(--text-subtle); }
+.dash-auf-frist.ist-ueberfaellig, .dash-auf-frist.ist-ueberfaellig em { color: var(--red); }
+.dash-auf-frist.ist-bald { color: var(--amber); }
+
+/* ---------- Rechte Zone: Freigaben und Abwesenheiten ---------- */
+.dash-rand-zeile {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 10px 14px;
+  border-bottom: 1px solid var(--line-soft);
+}
+.dash-rand-zeile:last-child { border-bottom: none; }
+.dash-avatar {
+  flex: 0 0 auto;
+  width: 28px;
+  height: 28px;
+  border-radius: 50%;
+  display: grid;
+  place-items: center;
+  font-size: 10.5px;
+  font-weight: 600;
+  background: var(--surface-sunk);
+  color: var(--text-muted);
+}
+.dash-rand-text { flex: 1; min-width: 0; }
+.dash-rand-name {
+  display: block;
+  font-size: 12.5px;
+  font-weight: 500;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.dash-rand-meta {
+  display: block;
+  font-size: 10.5px;
+  color: var(--text-subtle);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.dash-chip {
+  flex: 0 0 auto;
+  font-size: 10px;
+  padding: 1px 7px;
+  border-radius: var(--r-pill);
+  background: var(--surface-sunk);
+  color: var(--text-muted);
+  white-space: nowrap;
+}
+/* Wer heute fehlt, ist die eigentliche Nachricht. */
+.dash-chip.ist-heute { background: var(--red); color: #fff; }
+
+@media (max-width: 1080px) {
+  .dash-zonen { grid-template-columns: 1fr; }
+}
+@media (max-width: 720px) {
+  .dash-auf-fortschritt { display: none; }
+  .dash-gruss { font-size: 19px; }
+}
+
+/* Farbe je Abwesenheitsart. Genutzt von .absence-chip (Projektbeteiligte,
+   Benutzerverwaltung, Projektbereich) und von .dash-chip im Dashboard.
+   .absence-chip-live ist entfallen — das Dashboard kennzeichnet eine heute
+   laufende Abwesenheit über .dash-chip.ist-heute. */
+.absence-type-urlaub      { background: rgba(36,138,61,.12);  color: var(--green); border-color: transparent; }
+.absence-type-krank       { background: rgba(215,0,21,.10);   color: var(--red);   border-color: transparent; }
+.absence-type-fortbildung { background: rgba(178,80,0,.12);   color: var(--amber); border-color: transparent; }
+
 /* Dark mode GANTT */
 @media (prefers-color-scheme: dark) {
   html:not([data-theme="light"]) .gantt-container { border-color: var(--line); }
@@ -2166,6 +3666,9 @@ html[data-theme="dark"] ::-webkit-scrollbar-thumb:hover { background: rgba(255,2
   html:not([data-theme="light"]) .gantt-row.gantt-project.highlighted { background: var(--accent-soft); }
   html:not([data-theme="light"]) .person-absences { background: var(--surface-sunk); border-color: var(--line); }
   html:not([data-theme="light"]) .absence-chip { background: var(--surface); border-color: var(--line); }
+  html:not([data-theme="light"]) .absence-type-urlaub      { background: rgba(48,209,88,.16); }
+  html:not([data-theme="light"]) .absence-type-krank       { background: rgba(255,69,58,.16); }
+  html:not([data-theme="light"]) .absence-type-fortbildung { background: rgba(255,159,10,.16); }
 }
 
 html[data-theme="dark"] .gantt-container { border-color: var(--line); }
@@ -2176,4 +3679,1267 @@ html[data-theme="dark"] .gantt-month { background: var(--surface-sunk); }
 html[data-theme="dark"] .gantt-day.weekend { background: var(--surface-sunk); }
 html[data-theme="dark"] .gantt-row.gantt-project.highlighted { background: var(--accent-soft); }
 html[data-theme="dark"] .person-absences { background: var(--surface-sunk); border-color: var(--line); }
-html[data-theme="dark"] .absence-chip { background: var(--surface); border-color: var(--line); }
\ No newline at end of file
+html[data-theme="dark"] .absence-chip { background: var(--surface); border-color: var(--line); }
+html[data-theme="dark"] .absence-type-urlaub      { background: rgba(48,209,88,.16); }
+html[data-theme="dark"] .absence-type-krank       { background: rgba(255,69,58,.16); }
+html[data-theme="dark"] .absence-type-fortbildung { background: rgba(255,159,10,.16); }
+/* === Bereich „Einstellungen" (js/settings/settings.js) ===
+   Karten in einem Raster: „Mein Konto" und „Honorar" sind schmal, die
+   Vorlagen-Pflege bekommt über .settings-card-wide die volle Breite, weil
+   dort eine Liste mit Bezeichnung, Versatz/Dauer und Lösch-Knopf steht. Die
+   Felder der beiden firmenweiten Abschnitte nutzen weiterhin die Klassen aus
+   plan-styles.css (.honorar-anteil-field, .template-admin-row …) — sie sind
+   mit den Masken aus den Projekt-Dialogen hierher gezogen und mussten dafür
+   nicht umbenannt werden. */
+.settings-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(320px, 1fr));
+  gap: 16px;
+  align-items: start;
+  /* Seit immer nur EIN Abschnitt sichtbar ist (showAdminSection()), füllt
+     eine einzelne Karte sonst die ganze Fensterbreite — Beschriftung links,
+     Eingabefeld ganz rechts. Die Grenze hält Feld und Bezeichnung beisammen
+     und lässt der Aufwands-Matrix trotzdem genug Platz. */
+  max-width: 1180px;
+}
+/* Ausnahme fuer breite Abschnitte (Kennzeichen wide in ADMIN_SECTIONS,
+   js/admin/admin.js): Die Benutzertabelle hat zehn Spalten und scrollte in
+   der begrenzten Breite quer. Sie darf das Fenster ausnutzen. */
+.settings-grid.is-wide { max-width: none; }
+.settings-card-wide { grid-column: 1 / -1; }
+
+.settings-card {
+  background: var(--surface);
+  border: 1px solid var(--line-soft);
+  border-radius: var(--r-lg);
+  padding: 16px 18px;
+  box-shadow: var(--sh-1);
+}
+.settings-card-title {
+  margin: 0 0 10px;
+  font-size: 14px;
+  font-weight: 600;
+  display: flex;
+  align-items: baseline;
+  gap: 10px;
+  flex-wrap: wrap;
+}
+/* Reichweite einer Einstellung — „firmenweit" heißt: wirkt bei allen. */
+.settings-scope {
+  font-size: 11px;
+  font-weight: 500;
+  letter-spacing: .04em;
+  text-transform: uppercase;
+  color: var(--text-muted);
+  background: var(--surface-alt);
+  border-radius: var(--r-pill);
+  padding: 2px 8px;
+}
+
+.settings-kv { display: flex; flex-direction: column; gap: 2px; margin-bottom: 10px; }
+.settings-kv-row {
+  display: flex;
+  gap: 10px;
+  font-size: 12.5px;
+  padding: 5px 0;
+  border-bottom: 1px solid var(--line-soft);
+}
+.settings-kv-row:last-child { border-bottom: none; }
+.settings-kv-key { width: 150px; flex-shrink: 0; color: var(--text-muted); }
+.settings-warn { color: var(--amber); }
+.settings-email-edit { display: flex; gap: 8px; align-items: center; flex: 1; flex-wrap: wrap; }
+.settings-email-edit input[type=email] { flex: 1; max-width: 320px; min-width: 160px; }
+
+.settings-inline-field {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 12.5px;
+  margin-bottom: 10px;
+}
+.settings-inline-field select { min-width: 120px; }
+
+/* KI-Zugangsdaten (Einstellungen -> Mein Konto, js/settings/settings.js):
+   ein umrandeter Block je Anbieter statt eines durchgehenden Feld-Rasters —
+   ChatGPT und Claude sind zwei getrennte Zugänge, keine vier gleichrangigen
+   Felder. Design-Entwurf mit Erik abgestimmt (Artifact d7ab2945). */
+.ai-provider { border: 1px solid var(--line-soft); border-radius: var(--r-md); padding: 14px 16px; }
+.ai-provider + .ai-provider { margin-top: 12px; }
+.ai-provider-head { display: flex; align-items: center; flex-wrap: wrap; gap: 10px; margin-bottom: 12px; }
+.ai-provider-info { min-width: 0; }
+.ai-provider-mark {
+  width: 26px; height: 26px; border-radius: 7px;
+  display: flex; align-items: center; justify-content: center;
+  font-size: 12px; font-weight: 700; color: #fff; flex-shrink: 0; letter-spacing: -.02em;
+}
+.ai-provider-mark.chatgpt { background: #10a37f; }
+.ai-provider-mark.claude  { background: #c96442; }
+.ai-provider-name { font-weight: 600; font-size: 13px; }
+.ai-provider-sub  { font-size: 11.5px; color: var(--text-subtle); }
+
+/* Status-Pill: derselbe Punkt-plus-Text-Aufbau wie an anderen Stellen der
+   App (z. B. .protokoll-status-dot), hier als Pill neben dem Anbieternamen. */
+.ai-status-chip {
+  margin-left: auto;
+  display: inline-flex; align-items: center; gap: 6px;
+  font-size: 11.5px; font-weight: 500;
+  padding: 3px 10px 3px 8px;
+  border-radius: var(--r-pill);
+  background: var(--surface-alt);
+  color: var(--text-muted);
+  flex-shrink: 0;
+}
+.ai-status-chip .dot { width: 6px; height: 6px; border-radius: 50%; background: var(--text-subtle); flex-shrink: 0; }
+.ai-status-chip.is-on { color: var(--green); }
+.ai-status-chip.is-on .dot { background: var(--green); }
+
+.ai-provider-row { display: flex; gap: 8px; }
+.ai-provider-row input[type=password],
+.ai-provider-row input[type=text] {
+  flex: 1; min-width: 0;
+  padding: 7px 10px;
+  font-size: 12.5px;
+  border: 1px solid var(--line);
+  border-radius: var(--r-sm);
+  background: var(--surface);
+  color: var(--text);
+  font-family: inherit;
+}
+.ai-provider-row input::placeholder { color: var(--text-subtle); }
+.ai-provider-row input:focus {
+  outline: none;
+  border-color: var(--accent);
+  box-shadow: 0 0 0 3px var(--accent-soft);
+}
+
+/* Häkchen-Knopf statt Textknopf "Speichern" — spricht für sich, direkt neben
+   dem Feld, das er betrifft. "Entfernen" bleibt ein leiser Text-Link, weil
+   er der seltenere, destruktivere Pfad ist. */
+.ai-icon-btn {
+  flex-shrink: 0;
+  width: 30px; height: 30px; padding: 0;
+  border-radius: var(--r-sm);
+  border: 1px solid var(--accent);
+  background: var(--accent);
+  color: #fff;
+  display: flex; align-items: center; justify-content: center;
+  cursor: pointer;
+  transition: background .15s var(--ease), border-color .15s var(--ease);
+}
+.ai-icon-btn:hover { background: var(--accent-hover); border-color: var(--accent-hover); }
+/* flex-shrink:0 ist hier kein Stil-Detail, sondern die Abhilfe für einen
+   Chromium-Eigenheit: ein <svg> als Flex-Kind schrumpft ohne explizites
+   flex-shrink:0 auf Breite 0 (min-width:auto berechnet die Inhaltsgröße
+   eines SVG offenbar als 0), wodurch das Häkchen-Icon unsichtbar wurde. */
+.ai-icon-btn svg { width: 15px; height: 15px; flex-shrink: 0; }
+
+.ai-text-btn {
+  flex-shrink: 0;
+  border: none; background: none;
+  font-size: 11.5px; color: var(--text-subtle);
+  cursor: pointer; padding: 0 2px;
+}
+.ai-text-btn:hover { color: var(--red); }
+.ai-text-btn:disabled { opacity: .4; cursor: default; }
+.ai-text-btn:disabled:hover { color: var(--text-subtle); }
+
+/* Cloud/Eigener-Server-Umschalter: ersetzt den früheren, eingeklappten
+   "API-URL"-Link. Ein eigener Server (LM Studio, Ollama) ist ein Kernfall,
+   kein Nebendetail — genau das wollte Erik als Erstes ausprobieren, als
+   er die Karte in echt benutzte — deshalb jetzt eine sichtbare Wahl statt
+   eines kleinen Links, den man erst entdecken muss. */
+.ai-mode-toggle {
+  display: inline-flex; background: var(--surface-sunk); border-radius: var(--r-pill);
+  padding: 3px; gap: 2px; margin-top: 12px;
+}
+.ai-mode-toggle button {
+  border: none; background: none; padding: 5px 13px; border-radius: var(--r-pill);
+  font-size: 12px; font-weight: 500; color: var(--text-muted); cursor: pointer; font-family: inherit;
+}
+.ai-mode-toggle button.is-active { background: var(--surface); color: var(--text); font-weight: 600; box-shadow: var(--sh-1); }
+
+.ai-url-panel { margin-top: 12px; padding-top: 12px; border-top: 1px dashed var(--line-soft); display: none; }
+.ai-url-panel.is-open { display: block; }
+.ai-url-panel label { display: block; font-size: 11px; color: var(--text-subtle); margin-bottom: 5px; }
+.ai-url-panel .ai-provider-row { margin-bottom: 0; }
+
+/* "Neu verbinden": prüft die gespeicherte Konfiguration wirklich (POST
+   /my-ai-settings/test), statt nur anzuzeigen, dass irgendein Schlüssel
+   gespeichert ist. Umrandet statt gefüllt, da kein primärer Speichern-
+   Knopf — sitzt direkt neben dem Status-Pill, den er betrifft. */
+.ai-reconnect-btn {
+  flex-shrink: 0; width: 26px; height: 26px; padding: 0; border-radius: 50%;
+  border: 1px solid var(--line); background: var(--surface); color: var(--text-muted);
+  display: flex; align-items: center; justify-content: center; cursor: pointer;
+  transition: background .15s var(--ease), color .15s var(--ease), border-color .15s var(--ease);
+}
+.ai-reconnect-btn:hover { background: var(--surface-alt); color: var(--accent); border-color: var(--accent); }
+.ai-reconnect-btn:disabled { opacity: .4; cursor: default; }
+.ai-reconnect-btn:disabled:hover { background: var(--surface); color: var(--text-muted); border-color: var(--line); }
+.ai-reconnect-btn svg { width: 13px; height: 13px; flex-shrink: 0; }
+.ai-reconnect-btn.is-testing svg { animation: ai-reconnect-spin .9s linear infinite; }
+@keyframes ai-reconnect-spin { from { transform: rotate(0deg); } to { transform: rotate(360deg); } }
+
+/* Fehler aus "Neu verbinden": bleibt stehen, bis der nächste Test läuft
+   oder erfolgreich ist — kein flüchtiger Hinweis. Dieselbe Lehre wie beim
+   Protokoll-Import-Banner: ein Toast neben einer sich gleichzeitig
+   ändernden Ansicht wird leicht übersehen. :empty blendet die Zeile aus,
+   solange kein Fehler ansteht, ohne eigenes hidden-Attribut in JS. */
+.ai-test-error { font-size: 11.5px; color: var(--red); margin-top: 8px; }
+.ai-test-error:empty { display: none; }
+
+/* Bestätigung nach dem Speichern. Bewusst kein alert(): ein gelungener
+   Speichervorgang soll den Arbeitsfluss nicht anhalten. */
+.settings-note {
+  margin-top: 14px;
+  font-size: 12.5px;
+  color: var(--green);
+  opacity: 0;
+  transition: opacity .25s var(--ease);
+}
+.settings-note.show { opacity: 1; }
+
+/* Felder und Matrix der firmenweiten Einstellungen (js/settings/settings.js).
+   Die Aufwands-Matrix kann breiter werden als die Karte — sie scrollt dann in
+   ihrem eigenen Container, statt die Seite quer zu ziehen. */
+.settings-field-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(230px, 1fr));
+  gap: 8px 16px;
+  margin-bottom: 12px;
+}
+.settings-field {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+  font-size: 12.5px;
+}
+.settings-field input { width: 88px; padding: 4px 7px; font-size: 12.5px; text-align: right; }
+
+.settings-check {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 12.5px;
+  margin: 4px 0 2px;
+}
+
+.settings-subtitle {
+  margin: 16px 0 4px;
+  font-size: 12.5px;
+  font-weight: 600;
+}
+
+.settings-matrix-wrap { overflow-x: auto; margin-bottom: 10px; }
+.settings-matrix { border-collapse: collapse; font-size: 12px; }
+.settings-matrix th, .settings-matrix td {
+  padding: 3px 6px;
+  border-bottom: 1px solid var(--line-soft);
+  text-align: center;
+}
+.settings-matrix thead th { color: var(--text-muted); font-weight: 500; white-space: nowrap; }
+.settings-matrix tbody th { text-align: left; font-weight: 500; white-space: nowrap; }
+.settings-matrix input { width: 62px; padding: 3px 6px; font-size: 12px; text-align: right; }
+
+.settings-holiday-list { display: flex; flex-direction: column; gap: 4px; margin-bottom: 10px; }
+
+/* Abweichende Stelle im Auslastungs-Tab (js/load/load.js) — steht nur da,
+   wenn die Person nicht voll beschäftigt ist. */
+.load-capacity {
+  font-size: 11px;
+  font-weight: 500;
+  color: var(--text-muted);
+  background: var(--surface-alt);
+  border-radius: var(--r-pill);
+  padding: 1px 7px;
+  margin-left: 6px;
+}
+
+/* Benutzerverwaltung (Abschnitt „Benutzerverwaltung" des Bereichs #admin,
+   js/admin-users.js). Diese Regeln standen als <style>-Block in der frueheren
+   eigenstaendigen Seite public/admin-users.html; die Regeln der dortigen
+   Seiten-Huelle (.admin-page/.admin-header/.admin-body) sind mit ihr
+   entfallen, weil der Abschnitt jetzt in der normalen App-Huelle liegt. */
+.admin-toolbar { margin-bottom: 14px; }
+td.actions-cell { white-space: nowrap; }
+td.actions-cell button { margin: 2px; }
+.badge-active { color: var(--green); font-weight: 600; }
+.badge-inactive { color: var(--text-muted); }
+.badge-warn { color: var(--amber); font-weight: 600; }
+/* Das einmalig angezeigte Passwort laesst sich mit einem Klick markieren. */
+#generatedPasswordBox {
+  display: none;
+  margin-bottom: 14px;
+  padding: 12px 14px;
+  border-radius: var(--r-md);
+  background: var(--surface-alt);
+  border: 1px solid var(--line-soft);
+  font-size: 13px;
+}
+#generatedPasswordBox b { user-select: all; }
+
+/* === Verlauf: die Kacheln der Vorwochen (js/wochenbericht/wochenbericht.js)
+   Im wöchentlichen Teammeeting wird jedes Projekt angesehen; der Verlauf
+   zeigt auf Knopfdruck, wie der Stand in den Sitzungen davor war. Waagerecht
+   und scrollbar, weil der Bericht ohnehin sehr lang ist — eine Liste
+   untereinander hätte ihn je Projekt um ein Vielfaches verlängert. === */
+.timeline-block {
+  grid-column: 1 / -1;
+  margin-top: 12px;
+  border-top: 1px solid var(--line-soft);
+  padding-top: 10px;
+}
+.timeline-block > summary {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  cursor: pointer;
+  font-size: 12.5px;
+  color: var(--text-muted);
+  list-style: none;
+  user-select: none;
+}
+.timeline-block > summary::-webkit-details-marker { display: none; }
+/* Der Zähler schiebt sich sonst über die ganze Kartenbreite ans rechte Ende
+   (margin-left:auto von .comment-history-count) und steht dort verloren —
+   hier gehört er direkt an das Wort "Verlauf". */
+.timeline-block > summary .comment-history-count { margin-left: 0; }
+.timeline-block > summary:hover { color: var(--text); }
+.timeline-block[open] > summary .comment-history-caret { transform: rotate(90deg); }
+
+.timeline-body { padding-top: 10px; }
+
+/* Die Schiene scrollt waagerecht; die Karte selbst darf dabei nicht breiter
+   werden, deshalb min-width:0 am Elternraster (siehe .board-drawer). */
+.timeline-rail {
+  display: flex;
+  gap: 10px;
+  overflow-x: auto;
+  padding-bottom: 6px;
+  scroll-snap-type: x proximity;
+}
+.timeline-card {
+  flex: 0 0 190px;
+  scroll-snap-align: start;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  padding: 10px 11px;
+  border: 1px solid var(--line-soft);
+  border-radius: var(--r-md);
+  background: var(--surface-alt);
+  font-size: 12px;
+}
+.timeline-card-head {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 6px;
+}
+.timeline-kw { font-weight: 600; white-space: nowrap; }
+.timeline-datum { color: var(--text-muted); font-size: 11px; white-space: nowrap; }
+
+/* Der Kommentar wird auf sechs Zeilen begrenzt, damit alle Kacheln einer
+   Schiene gleich hoch bleiben; der vollständige Text steht im Tooltip. */
+.timeline-text {
+  display: -webkit-box;
+  -webkit-line-clamp: 6;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+  line-height: 1.45;
+  min-height: 3em;
+}
+.timeline-leer { color: var(--text-muted); font-style: italic; }
+
+.timeline-lph-list { display: flex; flex-direction: column; gap: 1px; }
+.timeline-lph {
+  display: flex;
+  justify-content: space-between;
+  gap: 8px;
+  font-variant-numeric: tabular-nums;
+  color: var(--text-muted);
+}
+.timeline-termine { display: flex; flex-direction: column; gap: 1px; }
+.timeline-termin { color: var(--text-muted); font-size: 11.5px; }
+
+/* Gegenüber der Kachel DAVOR geänderte Werte. Dezent, aber auffindbar: Bei
+   zehn Leistungsphasen findet man die eine geänderte Zahl sonst nicht. */
+.timeline-lph.is-changed,
+.timeline-termin.is-changed { color: var(--accent); font-weight: 600; }
+
+/* "übernehmen" in der Verlaufs-Kachel: übernimmt die einzige Funktion, die
+   der entfallene Aufklapper "Frühere Sitzungen" über das Anzeigen hinaus
+   hatte. Dezent, weil es in jeder Kachel steht und nicht mit dem Kommentar
+   um Aufmerksamkeit ringen soll. */
+.timeline-take {
+  align-self: flex-start;
+  padding: 1px 8px;
+  border: 1px solid var(--line);
+  border-radius: var(--r-pill);
+  background: transparent;
+  color: var(--text-muted);
+  font-family: inherit;
+  font-size: 10.5px;
+  cursor: pointer;
+}
+.timeline-take:hover { background: var(--accent); border-color: var(--accent); color: #fff; }
+.timeline-take:focus-visible { outline: 2px solid var(--accent); outline-offset: 1px; }
+
+/* Der Verfasser steht in der dichten Fassung in der Fußzeile neben den
+   Knöpfen statt in einer eigenen Kopfzeile darüber. */
+/* Der Verfasser teilt sich die Fußzeile mit den Knöpfen. Er darf sie nicht
+   zweizeilig machen — deshalb bleibt er auf einer Zeile und wird lieber
+   gekürzt; der vollständige Eintrag steht ohnehin im Verlauf. */
+.comment-foot-author {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-size: 11px;
+  color: var(--text-subtle);
+}
+.comment-foot-author * { display: inline; white-space: nowrap; }
+/* Das Verfasser-Kürzel klebte sonst am Namen: Der Avatar ist in der Fußzeile
+   inline gesetzt und bringt keinen eigenen Abstand mehr mit. */
+.comment-foot-author .comment-av { margin-right: 4px; }
+.comment-foot-author .comment-sep { margin: 0 4px; }
+
+.timeline-people { display: flex; flex-wrap: wrap; gap: 3px; margin-top: auto; padding-top: 2px; }
+.timeline-chip {
+  font-size: 10.5px;
+  font-weight: 600;
+  padding: 1px 6px;
+  border-radius: var(--r-pill);
+  background: var(--surface-sunk);
+  color: var(--text-muted);
+}
+
+/* === Wochenbericht als Tagesordnung (js/wochenbericht/wochenbericht.js) ===
+   Links die vollständige Projektliste, rechts das gewählte Projekt. Die
+   frühere Abfolge gestapelter Karten war bei 29 Projekten 18 Bildschirmseiten
+   lang; hier bleibt die Liste stehen und man sieht jederzeit, wo man steht
+   und was noch kommt. */
+.bericht-titelzeile { display: flex; align-items: center; gap: 12px; margin-bottom: 10px; }
+.bericht-titelzeile button { margin-left: auto; }
+
+.bericht-kopf {
+  display: flex; align-items: center; gap: 14px; flex-wrap: wrap;
+  margin-bottom: 12px;
+}
+.bericht-gewerk-select { font-size: 12.5px; padding: 5px 10px; min-width: 170px; }
+
+/* ---------- Planung (Terminplan-Sandbox, js/planung/planung.js) ---------- */
+.planung-row {
+  display: flex; align-items: center; gap: 14px;
+  padding: 13px 16px; border-radius: var(--r-md);
+  background: var(--surface); border: 1px solid var(--line-soft);
+  margin-bottom: 8px; cursor: pointer; transition: background .15s var(--ease);
+}
+.planung-row:hover { background: var(--surface-alt); }
+.planung-row-icon {
+  width: 34px; height: 34px; border-radius: 9px; flex: 0 0 auto;
+  display: flex; align-items: center; justify-content: center; font-size: 14px;
+}
+.planung-row-icon.honorar { background: var(--accent-soft); color: var(--accent); }
+.planung-row-icon.leer { background: var(--surface-sunk); color: var(--text-subtle); }
+.planung-row-main { flex: 1; min-width: 0; }
+.planung-row-name { font-size: 14px; font-weight: 600; margin: 0; }
+.planung-row-meta { font-size: 12px; color: var(--text-muted); margin: 2px 0 0; }
+.planung-row-stat { text-align: right; font-size: 12px; color: var(--text-muted); white-space: nowrap; }
+.planung-row-stat b { display: block; color: var(--text); font-size: 13px; font-variant-numeric: tabular-nums; }
+
+.planung-choice-cards { display: grid; grid-template-columns: 1fr 1fr; gap: 10px; }
+.choice-card {
+  border: 1.5px solid var(--line); border-radius: var(--r-md); padding: 14px 14px 12px;
+  cursor: pointer; background: var(--surface-alt); transition: border-color .15s ease;
+}
+.choice-card:hover { border-color: var(--accent); }
+.choice-card.is-gewaehlt { border-color: var(--accent); }
+.choice-card-icon { font-size: 18px; margin-bottom: 8px; display: block; }
+.choice-card-title { font-size: 13px; font-weight: 600; margin-bottom: 3px; }
+.choice-card-desc { font-size: 11.5px; color: var(--text-muted); line-height: 1.4; }
+.empty-hint { text-align: center; padding: 60px 20px; color: var(--text-subtle); font-size: 13px; }
+.empty-hint .big { font-size: 15px; color: var(--text-muted); margin-bottom: 6px; display: block; }
+.bericht-fortschritt { display: flex; align-items: center; gap: 9px; margin-left: auto; }
+.bericht-fortschritt-text { font-size: 12.5px; color: var(--text-muted); font-variant-numeric: tabular-nums; white-space: nowrap; }
+.bericht-fortschritt-bar { width: 120px; height: 6px; border-radius: 3px; background: var(--surface-sunk); overflow: hidden; }
+.bericht-fortschritt-bar i { display: block; height: 100%; background: var(--green); transition: width .25s var(--ease); }
+
+.bericht-split {
+  display: grid;
+  grid-template-columns: 272px minmax(0, 1fr);
+  gap: 16px;
+  align-items: start;
+}
+@media (max-width: 900px) { .bericht-split { grid-template-columns: 1fr; } }
+
+.bericht-liste-spalte {
+  background: var(--surface); border-radius: var(--r-md); box-shadow: var(--sh-1);
+  overflow: hidden;
+  /* Die Liste bleibt beim Scrollen im Blick — sie IST die Tagesordnung. */
+  position: sticky; top: 64px;
+}
+.bericht-suche { padding: 8px 9px; border-bottom: 1px solid var(--line-soft); }
+.bericht-suche input { width: 100%; padding: 5px 9px; font-size: 12.5px; }
+.bericht-liste { max-height: min(62vh, 620px); overflow-y: auto; }
+
+.bericht-gruppe {
+  font-size: 10px; font-weight: 600; letter-spacing: .05em; text-transform: uppercase;
+  color: var(--text-subtle); padding: 9px 11px 3px;
+}
+.bericht-zeile {
+  display: flex; align-items: center; gap: 7px;
+  padding: 5px 10px; cursor: pointer;
+  border-left: 2px solid transparent;
+  font-size: 12.5px;
+}
+.bericht-zeile:hover { background: var(--surface-alt); }
+.bericht-zeile:focus-visible { outline: 2px solid var(--accent); outline-offset: -2px; }
+.bericht-zeile.is-aktiv { background: var(--accent-soft); border-left-color: var(--accent); }
+/* Abgehakt: zurückgenommen, aber lesbar — man muss im Meeting noch erkennen
+   können, was man besprochen hat. */
+.bericht-zeile.is-ab .bericht-zeile-name,
+.bericht-zeile.is-ab .bericht-zeile-nr { color: var(--text-subtle); }
+.bericht-zeile-nr {
+  font-family: ui-monospace, 'SF Mono', monospace; font-size: 11px;
+  color: var(--text-muted); flex-shrink: 0;
+}
+.bericht-zeile-name { flex: 1; min-width: 0; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+
+.bericht-haken {
+  width: 17px; height: 17px; flex-shrink: 0; padding: 0;
+  display: inline-flex; align-items: center; justify-content: center;
+  border: 1.5px solid var(--line); border-radius: 50%;
+  background: transparent; color: transparent;
+  font-size: 10px; line-height: 1; cursor: pointer;
+}
+.bericht-haken:hover:not(:disabled) { border-color: var(--green); color: var(--green); }
+.bericht-haken.ab { background: var(--green); border-color: var(--green); color: #fff; }
+.bericht-haken:disabled { cursor: default; opacity: .5; }
+
+/* Änderungs-Kennzeichen: nur noch ein Punkt in der Liste — die Gruppierung
+   nach Änderungsart ist entfallen, weil im Meeting ohnehin jedes Projekt
+   besprochen wird. Die ausformulierte Begründung steht im Detail. */
+/* Die Zustandsklassen tragen ein "is-"-Präfix: Ohne es hieß eine davon
+   schlicht "status" und traf die Regel .status { min-width: 240px } weiter
+   oben — der 7-px-Punkt wurde 240 px breit und quetschte den Projektnamen
+   auf null. */
+.bericht-punkt { width: 7px; height: 7px; border-radius: 50%; flex-shrink: 0; }
+.bericht-punkt.is-new, .bericht-punkt.is-status { background: var(--band-neu); }
+.bericht-punkt.is-progress { background: var(--band-fortschritt); }
+.bericht-abwesend {
+  font-size: 10px; font-weight: 600; color: var(--amber);
+  background: color-mix(in srgb, var(--amber) 15%, transparent);
+  border-radius: var(--r-pill); padding: 0 5px; flex-shrink: 0;
+}
+
+.bericht-detail {
+  background: var(--surface); border-radius: var(--r-md); box-shadow: var(--sh-1);
+  padding: 15px 17px 16px; min-width: 0;
+}
+.bericht-detail-kopf { display: flex; align-items: baseline; gap: 9px; flex-wrap: wrap; }
+.bericht-detail-kopf h3 { margin: 0; font-size: 16px; font-weight: 600; }
+.bericht-detail-zaehler {
+  font-family: ui-monospace, 'SF Mono', monospace; font-size: 11px;
+  color: var(--text-subtle); font-variant-numeric: tabular-nums;
+}
+.bericht-detail-meta { color: var(--text-muted); font-size: 12px; margin: 2px 0 12px; }
+.bericht-kennz {
+  font-size: 11px; border-radius: var(--r-pill); padding: 1px 9px; color: #fff;
+}
+.bericht-kennz.is-new, .bericht-kennz.is-status { background: var(--band-neu); }
+.bericht-kennz.is-progress { background: var(--band-fortschritt); }
+
+.bericht-abwesend-hinweis {
+  font-size: 12.5px; color: var(--amber);
+  background: color-mix(in srgb, var(--amber) 10%, transparent);
+  border-radius: var(--r-sm); padding: 6px 10px; margin-bottom: 10px;
+}
+
+/* Der Kommentar der Vorwoche steht ÜBER dem Eingabefeld: "Was hatten wir
+   letzte Woche vereinbart?" ist die häufigste Frage im Meeting. */
+.bericht-vorwoche {
+  display: flex; gap: 9px; align-items: baseline;
+  padding: 7px 10px; margin-bottom: 11px;
+  background: var(--surface-alt); border-left: 2px solid var(--line);
+  border-radius: 0 var(--r-sm) var(--r-sm) 0;
+  font-size: 12.5px;
+}
+.bericht-vorwoche-label { font-weight: 600; color: var(--text-muted); white-space: nowrap; flex-shrink: 0; }
+.bericht-vorwoche-text { color: var(--text-muted); }
+
+.bericht-detail-fuss {
+  display: flex; align-items: center; gap: 9px; flex-wrap: wrap;
+  margin-top: 14px; padding-top: 12px; border-top: 1px solid var(--line-soft);
+}
+.bericht-fuss-spacer { flex: 1; }
+
+.person-chip-label { display: inline-flex; align-items: center; gap: 5px; cursor: pointer; }
+.protokoll-text {
+  width: 100%; font-family: ui-monospace, 'SF Mono', monospace;
+  font-size: 12px; line-height: 1.5; resize: vertical;
+}
+
+/* === Projektbereich: Leistungsstand & Abrechnung ===========================
+   Karte im Dashboard des Projektbereichs (renderPlanLeistung() in
+   js/plan/plan-leistung.js): erbrachter Leistungswert aus Honorar, HOAI-Anteil
+   je Leistungsphase und Fortschritt der Phase. Ausschliesslich Design-Tokens,
+   damit die Karte in hellem und dunklem Thema ohne eigene Dark-Regeln traegt.
+   Die Tabelle nutzt .lp-matrix als Grundlage; .num/.strong sind hier eigene
+   Regeln, weil die gleichnamigen des Honorar-Dialogs auf .honorar-table
+   eingeschraenkt sind (plan-styles.css). */
+
+.leistung-kpis {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+  margin-bottom: 12px;
+}
+.leistung-kpi {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  flex: 1 1 160px;
+  min-width: 150px;
+  padding: 10px 12px;
+  background: var(--surface-alt);
+  border: 1px solid var(--line-soft);
+  border-radius: var(--r-md);
+}
+.leistung-kpi-label {
+  font-size: 11px;
+  font-weight: 500;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: .03em;
+}
+.leistung-kpi-value {
+  font-size: 19px;
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+  line-height: 1.2;
+}
+.leistung-kpi-value.accent { color: var(--accent); }
+.leistung-kpi-sub {
+  font-size: 11.5px;
+  color: var(--text-subtle);
+  font-variant-numeric: tabular-nums;
+}
+
+/* Fortschrittsbalken: derselbe Prozentwert wie die Kennzahl darueber, nur als
+   Flaeche — bei zehn Leistungsphasen ist die Gesamtlage sonst nur aus der
+   Tabelle zu erschliessen. */
+.leistung-balken {
+  height: 7px;
+  border-radius: var(--r-pill);
+  background: var(--surface-sunk);
+  overflow: hidden;
+  margin: 0 0 14px;
+}
+.leistung-balken > span {
+  display: block;
+  height: 100%;
+  background: var(--accent);
+  border-radius: var(--r-pill);
+  transition: width .25s var(--ease);
+}
+
+.leistung-table { font-size: 12.5px; }
+.leistung-table th.num,
+.leistung-table td.num { text-align: right; font-variant-numeric: tabular-nums; }
+.leistung-table td.strong { font-weight: 600; }
+.leistung-table tfoot th,
+.leistung-table tfoot td {
+  border-top: 1px solid var(--line);
+  padding: 6px 8px;
+  font-weight: 600;
+  background: var(--surface-alt);
+}
+
+/* Hinweis, wenn die Rechnung nicht moeglich ist (kein Honorar, keine
+   beauftragte Phase, keine Anteile). Bewusst als Text und nicht als "0 EUR":
+   unbekannt ist nicht dasselbe wie nichts erbracht. */
+.leistung-leer {
+  font-size: 12.5px;
+  color: var(--text-muted);
+  padding: 10px 12px;
+  background: var(--surface-alt);
+  border-left: 2px solid var(--amber);
+  border-radius: 0 var(--r-sm) var(--r-sm) 0;
+}
+
+/* === Auftragsstatus: Kennzeichen an der Projektzeile und Auswahlfeld in den
+   Pflegemasken (js/auftrag.js) ===
+   Die Farbflächen entstehen mit color-mix aus den Ampel-Tokens, damit sie im
+   hellen und im dunklen Erscheinungsbild von selbst mitwandern (feste rgba-
+   Flächen tragen im Dark Mode nicht, siehe --attend-bg). Die Schriftfarbe ist
+   dasselbe Token — es dreht je Erscheinungsbild ins jeweils kontrastreichere
+   Ende. */
+.auftrag-chip {
+  display: inline-flex;
+  align-items: center;
+  border-radius: var(--r-pill);
+  padding: 1px 8px;
+  font-size: 11px;
+  font-weight: 500;
+  white-space: nowrap;
+  background: var(--surface-sunk);
+  border: 1px solid var(--line-soft);
+  color: var(--text-muted);
+}
+/* Anfrage: hereinkommend, noch nichts entschieden. */
+.auftrag-chip-anfrage {
+  background: color-mix(in srgb, var(--accent) 12%, transparent);
+  border-color: color-mix(in srgb, var(--accent) 30%, transparent);
+  color: var(--accent);
+}
+/* Angebot: draußen, Entscheidung offen — dieselbe Warnfarbe wie die Ampel. */
+.auftrag-chip-angebot {
+  background: color-mix(in srgb, var(--amber) 12%, transparent);
+  border-color: color-mix(in srgb, var(--amber) 30%, transparent);
+  color: var(--amber);
+}
+/* Beauftragt: der Regelfall. Wird an der Projektzeile normalerweise gar nicht
+   gezeigt (auftragsstatusChip() gibt dafür einen leeren String zurück), nur in
+   Masken, die den Status ausdrücklich ausweisen. */
+.auftrag-chip-beauftragt {
+  background: color-mix(in srgb, var(--green) 12%, transparent);
+  border-color: color-mix(in srgb, var(--green) 30%, transparent);
+  color: var(--green);
+}
+/* Abgeschlossen: erledigt, tritt bewusst zurück. */
+.auftrag-chip-abgeschlossen {
+  background: var(--surface-sunk);
+  border-color: var(--line);
+  color: var(--text-subtle);
+}
+
+/* Status-Chip einer Sitzung in der Admin-Liste "Termine & Sitzungen"
+   (renderAdminSitzungen(), js/admin/admin.js) — dasselbe Muster wie
+   .auftrag-chip: eine neutrale Grundform, drei eingefärbte Zustände. */
+.sitzung-chip {
+  display: inline-flex;
+  align-items: center;
+  border-radius: var(--r-pill);
+  padding: 1px 8px;
+  font-size: 11px;
+  font-weight: 500;
+  white-space: nowrap;
+  background: var(--surface-sunk);
+  border: 1px solid var(--line-soft);
+  color: var(--text-muted);
+}
+.sitzung-chip.ist-geoeffnet {
+  background: color-mix(in srgb, var(--green) 12%, transparent);
+  border-color: color-mix(in srgb, var(--green) 30%, transparent);
+  color: var(--green);
+}
+.sitzung-chip.ist-entsperrt {
+  background: color-mix(in srgb, var(--accent) 12%, transparent);
+  border-color: color-mix(in srgb, var(--accent) 30%, transparent);
+  color: var(--accent);
+}
+.sitzung-chip.ist-gesperrt {
+  background: color-mix(in srgb, var(--amber) 12%, transparent);
+  border-color: color-mix(in srgb, var(--amber) 30%, transparent);
+  color: var(--amber);
+}
+
+.auftrag-select {
+  font-size: 12px;
+  padding: 3px 8px;
+  border: 1px solid var(--line);
+  border-radius: var(--r-sm);
+  background: var(--surface);
+  color: var(--text);
+  max-width: 100%;
+}
+.auftrag-select:focus-visible { outline: 2px solid var(--accent); outline-offset: 1px; }
+
+/* ===========================================================
+   Ein Ort je Angabe — Anzeige statt Eingabe
+   ===========================================================
+   Kommentar, Fortschritt und Zuordnung werden nur noch im Wochenbericht
+   erfasst. Die Projektliste und der Projektbereich zeigen dieselben Werte in
+   derselben Anordnung, aber ohne Eingabefelder (Klasse is-ansicht) — daneben
+   steht der Weg zur Bearbeitung (.drawer-verweis/.plan-verweis). */
+
+/* Der Kommentar als Text: dieselbe Fläche wie der Editor, nur ruhiger. */
+.status-edit.is-ansicht{
+  cursor: default;
+  background: var(--surface-sunk);
+  border-style: dashed;
+}
+
+.board-lph-cell.is-ansicht{ cursor: default; }
+
+/* Ein Kürzel, das nicht angeklickt werden kann, zeigt das auch. */
+.board-avatar.is-ansicht{ cursor: default; }
+
+/* Der Verweis auf den Erfassungsort. Er steht unter der Karte, in einer
+   Zeile mit der Begründung, warum hier nichts einzugeben ist. */
+.drawer-verweis{
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 10px;
+  padding: 8px 2px 2px;
+}
+.plan-verweis{
+  background: none;
+  border: 1px solid var(--line);
+  border-radius: var(--r-pill);
+  padding: 3px 12px;
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--accent);
+  cursor: pointer;
+}
+.plan-verweis:hover{ background: var(--accent-soft); }
+.plan-verweis:focus-visible{ outline: 2px solid var(--accent); outline-offset: 2px; }
+
+/* ===========================================================
+   Projektliste: die Listenoperationen des früheren Projekte-Tabs
+   =========================================================== */
+
+/* Öffnen/Löschen am Zeilenende. Sichtbar erst beim Überfahren der Zeile,
+   damit die Liste im Ruhezustand ruhig bleibt — auf Tastatur-Fokus aber
+   ebenfalls, sonst wären die Knöpfe nicht erreichbar. */
+.board-row-actions{
+  display: flex;
+  gap: 6px;
+  flex: 0 0 auto;
+  opacity: 0;
+  transition: opacity .12s;
+}
+.board-row:hover .board-row-actions,
+.board-row.open .board-row-actions,
+.board-row-actions:focus-within{ opacity: 1; }
+
+/* Der Ziehgriff steht vor dem Aufklapp-Pfeil. */
+.board-row .drag-handle{
+  flex: 0 0 auto;
+  cursor: grab;
+  color: var(--text-subtle);
+  display: inline-flex;
+  align-items: center;
+}
+.board-row .drag-handle:active{ cursor: grabbing; }
+
+/* Die Gruppe ist eine Ablagefläche: sie behält eine Mindesthöhe, damit eine
+   leer geräumte Gruppe ein Ziel bleibt. */
+.board-list.projects-sortable{ min-height: 34px; }
+
+/* Der Verweis unter einer Anzeige-Karte im Projektbereich. */
+.plan-verweis-row{
+  display: flex;
+  justify-content: flex-end;
+  padding-top: 10px;
+}
+.plan-verweis-row:empty{ display: none; }
+
+/* Die Schlagwörter-Liste in den Projekteinstellungen darf umbrechen. */
+#settingsProjTags{
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 6px;
+}
+#settingsProjTags .tag-input{ width: 110px; }
+
+/* === Dashboard: Termine meiner Projekte ===
+   Die Aufgaben und Meilensteine der Projekte, denen man zugeordnet ist
+   (GET /my-dashboard, Feld projectDates). Bewusst eine Liste und keine
+   Kartenwand wie "Meine Aufgaben": Hier geht es um Reihenfolge in der Zeit,
+   und Termine, die untereinander stehen, lassen sich der Reihe nach
+   abarbeiten. */
+/* Die Gruppen sitzen in derselben .dash-karte wie die eigenen Aufgaben
+   darüber — beides ist der eigene Arbeitsstrom und soll gleich aussehen.
+   Die Titelzeile ist deshalb ein abgesetzter Streifen innerhalb der Karte
+   und kein freistehender Abschnittstitel mehr. */
+.fristen-gruppe + .fristen-gruppe { border-top: 1px solid var(--line); }
+
+.fristen-gruppe-titel {
+  display: flex;
+  align-items: center;
+  gap: 9px;
+  padding: 9px 16px 6px;
+  background: var(--surface-alt);
+  font-size: 10.5px;
+  font-weight: 600;
+  letter-spacing: .06em;
+  text-transform: uppercase;
+  color: var(--text-muted);
+}
+.fristen-gruppe-titel span {
+  font-size: 10px;
+  padding: 1px 7px;
+  border-radius: var(--r-pill);
+  background: var(--surface-sunk);
+  color: var(--text-muted);
+  letter-spacing: 0;
+}
+.fristen-gruppe.ist-ueberfaellig .fristen-gruppe-titel { color: var(--red); }
+.fristen-gruppe.ist-ueberfaellig .fristen-gruppe-titel span {
+  background: var(--red);
+  color: #fff;
+}
+.fristen-gruppe.ist-bald .fristen-gruppe-titel { color: var(--amber); }
+
+/* Eine Zeile: Datum — Art — Bezeichnung — Projekt — Zuständige.
+   Die Bezeichnung nimmt den freien Platz, alles andere hat feste Breiten,
+   damit die Spalten über alle Zeilen fluchten. */
+.fristen-zeile {
+  display: flex;
+  align-items: center;
+  gap: 14px;
+  padding: 9px 16px;
+  border-bottom: 1px solid var(--line-soft);
+  text-decoration: none;
+  color: inherit;
+  transition: background .12s var(--ease);
+}
+.fristen-zeile:last-child { border-bottom: none; }
+.fristen-zeile:hover { background: var(--surface); }
+.fristen-zeile:focus-visible {
+  outline: 2px solid var(--accent);
+  outline-offset: -2px;
+}
+
+.fristen-datum {
+  flex: 0 0 104px;
+  display: flex;
+  flex-direction: column;
+  line-height: 1.25;
+  font-variant-numeric: tabular-nums;
+}
+.fristen-datum b { font-size: 13px; font-weight: 600; }
+.fristen-datum em {
+  font-style: normal;
+  font-size: 11px;
+  color: var(--text-subtle);
+}
+.ist-ueberfaellig .fristen-datum b,
+.ist-ueberfaellig .fristen-datum em { color: var(--red); }
+.ist-bald .fristen-datum b { color: var(--amber); }
+
+.fristen-art {
+  flex: 0 0 auto;
+  font-size: 10px;
+  font-weight: 600;
+  padding: 2px 8px;
+  border-radius: var(--r-pill);
+  background: var(--surface-sunk);
+  color: var(--text-muted);
+  white-space: nowrap;
+}
+.fristen-art.ist-meilenstein {
+  background: var(--accent-soft);
+  color: var(--accent);
+}
+
+.fristen-titel {
+  flex: 1 1 auto;
+  min-width: 0;
+  font-size: 13.5px;
+  font-weight: 500;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.fristen-projekt {
+  flex: 0 0 auto;
+  max-width: 230px;
+  font-size: 12px;
+  color: var(--text-muted);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.fristen-wer {
+  flex: 0 0 140px;
+  font-size: 11px;
+  color: var(--text-subtle);
+  text-align: right;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+/* Die Warn-Kachel im Kennzahlenband. Eine Null bleibt neutral — "0
+   überfällig" ist eine gute Nachricht und darf nicht rot sein (siehe
+   renderStatTile()). */
+.load-num-warnung { color: var(--red); }
+
+@media (max-width: 860px) {
+  .fristen-projekt, .fristen-wer { display: none; }
+  .fristen-datum { flex-basis: 92px; }
+}
+
+/* Überfälliges Datum in der Aufgabenkarte des Dashboards — dieselbe
+   Kennzeichnung wie in der Terminliste darunter, damit die Kachel
+   "Überfällig" und die Listen zusammenpassen. */
+.load-detail b.ist-ueberfaellig { color: var(--red); }
+
+/* === Assistent "Neues Projekt" (js/projekt-wizard.js) ===
+   Ersetzt den früheren Dialog #newProjModal, der alle Felder auf einmal
+   zeigte. Sechs Schritte, und jeder muss vollständig sein, bevor es
+   weitergeht — genau die Lücken, die sonst entstehen (kein Honorar, keine
+   Phase, niemand zugeordnet), sind der Grund für Projekte, die später in
+   der Auslastung als "nicht bewertbar" erscheinen. */
+.wizard-modal {
+  max-width: 820px;
+  width: 100%;
+  padding: 0;
+  overflow: hidden;
+}
+
+.wiz-kopf {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 18px 24px 14px;
+  border-bottom: 1px solid var(--line-soft);
+}
+.wiz-kopf h2 { margin: 0; flex: 1; }
+.wiz-schliessen {
+  font-size: 20px;
+  line-height: 1;
+  padding: 2px 9px;
+  background: none;
+  border: none;
+  color: var(--text-subtle);
+  cursor: pointer;
+}
+.wiz-schliessen:hover { color: var(--text); background: none; }
+
+/* Schrittleiste: erledigte Stationen tragen einen Haken, damit auch bei
+   sechs Schritten jederzeit erkennbar ist, was noch aussteht. */
+.wiz-leiste {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  padding: 16px 24px 0;
+}
+.wiz-stufe {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 12px;
+  color: var(--text-subtle);
+}
+.wiz-stufe b {
+  width: 24px; height: 24px;
+  border-radius: 50%;
+  display: grid;
+  place-items: center;
+  font-size: 11px;
+  font-weight: 600;
+  background: var(--surface-sunk);
+  color: var(--text-muted);
+  font-variant-numeric: tabular-nums;
+}
+.wiz-stufe.ist-aktiv { color: var(--text); font-weight: 600; }
+.wiz-stufe.ist-aktiv b { background: var(--accent); color: #fff; }
+.wiz-stufe.ist-fertig b { background: var(--green); color: #fff; }
+.wiz-strich {
+  flex: 1 1 16px;
+  min-width: 10px;
+  height: 1px;
+  background: var(--line);
+  margin: 0 8px;
+}
+
+.wiz-inhalt {
+  padding: 20px 24px 22px;
+  min-height: 300px;
+  max-height: 58vh;
+  overflow-y: auto;
+}
+.wiz-titel { margin: 0 0 3px; font-size: 19px; font-weight: 600; letter-spacing: -.02em; }
+.wiz-unter { margin: 0 0 20px; font-size: 13px; color: var(--text-muted); }
+.wiz-zeile { display: grid; grid-template-columns: 1fr 1fr; gap: 16px; }
+.wiz-pflicht { color: var(--red); }
+
+/* Fußzeile: Der Weiter-Knopf bleibt gesperrt, solange etwas fehlt — und
+   daneben steht, WAS fehlt. Ein gesperrter Knopf ohne Begründung ist eine
+   Sackgasse. */
+.wiz-fuss {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 14px 24px;
+  border-top: 1px solid var(--line-soft);
+  background: var(--surface-alt);
+}
+.wiz-zaehler { font-size: 12px; color: var(--text-subtle); }
+.wiz-fuss-rechts {
+  margin-left: auto;
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+}
+.wiz-fehlt { font-size: 11.5px; color: var(--amber); text-align: right; }
+
+/* Auswahl-Chips (Gewerke, Phasen, Schlagwörter, Grundlage) */
+.wiz-chips { display: flex; flex-wrap: wrap; gap: 6px; }
+.wiz-chip {
+  font: inherit;
+  font-size: 12px;
+  padding: 5px 11px;
+  cursor: pointer;
+  border: 1px solid var(--line);
+  border-radius: var(--r-pill);
+  background: var(--surface);
+  color: var(--text-muted);
+}
+.wiz-chip:hover { border-color: var(--accent); background: var(--surface); }
+.wiz-chip[aria-pressed="true"] { background: var(--accent); border-color: var(--accent); color: #fff; }
+.wiz-chip-gewerk { font-weight: 600; letter-spacing: .02em; padding: 6px 14px; }
+
+/* Beteiligte je Rolle */
+.wiz-rollen { display: flex; flex-direction: column; gap: 12px; }
+.wiz-rolle { display: flex; align-items: flex-start; gap: 12px; flex-wrap: wrap; }
+.wiz-rolle-name {
+  flex: 0 0 116px;
+  font-size: 11.5px;
+  font-weight: 600;
+  padding-top: 7px;
+  color: var(--text-muted);
+}
+.wiz-person {
+  font: inherit;
+  font-size: 11px;
+  font-weight: 600;
+  cursor: pointer;
+  width: 34px; height: 34px;
+  border-radius: 50%;
+  border: 1px solid var(--line);
+  background: var(--surface);
+  color: var(--text-muted);
+  padding: 0;
+}
+.wiz-person[aria-pressed="true"] { background: var(--accent); border-color: var(--accent); color: #fff; }
+.wiz-person[data-rolle="Projektleitung"][aria-pressed="true"] { background: var(--red); border-color: var(--red); }
+.wiz-person[data-rolle="Bauüberwachung"][aria-pressed="true"] { background: var(--green); border-color: var(--green); }
+/* Wer aus einem anderen Gewerk dazugeholt wurde: gestrichelter Rand, damit
+   die Herkunft sichtbar bleibt, ohne eine zweite Farbe einzuführen. */
+.wiz-person.ist-fremd { border-style: dashed; border-width: 1.5px; }
+
+.wiz-fremd { margin-top: 20px; padding-top: 16px; border-top: 1px solid var(--line-soft); }
+.wiz-fremd label {
+  display: block;
+  font-size: 11.5px;
+  font-weight: 600;
+  margin-bottom: 6px;
+  color: var(--text-muted);
+}
+.wiz-fremd select { width: 100%; max-width: 420px; }
+.wiz-fremd-liste { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 10px; }
+.wiz-fremd-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  font-size: 11px;
+  padding: 3px 6px 3px 10px;
+  border-radius: var(--r-pill);
+  border: 1px dashed var(--line);
+  color: var(--text-muted);
+}
+.wiz-fremd-chip button {
+  font: inherit;
+  font-size: 13px;
+  line-height: 1;
+  cursor: pointer;
+  border: none;
+  background: none;
+  color: var(--text-subtle);
+  padding: 0 2px;
+}
+.wiz-fremd-chip button:hover { color: var(--red); background: none; }
+
+/* Hinweis anstelle eines Schritts, der gerade nicht möglich ist */
+.wiz-sperre {
+  padding: 18px 20px;
+  border: 1px dashed var(--line);
+  border-radius: var(--r-lg);
+  background: var(--surface-alt);
+}
+.wiz-sperre b { display: block; font-size: 14px; margin-bottom: 6px; }
+.wiz-sperre p { margin: 0 0 8px; font-size: 13px; color: var(--text-muted); max-width: 58ch; }
+.wiz-sperre p:last-child { margin-bottom: 0; }
+
+.wiz-schalter { display: flex; align-items: center; gap: 9px; font-size: 13.5px; cursor: pointer; }
+.wiz-schalter input { width: 16px; height: 16px; accent-color: var(--accent); }
+
+/* Terminplan-Tabelle */
+.wiz-plan {
+  margin-top: 16px;
+  border: 1px solid var(--line-soft);
+  border-radius: var(--r-md);
+  overflow: hidden;
+}
+.wiz-plan-zeile {
+  display: grid;
+  grid-template-columns: 78px 62px 1fr 64px 170px;
+  gap: 10px;
+  padding: 7px 12px;
+  font-size: 12.5px;
+  border-bottom: 1px solid var(--line-soft);
+  font-variant-numeric: tabular-nums;
+}
+.wiz-plan-zeile:last-child { border-bottom: none; }
+.wiz-plan-zeile span:nth-child(2),
+.wiz-plan-zeile span:nth-child(3),
+.wiz-plan-zeile span:nth-child(4) { text-align: right; }
+.wiz-plan-kopf {
+  background: var(--surface-alt);
+  font-size: 10.5px;
+  font-weight: 600;
+  letter-spacing: .05em;
+  text-transform: uppercase;
+  color: var(--text-subtle);
+}
+.wiz-plan-summe { background: var(--surface-alt); font-weight: 600; }
+
+/* Zusammenfassung */
+.wiz-pruef { font-size: 13.5px; }
+.wiz-pruef-zeile {
+  display: flex;
+  justify-content: space-between;
+  gap: 18px;
+  padding: 7px 0;
+  border-bottom: 1px solid var(--line-soft);
+}
+.wiz-pruef-zeile:last-child { border-bottom: none; }
+.wiz-pruef-zeile span { color: var(--text-muted); flex: 0 0 auto; }
+.wiz-pruef-zeile b { font-weight: 500; text-align: right; min-width: 0; overflow-wrap: anywhere; }
+.wiz-pruef-zeile b.fehlt { color: var(--text-subtle); font-weight: 400; font-style: italic; }
+
+/* Abschluss */
+.wiz-fertig { text-align: center; padding: 44px 24px; }
+.wiz-haken {
+  width: 52px; height: 52px;
+  border-radius: 50%;
+  margin: 0 auto 16px;
+  display: grid;
+  place-items: center;
+  font-size: 26px;
+  background: var(--green);
+  color: #fff;
+}
+.wiz-fertig h3 { margin: 0 0 8px; font-size: 20px; font-weight: 600; }
+.wiz-fertig p { margin: 0 auto 20px; color: var(--text-muted); max-width: 46ch; font-size: 13.5px; }
+
+@media (max-width: 760px) {
+  .wiz-zeile { grid-template-columns: 1fr; }
+  .wiz-stufe span { display: none; }
+  .wiz-plan-zeile { grid-template-columns: 66px 1fr 130px; }
+  .wiz-plan-zeile span:nth-child(2),
+  .wiz-plan-zeile span:nth-child(4) { display: none; }
+}
diff --git a/server.js b/server.js
index 08fd241..50749b8 100644
--- a/server.js
+++ b/server.js
@@ -1,6 +1,6 @@
 /*
  * Express-Server der Projektübersicht: liefert die statischen Frontend-Dateien aus
- * public/ (Test.html unter "/") und stellt den Frontend-Modulen unter public/js/
+ * public/ (App.html unter "/") und stellt den Frontend-Modulen unter public/js/
  * eine JSON-API zum Laden und Speichern der Sitzungsdaten bereit. Die Daten liegen
  * in einer SQLite-Datenbank (node:sqlite, Node >= 22.13) unter sessions/projektuebersicht.db.
  *
@@ -17,8 +17,8 @@
  *  automatisch auf das relationale Schema umgestellt.
  *
  *  Standardport ist 3003, überschreibbar über die Umgebungsvariable PORT.
- *  Endpunkte: GET /, GET /health, GET /load-all, POST /save-week, POST /save-people,
- *  POST /delete-week, GET /export-csv (ZIP mit CSV je logischer Entität je Abteilung),
+ *  Endpunkte: GET /, GET /health, GET /load-all, POST /save-week,
+ *  POST /delete-week,
  *  GET /backup (SQLite-Snapshot als .db-Download; zusätzlich automatische Backups
  *  nach sessions/backups/ beim Serverstart), POST /import (Backup-Wiederherstellung,
  *  roher Binär-Body, schema-validiert).
@@ -29,16 +29,153 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const zlib = require('zlib');
+const crypto = require('crypto');
 const { DatabaseSync } = require('node:sqlite');
+// pdfjs-dist/mammoth: reine Textauszug-Bibliotheken für den Protokoll-Import
+// (POST /project-protokolle/import) — erste Abhängigkeiten außer
+// express/cors, siehe CLAUDE.md "### Protokolle". pdfjs-dist statt des
+// zunächst gewählten pdf-parse: dessen mitgelieferte, seit 2017
+// eingefrorene pdf.js-Kopie liefert in diesem Prozess reproduzierbar
+// "bad XRef entry", sobald Node's eigenes http-Modul geladen ist (bereits
+// durch das bloße `require('http')` allein auslösbar, unabhängig vom
+// tatsächlichen PDF-Inhalt) — in einem Express-Server also immer, da
+// express selbst transitiv http lädt. Ein eigenständiges pdfjs-dist ist
+// nicht betroffen. Das native @napi-rs/canvas (nur für Seiten-Rendering
+// zu Bildern, hier nie gebraucht) ist bei pdfjs-dist nur eine optionale
+// Abhängigkeit; die Projekt-.npmrc (`omit=optional`) verhindert, dass es
+// überhaupt installiert wird — keine native Kompilierung, kein Canvas.
+const mammoth = require('mammoth');
+// undici: NICHT für fetch() selbst (das liefert Node schon global) — nur für
+// die Agent-Klasse, um der KI-Erkennung gegen einen eigenen Server (siehe
+// fetchMitTimeout() weiter unten) ein höheres Verbindungslimit als Node/
+// undicis eigenen Vorgabewert mitzugeben, siehe dort.
+const { Agent: UndiciAgent } = require('undici');
+let pdfjsLibPromise = null;
+function ladePdfjs(){
+  if(!pdfjsLibPromise) pdfjsLibPromise = import('pdfjs-dist/legacy/build/pdf.mjs');
+  return pdfjsLibPromise;
+}
+async function extrahierePdfText(buf){
+  const pdfjsLib = await ladePdfjs();
+  const loadingTask = pdfjsLib.getDocument({ data: new Uint8Array(buf) });
+  try {
+    const doc = await loadingTask.promise;
+    let text = '';
+    for(let i = 1; i <= doc.numPages; i++){
+      const page = await doc.getPage(i);
+      const content = await page.getTextContent();
+      // Textfragmente stehen ohne Zeilenumbrüche in content.items — erkennePunkteAusText()
+      // braucht aber echte Zeilen (Punkt-Marker müssen am Zeilenanfang stehen). Ein
+      // Umbruch wird eingefügt, sobald sich die Y-Koordinate (transform[5]) ändert,
+      // exakt wie es das vormals genutzte pdf-parse intern selbst tat.
+      let lastY = null;
+      content.items.forEach(item => {
+        if(lastY !== null && item.transform[5] !== lastY) text += '\n';
+        else if(lastY !== null) text += ' ';
+        text += item.str;
+        lastY = item.transform[5];
+      });
+      text += '\n\n';
+    }
+    return text;
+  } finally {
+    loadingTask.destroy();
+  }
+}
 const app = express();
 
 // Wichtige Konstanten: Serverport (PORT-Env) und die gültigen Abteilungsordner
 const PORT = process.env.PORT || 3003;
 const VALID_DEPARTMENTS = new Set(['ELT','HLS','ARCH']);
 
+// SANDBOX_WEEK_LABEL: die eine, dauerhaft reservierte "Sitzung", in der alle
+// Planung-Terminpläne liegen (CLAUDE.md, "Planung — projektunabhängige
+// Terminplan-Sandbox"). Kein echtes Datum, keine echte Kalenderwoche — der
+// Name selbst ist der Marker, der dieses `weeks`-Label von jeder echten
+// Sitzung unterscheidet. MUSS mit der gleichnamigen Konstante in
+// public/js/globals.js übereinstimmen (kein gemeinsames Modulsystem zwischen
+// Server und Client in diesem Projekt, siehe "Frontend architecture").
+const SANDBOX_WEEK_LABEL = '__sandbox__';
+// Projekt-Zuordnungs-Rollen aus ROLES in public/js/globals.js (bewusst dupliziert,
+// kein Bundler vorhanden — NICHT zu verwechseln mit users.role, s. VALID_ROLES).
+const VALID_DISCIPLINE_ROLES = new Set(['Planung','Projektleitung','Bauüberwachung']);
+// VALID_ROLES: die Systemrollen eines Kontos (users.role, keine CHECK-
+// Constraint im Schema, daher hier die eine Stelle, die einen Wert
+// zurückweist). 'kiosk' ist das Wandtafel-Konto (siehe CLAUDE.md
+// "Wandtafel"): darf nur die lesenden Routen erreichen, die die Wandtafel
+// braucht (requireAuthOderKiosk weiter unten), überall sonst wie requireAuth
+// abgewiesen — und darf keine Fachrolle tragen (dort geprüft, wo roles
+// validiert wird).
+const VALID_ROLES = new Set(['admin', 'member', 'kiosk']);
+// VALID_AUFTRAGSSTATUS: der Weg von der Anfrage zum abgeschlossenen Auftrag
+// (projects.auftragsstatus). Die Reihenfolge ist die fachliche Abfolge und
+// steht genauso in AUFTRAGSSTATUS in public/js/auftrag.js — bewusst
+// dupliziert, es gibt keinen Bundler. Serverseitig geprüft wird das nicht
+// wegen der Oberfläche, sondern weil /save-week der einzige Schreibweg ist:
+// ein Tippfehler im Wert wäre sonst dauerhaft in der Datenbank und jede
+// Auswertung ("welche Projekte sind noch Angebot?") liefe daran vorbei.
+const VALID_AUFTRAGSSTATUS = new Set(['anfrage','angebot','beauftragt','abgeschlossen']);
+// DEFAULT_AUFTRAGSSTATUS: Vorgabe für Bestandsdaten und für unbelegte Felder.
+// 'beauftragt' und nicht 'anfrage', weil der gesamte Altbestand beauftragte
+// Arbeit ist — jeder andere Anfangswert hätte alle laufenden Projekte
+// rückwirkend zu Akquise erklärt.
+const DEFAULT_AUFTRAGSSTATUS = 'beauftragt';
+// AUFTRAGSSTATUS_LABELS: lesbare Bezeichnungen für den CSV-Export. Der
+// Schlüssel selbst ('anfrage') steht in der Datenbank, in einer Tabelle für
+// Menschen hat er nichts zu suchen.
+const AUFTRAGSSTATUS_LABELS = {
+  anfrage: 'Anfrage', angebot: 'Angebot',
+  beauftragt: 'Beauftragt', abgeschlossen: 'Abgeschlossen'
+};
+
+// normalizeAuftragsstatus: bringt einen eingehenden Wert auf einen gültigen
+// Schlüssel. Wird beim SCHREIBEN gebraucht (serializeWeek) — dort ist der Wert
+// bereits von der Route geprüft, leer oder fehlend darf er aber sein (alte
+// Clients, Demo-Daten) und wird dann zur Vorgabe.
+function normalizeAuftragsstatus(value){
+  const v = String(value || '').trim();
+  return VALID_AUFTRAGSSTATUS.has(v) ? v : DEFAULT_AUFTRAGSSTATUS;
+}
+
+// findInvalidAuftragsstatus: sucht in einer eingehenden Woche das erste Projekt
+// mit unbekanntem Auftragsstatus. Getrennt von normalizeAuftragsstatus(), weil
+// der Schreibweg BEIM SPEICHERN nicht stillschweigend zurechtbiegen darf: Ein
+// unbekannter Wert ist ein Fehler im Aufruf und wird mit 400 abgewiesen,
+// sonst käme aus der Oberfläche "Angebot" heraus und in der Datenbank stünde
+// "beauftragt". Ein fehlendes/leeres Feld ist dagegen erlaubt (alte Clients).
+// Rückgabe: { nr, name, wert } oder null, wenn alles gültig ist.
+function findInvalidAuftragsstatus(week){
+  const projects = Array.isArray(week && week.projects) ? week.projects : [];
+  for(const p of projects){
+    const raw = p && p.auftragsstatus;
+    if(raw === undefined || raw === null || raw === '') continue;
+    const v = String(raw).trim();
+    if(!VALID_AUFTRAGSSTATUS.has(v)){
+      return { nr: String((p && p.nr) || ''), name: String((p && p.name) || ''), wert: v };
+    }
+  }
+  return null;
+}
+
 // Globale Middleware: CORS, JSON-Body-Limit (2 MB) und statisches Serving von public/ ohne Cache für Skripte/Styles
 app.use(require('cors')());
-app.use(express.json({ limit: '2mb' }));
+// Der JSON-Parser darf NICHT über die Routen mit rohem Binär-Body laufen:
+// Der Browser schickt beim Datei-Upload den Content-Type der Datei mit, und
+// bei einer .json-Datei würde express.json() den Datenstrom verbrauchen, bevor
+// express.raw() ihn bekommt ("Keine Datei empfangen"). 8 MB statt 2 MB, weil
+// eine Sitzung mit vielen Projekten und langen Kommentaren sonst irgendwann
+// still am 413 scheitert.
+const RAW_BODY_ROUTES = new Set(['/import', '/project-files', '/project-protokolle/import']);
+const jsonBodyParser = express.json({ limit: '8mb' });
+app.use((req, res, next) => {
+  if(req.method === 'POST' && RAW_BODY_ROUTES.has(req.path)) return next();
+  jsonBodyParser(req, res, next);
+});
+// attachUser liest bei jedem Request das Session-Cookie und setzt req.user
+// (siehe Definition weiter unten im Abschnitt "Auth: Sessions, Middleware,
+// Endpunkte" — als function-Deklaration ist sie im gesamten Modul gehoistet).
+// Muss vor express.static laufen, damit sie garantiert für jeden Request greift.
+app.use(attachUser);
 app.use(express.static(path.join(__dirname, 'public'), {
   setHeaders: (res, path) => {
     if(path.endsWith('.js') || path.endsWith('.css') || path.endsWith('.html')){
@@ -75,105 +212,163 @@ db.exec('PRAGMA busy_timeout = 5000;'); // 5 s warten statt SQLITE_BUSY-Fehlern
 //  - plan_people: im Plan beteiligte Personen
 //  - plan_todos / plan_todo_assignees / plan_todo_deps: TODO-Listen
 //  - plan_milestones / plan_milestone_deps: Meilensteine
-//  - people / person_roles / person_absences: globale Personen pro Abteilung
+//  - globale Personen pro Abteilung kommen seit der Ablösung von
+//    people/person_roles/person_absences aus users/user_roles/user_absences
+//    (siehe loadGlobalPeople, migrateRetirePeopleTablesIntoUsers)
 
 db.exec(`CREATE TABLE IF NOT EXISTS weeks (
-  department TEXT NOT NULL,
   label TEXT NOT NULL,
   week_id TEXT NOT NULL DEFAULT '',
   date TEXT NOT NULL DEFAULT '',
   locked INTEGER NOT NULL DEFAULT 0,
   updated_at TEXT NOT NULL DEFAULT '',
-  PRIMARY KEY (department, label)
+  PRIMARY KEY (label)
 )`);
 db.exec(`CREATE TABLE IF NOT EXISTS week_people (
-  department TEXT NOT NULL,
   week_label TEXT NOT NULL,
   person_id TEXT NOT NULL,
   name TEXT NOT NULL DEFAULT '',
   full_name TEXT NOT NULL DEFAULT '',
   array_order INTEGER NOT NULL DEFAULT 0,
-  PRIMARY KEY (department, week_label, person_id)
+  PRIMARY KEY (week_label, person_id)
 )`);
 db.exec(`CREATE TABLE IF NOT EXISTS week_people_roles (
-  department TEXT NOT NULL,
   week_label TEXT NOT NULL,
   person_id TEXT NOT NULL,
   role TEXT NOT NULL,
   role_order INTEGER NOT NULL DEFAULT 0,
-  PRIMARY KEY (department, week_label, person_id, role)
+  PRIMARY KEY (week_label, person_id, role)
 )`);
 db.exec(`CREATE TABLE IF NOT EXISTS attendance (
-  department TEXT NOT NULL,
   week_label TEXT NOT NULL,
   person_id TEXT NOT NULL,
   present INTEGER NOT NULL DEFAULT 0,
-  PRIMARY KEY (department, week_label, person_id)
+  PRIMARY KEY (week_label, person_id)
 )`);
 db.exec(`CREATE TABLE IF NOT EXISTS projects (
-  department TEXT NOT NULL,
   week_label TEXT NOT NULL,
   project_id TEXT NOT NULL,
   nr TEXT NOT NULL DEFAULT '',
   name TEXT NOT NULL DEFAULT '',
   status TEXT NOT NULL DEFAULT '',
+  status_author TEXT NOT NULL DEFAULT '',
+  status_at TEXT NOT NULL DEFAULT '',
   "group" TEXT NOT NULL DEFAULT '',
   array_order INTEGER NOT NULL DEFAULT 0,
   order_value INTEGER NOT NULL DEFAULT 0,
-  PRIMARY KEY (department, week_label, project_id)
+  -- besprochen: im Teammeeting abgehakt. Gehört zur SITZUNG, nicht zum
+  -- Projekt: Jede Woche wird jedes Projekt neu durchgegangen, und der
+  -- Haken beantwortet die Frage "hatten wir das schon?" nur für diese eine
+  -- Sitzung. Deshalb steht er hier und nicht an einer wochenunabhängigen
+  -- Stelle; beim Duplizieren einer Sitzung wird er zurückgesetzt.
+  besprochen INTEGER NOT NULL DEFAULT 0,
+  -- groesse: Umfang des Projekts als Zahl zwischen 0 und 1, gemessen am
+  -- Referenzhonorar (app_settings.referenzHonorar). Sie tritt an die Stelle
+  -- des Honorars, wenn keines hinterlegt ist, und ist damit die Grundlage
+  -- der Auslastungsrechnung in Stunden. 0 = keine Angabe: Das Projekt ist
+  -- dann nicht bewertbar und wird in der Auslastung als Lücke ausgewiesen,
+  -- nicht stillschweigend als Null gezählt.
+  groesse REAL NOT NULL DEFAULT 0,
+  -- auftragsstatus: Wo das Projekt zwischen Anfrage und Abschluss steht
+  -- ('anfrage'|'angebot'|'beauftragt'|'abgeschlossen', siehe
+  -- VALID_AUFTRAGSSTATUS). Im Unterschied zu besprochen gehört der Wert zum
+  -- PROJEKT und nicht zur Sitzung: Ein Angebot bleibt ein Angebot, bis es
+  -- beauftragt wird, und wandert beim Duplizieren der Sitzung deshalb mit.
+  -- Die Gruppe "In Anbahnung" deutete das bisher nur an; sie bleibt die
+  -- Sortierung auf dem Board, sagt aber nichts darüber, ob schon ein Angebot
+  -- draußen ist.
+  auftragsstatus TEXT NOT NULL DEFAULT 'beauftragt',
+  -- updated_at: Zeitstempel der letzten Speicherung DIESES Projekts. Bis zur
+  -- Planung-Sandbox (CLAUDE.md, "Planung — projektunabhängige Terminplan-
+  -- Sandbox") gab es nur eine Revision je WOCHE (weeks.updated_at) — genug,
+  -- solange jede Sitzung nur wenige Projekte auf einmal hat. Die Sandbox legt
+  -- aber mehrere, voneinander unabhängige Terminpläne in EINER reservierten
+  -- Woche ab; ohne eine Zeitangabe je Projekt ließe sich "zuletzt bearbeitet"
+  -- in der Planungsliste nicht je Plan unterscheiden. Für echte Projekte
+  -- harmlos mitgeführt, aber ungenutzt.
+  updated_at TEXT NOT NULL DEFAULT '',
+  PRIMARY KEY (week_label, project_id)
+)`);
+db.exec(`CREATE TABLE IF NOT EXISTS project_tags (
+  week_label TEXT NOT NULL,
+  project_id TEXT NOT NULL,
+  tag TEXT NOT NULL,
+  tag_order INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (week_label, project_id, tag)
 )`);
 db.exec(`CREATE TABLE IF NOT EXISTS project_lph (
-  department TEXT NOT NULL,
   week_label TEXT NOT NULL,
   project_id TEXT NOT NULL,
   lph TEXT NOT NULL,
   value TEXT NOT NULL DEFAULT '',
-  PRIMARY KEY (department, week_label, project_id, lph)
+  PRIMARY KEY (week_label, project_id, lph)
 )`);
 db.exec(`CREATE TABLE IF NOT EXISTS project_assign (
-  department TEXT NOT NULL,
   week_label TEXT NOT NULL,
   project_id TEXT NOT NULL,
   person_id TEXT NOT NULL,
   role TEXT NOT NULL DEFAULT '',
   state INTEGER NOT NULL DEFAULT 0,
-  PRIMARY KEY (department, week_label, project_id, person_id, role)
+  PRIMARY KEY (week_label, project_id, person_id, role)
 )`);
 db.exec(`CREATE TABLE IF NOT EXISTS project_aufwand (
-  department TEXT NOT NULL,
   week_label TEXT NOT NULL,
   project_id TEXT NOT NULL,
   lph TEXT NOT NULL,
   role TEXT NOT NULL DEFAULT '',
   value REAL NOT NULL DEFAULT 0,
-  PRIMARY KEY (department, week_label, project_id, lph, role)
+  PRIMARY KEY (week_label, project_id, lph, role)
 )`);
 db.exec(`CREATE TABLE IF NOT EXISTS project_aktuelle_lp (
-  department TEXT NOT NULL,
   week_label TEXT NOT NULL,
   project_id TEXT NOT NULL,
   lph TEXT NOT NULL,
-  PRIMARY KEY (department, week_label, project_id, lph)
+  PRIMARY KEY (week_label, project_id, lph)
+)`);
+// project_beauftragte_lph: welche Leistungsphasen für dieses Projekt
+// BEAUFTRAGT sind — nicht zu verwechseln mit project_aktuelle_lp (die eine
+// gerade amtierende Phase) oder project_lph (Fortschritt in Prozent).
+// Grundlage für die Honorar-Terminplanung (siehe js/plan/plan-honorar.js):
+// das vereinbarte Honorar wird auf genau diese Phasen verteilt.
+db.exec(`CREATE TABLE IF NOT EXISTS project_beauftragte_lph (
+  week_label TEXT NOT NULL,
+  project_id TEXT NOT NULL,
+  lph TEXT NOT NULL,
+  PRIMARY KEY (week_label, project_id, lph)
+)`);
+// project_gewerke: welche Fachbereiche des Büros das Projekt bearbeiten
+// ('ELT'|'HLS'|'ARCH', dieselben Werte wie users.department). Ein Projekt
+// kann zu mehreren gehören — ein Schulanbau etwa zu ELT und HLS.
+//
+// Wozu: Die Auswahl der Projektbeteiligten wird darauf eingeschränkt. Ein
+// reines Elektro-Projekt soll nicht die ganze Belegschaft zur Auswahl
+// stellen; wer trotzdem jemanden aus einem anderen Gewerk braucht, holt ihn
+// ausdrücklich dazu (siehe den Wizard in js/projekt-wizard.js).
+//
+// Eigene Tabelle statt einer Spalte mit Trennzeichen — gleiche Bauart wie
+// project_beauftragte_lph, und damit dieselben Wege beim Serialisieren.
+db.exec(`CREATE TABLE IF NOT EXISTS project_gewerke (
+  week_label TEXT NOT NULL,
+  project_id TEXT NOT NULL,
+  gewerk TEXT NOT NULL,
+  PRIMARY KEY (week_label, project_id, gewerk)
 )`);
 db.exec(`CREATE TABLE IF NOT EXISTS project_plan (
-  department TEXT NOT NULL,
   week_label TEXT NOT NULL,
   project_id TEXT NOT NULL,
   start TEXT NOT NULL DEFAULT '',
   end TEXT NOT NULL DEFAULT '',
   progress INTEGER NOT NULL DEFAULT 0,
-  PRIMARY KEY (department, week_label, project_id)
+  PRIMARY KEY (week_label, project_id)
 )`);
 db.exec(`CREATE TABLE IF NOT EXISTS plan_people (
-  department TEXT NOT NULL,
   week_label TEXT NOT NULL,
   project_id TEXT NOT NULL,
   person_id TEXT NOT NULL,
   array_order INTEGER NOT NULL DEFAULT 0,
-  PRIMARY KEY (department, week_label, project_id, person_id)
+  PRIMARY KEY (week_label, project_id, person_id)
 )`);
 db.exec(`CREATE TABLE IF NOT EXISTS plan_todos (
-  department TEXT NOT NULL,
   week_label TEXT NOT NULL,
   project_id TEXT NOT NULL,
   todo_id TEXT NOT NULL,
@@ -183,26 +378,23 @@ db.exec(`CREATE TABLE IF NOT EXISTS plan_todos (
   done INTEGER NOT NULL DEFAULT 0,
   progress INTEGER NOT NULL DEFAULT 0,
   sort_order INTEGER NOT NULL DEFAULT 0,
-  PRIMARY KEY (department, week_label, project_id, todo_id)
+  PRIMARY KEY (week_label, project_id, todo_id)
 )`);
 db.exec(`CREATE TABLE IF NOT EXISTS plan_todo_assignees (
-  department TEXT NOT NULL,
   week_label TEXT NOT NULL,
   project_id TEXT NOT NULL,
   todo_id TEXT NOT NULL,
   person_id TEXT NOT NULL,
-  PRIMARY KEY (department, week_label, project_id, todo_id, person_id)
+  PRIMARY KEY (week_label, project_id, todo_id, person_id)
 )`);
 db.exec(`CREATE TABLE IF NOT EXISTS plan_todo_deps (
-  department TEXT NOT NULL,
   week_label TEXT NOT NULL,
   project_id TEXT NOT NULL,
   todo_id TEXT NOT NULL,
   depends_on_id TEXT NOT NULL,
-  PRIMARY KEY (department, week_label, project_id, todo_id, depends_on_id)
+  PRIMARY KEY (week_label, project_id, todo_id, depends_on_id)
 )`);
 db.exec(`CREATE TABLE IF NOT EXISTS plan_milestones (
-  department TEXT NOT NULL,
   week_label TEXT NOT NULL,
   project_id TEXT NOT NULL,
   milestone_id TEXT NOT NULL,
@@ -210,43 +402,230 @@ db.exec(`CREATE TABLE IF NOT EXISTS plan_milestones (
   date TEXT NOT NULL DEFAULT '',
   position TEXT NOT NULL DEFAULT '',
   sort_order INTEGER NOT NULL DEFAULT 0,
-  PRIMARY KEY (department, week_label, project_id, milestone_id)
+  PRIMARY KEY (week_label, project_id, milestone_id)
 )`);
 db.exec(`CREATE TABLE IF NOT EXISTS plan_milestone_deps (
-  department TEXT NOT NULL,
   week_label TEXT NOT NULL,
   project_id TEXT NOT NULL,
   milestone_id TEXT NOT NULL,
   depends_on_id TEXT NOT NULL,
-  PRIMARY KEY (department, week_label, project_id, milestone_id, depends_on_id)
+  PRIMARY KEY (week_label, project_id, milestone_id, depends_on_id)
 )`);
-db.exec(`CREATE TABLE IF NOT EXISTS people (
-  department TEXT NOT NULL,
-  person_id TEXT NOT NULL,
-  name TEXT NOT NULL DEFAULT '',
-  full_name TEXT NOT NULL DEFAULT '',
+// people / person_roles / person_absences (globale Personen pro Abteilung) sind
+// abgelöst worden (siehe migrateRetirePeopleTablesIntoUsers weiter unten) —
+// werden deshalb hier bewusst NICHT mehr unconditionally angelegt. Für Alt-DBs
+// im früheren Ein-Dokument-Format legt migrateLegacySchema() sie transient an,
+// migrateRetirePeopleTablesIntoUsers() überführt/droppt sie danach beim selben
+// Start.
+
+// ---------- User-Management, Sessions, Datei-Freigabe (Schema, additiv) ----------
+db.exec(`CREATE TABLE IF NOT EXISTS users (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  username TEXT NOT NULL UNIQUE,
+  display_name TEXT NOT NULL DEFAULT '',
   email TEXT NOT NULL DEFAULT '',
-  sort_order INTEGER NOT NULL DEFAULT 0,
-  PRIMARY KEY (department, person_id)
+  password_hash TEXT NOT NULL,
+  password_salt TEXT NOT NULL,
+  role TEXT NOT NULL DEFAULT 'member',
+  person_id TEXT NOT NULL DEFAULT '',
+  active INTEGER NOT NULL DEFAULT 1,
+  must_change_password INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL DEFAULT '',
+  updated_at TEXT NOT NULL DEFAULT ''
 )`);
-db.exec(`CREATE TABLE IF NOT EXISTS person_roles (
-  department TEXT NOT NULL,
-  person_id TEXT NOT NULL,
-  role TEXT NOT NULL,
-  role_order INTEGER NOT NULL DEFAULT 0,
-  PRIMARY KEY (department, person_id, role)
-)`);
-db.exec(`CREATE TABLE IF NOT EXISTS person_absences (
-  department TEXT NOT NULL,
-  person_id TEXT NOT NULL,
-  absence TEXT NOT NULL,
-  PRIMARY KEY (department, person_id, absence)
+db.exec(`CREATE INDEX IF NOT EXISTS idx_users_person_id ON users(person_id)`);
+
+db.exec(`CREATE TABLE IF NOT EXISTS user_sessions (
+  token TEXT PRIMARY KEY,
+  user_id INTEGER NOT NULL,
+  created_at TEXT NOT NULL DEFAULT '',
+  last_seen_at TEXT NOT NULL DEFAULT '',
+  expires_at TEXT NOT NULL DEFAULT '',
+  FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE
 )`);
 
-// Erlaubt ausschliesslich die gültigen Abteilungen (ELT|HLS|ARCH, sonst ELT)
-function departmentKey(department){
-  return (typeof department === 'string' && VALID_DEPARTMENTS.has(department)) ? department : 'ELT';
-}
+// user_roles/user_absences: Rollen (Planung/Projektleitung/Bauüberwachung) und
+// Abwesenheiten je Benutzer — lösen die alten people/person_roles/
+// person_absences-Tabellen vollständig ab (loadGlobalPeople liest nur noch
+// hieraus, migrateRetirePeopleTablesIntoUsers überführt/droppt die Altdaten).
+db.exec(`CREATE TABLE IF NOT EXISTS user_roles (
+  user_id INTEGER NOT NULL, role TEXT NOT NULL, role_order INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (user_id, role),
+  FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE
+)`);
+// created_by: wer den Eintrag angelegt hat. Grundlage der Löschberechtigung —
+// eintragen darf jeder für jeden (die Projektleitung pflegt Urlaube ihres
+// Teams mit), aber entfernen nur die betroffene Person selbst, wer ihn
+// eingetragen hat, oder ein Administrator. 0 = Altbestand ohne Angabe.
+db.exec(`CREATE TABLE IF NOT EXISTS user_absences (
+  user_id INTEGER NOT NULL, id TEXT NOT NULL,
+  start TEXT NOT NULL DEFAULT '', end TEXT NOT NULL DEFAULT '',
+  type TEXT NOT NULL DEFAULT '', note TEXT NOT NULL DEFAULT '',
+  created_by INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (user_id, id),
+  FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE
+)`);
+// Persönliche KI-Zugangsdaten für den Protokoll-Import (POST
+// /project-protokolle/import), siehe readUserAiKey()/writeUserAiKey() und
+// CLAUDE.md "### Protokolle": jedes Konto pflegt seinen eigenen Schlüssel +
+// optionale abweichende API-URL (z. B. ein Firmen-Proxy statt der
+// offiziellen Cloud-API) unter Einstellungen → Mein Konto — bewusst eine
+// eigene, kleine User-Kind-Tabelle statt Zeilen in app_settings, das
+// strukturell ein firmenweiter Singleton-Speicher ist.
+db.exec(`CREATE TABLE IF NOT EXISTS user_ai_keys (
+  user_id INTEGER NOT NULL, provider TEXT NOT NULL,
+  api_key TEXT NOT NULL DEFAULT '', api_url TEXT NOT NULL DEFAULT '',
+  PRIMARY KEY (user_id, provider),
+  FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE
+)`);
+
+db.exec(`CREATE TABLE IF NOT EXISTS project_files (
+  id TEXT PRIMARY KEY,
+  project_nr TEXT NOT NULL,
+  project_name TEXT NOT NULL DEFAULT '',
+  original_filename TEXT NOT NULL,
+  stored_name TEXT NOT NULL,
+  content_type TEXT NOT NULL DEFAULT 'application/octet-stream',
+  size_bytes INTEGER NOT NULL DEFAULT 0,
+  uploaded_by_user_id INTEGER NOT NULL,
+  status TEXT NOT NULL DEFAULT 'pending',
+  created_at TEXT NOT NULL DEFAULT '',
+  updated_at TEXT NOT NULL DEFAULT ''
+)`);
+db.exec(`CREATE INDEX IF NOT EXISTS idx_project_files_scope ON project_files(project_nr)`);
+
+db.exec(`CREATE TABLE IF NOT EXISTS project_file_reviewers (
+  file_id TEXT NOT NULL,
+  user_id INTEGER NOT NULL,
+  decision TEXT NOT NULL DEFAULT 'pending',
+  decided_at TEXT NOT NULL DEFAULT '',
+  note TEXT NOT NULL DEFAULT '',
+  PRIMARY KEY (file_id, user_id)
+)`);
+db.exec(`CREATE INDEX IF NOT EXISTS idx_pfr_user_pending ON project_file_reviewers(user_id, decision)`);
+
+db.exec(`CREATE TABLE IF NOT EXISTS project_file_comments (
+  id TEXT PRIMARY KEY,
+  file_id TEXT NOT NULL,
+  user_id INTEGER NOT NULL,
+  body TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT ''
+)`);
+
+// Protokolle (Besprechungsprotokolle je Projekt) — wie project_files über
+// project_nr mit dem Projekt verknüpft, NICHT über week_label/project_id:
+// project_id wird bei jedem automatischen Sitzungswechsel
+// (ensureCurrentWeekRollover()) neu vergeben, ein Protokoll muss aber über
+// Sitzungen hinweg bestehen bleiben. week_label ist hier reine Information
+// (welche Sitzung lief beim Anlegen), keine Scoping-Spalte.
+db.exec(`CREATE TABLE IF NOT EXISTS project_protokolle (
+  id TEXT PRIMARY KEY,
+  project_nr TEXT NOT NULL,
+  project_name TEXT NOT NULL DEFAULT '',
+  nummer INTEGER NOT NULL,
+  datum TEXT NOT NULL DEFAULT '',
+  betreff TEXT NOT NULL DEFAULT '',
+  ort TEXT NOT NULL DEFAULT '',
+  verfasser_user_id INTEGER NOT NULL,
+  week_label TEXT NOT NULL DEFAULT '',
+  quelle_dateiname TEXT NOT NULL DEFAULT '',
+  quelle_stored_name TEXT NOT NULL DEFAULT '',
+  created_at TEXT NOT NULL DEFAULT '',
+  updated_at TEXT NOT NULL DEFAULT ''
+)`);
+db.exec(`CREATE INDEX IF NOT EXISTS idx_protokolle_project ON project_protokolle(project_nr)`);
+
+// protokoll_teilnehmer: Freitext-Teilnehmerliste je Protokoll (Name + Firma),
+// unabhängig von Benutzerkonten — Baubesprechungen haben typischerweise
+// externe Teilnehmer (Bauherr, ausführende Firmen) ohne Login hier.
+db.exec(`CREATE TABLE IF NOT EXISTS protokoll_teilnehmer (
+  id TEXT PRIMARY KEY,
+  protokoll_id TEXT NOT NULL,
+  name TEXT NOT NULL DEFAULT '',
+  firma TEXT NOT NULL DEFAULT '',
+  anwesend INTEGER NOT NULL DEFAULT 1,
+  array_order INTEGER NOT NULL DEFAULT 0
+)`);
+db.exec(`CREATE INDEX IF NOT EXISTS idx_protokoll_teilnehmer_protokoll ON protokoll_teilnehmer(protokoll_id)`);
+
+// protokoll_punkte: die eigentlichen Besprechungspunkte. stamm_id verbindet
+// alle fortgeschriebenen Kopien "desselben" Punkts über mehrere Protokolle
+// hinweg (siehe createProtokoll()) — nur daran hängt, ob ein Punkt als neu
+// gilt (neu=1), NICHT an nummer/gruppe: beides ist freier, jederzeit vom
+// Nutzer änderbarer Anzeige-Text (nummer z.B. "1", "1.1", "2.3"; gruppe z.B.
+// "ELT"/"HLS" — keine feste Liste, entsteht einfach durchs Eintragen).
+db.exec(`CREATE TABLE IF NOT EXISTS protokoll_punkte (
+  id TEXT PRIMARY KEY,
+  protokoll_id TEXT NOT NULL,
+  stamm_id TEXT NOT NULL,
+  nummer TEXT NOT NULL DEFAULT '',
+  gruppe TEXT NOT NULL DEFAULT '',
+  neu INTEGER NOT NULL DEFAULT 0,
+  thema TEXT NOT NULL DEFAULT '',
+  text TEXT NOT NULL DEFAULT '',
+  zustaendig TEXT NOT NULL DEFAULT '',
+  termin TEXT NOT NULL DEFAULT '',
+  erledigt INTEGER NOT NULL DEFAULT 0,
+  erstellt_am TEXT NOT NULL DEFAULT '',
+  status TEXT NOT NULL DEFAULT 'offen',
+  array_order INTEGER NOT NULL DEFAULT 0
+)`);
+db.exec(`CREATE INDEX IF NOT EXISTS idx_protokoll_punkte_protokoll ON protokoll_punkte(protokoll_id)`);
+
+// lph_templates: firmenweite Aufgaben-Vorlagen je Leistungsphase. Anders als
+// alle Tabellen darüber hängt diese an KEINER Sitzung und an keinem Projekt —
+// sie ist globale Konfiguration ("in LPH 5 machen wir immer diese Schritte"),
+// aus der auf der Projektplan-Seite per Klick TODOs erzeugt werden (siehe
+// js/plan/plan-templates.js). offset_days = Start relativ zum beim Einfügen
+// gewählten Datum (0 = am Starttag), duration_days = Dauer in Kalendertagen
+// (mindestens 1). Die erzeugten TODOs sind danach ganz normale plan_todos und
+// haben keinerlei Verbindung mehr zur Vorlage — spätere Änderungen an der
+// Vorlage wirken sich also NICHT auf bereits eingefügte Aufgaben aus (bewusst:
+// ein laufender Projektplan soll sich nicht rückwirkend ändern).
+db.exec(`CREATE TABLE IF NOT EXISTS lph_templates (
+  id TEXT PRIMARY KEY,
+  lph TEXT NOT NULL,
+  title TEXT NOT NULL DEFAULT '',
+  offset_days INTEGER NOT NULL DEFAULT 0,
+  duration_days INTEGER NOT NULL DEFAULT 1,
+  sort_order INTEGER NOT NULL DEFAULT 0
+)`);
+db.exec('CREATE INDEX IF NOT EXISTS idx_lph_templates_lph ON lph_templates(lph)');
+
+// lph_honorar_anteile: firmenweite Honorar-Anteile je Leistungsphase in
+// Prozent (HOAI-Sätze). Bewusst NICHT als Konstante im Code, sondern
+// pflegbar — die Sätze hängen vom Leistungsbild ab (Technische Ausrüstung
+// nach Anlage 15 unterscheidet sich von der Objektplanung nach Anlage 10)
+// und ändern sich mit HOAI-Novellen. Startet leer und wird in der
+// Honorar-Maske auf der Projektplan-Seite von Administratoren befüllt.
+db.exec(`CREATE TABLE IF NOT EXISTS lph_honorar_anteile (
+  lph TEXT PRIMARY KEY,
+  percent REAL NOT NULL DEFAULT 0
+)`);
+
+// app_settings: firmenweite Einzelwerte als Schlüssel/Wert-Paare. Werte
+// stehen als TEXT und werden beim Lesen gewandelt; welche Schlüssel es gibt,
+// welchen Typ und welche Vorgabe sie haben, steht in APP_SETTING_DEFS weiter
+// unten — dort liegt auch die Prüfung. Eine Zeile existiert erst, wenn der
+// Wert einmal gesetzt wurde; sonst gilt die Vorgabe. Damit brauchen neue
+// Einstellungen weder eine eigene Tabelle noch eine Migration.
+db.exec(`CREATE TABLE IF NOT EXISTS app_settings (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL DEFAULT ''
+)`);
+
+// holidays: firmenweite Feiertage und sonstige arbeitsfreie Tage. Bewusst
+// eine eigene Tabelle statt eines JSON-Werts in app_settings — es ist eine
+// Liste, die wächst, und sie soll sich einzeln pflegen lassen. Sie wirkt
+// überall dort, wo in WERKTAGEN gerechnet wird: workdaysBetween()/
+// addWorkdays() in public/js/utils.js, also in der Terminplan-Berechnung aus
+// dem Honorar und in der Ressourcen-Auslastung des Projektbereichs. Die
+// Terminplanung über Abhängigkeiten (Auto-Schedule) rechnet weiterhin in
+// Kalendertagen — das war schon vorher so.
+db.exec(`CREATE TABLE IF NOT EXISTS holidays (
+  date TEXT PRIMARY KEY,
+  name TEXT NOT NULL DEFAULT ''
+)`);
 
 // ---------- Migration: altes Ein-Dokument-Format -> relationales Schema ----------
 
@@ -256,95 +635,296 @@ function hasLegacyWeeksTable(){
   return cols.length > 0;
 }
 
+// ---------- Serverseitige Bereinigung von Formatierungs-HTML ----------
+//
+// Gegenstück zu sanitizeStatusHtml() (public/js/utils.js) für den Server.
+// Dieselbe Positivliste, dieselben Regeln — aber ohne DOM, deshalb ein
+// eigener, kleiner Tokenizer statt eines Parsers.
+//
+// Warum überhaupt serverseitig, wo der Client doch schon bereinigt: Weil die
+// Bereinigung im Client eine ANZEIGE-Maßnahme ist, keine Eingangskontrolle.
+// Wer eine gültige Anmeldung hat, kann die Routen direkt ansprechen und
+// beliebiges HTML in einen Kommentar oder Protokollpunkt schreiben. Bis
+// hierher wurde das unverändert gespeichert und erst beim Anzeigen entschärft
+// — jede Stelle, die das Feld künftig einmal ohne Bereinigung anfasst, wäre
+// damit sofort ein Einfallstor. Die Prüfung gehört an die Schreibstelle.
+//
+// Bewusst keine Abhängigkeit: Das Projekt kommt mit express/cors plus den
+// drei Protokoll-Import-Bibliotheken aus; ein Sanitizer-Paket dafür
+// aufzunehmen stünde in keinem Verhältnis zu diesen gut hundert Zeilen.
+
+const SICHERE_TAGS = new Set(['b','strong','i','em','u','p','br','div','span','font']);
+// Tags, deren INHALT mitverschwindet, statt ausgepackt zu werden: Bei
+// <script> wäre der ausgepackte Rest sonst der sichtbare Quelltext.
+const TAGS_MIT_INHALT_VERWERFEN = new Set(['script','style','noscript','template','iframe','object','embed']);
+// Leere Elemente haben kein schließendes Gegenstück.
+const LEERE_TAGS = new Set(['br']);
+
+// htmlEscape: maskiert Text für die Ausgabe in HTML (wie esc() im Client).
+function htmlEscape(s){
+  return String(s)
+    .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;').replace(/'/g, '&#39;');
+}
+
+// sicheresStyleAttribut: lässt aus einem style-Attribut nur color und
+// font-weight durch — identisch zur Client-Regel. Rückgabe: bereinigter
+// Wert oder '' (dann wird das Attribut ganz weggelassen).
+function sicheresStyleAttribut(wert){
+  return String(wert || '').split(';').map(s => s.trim()).filter(s => {
+    const prop = s.split(':')[0].trim().toLowerCase();
+    if(prop !== 'color' && prop !== 'font-weight') return false;
+    // url(), expression() und Konsorten haben in einer Farbangabe nichts zu
+    // suchen; ein Wert mit Klammern oder Semikolon fliegt vorsichtshalber raus.
+    const val = s.slice(s.indexOf(':') + 1);
+    return !/[()\\]/.test(val);
+  }).join('; ');
+}
+
+// tagLesen: liest ab Position i (wo '<' steht) ein vollständiges Tag.
+// Beachtet Anführungszeichen in Attributwerten, damit ein '>' DARIN das Tag
+// nicht vorzeitig beendet. Rückgabe: { name, schliessend, attribute, ende }
+// oder null, wenn an dieser Stelle kein gültiges Tag steht (dann ist das '<'
+// schlicht Text).
+function tagLesen(html, i){
+  if(html[i] !== '<') return null;
+  // Kommentare und Deklarationen überspringen und verwerfen
+  if(html.startsWith('<!--', i)){
+    const ende = html.indexOf('-->', i + 4);
+    return { kommentar: true, ende: ende === -1 ? html.length : ende + 3 };
+  }
+  if(html[i + 1] === '!' || html[i + 1] === '?'){
+    const ende = html.indexOf('>', i);
+    return { kommentar: true, ende: ende === -1 ? html.length : ende + 1 };
+  }
+  let p = i + 1;
+  const schliessend = html[p] === '/';
+  if(schliessend) p++;
+  const nameStart = p;
+  while(p < html.length && /[a-zA-Z0-9]/.test(html[p])) p++;
+  if(p === nameStart) return null;              // '<' ohne Tagnamen -> Text
+  const name = html.slice(nameStart, p).toLowerCase();
+  // Attributbereich bis zum '>' lesen, Anführungszeichen beachten
+  let attr = '';
+  let inQuote = null;
+  while(p < html.length){
+    const c = html[p];
+    if(inQuote){
+      if(c === inQuote) inQuote = null;
+      attr += c;
+    } else if(c === '"' || c === "'"){
+      inQuote = c; attr += c;
+    } else if(c === '>'){
+      p++; break;
+    } else {
+      attr += c;
+    }
+    p++;
+  }
+  return { name, schliessend, attribute: attr, ende: p };
+}
+
+// attributeLesen: zieht die Attribute eines Tags als Map heraus.
+function attributeLesen(roh){
+  const map = {};
+  const re = /([a-zA-Z_:][-\w:.]*)\s*=\s*("([^"]*)"|'([^']*)'|([^\s"'>]+))/g;
+  let m;
+  while((m = re.exec(roh))){
+    map[m[1].toLowerCase()] = m[3] !== undefined ? m[3] : (m[4] !== undefined ? m[4] : m[5]);
+  }
+  return map;
+}
+
+// sanitizeFormatHtml: die eigentliche Bereinigung. Erlaubte Tags bleiben
+// (mit höchstens einem gefilterten style-Attribut), verworfene Tags nehmen
+// ihren Inhalt mit, alle übrigen werden ausgepackt (Inhalt bleibt, Tag fällt
+// weg). Offen gebliebene Tags werden am Ende geschlossen, sodass das
+// Ergebnis immer wohlgeformt ist. Parameter: html (String).
+// Rückgabe: bereinigter HTML-String.
+function sanitizeFormatHtml(html){
+  if(html === null || html === undefined) return '';
+  const quelle = String(html);
+  let aus = '';
+  const offen = [];            // Stapel offener, erlaubter Tags
+  let verwerfenBis = null;     // Name des Tags, dessen Inhalt verworfen wird
+  let verwerfenTiefe = 0;
+  let i = 0;
+
+  while(i < quelle.length){
+    const c = quelle[i];
+    if(c !== '<'){
+      const naechstes = quelle.indexOf('<', i);
+      const text = quelle.slice(i, naechstes === -1 ? quelle.length : naechstes);
+      if(!verwerfenBis) aus += htmlEscape(text);
+      i += text.length;
+      continue;
+    }
+    const tag = tagLesen(quelle, i);
+    if(!tag){                                   // '<' ist hier blosser Text
+      if(!verwerfenBis) aus += '&lt;';
+      i++;
+      continue;
+    }
+    i = tag.ende;
+    if(tag.kommentar) continue;
+
+    if(verwerfenBis){
+      // Innerhalb eines verworfenen Blocks zählt nur, wann er wieder endet.
+      if(tag.name === verwerfenBis){
+        if(tag.schliessend){ verwerfenTiefe--; if(verwerfenTiefe <= 0) verwerfenBis = null; }
+        else verwerfenTiefe++;
+      }
+      continue;
+    }
+    if(TAGS_MIT_INHALT_VERWERFEN.has(tag.name)){
+      if(!tag.schliessend){ verwerfenBis = tag.name; verwerfenTiefe = 1; }
+      continue;
+    }
+    if(!SICHERE_TAGS.has(tag.name)) continue;   // auspacken: Tag weg, Inhalt bleibt
+
+    if(tag.schliessend){
+      // Nur schliessen, wenn das Tag auch offen ist — sonst ignorieren.
+      const pos = offen.lastIndexOf(tag.name);
+      if(pos !== -1){
+        // Zwischendrin offen gebliebene Tags mitschliessen (korrekte Schachtelung).
+        for(let k = offen.length - 1; k >= pos; k--) aus += '</' + offen[k] + '>';
+        offen.length = pos;
+      }
+      continue;
+    }
+    const attrs = attributeLesen(tag.attribute);
+    const style = sicheresStyleAttribut(attrs.style);
+    aus += '<' + tag.name + (style ? ' style="' + htmlEscape(style) + '"' : '') + '>';
+    if(!LEERE_TAGS.has(tag.name)) offen.push(tag.name);
+  }
+  for(let k = offen.length - 1; k >= 0; k--) aus += '</' + offen[k] + '>';
+  return aus;
+}
+
 // serializeWeek: zerlegt ein Wochen-Objekt (JSON vom Frontend) in die relationalen
 // Tabellen. Wird in einer Transaktion vom Aufrufer verwendet (deleteWeekData +
 // serializeWeek). Ersetzt alle Zeilen der Woche.
-function serializeWeek(department, week){
+function serializeWeek(week){
   const weekLabel = String(week.label || '');
   const nowIso = new Date().toISOString(); // Revision: wird bei jedem Speichern aktualisiert
-  const upsertWeek = db.prepare(`INSERT INTO weeks (department, label, week_id, date, locked, updated_at) VALUES (?, ?, ?, ?, ?, ?)
-    ON CONFLICT(department, label) DO UPDATE SET week_id = excluded.week_id, date = excluded.date, locked = excluded.locked, updated_at = excluded.updated_at`);
-  upsertWeek.run(department, weekLabel, String(week.id || ''), String(week.date || ''), week.locked ? 1 : 0, nowIso);
+  const upsertWeek = db.prepare(`INSERT INTO weeks (label, week_id, date, locked, updated_at) VALUES (?, ?, ?, ?, ?)
+    ON CONFLICT(label) DO UPDATE SET week_id = excluded.week_id, date = excluded.date, locked = excluded.locked, updated_at = excluded.updated_at`);
+  upsertWeek.run(weekLabel, String(week.id || ''), String(week.date || ''), week.locked ? 1 : 0, nowIso);
 
-  const insWeekPerson = db.prepare(`INSERT INTO week_people (department, week_label, person_id, name, full_name, array_order)
-    VALUES (?, ?, ?, ?, ?, ?)`);
-  const insWeekPersonRole = db.prepare(`INSERT OR IGNORE INTO week_people_roles (department, week_label, person_id, role, role_order)
+  const insWeekPerson = db.prepare(`INSERT INTO week_people (week_label, person_id, name, full_name, array_order)
     VALUES (?, ?, ?, ?, ?)`);
-  const insAttendance = db.prepare(`INSERT OR REPLACE INTO attendance (department, week_label, person_id, present)
+  const insWeekPersonRole = db.prepare(`INSERT OR IGNORE INTO week_people_roles (week_label, person_id, role, role_order)
     VALUES (?, ?, ?, ?)`);
+  const insAttendance = db.prepare(`INSERT OR REPLACE INTO attendance (week_label, person_id, present)
+    VALUES (?, ?, ?)`);
 
-  (Array.isArray(week.people) ? week.people : []).forEach((p, idx) => {
-    insWeekPerson.run(department, weekLabel, String(p.id || ''), String(p.name || ''), String(p.fullName || ''), idx);
-    (Array.isArray(p.role) ? p.role : []).forEach((r, ridx) => insWeekPersonRole.run(department, weekLabel, String(p.id || ''), String(r || ''), ridx));
+  // Sicherheitsnetz gegen doppelte Personen-Kennungen im Teilnehmerkreis:
+  // ein zweiter Eintrag mit derselben id würde den Primärschlüssel verletzen
+  // und die gesamte Transaktion (= das Speichern der Sitzung) abbrechen.
+  const seenPersonIds = new Set();
+  (Array.isArray(week.people) ? week.people : []).filter(p => {
+    const pid = String((p && p.id) || '');
+    if(!pid || seenPersonIds.has(pid)) return false;
+    seenPersonIds.add(pid);
+    return true;
+  }).forEach((p, idx) => {
+    insWeekPerson.run(weekLabel, String(p.id || ''), String(p.name || ''), String(p.fullName || ''), idx);
+    (Array.isArray(p.role) ? p.role : []).forEach((r, ridx) => insWeekPersonRole.run(weekLabel, String(p.id || ''), String(r || ''), ridx));
   });
   const att = week.attendance || {};
   Object.keys(att).forEach(pid => {
-    insAttendance.run(department, weekLabel, pid, att[pid] ? 1 : 0);
+    insAttendance.run(weekLabel, pid, att[pid] ? 1 : 0);
   });
 
-  const insProject = db.prepare(`INSERT INTO projects (department, week_label, project_id, nr, name, status, "group", array_order, order_value)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-  const insLph = db.prepare(`INSERT OR REPLACE INTO project_lph (department, week_label, project_id, lph, value)
-    VALUES (?, ?, ?, ?, ?)`);
-  const insAssign = db.prepare(`INSERT OR REPLACE INTO project_assign (department, week_label, project_id, person_id, role, state)
-    VALUES (?, ?, ?, ?, ?, ?)`);
-  const insAufwand = db.prepare(`INSERT OR REPLACE INTO project_aufwand (department, week_label, project_id, lph, role, value)
-    VALUES (?, ?, ?, ?, ?, ?)`);
-  const insAktuelleLp = db.prepare(`INSERT OR IGNORE INTO project_aktuelle_lp (department, week_label, project_id, lph)
+  const insProject = db.prepare(`INSERT INTO projects (week_label, project_id, nr, name, status, status_author, status_at, "group", array_order, order_value, project_uid, honorar, besprochen, auftragsstatus, groesse, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+  const insBeauftragteLp = db.prepare(`INSERT OR IGNORE INTO project_beauftragte_lph (week_label, project_id, lph)
+    VALUES (?, ?, ?)`);
+  const insGewerk = db.prepare(`INSERT OR IGNORE INTO project_gewerke (week_label, project_id, gewerk)
+    VALUES (?, ?, ?)`);
+  const insTag = db.prepare(`INSERT OR IGNORE INTO project_tags (week_label, project_id, tag, tag_order)
     VALUES (?, ?, ?, ?)`);
-  const insPlan = db.prepare(`INSERT OR REPLACE INTO project_plan (department, week_label, project_id, start, end, progress)
-    VALUES (?, ?, ?, ?, ?, ?)`);
-  const insPlanPerson = db.prepare(`INSERT OR IGNORE INTO plan_people (department, week_label, project_id, person_id, array_order)
+  const insLph = db.prepare(`INSERT OR REPLACE INTO project_lph (week_label, project_id, lph, value)
+    VALUES (?, ?, ?, ?)`);
+  const insAssign = db.prepare(`INSERT OR REPLACE INTO project_assign (week_label, project_id, person_id, role, state)
     VALUES (?, ?, ?, ?, ?)`);
-  const insTodo = db.prepare(`INSERT INTO plan_todos (department, week_label, project_id, todo_id, title, start, end, done, progress, sort_order)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-  const insTodoAssignee = db.prepare(`INSERT OR IGNORE INTO plan_todo_assignees (department, week_label, project_id, todo_id, person_id)
+  const insAufwand = db.prepare(`INSERT OR REPLACE INTO project_aufwand (week_label, project_id, lph, role, value)
     VALUES (?, ?, ?, ?, ?)`);
-  const insTodoDep = db.prepare(`INSERT OR IGNORE INTO plan_todo_deps (department, week_label, project_id, todo_id, depends_on_id)
-    VALUES (?, ?, ?, ?, ?)`);
-  const insMilestone = db.prepare(`INSERT INTO plan_milestones (department, week_label, project_id, milestone_id, name, date, position, sort_order)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
-  const insMilestoneDep = db.prepare(`INSERT OR IGNORE INTO plan_milestone_deps (department, week_label, project_id, milestone_id, depends_on_id)
+  const insAktuelleLp = db.prepare(`INSERT OR IGNORE INTO project_aktuelle_lp (week_label, project_id, lph)
+    VALUES (?, ?, ?)`);
+  const insPlan = db.prepare(`INSERT OR REPLACE INTO project_plan (week_label, project_id, start, end, progress)
     VALUES (?, ?, ?, ?, ?)`);
+  const insPlanPerson = db.prepare(`INSERT OR IGNORE INTO plan_people (week_label, project_id, person_id, array_order)
+    VALUES (?, ?, ?, ?)`);
+  const insTodo = db.prepare(`INSERT INTO plan_todos (week_label, project_id, todo_id, title, start, end, done, progress, sort_order)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+  const insTodoAssignee = db.prepare(`INSERT OR IGNORE INTO plan_todo_assignees (week_label, project_id, todo_id, person_id)
+    VALUES (?, ?, ?, ?)`);
+  const insTodoDep = db.prepare(`INSERT OR IGNORE INTO plan_todo_deps (week_label, project_id, todo_id, depends_on_id)
+    VALUES (?, ?, ?, ?)`);
+  const insMilestone = db.prepare(`INSERT INTO plan_milestones (week_label, project_id, milestone_id, name, date, position, sort_order)
+    VALUES (?, ?, ?, ?, ?, ?, ?)`);
+  const insMilestoneDep = db.prepare(`INSERT OR IGNORE INTO plan_milestone_deps (week_label, project_id, milestone_id, depends_on_id)
+    VALUES (?, ?, ?, ?)`);
 
   (Array.isArray(week.projects) ? week.projects : []).forEach((p, idx) => {
     const projId = String(p.id || '');
-    insProject.run(department, weekLabel, projId, String(p.nr || ''), String(p.name || ''),
-      String(p.status || ''), String(p.group || ''), idx, typeof p.order === 'number' ? p.order : idx);
+    // status trägt Formatierungs-HTML (Fett/Kursiv/Farbe aus dem
+    // Kommentar-Editor) und wird hier — an der Schreibstelle — auf die
+    // erlaubte Positivliste reduziert, nicht erst beim Anzeigen. Siehe
+    // sanitizeFormatHtml() oben.
+    insProject.run(weekLabel, projId, String(p.nr || ''), String(p.name || ''),
+      sanitizeFormatHtml(p.status), String(p.statusAuthor || ''), String(p.statusAt || ''),
+      String(p.group || ''), idx, typeof p.order === 'number' ? p.order : idx,
+      String(p.projectUid || ''), Number(p.honorar) || 0, p.besprochen ? 1 : 0,
+      normalizeAuftragsstatus(p.auftragsstatus), normalizeGroesse(p.groesse), nowIso);
+    (Array.isArray(p.beauftragteLP) ? p.beauftragteLP : []).forEach(lph => {
+      insBeauftragteLp.run(weekLabel, projId, String(lph || ''));
+    });
+    // Nur gültige Gewerke schreiben: Ein unbekannter Wert wäre stiller
+    // Datenmüll, der die Beteiligten-Auswahl später leer laufen ließe.
+    (Array.isArray(p.gewerke) ? p.gewerke : []).forEach(g => {
+      const wert = String(g || '').trim().toUpperCase();
+      if(VALID_DEPARTMENTS.has(wert)) insGewerk.run(weekLabel, projId, wert);
+    });
+    (Array.isArray(p.tags) ? p.tags : []).forEach((tag, tidx) => {
+      const clean = String(tag || '').trim();
+      if(clean) insTag.run(weekLabel, projId, clean, tidx);
+    });
     const lph = p.lph || {};
-    Object.keys(lph).forEach(l => insLph.run(department, weekLabel, projId, String(l || ''), String(lph[l] === undefined ? '' : lph[l])));
+    Object.keys(lph).forEach(l => insLph.run(weekLabel, projId, String(l || ''), String(lph[l] === undefined ? '' : lph[l])));
     const assign = p.assign || {};
     Object.keys(assign).forEach(key => {
       // Key-Format: "personId|Rolle"
       const sep = key.indexOf('|');
       const pid = sep >= 0 ? key.slice(0, sep) : key;
       const role = sep >= 0 ? key.slice(sep + 1) : '';
-      insAssign.run(department, weekLabel, projId, pid, role, Number(assign[key]) || 0);
+      insAssign.run(weekLabel, projId, pid, role, Number(assign[key]) || 0);
     });
     const aufwand = p.aufwandProLP || {};
     Object.keys(aufwand).forEach(lph => {
       const roles = aufwand[lph] || {};
       Object.keys(roles).forEach(role => {
         const v = Number(roles[role]);
-        if(!isNaN(v)) insAufwand.run(department, weekLabel, projId, String(lph || ''), String(role || ''), v);
+        if(!isNaN(v)) insAufwand.run(weekLabel, projId, String(lph || ''), String(role || ''), v);
       });
     });
     (Array.isArray(p.aktuelleLP) ? p.aktuelleLP : []).forEach(lph => {
-      insAktuelleLp.run(department, weekLabel, projId, String(lph || ''));
+      insAktuelleLp.run(weekLabel, projId, String(lph || ''));
     });
     const plan = p.plan || null;
     if(plan){
-      insPlan.run(department, weekLabel, projId, String(plan.start || ''), String(plan.end || ''), Number(plan.progress) || 0);
-      (Array.isArray(plan.people) ? plan.people : []).forEach((pid, pidx) => insPlanPerson.run(department, weekLabel, projId, String(pid || ''), pidx));
+      insPlan.run(weekLabel, projId, String(plan.start || ''), String(plan.end || ''), Number(plan.progress) || 0);
+      (Array.isArray(plan.people) ? plan.people : []).forEach((pid, pidx) => insPlanPerson.run(weekLabel, projId, String(pid || ''), pidx));
       (Array.isArray(plan.todos) ? plan.todos : []).forEach((t, tidx) => {
-        insTodo.run(department, weekLabel, projId, String(t.id || ''), String(t.title || ''),
+        insTodo.run(weekLabel, projId, String(t.id || ''), String(t.title || ''),
           String(t.start || ''), String(t.end || ''), t.done ? 1 : 0, Number(t.progress) || 0, tidx);
-        (Array.isArray(t.assignees) ? t.assignees : []).forEach(pid => insTodoAssignee.run(department, weekLabel, projId, String(t.id || ''), String(pid || '')));
-        (Array.isArray(t.dependsOn) ? t.dependsOn : []).forEach(did => insTodoDep.run(department, weekLabel, projId, String(t.id || ''), String(did || '')));
+        (Array.isArray(t.assignees) ? t.assignees : []).forEach(pid => insTodoAssignee.run(weekLabel, projId, String(t.id || ''), String(pid || '')));
+        (Array.isArray(t.dependsOn) ? t.dependsOn : []).forEach(did => insTodoDep.run(weekLabel, projId, String(t.id || ''), String(did || '')));
       });
       (Array.isArray(plan.milestones) ? plan.milestones : []).forEach((m, midx) => {
-        insMilestone.run(department, weekLabel, projId, String(m.id || ''), String(m.name || ''), String(m.date || ''), String(m.position || ''), midx);
-        (Array.isArray(m.dependsOn) ? m.dependsOn : []).forEach(did => insMilestoneDep.run(department, weekLabel, projId, String(m.id || ''), String(did || '')));
+        insMilestone.run(weekLabel, projId, String(m.id || ''), String(m.name || ''), String(m.date || ''), String(m.position || ''), midx);
+        (Array.isArray(m.dependsOn) ? m.dependsOn : []).forEach(did => insMilestoneDep.run(weekLabel, projId, String(m.id || ''), String(did || '')));
       });
     }
   });
@@ -352,29 +932,29 @@ function serializeWeek(department, week){
   return nowIso;
 }
 
-// deleteWeekData: entfernt alle relationalen Zeilen einer Woche (Abteilung + Label)
-function deleteWeekData(department, weekLabel){
-  const tables = ['week_people_roles','week_people','attendance','project_lph','project_assign',
-    'project_aufwand','project_aktuelle_lp',
+// deleteWeekData: entfernt alle relationalen Zeilen einer Woche (Label)
+function deleteWeekData(weekLabel){
+  const tables = ['week_people_roles','week_people','attendance','project_tags','project_lph','project_assign',
+    'project_aufwand','project_aktuelle_lp','project_beauftragte_lph','project_gewerke',
     'project_plan','plan_people','plan_todos','plan_todo_assignees','plan_todo_deps',
     'plan_milestones','plan_milestone_deps','projects'];
   tables.forEach(t => {
-    db.prepare(`DELETE FROM ${t} WHERE department = ? AND week_label = ?`).run(department, weekLabel);
+    db.prepare(`DELETE FROM ${t} WHERE week_label = ?`).run(weekLabel);
   });
   // Die Wochen-Tabelle selbst nutzt `label` statt `week_label`
-  db.prepare('DELETE FROM weeks WHERE department = ? AND label = ?').run(department, weekLabel);
+  db.prepare('DELETE FROM weeks WHERE label = ?').run(weekLabel);
 }
 
 // saveWeekRelational: speichert eine Woche vollständig relational (Transaktion).
 // Rückgabe: die neu gesetzte Revision `updated_at` (ISO-Zeitstempel), damit der
 // Client seine lokale Basis aktualisieren kann (sonst würde er beim nächsten
 // Speichern einen falschen Konflikt mit sich selbst melden).
-function saveWeekRelational(department, week){
+function saveWeekRelational(week){
   const weekLabel = String(week.label || '');
   const tx = db.exec('BEGIN');
   try {
-    deleteWeekData(department, weekLabel);
-    const updatedAt = serializeWeek(department, week);
+    deleteWeekData(weekLabel);
+    const updatedAt = serializeWeek(week);
     db.exec('COMMIT');
     return updatedAt;
   } catch(err){
@@ -383,84 +963,81 @@ function saveWeekRelational(department, week){
   }
 }
 
-// serializeGlobalPeople: zerlegt die globale Personenliste (JSON-Array) in die
-// Tabellen people/person_roles/person_absences. Ersetzt die gesamte Abteilungsliste.
-function serializeGlobalPeople(department, people){
-  const del = db.prepare(`DELETE FROM people WHERE department = ?`);
-  const delRoles = db.prepare(`DELETE FROM person_roles WHERE department = ?`);
-  const delAbsences = db.prepare(`DELETE FROM person_absences WHERE department = ?`);
-  const tx = db.exec('BEGIN');
-  try {
-    del.run(department); delRoles.run(department); delAbsences.run(department);
-    const insPerson = db.prepare(`INSERT INTO people (department, person_id, name, full_name, email, sort_order)
-      VALUES (?, ?, ?, ?, ?, ?)`);
-    const insRole = db.prepare(`INSERT OR IGNORE INTO person_roles (department, person_id, role, role_order) VALUES (?, ?, ?, ?)`);
-    const insAbsence = db.prepare(`INSERT OR IGNORE INTO person_absences (department, person_id, absence) VALUES (?, ?, ?)`);
-    people.forEach((p, idx) => {
-      insPerson.run(department, String(p.id || ''), String(p.name || ''), String(p.fullName || ''), String(p.email || ''), idx);
-      (Array.isArray(p.role) ? p.role : []).forEach((r, ridx) => insRole.run(department, String(p.id || ''), String(r || ''), ridx));
-      (Array.isArray(p.absences) ? p.absences : []).forEach(a => insAbsence.run(department, String(p.id || ''), String(a || '')));
-    });
-    db.exec('COMMIT');
-  } catch(err){
-    db.exec('ROLLBACK');
-    throw err;
-  }
-}
-
-// loadGlobalPeople: setzt die globale Personenliste einer Abteilung aus den
-// Tabellen people/person_roles/person_absences wieder zusammen. Rückgabe: Array.
-function loadGlobalPeople(department){
-  const people = db.prepare('SELECT * FROM people WHERE department = ? ORDER BY sort_order').all(department);
-  const roles = db.prepare('SELECT * FROM person_roles WHERE department = ? ORDER BY role_order').all(department);
-  const absences = db.prepare('SELECT * FROM person_absences WHERE department = ?').all(department);
-  const rolesByPerson = {};
-  const absByPerson = {};
-  roles.forEach(r => { (rolesByPerson[r.person_id] = rolesByPerson[r.person_id] || []).push(r.role); });
-  absences.forEach(a => { (absByPerson[a.person_id] = absByPerson[a.person_id] || []).push(a.absence); });
-  return people.map(p => ({
-    id: p.person_id,
-    name: p.name,
-    fullName: p.full_name,
-    email: p.email,
-    role: rolesByPerson[p.person_id] || [],
-    absences: absByPerson[p.person_id] || [],
+// loadGlobalPeople: setzt die (jetzt firmenweite, nicht mehr abteilungs-
+// gescopte) Personenliste aus den Tabellen users/user_roles/user_absences
+// zusammen. Rückgabeform unverändert: Array von
+// {id,name,fullName,email,role:[],absences:[]}.
+function loadGlobalPeople(){
+  // person_id != '' : Ein Konto ohne Personen-Kennung (z. B. das Bootstrap-
+  // Konto "admin") ist keine planbare Person. Ohne diesen Filter landen
+  // mehrere solcher Konten mit derselben leeren Kennung im Teilnehmerkreis
+  // einer Sitzung und verletzen dort den Primärschlüssel
+  // (week_label, person_id) — das Speichern schlüge dauerhaft mit 500 fehl.
+  const users = db.prepare(`SELECT * FROM users WHERE active = 1 AND person_id != '' ORDER BY display_name, username`).all();
+  const roles = db.prepare(`SELECT * FROM user_roles ORDER BY role_order`).all();
+  const absences = db.prepare(`SELECT * FROM user_absences`).all();
+  const rolesByUser = {}; roles.forEach(r => (rolesByUser[r.user_id] = rolesByUser[r.user_id] || []).push(r.role));
+  const absByUser = {}; absences.forEach(a => (absByUser[a.user_id] = absByUser[a.user_id] || []).push({ id:a.id, start:a.start, end:a.end, type:a.type, note:a.note }));
+  return users.map(u => ({
+    id: u.person_id,
+    name: u.initials || u.username,
+    fullName: u.display_name,
+    email: u.email,
+    role: rolesByUser[u.id] || [],
+    absences: absByUser[u.id] || [],
+    // Vertragliche Wochenstunden; 0 heißt "nicht gepflegt" und wird im
+    // Frontend wie eine volle Stelle behandelt (js/load/load.js).
+    capacityHours: Number(u.capacity_hours) || 0,
+    // Gewerk der Person (users.department, ein VALID_DEPARTMENTS-Wert).
+    // Nötig für die Auswahl der Projektbeteiligten: Ein Projekt trägt seine
+    // Gewerke (project_gewerke), und angeboten werden zunächst nur die
+    // Mitarbeiter daraus. Leer = keinem Gewerk zugeordnet; solche Personen
+    // erscheinen nur über die ausdrückliche Auswahl "aus anderen Gewerken".
+    gewerk: u.department || '',
   }));
 }
 
-// loadWeeks: setzt alle Wochen einer Abteilung aus den relationalen Tabellen
-// wieder zu kompletten Wochen-Objekten zusammen (Format wie vom Frontend erwartet).
-// Rückgabe: Array von Wochen-Objekten, sortiert nach Label.
-function loadWeeks(department){
-  const weeks = db.prepare('SELECT * FROM weeks WHERE department = ? ORDER BY label').all(department);
-  const weekPeople = db.prepare('SELECT * FROM week_people WHERE department = ? ORDER BY array_order').all(department);
-  const weekRoles = db.prepare('SELECT * FROM week_people_roles WHERE department = ? ORDER BY role_order').all(department);
-  const attendance = db.prepare('SELECT * FROM attendance WHERE department = ?').all(department);
-  const projects = db.prepare('SELECT * FROM projects WHERE department = ? ORDER BY array_order').all(department);
-  const lph = db.prepare('SELECT * FROM project_lph WHERE department = ?').all(department);
-  const assign = db.prepare('SELECT * FROM project_assign WHERE department = ?').all(department);
-  const aufwand = db.prepare('SELECT * FROM project_aufwand WHERE department = ?').all(department);
-  const aktuelleLp = db.prepare('SELECT * FROM project_aktuelle_lp WHERE department = ?').all(department);
-  const plans = db.prepare('SELECT * FROM project_plan WHERE department = ?').all(department);
-  const planPeople = db.prepare('SELECT * FROM plan_people WHERE department = ? ORDER BY array_order').all(department);
-  const todos = db.prepare('SELECT * FROM plan_todos WHERE department = ? ORDER BY sort_order').all(department);
-  const todoAssignees = db.prepare('SELECT * FROM plan_todo_assignees WHERE department = ?').all(department);
-  const todoDeps = db.prepare('SELECT * FROM plan_todo_deps WHERE department = ?').all(department);
-  const milestones = db.prepare('SELECT * FROM plan_milestones WHERE department = ? ORDER BY sort_order').all(department);
-  const milestoneDeps = db.prepare('SELECT * FROM plan_milestone_deps WHERE department = ?').all(department);
+// loadWeeks: setzt alle Wochen (jetzt eine einzige globale Reihe, nicht mehr
+// pro Abteilung) aus den relationalen Tabellen wieder zu kompletten
+// Wochen-Objekten zusammen. Rückgabe: Array von Wochen-Objekten, sortiert
+// nach Label.
+function loadWeeks(){
+  const weeks = db.prepare('SELECT * FROM weeks ORDER BY label').all();
+  const weekPeople = db.prepare('SELECT * FROM week_people ORDER BY array_order').all();
+  const weekRoles = db.prepare('SELECT * FROM week_people_roles ORDER BY role_order').all();
+  const attendance = db.prepare('SELECT * FROM attendance').all();
+  const projects = db.prepare('SELECT * FROM projects ORDER BY array_order').all();
+  const tags = db.prepare('SELECT * FROM project_tags ORDER BY tag_order').all();
+  const lph = db.prepare('SELECT * FROM project_lph').all();
+  const assign = db.prepare('SELECT * FROM project_assign').all();
+  const aufwand = db.prepare('SELECT * FROM project_aufwand').all();
+  const aktuelleLp = db.prepare('SELECT * FROM project_aktuelle_lp').all();
+  const beauftragteLp = db.prepare('SELECT * FROM project_beauftragte_lph').all();
+  const gewerke = db.prepare('SELECT * FROM project_gewerke').all();
+  const plans = db.prepare('SELECT * FROM project_plan').all();
+  const planPeople = db.prepare('SELECT * FROM plan_people ORDER BY array_order').all();
+  const todos = db.prepare('SELECT * FROM plan_todos ORDER BY sort_order').all();
+  const todoAssignees = db.prepare('SELECT * FROM plan_todo_assignees').all();
+  const todoDeps = db.prepare('SELECT * FROM plan_todo_deps').all();
+  const milestones = db.prepare('SELECT * FROM plan_milestones ORDER BY sort_order').all();
+  const milestoneDeps = db.prepare('SELECT * FROM plan_milestone_deps').all();
 
   // Index-Karten für schnellen Zugriff
-  const weekKey = (label) => department + '|' + label;
-  const projKey = (label, pid) => department + '|' + label + '|' + pid;
-  const todoKey = (label, pid, tid) => department + '|' + label + '|' + pid + '|' + tid;
-  const msKey = (label, pid, mid) => department + '|' + label + '|' + pid + '|' + mid;
+  const weekKey = (label) => label;
+  const projKey = (label, pid) => label + '|' + pid;
+  const todoKey = (label, pid, tid) => label + '|' + pid + '|' + tid;
+  const msKey = (label, pid, mid) => label + '|' + pid + '|' + mid;
 
   const weekPeopleMap = {};
   const weekRolesMap = {};
   const attendanceMap = {};
+  // Anhängen statt per Index setzen: Die Abfrage ist bereits nach array_order
+  // sortiert. Eine Index-Zuweisung würde bei zwei gleichen Ordnungszahlen in
+  // derselben Woche (möglich nach der Abteilungs-Zusammenführung) die erste
+  // Person still überschreiben und Lücken im Array hinterlassen.
   weekPeople.forEach(r => {
     const k = weekKey(r.week_label);
-    (weekPeopleMap[k] = weekPeopleMap[k] || [])[r.array_order] = { id: r.person_id, name: r.name, fullName: r.full_name };
+    (weekPeopleMap[k] = weekPeopleMap[k] || []).push({ id: r.person_id, name: r.name, fullName: r.full_name });
   });
   weekRoles.forEach(r => {
     const k = weekKey(r.week_label);
@@ -474,11 +1051,26 @@ function loadWeeks(department){
   const projectsMap = {};
   projects.forEach(r => {
     projectsMap[projKey(r.week_label, r.project_id)] = {
-      id: r.project_id, nr: r.nr, name: r.name, status: r.status, group: r.group,
-      lph: {}, assign: {}, order: r.order_value, plan: null,
+      id: r.project_id, nr: r.nr, name: r.name, status: r.status,
+      statusAuthor: r.status_author || '', statusAt: r.status_at || '',
+      group: r.group,
+      tags: [], lph: {}, assign: {}, order: r.order_value, plan: null,
+      projectUid: r.project_uid,
+      honorar: r.honorar,
+      besprochen: !!r.besprochen,
+      groesse: normalizeGroesse(r.groesse),
+      // Rückfall auf die Vorgabe, weil Zeilen aus der Zeit vor der Spalte
+      // (und aus einem älteren Backup, siehe IMPORT_OPTIONAL_COLS) einen
+      // leeren Wert tragen können — die Oberfläche soll keinen Leerzustand
+      // anzeigen müssen.
+      auftragsstatus: normalizeAuftragsstatus(r.auftragsstatus),
+      beauftragteLP: [],
+      gewerke: [],
+      updatedAt: r.updated_at || '',
       _arrayOrder: r.array_order,
     };
   });
+  tags.forEach(r => { const p = projectsMap[projKey(r.week_label, r.project_id)]; if(p) p.tags.push(r.tag); });
   lph.forEach(r => { const p = projectsMap[projKey(r.week_label, r.project_id)]; if(p) p.lph[r.lph] = r.value; });
   assign.forEach(r => {
     const p = projectsMap[projKey(r.week_label, r.project_id)];
@@ -492,6 +1084,14 @@ function loadWeeks(department){
     const p = projectsMap[projKey(r.week_label, r.project_id)];
     if(p){ p.aktuelleLP = p.aktuelleLP || []; if(!p.aktuelleLP.includes(r.lph)) p.aktuelleLP.push(r.lph); }
   });
+  beauftragteLp.forEach(r => {
+    const p = projectsMap[projKey(r.week_label, r.project_id)];
+    if(p && !p.beauftragteLP.includes(r.lph)) p.beauftragteLP.push(r.lph);
+  });
+  gewerke.forEach(r => {
+    const p = projectsMap[projKey(r.week_label, r.project_id)];
+    if(p && !p.gewerke.includes(r.gewerk)) p.gewerke.push(r.gewerk);
+  });
 
   const planMap = {};
   plans.forEach(r => { planMap[projKey(r.week_label, r.project_id)] = { start: r.start, end: r.end, progress: r.progress, people: [], todos: [], milestones: [] }; });
@@ -501,8 +1101,6 @@ function loadWeeks(department){
   });
 
   const todoMap = {};
-  const todoAssigneeMap = {};
-  const todoDepMap = {};
   todos.forEach(r => {
     const k = todoKey(r.week_label, r.project_id, r.todo_id);
     todoMap[k] = { id: r.todo_id, title: r.title, start: r.start, end: r.end, done: !!r.done, dependsOn: [], assignees: [], progress: r.progress };
@@ -517,7 +1115,6 @@ function loadWeeks(department){
   });
 
   const msMap = {};
-  const msDepMap = {};
   milestones.forEach(r => {
     const k = msKey(r.week_label, r.project_id, r.milestone_id);
     msMap[k] = { id: r.milestone_id, name: r.name, date: r.date, position: r.position, dependsOn: [] };
@@ -530,12 +1127,12 @@ function loadWeeks(department){
   // TODO- und Meilenstein-Objekte in die Projekt-Pläne einsortieren
   Object.keys(todoMap).forEach(k => {
     const parts = k.split('|');
-    const plan = planMap[department + '|' + parts[1] + '|' + parts[2]];
+    const plan = planMap[parts[0] + '|' + parts[1]];
     if(plan) plan.todos.push(todoMap[k]);
   });
   Object.keys(msMap).forEach(k => {
     const parts = k.split('|');
-    const plan = planMap[department + '|' + parts[1] + '|' + parts[2]];
+    const plan = planMap[parts[0] + '|' + parts[1]];
     if(plan) plan.milestones.push(msMap[k]);
   });
 
@@ -554,7 +1151,7 @@ function loadWeeks(department){
       if(present !== undefined) att[p.id] = present;
     });
     const weekProjects = Object.keys(projectsMap)
-      .filter(k => k.startsWith(department + '|' + w.label + '|'))
+      .filter(k => k.startsWith(w.label + '|'))
       .map(k => {
         const p = projectsMap[k];
         const plan = planMap[k];
@@ -571,334 +1168,11 @@ function loadWeeks(department){
   });
 }
 
-// ---------- CSV-/ZIP-Export ----------
-//
-// GET /export-csv?department=<ELT|HLS|ARCH> liefert einen ZIP, der pro logischer
-// Entität eine übersichtliche CSV-Datei enthält (Wochen, Personen, Projekte,
-// Zuordnungen, Leistungsphasen, Pläne/TODOs/Meilensteine). Zielgruppe ist vor
-// allem Excel; deshalb sind die CSVs UTF-8 mit BOM, CRLF-Zeilenenden und
-// Semikolon als Trenner (MS-Excel-de standardmäßig). Das Trennzeichen lässt
-// sich über das Query-Parameter `sep` übersteuern (z. B. `?sep=,`).
-
-// CSV_TABLE: CRC32-Prüftabelle für den ZIP-Build (ZIP verlangt pro Datei eine
-// CRC32-Summe; zlib.crc32 existiert erst ab neueren Node-Versionen, daher hier
-// manuell).
-const CSV_TABLE = (() => {
-  const t = new Uint32Array(256);
-  for(let n = 0; n < 256; n++){
-    let c = n;
-    for(let k = 0; k < 8; k++) c = (c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1);
-    t[n] = c;
-  }
-  return t;
-})();
-
-function crc32(buf){
-  let c = 0xFFFFFFFF;
-  for(let i = 0; i < buf.length; i++) c = CSV_TABLE[(c ^ buf[i]) & 0xFF] ^ (c >>> 8);
-  return (c ^ 0xFFFFFFFF) >>> 0;
-}
-
-// dosDateTime: kodiert einen Zeitpunkt als DOS-Datum/-Uhrzeit (FAT-Format des
-// ZIP-Headers). Rückgabe: {time, date}.
-function dosDateTime(d){
-  const time = (d.getHours() << 11) | (d.getMinutes() << 5) | Math.floor(d.getSeconds() / 2);
-  const date = ((d.getFullYear() - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate();
-  return { time, date };
-}
-
-// buildZip: packt mehrere Dateien ohne externe Bibliothek in ein ZIP-Archiv
-// (Deflate-Kompression, UTF-8-Dateinamen). Parameter: files = Array von
-// {name, data}, wobei data Buffer oder String ist. Rückgabe: Buffer.
-function buildZip(files){
-  const localParts = [];
-  const centralParts = [];
-  let offset = 0;
-  files.forEach(f => {
-    const nameBuf = Buffer.from(f.name, 'utf8');
-    const raw = Buffer.isBuffer(f.data) ? f.data : Buffer.from(f.data, 'utf8');
-    const compressed = zlib.deflateRawSync(raw);
-    const crc = crc32(raw);
-    const dt = dosDateTime(new Date());
-    const csize = compressed.length;
-    const usize = raw.length;
-    const nlen = nameBuf.length;
-
-    // Lokaler Datei-Header (30 Byte) + Name + Daten
-    const lh = Buffer.alloc(30);
-    lh.writeUInt32LE(0x04034b50, 0);
-    lh.writeUInt16LE(20, 4);       // Version benötigt
-    lh.writeUInt16LE(0x0800, 6);   // Flag: UTF-8-Namen
-    lh.writeUInt16LE(8, 8);        // Methode: Deflate
-    lh.writeUInt16LE(dt.time, 10);
-    lh.writeUInt16LE(dt.date, 12);
-    lh.writeUInt32LE(crc, 14);
-    lh.writeUInt32LE(csize, 18);
-    lh.writeUInt32LE(usize, 22);
-    lh.writeUInt16LE(nlen, 26);
-    lh.writeUInt16LE(0, 28);       // Extra-Länge
-    const local = Buffer.concat([lh, nameBuf, compressed]);
-    localParts.push(local);
-
-    // Zentralverzeichnis-Eintrag (46 Byte) + Name
-    const ch = Buffer.alloc(46);
-    ch.writeUInt32LE(0x02014b50, 0);
-    ch.writeUInt16LE(20, 4);       // Version erstellt
-    ch.writeUInt16LE(20, 6);       // Version benötigt
-    ch.writeUInt16LE(0x0800, 8);
-    ch.writeUInt16LE(8, 10);
-    ch.writeUInt16LE(dt.time, 12);
-    ch.writeUInt16LE(dt.date, 14);
-    ch.writeUInt32LE(crc, 16);
-    ch.writeUInt32LE(csize, 20);
-    ch.writeUInt32LE(usize, 24);
-    ch.writeUInt16LE(nlen, 28);
-    ch.writeUInt16LE(0, 30);       // Extra
-    ch.writeUInt16LE(0, 32);       // Kommentar
-    ch.writeUInt16LE(0, 34);       // Datenträger
-    ch.writeUInt16LE(0, 36);       // Interne Attribute
-    ch.writeUInt32LE(0, 38);       // Externe Attribute
-    ch.writeUInt32LE(offset, 42);  // Offset des lokalen Headers
-    centralParts.push(Buffer.concat([ch, nameBuf]));
-    offset += local.length;
-  });
-
-  const centralBuf = Buffer.concat(centralParts);
-  const end = Buffer.alloc(22);
-  end.writeUInt32LE(0x06054b50, 0);
-  end.writeUInt16LE(0, 4);             // Datenträger
-  end.writeUInt16LE(0, 6);             // Datenträger mit CD
-  end.writeUInt16LE(files.length, 8);  // Einträge auf Datenträger
-  end.writeUInt16LE(files.length, 10); // Einträge gesamt
-  end.writeUInt32LE(centralBuf.length, 12);
-  end.writeUInt32LE(offset, 16);
-  end.writeUInt16LE(0, 20);            // Kommentarlänge
-  return Buffer.concat([...localParts, centralBuf, end]);
-}
-
-// CSV_SEP: Trennzeichen der Export-CSVs. Standard Semikolon, damit die Dateien
-// in der deutschen Excel-Version direkt sauber öffnen; über `?sep=` übersteuerbar.
-let CSV_SEP = ';';
-
-// csvCell: escaped eine Zelle für CSV (Anführungszeichen verdoppeln, Zellen
-// mit Trenner/Quote/Zeilenumbruch in Anführungszeichen setzen).
-function csvCell(v){
-  const s = v === undefined || v === null ? '' : String(v);
-  if(s.includes(CSV_SEP) || s.includes('"') || s.includes('\n') || s.includes('\r')){
-    return '"' + s.replace(/"/g, '""') + '"';
-  }
-  return s;
-}
-
-// csvFile: erzeugt aus Spaltenüberschriften (headers) und Zeilen (rows, je
-// Array von Werten) eine fertige CSV-Datei-Beschreibung {name, data} für den
-// ZIP-Build. Daten werden mit BOM + CRLF (Excel-kompatibel) erzeugt.
-// name: Dateiname inkl. Unterordner (z. B. "ELT/projekte.csv").
-function csvFile(name, headers, rows){
-  const lines = [csvRow(headers)];
-  rows.forEach(r => lines.push(csvRow(r)));
-  return { name, data: '\uFEFF' + lines.join('') };
-}
-
-// csvRow: eine CSV-Zeile als String (inkl. Zeilenende CRLF).
-function csvRow(values){
-  return (values || []).map(csvCell).join(CSV_SEP) + '\r\n';
-}
-
-// csvStatusText: reduziert ein Status-HTML-Feld auf reinen Text für CSV
-// (<br>/<p>/<div> werden zu Zeilenumbrüchen, alle übrigen Tags entfernt).
-function csvStatusText(html){
-  if(!html) return '';
-  return String(html)
-    .replace(/<br\s*\/?>/gi, '\n')
-    .replace(/<\/(p|div)>/gi, '\n')
-    .replace(/<[^>]+>/g, '')
-    .replace(/\u00A0/g, ' ')
-    .replace(/\n{3,}/g, '\n\n')
-    .trim();
-}
-
-// personNameById: Namen der Wochen-Personen nachschlagen (Kurzname bevorzugt).
-function weekPersonName(week, id){
-  const p = (week.people || []).find(e => e.id === id);
-  return p ? (p.name || p.fullName || id) : id;
-}
-
-// buildExportCsvs: erzeugt alle CSV-Dateien für eine Abteilung auf Basis der
-// auch fürs Frontend verwendeten Deserialisierer (loadWeeks/loadGlobalPeople).
-// Rückgabe: Array von {name, data} für buildZip.
-function buildExportCsvs(department){
-  const weeks = loadWeeks(department);
-  const people = loadGlobalPeople(department);
-  const dir = department + '/';
-  const files = [];
-
-  // 1) Wochen
-  files.push(csvFile(dir + 'wochen.csv',
-    ['Abteilung', 'Woche (KW)', 'ID', 'Datum', 'Gesperrt'],
-    weeks.map(w => [department, w.label || '', String(w.id || ''), w.date || '', w.locked ? 'Ja' : 'Nein'])));
-
-  // 2) Globale Personen
-  files.push(csvFile(dir + 'personen.csv',
-    ['Abteilung', 'Kürzel', 'Voller Name', 'E-Mail', 'Rollen', 'Abwesenheiten'],
-    people.map(p => [
-      department, p.name || '', p.fullName || '', p.email || '',
-      Array.isArray(p.role) ? p.role.join(', ') : '',
-      Array.isArray(p.absences) ? p.absences.join(', ') : '',
-    ])));
-
-  // 3) Sitzungsteilnehmer inkl. Anwesenheit
-  const teilnehmer = [];
-  weeks.forEach(w => {
-    (w.people || []).forEach(p => {
-      const att = w.attendance || {};
-      teilnehmer.push([
-        w.label || '', p.name || '', p.fullName || '',
-        Array.isArray(p.role) ? p.role.join(', ') : '',
-        att[p.id] === undefined ? '' : (att[p.id] ? 'Ja' : 'Nein'),
-      ]);
-    });
-  });
-  files.push(csvFile(dir + 'sitzungsteilnehmer.csv',
-    ['Woche (KW)', 'Kürzel', 'Voller Name', 'Rollen', 'Anwesend'],
-    teilnehmer));
-
-  // 4) Projekte
-  files.push(csvFile(dir + 'projekte.csv',
-    ['Woche (KW)', 'Projekt-Nr.', 'Bezeichnung', 'Gruppe', 'Reihenfolge', 'Status'],
-    weeks.flatMap(w => (w.projects || []).map(p => [
-      w.label || '', p.nr || '', p.name || '', p.group || '',
-      typeof p.order === 'number' ? p.order : '', csvStatusText(p.status),
-    ]))));
-
-  // 5) Projekt-Zuordnungen (Haupt/Optional je Person/Rolle)
-  const zuordnungen = [];
-  weeks.forEach(w => {
-    (w.projects || []).forEach(p => {
-      Object.keys(p.assign || {}).forEach(aKey => {
-        const sep = aKey.indexOf('|');
-        const pid = sep >= 0 ? aKey.slice(0, sep) : aKey;
-        const role = sep >= 0 ? aKey.slice(sep + 1) : '';
-        const state = Number(p.assign[aKey]) || 0;
-        zuordnungen.push([
-          w.label || '', p.nr || '', p.name || '', weekPersonName(w, pid), role,
-          state === 1 ? 'Haupt' : state === 2 ? 'Optional' : String(state),
-        ]);
-      });
-    });
-  });
-  files.push(csvFile(dir + 'zuordnungen.csv',
-    ['Woche (KW)', 'Projekt-Nr.', 'Bezeichnung', 'Kürzel', 'Rolle', 'Art'],
-    zuordnungen));
-
-  // 6) Leistungsphasen (Fortschrittswerte je Projekt/LPH)
-  const lphRows = [];
-  weeks.forEach(w => {
-    (w.projects || []).forEach(p => {
-      (p.lph || {}) && Object.keys(p.lph || {}).forEach(l =>
-        lphRows.push([w.label || '', p.nr || '', p.name || '', l, p.lph[l]]));
-    });
-  });
-  files.push(csvFile(dir + 'leistungsphasen.csv',
-    ['Woche (KW)', 'Projekt-Nr.', 'Bezeichnung', 'Leistungsphase', 'Wert'],
-    lphRows));
-
-  // 7) Aktuelle Leistungsphasen je Projekt
-  const aktLpRows = [];
-  weeks.forEach(w => {
-    (w.projects || []).forEach(p => {
-      (Array.isArray(p.aktuelleLP) ? p.aktuelleLP : []).forEach(l =>
-        aktLpRows.push([w.label || '', p.nr || '', p.name || '', l]));
-    });
-  });
-  files.push(csvFile(dir + 'aktuelle-leistungsphasen.csv',
-    ['Woche (KW)', 'Projekt-Nr.', 'Bezeichnung', 'Leistungsphase'],
-    aktLpRows));
-
-  // 8) Aufwand je Leistungsphase/Rolle (Gewichtungsfaktoren)
-  const aufwandRows = [];
-  weeks.forEach(w => {
-    (w.projects || []).forEach(p => {
-      (p.aufwandProLP || {}) && Object.keys(p.aufwandProLP || {}).forEach(l => {
-        Object.keys(p.aufwandProLP[l] || {}).forEach(role =>
-          aufwandRows.push([w.label || '', p.nr || '', p.name || '', l, role, p.aufwandProLP[l][role]]));
-      });
-    });
-  });
-  files.push(csvFile(dir + 'aufwand-je-leistungsphase.csv',
-    ['Woche (KW)', 'Projekt-Nr.', 'Bezeichnung', 'Leistungsphase', 'Rolle', 'Faktor'],
-    aufwandRows));
-
-  // 9) Projektpläne (GANTT-Kopf)
-  const planRows = [];
-  weeks.forEach(w => {
-    (w.projects || []).forEach(p => {
-      const plan = p.plan;
-      if(!plan) return;
-      planRows.push([
-        w.label || '', p.nr || '', p.name || '', plan.start || '', plan.end || '',
-        Number(plan.progress) || 0,
-        (plan.people || []).map(pid => weekPersonName(w, pid)).join(', '),
-      ]);
-    });
-  });
-  files.push(csvFile(dir + 'projektplaene.csv',
-    ['Woche (KW)', 'Projekt-Nr.', 'Bezeichnung', 'Start', 'Ende', 'Fortschritt (%)', 'Beteiligte'],
-    planRows));
-
-  // 10) TODOs der Projektpläne (Zuständige und Abhängigkeiten als lesbare Namen)
-  const todoRows = [];
-  weeks.forEach(w => {
-    (w.projects || []).forEach(p => {
-      const plan = p.plan;
-      if(!plan || !Array.isArray(plan.todos)) return;
-      const titleById = {};
-      (plan.todos || []).forEach(t => { titleById[t.id] = t.title; });
-      (plan.milestones || []).forEach(m => { titleById[m.id] = m.name; });
-      (plan.todos || []).forEach(t => {
-        todoRows.push([
-          w.label || '', p.nr || '', p.name || '', t.title || '', t.start || '',
-          t.end || '', t.done ? 'Ja' : 'Nein', Number(t.progress) || 0,
-          (t.assignees || []).map(pid => weekPersonName(w, pid)).join(', '),
-          (t.dependsOn || []).map(did => titleById[did] || did).join(', '),
-        ]);
-      });
-    });
-  });
-  files.push(csvFile(dir + 'todos.csv',
-    ['Woche (KW)', 'Projekt-Nr.', 'Bezeichnung', 'TODO', 'Start', 'Ende', 'Erledigt', 'Fortschritt (%)', 'Zuständige', 'Hängt ab von'],
-    todoRows));
-
-  // 11) Meilensteine der Projektpläne
-  const msRows = [];
-  weeks.forEach(w => {
-    (w.projects || []).forEach(p => {
-      const plan = p.plan;
-      if(!plan || !Array.isArray(plan.milestones)) return;
-      const titleById = {};
-      (plan.todos || []).forEach(t => { titleById[t.id] = t.title; });
-      (plan.milestones || []).forEach(m => { titleById[m.id] = m.name; });
-      (plan.milestones || []).forEach(m => {
-        msRows.push([
-          w.label || '', p.nr || '', p.name || '', m.name || '', m.date || '',
-          m.position || '',
-          (m.dependsOn || []).map(did => titleById[did] || did).join(', '),
-        ]);
-      });
-    });
-  });
-  files.push(csvFile(dir + 'meilensteine.csv',
-    ['Woche (KW)', 'Projekt-Nr.', 'Bezeichnung', 'Meilenstein', 'Datum', 'Position', 'Hängt ab von'],
-    msRows));
-
-  return files;
-}
-
-// ---------- Datenbank-Backup (Ergänzung zum CSV-Export) ----------
+// ---------- Datenbank-Backup ----------
 //
 // Zwei Wege: (1) Beim Serverstart wird automatisch eine Kopie der SQLite-DB
 // als zeitgestempelte Datei in sessions/backups/ abgelegt (nur die letzten
-// MAX_BACKUPS werden behalten). (2) GET /backup liefert einen konsistenten
+// aufbewahrten Backups werden behalten). (2) GET /backup liefert einen konsistenten
 // Snapshot der DB als herunterladbare .db-Datei (z. B. über den Button
 // "DB Backup" im Menü der Hauptseite). Beide nutzen `VACUUM INTO`, das auch
 // bei aktivem WAL-Mode eine konsistente Einzeldatei erzeugt (WAL-Inhalte
@@ -907,8 +1181,11 @@ function buildExportCsvs(department){
 // BACKUP_DIR: Zielordner der automatischen Backups (sessions/backups, Docker-
 // bind-mounted → bleibt persistent).
 const BACKUP_DIR = path.join(SESSIONS_DIR, 'backups');
-// MAX_BACKUPS: Anzahl der automatisch behaltenen Backups (Älteste werden verworfen)
-const MAX_BACKUPS = 10;
+// Anzahl der automatisch behaltenen Backups (die ältesten werden verworfen)
+// Wie viele automatische Backups aufbewahrt werden, ist seit dem Ausbau der
+// Einstellungen firmenweit pflegbar (Schlüssel 'maxBackups'); dieser Wert ist
+// nur noch die Vorgabe, falls nichts gesetzt ist.
+const DEFAULT_MAX_BACKUPS = 10;
 
 // createDbSnapshot: erzeugt einen konsistenten Snapshot der SQLite-DB in die
 // angegebene Zieldatei (VACUUM INTO; funktioniert auch bei WAL-Mode).
@@ -918,7 +1195,7 @@ function createDbSnapshot(targetPath){
 }
 
 // runAutoBackup: legt ein zeitgestempeltes Backup in BACKUP_DIR ab und
-// verwirft ältere, sobald MAX_BACKUPS überschritten ist. Fehler werden nur
+// verwirft ältere, sobald die eingestellte Anzahl überschritten ist. Fehler werden nur
 // geloggt (Backup darf den Serverstart nicht verhindern).
 function runAutoBackup(){
   try {
@@ -932,12 +1209,12 @@ function runAutoBackup(){
     createDbSnapshot(file);
     console.log('Datenbank-Backup erstellt:', file);
 
-    // Nur die letzten MAX_BACKUPS behalten
+    // Nur die letzten (einstellbar, Schlüssel 'maxBackups') behalten
     const backups = fs.readdirSync(BACKUP_DIR)
       .filter(f => /^projektuebersicht_.+\.db$/.test(f))
       .map(f => ({ name: f, mtime: fs.statSync(path.join(BACKUP_DIR, f)).mtimeMs }))
       .sort((a, b) => b.mtime - a.mtime);
-    backups.slice(MAX_BACKUPS).forEach(b => {
+    backups.slice(readAppSetting('maxBackups')).forEach(b => {
       fs.unlinkSync(path.join(BACKUP_DIR, b.name));
     });
   } catch(err){
@@ -955,13 +1232,21 @@ function runAutoBackup(){
 // zurückgerollt. Vor dem Import wird der Zustand vor dem Import als frisches
 // Backup gesichert (runAutoBackup), damit er rückgängig gemacht werden kann.
 
-// IMPORT_TABLES: alle Tabellen des relationalen Schemas; Grundlage für
-// Validierung, Löschvorgang und Datentransfer. Die Reihenfolge ist ohne
-// Bedeutung, da das Schema keine Foreign-Key-Constraints deklariert.
+// IMPORT_TABLES: die Sitzungs-/Projektdaten-Tabellen des relationalen Schemas;
+// Grundlage für Validierung, Löschvorgang und Datentransfer. Die Reihenfolge
+// ist ohne Bedeutung, da das Schema keine Foreign-Key-Constraints deklariert.
+// BEWUSST NICHT enthalten sind die firmenweiten Konfigurations- und
+// Kontotabellen (users, user_sessions, user_roles, user_absences,
+// project_files, project_file_reviewers, project_file_comments sowie
+// lph_templates): eine Wiederherstellung soll Sitzungsdaten zurückrollen,
+// aber niemals Konten, Freigabestände oder Aufgaben-Vorlagen überschreiben.
 const IMPORT_TABLES = ['weeks','week_people','week_people_roles','attendance','projects',
-  'project_lph','project_assign','project_aufwand','project_aktuelle_lp',
+  'project_tags','project_lph','project_assign','project_aufwand','project_aktuelle_lp',
+  'project_beauftragte_lph',
+  'project_gewerke',
   'project_plan','plan_people','plan_todos','plan_todo_assignees','plan_todo_deps',
-  'plan_milestones','plan_milestone_deps','people','person_roles','person_absences'];
+  'plan_milestones','plan_milestone_deps',
+  'project_protokolle','protokoll_teilnehmer','protokoll_punkte'];
 
 // dbTableColumns: liefert die Spaltennamen einer Tabelle (funktioniert gegen
 // jede DatabaseSync-Instanz, auch read-only Backups) via pragma_table_info.
@@ -971,7 +1256,12 @@ function dbTableColumns(conn, table){
 
 // IMPORT_OPTIONAL_COLS: Spalten, die in älteren Backups fehlen dürfen (sie
 // werden beim Import mit dem Default-Wert der Live-Tabelle neu belegt).
-const IMPORT_OPTIONAL_COLS = ['updated_at'];
+// Die Liste muss mitwachsen, wenn Spalten ergänzt werden — sonst ist
+// ausgerechnet das automatische Backup, das unmittelbar VOR einer
+// Wiederherstellung geschrieben wird, nach einem Versionssprung nicht mehr
+// einspielbar.
+const IMPORT_OPTIONAL_COLS = ['updated_at', 'project_uid', 'honorar', 'status_author', 'status_at',
+  'auftragsstatus', 'groesse', 'besprochen'];
 
 // restoreDbFromBackup: validiert die Backup-Datei (muss das bekannte Schema
 // mit identischen Spalten wie die Live-DB besitzen) und ersetzt den
@@ -993,9 +1283,13 @@ function restoreDbFromBackup(backupPath){
     }
 
     // 2) Datentransfer: Backup anbinden, Bestand löschen, Snapshot übernehmen.
-    db.exec(`ATTACH DATABASE '${String(backupPath).replace(/'/g, "''")}' AS import_backup`);
-    db.exec('BEGIN');
+    // ATTACH und BEGIN stehen INNERHALB des try: Bricht BEGIN ab (z. B. weil
+    // noch eine Transaktion offen ist), muss das finally trotzdem abhängen —
+    // sonst bliebe import_backup dauerhaft gebunden und jeder weitere Import
+    // scheiterte bis zum Serverneustart.
     try {
+      db.exec(`ATTACH DATABASE '${String(backupPath).replace(/'/g, "''")}' AS import_backup`);
+      db.exec('BEGIN');
       IMPORT_TABLES.forEach(t => db.exec('DELETE FROM ' + t));
       for(const t of IMPORT_TABLES){
         const liveCols = dbTableColumns(db, t);
@@ -1013,10 +1307,13 @@ function restoreDbFromBackup(backupPath){
       }
       db.exec('COMMIT');
     } catch(err){
-      db.exec('ROLLBACK');
+      // Beide Aufräumschritte dürfen den ursprünglichen Fehler nicht
+      // verdecken: Scheiterte schon ATTACH, gibt es weder Transaktion noch
+      // angehängte Datenbank, und ROLLBACK/DETACH würden ihrerseits werfen.
+      try { db.exec('ROLLBACK'); } catch(e){ /* keine offene Transaktion */ }
       throw err;
     } finally {
-      db.exec('DETACH DATABASE import_backup');
+      try { db.exec('DETACH DATABASE import_backup'); } catch(e){ /* nie angehängt */ }
     }
   } finally {
     backupConn.close();
@@ -1157,7 +1454,7 @@ function migrateLegacySchema(){
       let week;
       try { week = JSON.parse(row.data); } catch(e){ console.error('Kaputte Woche bei Migration:', row.label, e.message); return; }
       if(!week || !week.label) return;
-      serializeWeek(row.department, week);
+      serializeWeek(week);
     });
     // Globale Personen aus dem alten Dokument-Format migrieren. serializeGlobalPeople
     // startet selbst eine Transaktion, daher werden die Zeilen hier direkt in die
@@ -1196,15 +1493,1539 @@ function migrateWeeksUpdatedAt(){
   }
 }
 
+// migrateRemoveDepartmentPartition: löst die bisherige Abteilungs-
+// Partitionierung (ELT/HLS/ARCH als getrennte Wochen-/Projekt-Reihen) auf.
+// Idempotent (Guard: `weeks` hat noch eine `department`-Spalte). Zweistufig:
+// (1) Wochen mit gleichem Label aus verschiedenen Ex-Abteilungen werden zu
+//     einer globalen Woche zusammengeführt (week_people/-roles/attendance
+//     ebenfalls vereinigt).
+// (2) Innerhalb jeder Woche werden Projekte mit gleicher, nicht-leerer `nr`
+//     aus verschiedenen Ex-Abteilungen zu EINEM Projekt verschmolzen
+//     (bestätigt vom Nutzer: es handelt sich um dieselben realen Bauprojekte,
+//     die bisher getrennt je Gewerk geführt wurden) — inkl. Team, Leistungs-
+//     phasen, Gantt/TODOs. Jede beteiligte Ex-Abteilung wird zum Tag
+//     (project_tags). Konflikte (abweichende Namen/Werte) werden mit
+//     deterministischer Präzedenz ELT→HLS→ARCH aufgelöst und vollständig
+//     protokolliert, niemals still verworfen.
+function migrateRemoveDepartmentPartition(){
+  const weeksCols = db.prepare("SELECT name FROM pragma_table_info('weeks')").all().map(r => r.name);
+  if(!weeksCols.includes('department')) return; // bereits migriert oder frische DB
+
+  console.log('Migriere: Abteilungs-Partitionierung wird entfernt (Wochen und gleichnummerige Projekte werden zusammengeführt) …');
+
+  // Zusätzlicher, eigens benannter Sicherheits-Schnappschuss VOR jeder
+  // Änderung (zusätzlich zum regulären Auto-Backup, das erst NACH dem
+  // Serverstart läuft) — falls je eine manuelle Wiederherstellung nötig wird.
+  try {
+    if(!fs.existsSync(BACKUP_DIR)) fs.mkdirSync(BACKUP_DIR, { recursive: true });
+    const snapshotPath = path.join(BACKUP_DIR, 'pre-department-migration-' + new Date().toISOString().replace(/[:.]/g, '-') + '.db');
+    createDbSnapshot(snapshotPath);
+    console.log('Vor-Migrations-Snapshot gespeichert:', snapshotPath);
+  } catch(err){
+    console.error('Vor-Migrations-Snapshot fehlgeschlagen (Migration wird trotzdem fortgesetzt):', err.message);
+  }
+
+  const DEPT_ORDER = ['ELT', 'HLS', 'ARCH'];
+  const deptRank = (d) => { const i = DEPT_ORDER.indexOf(d); return i === -1 ? DEPT_ORDER.length : i; };
+  const conflicts = [];
+
+  db.exec('BEGIN');
+  try {
+    // ---------- Stufe 1: Wochen zusammenführen (nach label) ----------
+    db.exec(`CREATE TABLE weeks_new (
+      label TEXT NOT NULL, week_id TEXT NOT NULL DEFAULT '', date TEXT NOT NULL DEFAULT '',
+      locked INTEGER NOT NULL DEFAULT 0, updated_at TEXT NOT NULL DEFAULT '', PRIMARY KEY (label)
+    )`);
+    const labels = db.prepare('SELECT DISTINCT label FROM weeks').all().map(r => r.label);
+    const insWeekNew = db.prepare('INSERT INTO weeks_new (label, week_id, date, locked, updated_at) VALUES (?,?,?,?,?)');
+    labels.forEach(label => {
+      const rows = db.prepare('SELECT * FROM weeks WHERE label = ?').all(label)
+        .sort((a, b) => deptRank(a.department) - deptRank(b.department));
+      if(rows.length > 1){
+        conflicts.push(`Woche "${label}": ${rows.length} Abteilungs-Kopien zusammengeführt (${rows.map(r => r.department + '=' + r.date).join(', ')}).`);
+      }
+      const canonical = rows[0];
+      const maxUpdatedAt = rows.map(r => r.updated_at || '').sort().slice(-1)[0] || '';
+      insWeekNew.run(label, canonical.week_id, canonical.date, canonical.locked, maxUpdatedAt);
+    });
+    db.exec('DROP TABLE weeks');
+    db.exec('ALTER TABLE weeks_new RENAME TO weeks');
+
+    // week_people: bei gleicher (week_label,person_id) aus mehreren
+    // Ex-Abteilungen gewinnt die Präzedenz-Reihenfolge.
+    db.exec(`CREATE TABLE week_people_new (
+      week_label TEXT NOT NULL, person_id TEXT NOT NULL, name TEXT NOT NULL DEFAULT '',
+      full_name TEXT NOT NULL DEFAULT '', array_order INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (week_label, person_id)
+    )`);
+    {
+      const wpInsert = db.prepare('INSERT INTO week_people_new (week_label,person_id,name,full_name,array_order) VALUES (?,?,?,?,?)');
+      const seen = new Set();
+      db.prepare('SELECT * FROM week_people').all()
+        .sort((a, b) => deptRank(a.department) - deptRank(b.department) || a.array_order - b.array_order)
+        .forEach(r => {
+          const key = r.week_label + '|' + r.person_id;
+          if(seen.has(key)){
+            conflicts.push(`week_people ${r.week_label}/${r.person_id}: Duplikat aus ${r.department} verworfen (Erst-Eintrag gewinnt).`);
+            return;
+          }
+          seen.add(key);
+          wpInsert.run(r.week_label, r.person_id, r.name, r.full_name, r.array_order);
+        });
+    }
+    db.exec('DROP TABLE week_people');
+    db.exec('ALTER TABLE week_people_new RENAME TO week_people');
+
+    // week_people_roles: reine Mengenvereinigung, keine Konflikte möglich
+    // (gleiche Rolle mehrfach ist harmlos, INSERT OR IGNORE übernimmt das).
+    db.exec(`CREATE TABLE week_people_roles_new (
+      week_label TEXT NOT NULL, person_id TEXT NOT NULL, role TEXT NOT NULL,
+      role_order INTEGER NOT NULL DEFAULT 0, PRIMARY KEY (week_label, person_id, role)
+    )`);
+    db.exec(`INSERT OR IGNORE INTO week_people_roles_new (week_label,person_id,role,role_order)
+      SELECT week_label,person_id,role,role_order FROM week_people_roles`);
+    db.exec('DROP TABLE week_people_roles');
+    db.exec('ALTER TABLE week_people_roles_new RENAME TO week_people_roles');
+
+    // attendance: bei widersprüchlicher Anwesenheit gewinnt die Präzedenz.
+    db.exec(`CREATE TABLE attendance_new (
+      week_label TEXT NOT NULL, person_id TEXT NOT NULL, present INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (week_label, person_id)
+    )`);
+    {
+      const attInsert = db.prepare('INSERT INTO attendance_new (week_label,person_id,present) VALUES (?,?,?)');
+      const seen = new Map();
+      db.prepare('SELECT * FROM attendance').all()
+        .sort((a, b) => deptRank(a.department) - deptRank(b.department))
+        .forEach(r => {
+          const key = r.week_label + '|' + r.person_id;
+          if(seen.has(key)){
+            if(seen.get(key) !== r.present){
+              conflicts.push(`attendance ${r.week_label}/${r.person_id}: widersprüchliche Anwesenheit (${r.department}=${r.present}) verworfen, Erst-Eintrag gewinnt.`);
+            }
+            return;
+          }
+          seen.set(key, r.present);
+          attInsert.run(r.week_label, r.person_id, r.present);
+        });
+    }
+    db.exec('DROP TABLE attendance');
+    db.exec('ALTER TABLE attendance_new RENAME TO attendance');
+
+    // ---------- Stufe 2: Projekte je Woche nach `nr` zusammenführen ----------
+    db.exec(`CREATE TABLE projects_new (
+      week_label TEXT NOT NULL, project_id TEXT NOT NULL, nr TEXT NOT NULL DEFAULT '',
+      name TEXT NOT NULL DEFAULT '', status TEXT NOT NULL DEFAULT '', "group" TEXT NOT NULL DEFAULT '',
+      array_order INTEGER NOT NULL DEFAULT 0, order_value INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (week_label, project_id)
+    )`);
+    db.exec(`CREATE TABLE IF NOT EXISTS project_tags (
+      week_label TEXT NOT NULL, project_id TEXT NOT NULL, tag TEXT NOT NULL,
+      tag_order INTEGER NOT NULL DEFAULT 0, PRIMARY KEY (week_label, project_id, tag)
+    )`);
+
+    // Gruppierung: gleiche (week_label,nr) mit nicht-leerer nr gehören
+    // zusammen; jede Zeile mit leerer nr bildet ihre eigene Einzel-Gruppe
+    // (nichts zum Abgleichen vorhanden, bleibt eigenständig).
+    const groups = new Map();
+    let soloCounter = 0;
+    db.prepare('SELECT * FROM projects').all().forEach(r => {
+      const groupKey = (r.nr && r.nr.trim() !== '')
+        ? r.week_label + '|nr:' + r.nr
+        : r.week_label + '|solo:' + (soloCounter++);
+      if(!groups.has(groupKey)) groups.set(groupKey, []);
+      groups.get(groupKey).push(r);
+    });
+
+    const insProjectNew = db.prepare(`INSERT INTO projects_new (week_label,project_id,nr,name,status,"group",array_order,order_value)
+      VALUES (?,?,?,?,?,?,?,?)`);
+    const insTagNew = db.prepare('INSERT OR IGNORE INTO project_tags (week_label,project_id,tag,tag_order) VALUES (?,?,?,?)');
+    // projectIdMap: alter Schlüssel "department|week_label|project_id" -> neue
+    // (überlebende) project_id innerhalb derselben week_label.
+    const projectIdMap = new Map();
+
+    groups.forEach(rawRows => {
+      const rows = rawRows.slice().sort((a, b) => deptRank(a.department) - deptRank(b.department));
+      const survivor = rows[0];
+      const weekLabel = survivor.week_label;
+      const newProjectId = survivor.project_id;
+
+      rows.forEach(r => projectIdMap.set(r.department + '|' + r.week_label + '|' + r.project_id, newProjectId));
+
+      if(rows.length > 1){
+        if(new Set(rows.map(r => r.name)).size > 1){
+          conflicts.push(`Projekt ${survivor.nr} (${weekLabel}): unterschiedliche Namen zusammengeführt (${rows.map(r => r.department + '="' + r.name + '"').join(', ')}), "${survivor.name}" übernommen.`);
+        }
+        if(new Set(rows.map(r => r.group)).size > 1){
+          conflicts.push(`Projekt ${survivor.nr} (${weekLabel}): unterschiedliche Gruppen (${rows.map(r => r.department + '="' + r.group + '"').join(', ')}), "${survivor.group}" übernommen.`);
+        }
+      }
+      // Status (freier Text): alle nicht-leeren Texte mit Abteilungs-Präfix
+      // zusammenführen statt einen zu verwerfen — kein Informationsverlust.
+      // Identischer Text aus mehreren Abteilungen (z. B. eine gemeinsame
+      // Besprechungsnotiz) wird dedupliziert statt wortgleich doppelt gezeigt.
+      const statusByText = new Map();
+      rows.forEach(r => {
+        const t = (r.status || '').trim();
+        if(!t) return;
+        if(!statusByText.has(t)) statusByText.set(t, []);
+        statusByText.get(t).push(r.department);
+      });
+      const mergedStatus = Array.from(statusByText.entries())
+        .map(([text, depts]) => `[${depts.join('+')}] ${text}`)
+        .join(' | ');
+
+      insProjectNew.run(weekLabel, newProjectId, survivor.nr, survivor.name, mergedStatus, survivor.group, survivor.array_order, survivor.order_value);
+
+      Array.from(new Set(rows.map(r => r.department))).forEach((d, idx) => insTagNew.run(weekLabel, newProjectId, d, idx));
+    });
+    db.exec('DROP TABLE projects');
+    db.exec('ALTER TABLE projects_new RENAME TO projects');
+
+    // mapProjectId: löst für eine alte (department,week_label,project_id) die
+    // neue (verschmolzene) project_id auf. Fällt auf die alte ID zurück, falls
+    // aus irgendeinem Grund kein Mapping existiert (sollte nie vorkommen, da
+    // JEDE alte projects-Zeile oben ein Mapping bekommen hat).
+    function mapProjectId(department, weekLabel, projectId){
+      return projectIdMap.get(department + '|' + weekLabel + '|' + projectId) || projectId;
+    }
+
+    // project_lph: Vereinigung je (week_label,neue_project_id,lph); bei
+    // widersprüchlichen Werten gewinnt das Maximum (weiter fortgeschrittene
+    // Abteilung bestimmt den gemeinsamen Fortschritt dieser Leistungsphase).
+    db.exec(`CREATE TABLE project_lph_new (
+      week_label TEXT NOT NULL, project_id TEXT NOT NULL, lph TEXT NOT NULL,
+      value TEXT NOT NULL DEFAULT '', PRIMARY KEY (week_label, project_id, lph)
+    )`);
+    {
+      const merged = new Map();
+      db.prepare('SELECT * FROM project_lph').all()
+        .sort((a, b) => deptRank(a.department) - deptRank(b.department))
+        .forEach(r => {
+          const newPid = mapProjectId(r.department, r.week_label, r.project_id);
+          const key = r.week_label + '|' + newPid + '|' + r.lph;
+          const existing = merged.get(key);
+          if(existing){
+            if(existing.value !== r.value){
+              const a = Number(existing.value), b = Number(r.value);
+              const winner = (!isNaN(a) && !isNaN(b)) ? (b > a ? r.value : existing.value) : existing.value;
+              conflicts.push(`project_lph ${r.week_label}/${newPid}/LP${r.lph}: unterschiedliche Werte (${existing.value} vs ${r.value}) — Maximum "${winner}" übernommen.`);
+              existing.value = winner;
+            }
+            return;
+          }
+          merged.set(key, { weekLabel: r.week_label, projectId: newPid, lph: r.lph, value: r.value });
+        });
+      const ins = db.prepare('INSERT INTO project_lph_new (week_label,project_id,lph,value) VALUES (?,?,?,?)');
+      merged.forEach(v => ins.run(v.weekLabel, v.projectId, v.lph, v.value));
+    }
+    db.exec('DROP TABLE project_lph');
+    db.exec('ALTER TABLE project_lph_new RENAME TO project_lph');
+
+    // project_assign: Vereinigung je (week_label,neue_project_id,person_id,role);
+    // bei widersprüchlichem Status (0/1/2) gewinnt das Maximum.
+    db.exec(`CREATE TABLE project_assign_new (
+      week_label TEXT NOT NULL, project_id TEXT NOT NULL, person_id TEXT NOT NULL,
+      role TEXT NOT NULL DEFAULT '', state INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (week_label, project_id, person_id, role)
+    )`);
+    {
+      const merged = new Map();
+      db.prepare('SELECT * FROM project_assign').all()
+        .sort((a, b) => deptRank(a.department) - deptRank(b.department))
+        .forEach(r => {
+          const newPid = mapProjectId(r.department, r.week_label, r.project_id);
+          const key = r.week_label + '|' + newPid + '|' + r.person_id + '|' + r.role;
+          const existing = merged.get(key);
+          if(existing){
+            if(existing.state !== r.state){
+              const winner = Math.max(existing.state, r.state);
+              conflicts.push(`project_assign ${r.week_label}/${newPid}/${r.person_id}|${r.role}: unterschiedlicher Status (${existing.state} vs ${r.state}) — Maximum ${winner} übernommen.`);
+              existing.state = winner;
+            }
+            return;
+          }
+          merged.set(key, { weekLabel: r.week_label, projectId: newPid, personId: r.person_id, role: r.role, state: r.state });
+        });
+      const ins = db.prepare('INSERT INTO project_assign_new (week_label,project_id,person_id,role,state) VALUES (?,?,?,?,?)');
+      merged.forEach(v => ins.run(v.weekLabel, v.projectId, v.personId, v.role, v.state));
+    }
+    db.exec('DROP TABLE project_assign');
+    db.exec('ALTER TABLE project_assign_new RENAME TO project_assign');
+
+    // project_aufwand: Vereinigung je (week_label,neue_project_id,lph,role);
+    // bei Widerspruch gewinnt die Präzedenz (Gewichtungsfaktoren sind eher
+    // Konfiguration als Fortschritt, kein "Maximum" sinnvoll).
+    db.exec(`CREATE TABLE project_aufwand_new (
+      week_label TEXT NOT NULL, project_id TEXT NOT NULL, lph TEXT NOT NULL,
+      role TEXT NOT NULL DEFAULT '', value REAL NOT NULL DEFAULT 0,
+      PRIMARY KEY (week_label, project_id, lph, role)
+    )`);
+    {
+      const merged = new Map();
+      db.prepare('SELECT * FROM project_aufwand').all()
+        .sort((a, b) => deptRank(a.department) - deptRank(b.department))
+        .forEach(r => {
+          const newPid = mapProjectId(r.department, r.week_label, r.project_id);
+          const key = r.week_label + '|' + newPid + '|' + r.lph + '|' + r.role;
+          const existing = merged.get(key);
+          if(existing){
+            if(existing.value !== r.value){
+              conflicts.push(`project_aufwand ${r.week_label}/${newPid}/LP${r.lph}/${r.role}: unterschiedliche Werte (${existing.value} vs ${r.value}) — erster Wert (${existing.value}) übernommen.`);
+            }
+            return;
+          }
+          merged.set(key, { weekLabel: r.week_label, projectId: newPid, lph: r.lph, role: r.role, value: r.value });
+        });
+      const ins = db.prepare('INSERT INTO project_aufwand_new (week_label,project_id,lph,role,value) VALUES (?,?,?,?,?)');
+      merged.forEach(v => ins.run(v.weekLabel, v.projectId, v.lph, v.role, v.value));
+    }
+    db.exec('DROP TABLE project_aufwand');
+    db.exec('ALTER TABLE project_aufwand_new RENAME TO project_aufwand');
+
+    // project_aktuelle_lp: reine Mengenvereinigung (ein Projekt kann jetzt
+    // mehrere gleichzeitig aktive Leistungsphasen zeigen — gewollt).
+    db.exec(`CREATE TABLE project_aktuelle_lp_new (
+      week_label TEXT NOT NULL, project_id TEXT NOT NULL, lph TEXT NOT NULL,
+      PRIMARY KEY (week_label, project_id, lph)
+    )`);
+    {
+      const ins = db.prepare('INSERT OR IGNORE INTO project_aktuelle_lp_new (week_label,project_id,lph) VALUES (?,?,?)');
+      db.prepare('SELECT * FROM project_aktuelle_lp').all().forEach(r => {
+        ins.run(r.week_label, mapProjectId(r.department, r.week_label, r.project_id), r.lph);
+      });
+    }
+    db.exec('DROP TABLE project_aktuelle_lp');
+    db.exec('ALTER TABLE project_aktuelle_lp_new RENAME TO project_aktuelle_lp');
+
+    // project_plan (Gantt-Rahmen je Projekt): start = frühester, end =
+    // spätester Termin (gemeinsame Zeitspanne beider Arbeitsanteile);
+    // progress-Widerspruch -> Maximum.
+    db.exec(`CREATE TABLE project_plan_new (
+      week_label TEXT NOT NULL, project_id TEXT NOT NULL, start TEXT NOT NULL DEFAULT '',
+      end TEXT NOT NULL DEFAULT '', progress INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (week_label, project_id)
+    )`);
+    {
+      const merged = new Map();
+      db.prepare('SELECT * FROM project_plan').all()
+        .sort((a, b) => deptRank(a.department) - deptRank(b.department))
+        .forEach(r => {
+          const newPid = mapProjectId(r.department, r.week_label, r.project_id);
+          const key = r.week_label + '|' + newPid;
+          const existing = merged.get(key);
+          if(existing){
+            if(r.start && (!existing.start || r.start < existing.start)) existing.start = r.start;
+            if(r.end && (!existing.end || r.end > existing.end)) existing.end = r.end;
+            if(existing.progress !== r.progress){
+              const winner = Math.max(existing.progress, r.progress);
+              conflicts.push(`project_plan ${r.week_label}/${newPid}: unterschiedlicher Fortschritt (${existing.progress}% vs ${r.progress}%) — Maximum ${winner}% übernommen.`);
+              existing.progress = winner;
+            }
+            return;
+          }
+          merged.set(key, { weekLabel: r.week_label, projectId: newPid, start: r.start, end: r.end, progress: r.progress });
+        });
+      const ins = db.prepare('INSERT INTO project_plan_new (week_label,project_id,start,end,progress) VALUES (?,?,?,?,?)');
+      merged.forEach(v => ins.run(v.weekLabel, v.projectId, v.start, v.end, v.progress));
+    }
+    db.exec('DROP TABLE project_plan');
+    db.exec('ALTER TABLE project_plan_new RENAME TO project_plan');
+
+    // plan_people: reine Mengenvereinigung.
+    db.exec(`CREATE TABLE plan_people_new (
+      week_label TEXT NOT NULL, project_id TEXT NOT NULL, person_id TEXT NOT NULL,
+      array_order INTEGER NOT NULL DEFAULT 0, PRIMARY KEY (week_label, project_id, person_id)
+    )`);
+    {
+      const ins = db.prepare('INSERT OR IGNORE INTO plan_people_new (week_label,project_id,person_id,array_order) VALUES (?,?,?,?)');
+      db.prepare('SELECT * FROM plan_people ORDER BY array_order').all().forEach(r => {
+        ins.run(r.week_label, mapProjectId(r.department, r.week_label, r.project_id), r.person_id, r.array_order);
+      });
+    }
+    db.exec('DROP TABLE plan_people');
+    db.exec('ALTER TABLE plan_people_new RENAME TO plan_people');
+
+    // plan_todos / plan_todo_assignees / plan_todo_deps / plan_milestones /
+    // plan_milestone_deps: todo_id/milestone_id sind zufällige uid()-Strings,
+    // daher praktisch kein Kollisionsrisiko — reines Umhängen auf die neue
+    // project_id (das Gantt/TODO des vereinten Projekts zeigt danach schlicht
+    // die Aufgaben aller beteiligten Abteilungen zusammen).
+    db.exec(`CREATE TABLE plan_todos_new (
+      week_label TEXT NOT NULL, project_id TEXT NOT NULL, todo_id TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT '', start TEXT NOT NULL DEFAULT '', end TEXT NOT NULL DEFAULT '',
+      done INTEGER NOT NULL DEFAULT 0, progress INTEGER NOT NULL DEFAULT 0, sort_order INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (week_label, project_id, todo_id)
+    )`);
+    {
+      const ins = db.prepare(`INSERT OR IGNORE INTO plan_todos_new (week_label,project_id,todo_id,title,start,end,done,progress,sort_order) VALUES (?,?,?,?,?,?,?,?,?)`);
+      db.prepare('SELECT * FROM plan_todos ORDER BY sort_order').all().forEach(r => {
+        ins.run(r.week_label, mapProjectId(r.department, r.week_label, r.project_id), r.todo_id, r.title, r.start, r.end, r.done, r.progress, r.sort_order);
+      });
+    }
+    db.exec('DROP TABLE plan_todos');
+    db.exec('ALTER TABLE plan_todos_new RENAME TO plan_todos');
+
+    db.exec(`CREATE TABLE plan_todo_assignees_new (
+      week_label TEXT NOT NULL, project_id TEXT NOT NULL, todo_id TEXT NOT NULL, person_id TEXT NOT NULL,
+      PRIMARY KEY (week_label, project_id, todo_id, person_id)
+    )`);
+    {
+      const ins = db.prepare('INSERT OR IGNORE INTO plan_todo_assignees_new (week_label,project_id,todo_id,person_id) VALUES (?,?,?,?)');
+      db.prepare('SELECT * FROM plan_todo_assignees').all().forEach(r => {
+        ins.run(r.week_label, mapProjectId(r.department, r.week_label, r.project_id), r.todo_id, r.person_id);
+      });
+    }
+    db.exec('DROP TABLE plan_todo_assignees');
+    db.exec('ALTER TABLE plan_todo_assignees_new RENAME TO plan_todo_assignees');
+
+    db.exec(`CREATE TABLE plan_todo_deps_new (
+      week_label TEXT NOT NULL, project_id TEXT NOT NULL, todo_id TEXT NOT NULL, depends_on_id TEXT NOT NULL,
+      PRIMARY KEY (week_label, project_id, todo_id, depends_on_id)
+    )`);
+    {
+      const ins = db.prepare('INSERT OR IGNORE INTO plan_todo_deps_new (week_label,project_id,todo_id,depends_on_id) VALUES (?,?,?,?)');
+      db.prepare('SELECT * FROM plan_todo_deps').all().forEach(r => {
+        ins.run(r.week_label, mapProjectId(r.department, r.week_label, r.project_id), r.todo_id, r.depends_on_id);
+      });
+    }
+    db.exec('DROP TABLE plan_todo_deps');
+    db.exec('ALTER TABLE plan_todo_deps_new RENAME TO plan_todo_deps');
+
+    db.exec(`CREATE TABLE plan_milestones_new (
+      week_label TEXT NOT NULL, project_id TEXT NOT NULL, milestone_id TEXT NOT NULL,
+      name TEXT NOT NULL DEFAULT '', date TEXT NOT NULL DEFAULT '', position TEXT NOT NULL DEFAULT '',
+      sort_order INTEGER NOT NULL DEFAULT 0, PRIMARY KEY (week_label, project_id, milestone_id)
+    )`);
+    {
+      const ins = db.prepare(`INSERT OR IGNORE INTO plan_milestones_new (week_label,project_id,milestone_id,name,date,position,sort_order) VALUES (?,?,?,?,?,?,?)`);
+      db.prepare('SELECT * FROM plan_milestones ORDER BY sort_order').all().forEach(r => {
+        ins.run(r.week_label, mapProjectId(r.department, r.week_label, r.project_id), r.milestone_id, r.name, r.date, r.position, r.sort_order);
+      });
+    }
+    db.exec('DROP TABLE plan_milestones');
+    db.exec('ALTER TABLE plan_milestones_new RENAME TO plan_milestones');
+
+    db.exec(`CREATE TABLE plan_milestone_deps_new (
+      week_label TEXT NOT NULL, project_id TEXT NOT NULL, milestone_id TEXT NOT NULL, depends_on_id TEXT NOT NULL,
+      PRIMARY KEY (week_label, project_id, milestone_id, depends_on_id)
+    )`);
+    {
+      const ins = db.prepare('INSERT OR IGNORE INTO plan_milestone_deps_new (week_label,project_id,milestone_id,depends_on_id) VALUES (?,?,?,?)');
+      db.prepare('SELECT * FROM plan_milestone_deps').all().forEach(r => {
+        ins.run(r.week_label, mapProjectId(r.department, r.week_label, r.project_id), r.milestone_id, r.depends_on_id);
+      });
+    }
+    db.exec('DROP TABLE plan_milestone_deps');
+    db.exec('ALTER TABLE plan_milestone_deps_new RENAME TO plan_milestone_deps');
+
+    // project_files: department-Spalte entfernen (jetzt korrekt über
+    // project_nr allein identifiziert, da gleichnummerige Projekte ab jetzt
+    // als EIN Projekt gelten). Physische Dateien lagen bisher unter
+    // sessions/uploads/<department>/<datei>, künftig flach unter
+    // sessions/uploads/<datei> — best-effort verschoben (Tabelle ist aktuell
+    // in der Praxis leer, dieser Pfad daher selten).
+    const pfCols = db.prepare("SELECT name FROM pragma_table_info('project_files')").all().map(r => r.name);
+    if(pfCols.includes('department')){
+      db.exec(`CREATE TABLE project_files_new (
+        id TEXT PRIMARY KEY, project_nr TEXT NOT NULL, project_name TEXT NOT NULL DEFAULT '',
+        original_filename TEXT NOT NULL, stored_name TEXT NOT NULL,
+        content_type TEXT NOT NULL DEFAULT 'application/octet-stream', size_bytes INTEGER NOT NULL DEFAULT 0,
+        uploaded_by_user_id INTEGER NOT NULL, status TEXT NOT NULL DEFAULT 'pending',
+        created_at TEXT NOT NULL DEFAULT '', updated_at TEXT NOT NULL DEFAULT ''
+      )`);
+      db.exec(`INSERT INTO project_files_new (id,project_nr,project_name,original_filename,stored_name,content_type,size_bytes,uploaded_by_user_id,status,created_at,updated_at)
+        SELECT id,project_nr,project_name,original_filename,stored_name,content_type,size_bytes,uploaded_by_user_id,status,created_at,updated_at FROM project_files`);
+      const oldFileRows = db.prepare('SELECT id, department, stored_name FROM project_files').all();
+      db.exec('DROP TABLE project_files');
+      db.exec('ALTER TABLE project_files_new RENAME TO project_files');
+      db.exec('DROP INDEX IF EXISTS idx_project_files_scope');
+      db.exec('CREATE INDEX idx_project_files_scope ON project_files(project_nr)');
+      oldFileRows.forEach(r => {
+        try {
+          const oldPath = path.join(SESSIONS_DIR, 'uploads', r.department, r.stored_name);
+          const newPath = path.join(SESSIONS_DIR, 'uploads', r.stored_name);
+          if(fs.existsSync(oldPath) && !fs.existsSync(newPath)) fs.renameSync(oldPath, newPath);
+        } catch(err){
+          conflicts.push(`project_files ${r.id}: physische Datei konnte nicht verschoben werden (${err.message}).`);
+        }
+      });
+    }
+
+    db.exec('COMMIT');
+    console.log(`Migration abgeschlossen. ${conflicts.length} Konflikt(e)/Hinweis(e) protokolliert:`);
+    conflicts.forEach(c => console.log('  - ' + c));
+  } catch(err){
+    db.exec('ROLLBACK');
+    console.error('Department-Migration fehlgeschlagen, Datenbank unverändert:', err);
+    throw err;
+  }
+}
+
+// migrateAddProjectUid: vergibt jeder projects-Zeile eine dauerhafte,
+// wochenunabhängige project_uid (Basis für echte Projekt-Historie über
+// mehrere Sitzungen hinweg, siehe "Projekt-Historie"-Architekturnotiz).
+// Anders als project_id (wird bei jedem cloneWeek() neu vergeben, siehe
+// js/weeks.js) und nr (informell stabil, aber änderbar/leer möglich) wird
+// project_uid einmal bei echter Projekt-Entstehung erzeugt
+// (saveNewProj()/demoProj()) und danach nie wieder verändert — cloneWeek()
+// kopiert sie unverändert mit. Läuft NACH migrateRemoveDepartmentPartition()
+// (setzt eine bereits globale, nicht mehr abteilungsgetrennte projects-
+// Tabelle voraus). Idempotent (Guard: Spalte existiert bereits).
+// migrateAddProjectBesprochen: rüstet die Spalte `besprochen` nach
+// (idempotentes ALTER TABLE, gleiches Muster wie migrateUsersDepartment()).
+// Bestandszeilen starten mit 0 — für vergangene Sitzungen ist der Haken
+// ohnehin bedeutungslos.
+function migrateAddProjectBesprochen(){
+  const cols = db.prepare("SELECT name FROM pragma_table_info('projects')").all().map(r => r.name);
+  if(!cols.includes('besprochen')){
+    db.exec('ALTER TABLE projects ADD COLUMN besprochen INTEGER NOT NULL DEFAULT 0');
+    console.log('Projekt-Tabelle um besprochen ergänzt.');
+  }
+}
+
+// migrateAddProjectGroesse: rüstet die Spalte `groesse` nach (idempotentes
+// ALTER TABLE, gleiches Muster wie migrateAddProjectBesprochen()).
+// Bestandszeilen starten mit 0 = keine Angabe; sie erscheinen in der
+// Auslastung als nicht bewertbar, bis jemand entweder ein Honorar oder eine
+// Größe pflegt. Absichtlich kein Vorgabewert wie 0,5: Eine erfundene Größe
+// erzeugte Zahlen, die nach Messung aussehen.
+// normalizeGroesse: Projektgröße auf den gültigen Bereich bringen.
+// Erlaubt ist 0 bis 1 (0 = keine Angabe, 1 = Projekt in Höhe des
+// Referenzhonorars). Unbrauchbare Werte werden zu 0 und damit zu einer
+// sichtbaren Lücke, nicht zu einer erfundenen Zahl.
+// Parameter: wert (beliebig). Rückgabe: Zahl zwischen 0 und 1.
+function normalizeGroesse(wert){
+  const n = Number(wert);
+  if(!Number.isFinite(n) || n <= 0) return 0;
+  return n > 1 ? 1 : n;
+}
+
+// migrateBackfillProjectGewerkeAusTags: setzt für Projekte OHNE jede
+// project_gewerke-Zeile das Gewerk aus dem Schlagwort, das
+// migrateRemoveDepartmentPartition() beim Zusammenführen der früheren
+// Abteilungs-Sitzungen automatisch als project_tags-Eintrag vergeben hat
+// (ELT/HLS/ARCH). Ohne diese Übernahme verschwände jedes Bestandsprojekt aus
+// jeder Gewerke-gefilterten Ansicht des Wochenberichts (berichtProjekte()),
+// weil project_gewerke — der Assistent "Neues Projekt" schreibt hierhin —
+// für alle vor dem Assistenten angelegten Projekte leer ist. Idempotent:
+// sobald ein Projekt mindestens eine project_gewerke-Zeile hat (egal woher,
+// auch aus dieser Migration selbst), wird es bei künftigen Läufen
+// übersprungen — eine spätere manuelle Korrektur in den Projekteinstellungen
+// wird also nicht rückgängig gemacht.
+function migrateBackfillProjectGewerkeAusTags(){
+  const kandidaten = db.prepare(`
+    SELECT DISTINCT pt.week_label, pt.project_id, pt.tag
+    FROM project_tags pt
+    WHERE pt.tag IN ('ELT','HLS','ARCH')
+      AND NOT EXISTS (
+        SELECT 1 FROM project_gewerke pg
+        WHERE pg.week_label = pt.week_label AND pg.project_id = pt.project_id
+      )
+  `).all();
+  if(!kandidaten.length) return;
+  const ins = db.prepare('INSERT OR IGNORE INTO project_gewerke (week_label, project_id, gewerk) VALUES (?,?,?)');
+  db.exec('BEGIN');
+  try {
+    kandidaten.forEach(r => ins.run(r.week_label, r.project_id, r.tag));
+    db.exec('COMMIT');
+    console.log('Gewerke aus Schlagwörtern übernommen:', kandidaten.length, 'Zuordnung(en).');
+  } catch(err){
+    db.exec('ROLLBACK');
+    console.error('Gewerke-Backfill aus Schlagwörtern fehlgeschlagen:', err.message);
+  }
+}
+
+function migrateAddProjectGroesse(){
+  const cols = db.prepare("SELECT name FROM pragma_table_info('projects')").all().map(r => r.name);
+  if(!cols.includes('groesse')){
+    db.exec('ALTER TABLE projects ADD COLUMN groesse REAL NOT NULL DEFAULT 0');
+    console.log('Projekt-Tabelle um groesse ergänzt.');
+  }
+}
+
+// migrateAddProjectUpdatedAt: rüstet die Spalte `updated_at` nach (idempotent,
+// gleiches ALTER-TABLE-Muster wie migrateAddProjectGroesse()). Gebraucht von
+// der Planung-Sandbox, siehe Spaltenkommentar am CREATE TABLE oben.
+function migrateAddProjectUpdatedAt(){
+  const cols = db.prepare("SELECT name FROM pragma_table_info('projects')").all().map(r => r.name);
+  if(!cols.includes('updated_at')){
+    db.exec("ALTER TABLE projects ADD COLUMN updated_at TEXT NOT NULL DEFAULT ''");
+    console.log('Projekt-Tabelle um updated_at ergänzt.');
+  }
+}
+
+// migrateAddProtokollQuelle: rüstet die beiden Spalten nach, die ein
+// importiertes Protokoll von einem manuell angelegten unterscheiden
+// (idempotent, gleiches Muster wie migrateAddProjectGroesse()). Beide
+// bleiben für ein manuell angelegtes Protokoll leer — siehe
+// legeProtokollAn() und CLAUDE.md "### Protokolle".
+function migrateAddProtokollQuelle(){
+  const cols = db.prepare("SELECT name FROM pragma_table_info('project_protokolle')").all().map(r => r.name);
+  if(!cols.includes('quelle_dateiname')){
+    db.exec("ALTER TABLE project_protokolle ADD COLUMN quelle_dateiname TEXT NOT NULL DEFAULT ''");
+    db.exec("ALTER TABLE project_protokolle ADD COLUMN quelle_stored_name TEXT NOT NULL DEFAULT ''");
+    console.log('Protokoll-Tabelle um Quelle-Spalten ergänzt.');
+  }
+}
+
+// migrateAddProtokollPunktErstelltAm: rüstet das Datum nach, an dem ein
+// Punkt zum ERSTEN Mal erfasst wurde (Erik's Wunsch) — bestehende Zeilen
+// bleiben leer, da ihr echtes Entstehungsdatum nicht mehr rekonstruierbar
+// ist (idempotent, gleiches Muster wie migrateAddProtokollQuelle()).
+function migrateAddProtokollPunktErstelltAm(){
+  const cols = db.prepare("SELECT name FROM pragma_table_info('protokoll_punkte')").all().map(r => r.name);
+  if(!cols.includes('erstellt_am')){
+    db.exec("ALTER TABLE protokoll_punkte ADD COLUMN erstellt_am TEXT NOT NULL DEFAULT ''");
+    console.log('Protokoll-Punkte-Tabelle um erstellt_am ergänzt.');
+  }
+}
+
+// migrateAddProtokollPunktStatus: löst das bisherige boolesche `erledigt`
+// in einen Status mit drei Werten auf (offen/erledigt/info, Eriks Wunsch
+// nach einem dritten Zustand für rein informative Punkte ohne eigene
+// Handlung). `erledigt` bleibt als Spalte bestehen und wird weiterhin
+// synchron mitgeschrieben (reine Rückwärtskompatibilität, z. B. für
+// IMPORT_TABLES-Restores älterer Backups) — maßgeblich für die Anwendung
+// ist ab hier ausschließlich `status`. Bestehende Zeilen werden anhand
+// ihres bisherigen `erledigt`-Werts befüllt, der ADD-COLUMN-Standardwert
+// 'offen' allein würde erledigte Altpunkte fälschlich wieder öffnen.
+function migrateAddProtokollPunktStatus(){
+  const cols = db.prepare("SELECT name FROM pragma_table_info('protokoll_punkte')").all().map(r => r.name);
+  if(!cols.includes('status')){
+    db.exec("ALTER TABLE protokoll_punkte ADD COLUMN status TEXT NOT NULL DEFAULT 'offen'");
+    db.exec("UPDATE protokoll_punkte SET status = 'erledigt' WHERE erledigt = 1");
+    console.log('Protokoll-Punkte-Tabelle um status ergänzt.');
+  }
+}
+
+// migrateAddProtokollPunktEntfaelltNaechstes: rüstet das Merkmal nach, das
+// einem erledigten Punkt EINE Gnadenrunde gibt (Eriks Wunsch): 'offen' und
+// 'info' laufen wie bisher unbegrenzt weiter, aber 'erledigt' soll nicht
+// sofort verschwinden, sondern genau einmal noch — als erledigt markiert,
+// zusätzlich mit einem Hinweis "entfällt im nächsten Protokoll" — im
+// nächsten Protokoll auftauchen und erst im übernächsten entfallen. Dieses
+// Flag steht NICHT auf dem Punkt, der gerade erledigt markiert wurde,
+// sondern wird erst von legeProtokollAn() auf die fortgeschriebene KOPIE
+// gesetzt, wenn ihre Quelle status='erledigt' hatte — siehe dort. Idempotent,
+// gleiches Muster wie migrateAddProtokollPunktStatus().
+function migrateAddProtokollPunktEntfaelltNaechstes(){
+  const cols = db.prepare("SELECT name FROM pragma_table_info('protokoll_punkte')").all().map(r => r.name);
+  if(!cols.includes('entfaellt_naechstes')){
+    db.exec("ALTER TABLE protokoll_punkte ADD COLUMN entfaellt_naechstes INTEGER NOT NULL DEFAULT 0");
+    console.log('Protokoll-Punkte-Tabelle um entfaellt_naechstes ergänzt.');
+  }
+}
+
+// ensureSandboxWeek: legt die reservierte `weeks`-Zeile für die Planung-
+// Sandbox einmalig an (INSERT OR IGNORE — beim zweiten und jedem weiteren
+// Start ist sie schon da). Kein echtes Datum, nie gesperrt. Alle Terminpläne
+// der Planung hängen an diesem einen `week_label`, siehe SANDBOX_WEEK_LABEL.
+function ensureSandboxWeek(){
+  db.prepare(`INSERT OR IGNORE INTO weeks (label, week_id, date, locked, updated_at)
+    VALUES (?, 'sandbox', '', 0, '')`).run(SANDBOX_WEEK_LABEL);
+}
+
+// getIsoWeekInfo: ISO-Kalenderwoche UND -Wochenjahr eines Datums (das
+// Wochenjahr kann an Jahresgrenzen vom Kalenderjahr abweichen — Silvester
+// kann in KW 1 des Folgejahres liegen). Portiert von getWeekNumber()
+// (public/js/utils.js) — reines, browserunabhängiges JS, hier um das
+// Wochenjahr erweitert, das für den Sitzungswechsel unten gebraucht wird.
+// Parameter: date (Date). Rückgabe: {week, year}.
+function getIsoWeekInfo(date){
+  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+  const dayNum = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+  const year = d.getUTCFullYear();
+  const yearStart = new Date(Date.UTC(year, 0, 1));
+  const week = Math.ceil((((d - yearStart) / 86400000) + 1) / 7);
+  return { week, year };
+}
+
+// formatWeekLabel: "KW <n zweistellig> / <JJJJ>" — das Format, das sowohl
+// validateWeekLabel()s Regex (früher public/js/weeks.js) als auch
+// weekSortKey()/weekSortKeyServer() erwarten.
+function formatWeekLabel(week, year){
+  return 'KW ' + String(week).padStart(2, '0') + ' / ' + year;
+}
+
+// ensureCurrentWeekRollover: legt automatisch eine neue Sitzung an, sobald
+// der Kalender in eine neue ISO-Woche gewechselt hat — unabhängig davon, ob
+// irgendjemand die Anwendung gerade nutzt (siehe CLAUDE.md, Abschnitt zum
+// automatischen Sitzungswechsel). Ersetzt die früheren, manuellen Knöpfe
+// "Neue Sitzung"/"Sitzung duplizieren" (public/js/weeks.js, entfernt).
+// Repliziert exakt das Rücksetzverhalten des früheren cloneWeek(): neue
+// week-/Projekt-ids, Kommentar/Verfasser/Zeitstempel/besprochen geleert,
+// alles andere (Beteiligte, Zuordnungen, Terminpläne, Honorar, beauftragte
+// Leistungsphasen, Gewerke, project_uid) bleibt unverändert erhalten. Sperrt
+// anschließend — sofern app_settings.autoLockAktiv aktiv ist — alle anderen
+// echten Sitzungen, dieselbe Invariante, die applyAutoLock() bisher nur
+// clientseitig durchsetzte. Ohne jede bestehende echte Sitzung (frische
+// Installation) wird stattdessen eine leere Sitzung angelegt (wie es früher
+// newWeek() tat), damit ein frisches System nicht für immer ohne jede
+// Sitzung dasteht. Fehler werden geloggt, nie geworfen — darf den
+// Serverbetrieb nie stören. Keine Parameter, keine Rückgabe.
+function ensureCurrentWeekRollover(){
+  try {
+    const echteWochen = loadWeeks().filter(w => w.label !== SANDBOX_WEEK_LABEL);
+    const { week, year } = getIsoWeekInfo(new Date());
+    const heuteKey = String(year) + '-' + String(week).padStart(2, '0');
+    const neuesLabel = formatWeekLabel(week, year);
+
+    let neueWoche;
+    if(echteWochen.length === 0){
+      // Frische Installation: keine Quelle zum Kopieren vorhanden.
+      neueWoche = {
+        id: crypto.randomUUID(), label: neuesLabel, date: heuteIsoLokal(),
+        people: loadGlobalPeople(), projects: [], attendance: {}, locked: false
+      };
+    } else {
+      const sortiert = echteWochen.slice()
+        .sort((a, b) => weekSortKeyServer(a.label).localeCompare(weekSortKeyServer(b.label)));
+      const letzte = sortiert[sortiert.length - 1];
+      const letzteKey = weekSortKeyServer(letzte.label);
+      if(heuteKey <= letzteKey) return; // schon auf dem Stand der aktuellen Kalenderwoche
+
+      neueWoche = JSON.parse(JSON.stringify(letzte));
+      neueWoche.id = crypto.randomUUID();
+      neueWoche.label = neuesLabel;
+      neueWoche.date = heuteIsoLokal();
+      neueWoche.attendance = {};
+      neueWoche.locked = false;
+      delete neueWoche.updatedAt;
+      (neueWoche.projects || []).forEach(p => {
+        p.id = crypto.randomUUID();
+        p.status = '';
+        p.statusAuthor = '';
+        p.statusAt = '';
+        p.besprochen = false;
+        delete p.statusState;
+      });
+    }
+
+    saveWeekRelational(neueWoche);
+    console.log('Automatischer Sitzungswechsel: neue Sitzung "' + neuesLabel + '" angelegt.');
+
+    if(Number(readAppSettings().autoLockAktiv)){
+      const nowIso = new Date().toISOString();
+      db.prepare(`UPDATE weeks SET locked = 1, updated_at = ?
+        WHERE label != ? AND label != ?`).run(nowIso, neuesLabel, SANDBOX_WEEK_LABEL);
+    }
+  } catch(err){
+    console.error('Automatischer Sitzungswechsel fehlgeschlagen:', err);
+  }
+}
+
+function migrateAddProjectUid(){
+  const cols = db.prepare("SELECT name FROM pragma_table_info('projects')").all().map(r => r.name);
+  if(!cols.includes('project_uid')){
+    db.exec("ALTER TABLE projects ADD COLUMN project_uid TEXT NOT NULL DEFAULT ''");
+  } else {
+    // Die Spalte allein genügt als Abschluss-Kennzeichen NICHT: Das ALTER
+    // TABLE läuft außerhalb der Transaktion, das Nachfüllen darin. Brach das
+    // Nachfüllen einmal ab (z. B. SQLITE_BUSY), existierte die Spalte, war
+    // aber überall leer — und jeder weitere Start übersprang die Migration.
+    // Die Projekt-Historie über Sitzungen hinweg wäre dauerhaft tot gewesen.
+    const offen = db.prepare("SELECT COUNT(*) AS c FROM projects WHERE project_uid = ''").get();
+    if(!offen || offen.c === 0) return; // wirklich fertig
+    console.log('Migriere: project_uid wird nachgefüllt (' + offen.c + ' Zeile(n) ohne Kennung) …');
+  }
+
+  // Backfill für Bestandsdaten: Zeilen mit gleicher, nicht-leerer nr über
+  // alle Wochen hinweg gelten als dasselbe reale Projekt und bekommen
+  // dieselbe uid. Zeilen ohne nr können nicht zusammengeführt werden (kein
+  // anderer stabiler Schlüssel vorhanden) und bekommen je eine eigene uid.
+  // Bekannte Grenze dieses einmaligen Rückblicks: eine in der Vergangenheit
+  // wiederverwendete nr (zwei echte Projekte) wird fälschlich zusammengeführt,
+  // eine mitten in der Historie geänderte nr wird fälschlich getrennt — ab
+  // dem Zeitpunkt dieser Migration tritt das Problem nicht mehr auf, da
+  // project_uid danach nie wieder aus nr neu berechnet wird.
+  const rows = db.prepare('SELECT week_label, project_id, nr, project_uid FROM projects').all();
+  const uidByNr = new Map();
+  // Bereits vergebene Kennungen als Vorgabe übernehmen: Beim Nachfüllen eines
+  // Teilbestands (siehe Guard oben) dürfen vorhandene Kennungen NICHT neu
+  // gewürfelt werden — sonst risse die Verbindung desselben Projekts über
+  // mehrere Sitzungen hinweg ab.
+  rows.forEach(r => {
+    const key = (r.nr || '').trim();
+    if(key && r.project_uid && !uidByNr.has(key)) uidByNr.set(key, r.project_uid);
+  });
+  const update = db.prepare('UPDATE projects SET project_uid = ? WHERE week_label = ? AND project_id = ?');
+
+  db.exec('BEGIN');
+  try {
+    rows.forEach(r => {
+      if(r.project_uid) return; // schon gesetzt, nicht anfassen
+      const key = (r.nr || '').trim();
+      let projectUid;
+      if(key){
+        if(!uidByNr.has(key)) uidByNr.set(key, crypto.randomUUID());
+        projectUid = uidByNr.get(key);
+      } else {
+        projectUid = crypto.randomUUID();
+      }
+      update.run(projectUid, r.week_label, r.project_id);
+    });
+    db.exec('COMMIT');
+  } catch(err){
+    db.exec('ROLLBACK');
+    console.error('project_uid-Migration fehlgeschlagen, Datenbank unverändert:', err);
+    throw err;
+  }
+  console.log(`project_uid vergeben: ${rows.length} Zeile(n), ${uidByNr.size} eindeutige Projekt-Historie(n) über nr gruppiert.`);
+}
+
+// migrateAddProjectHonorar: ergänzt die Spalte `honorar` in der Tabelle
+// `projects` (vereinbartes Netto-Honorar in Euro, Grundlage der
+// Honorar-Terminplanung). Idempotent, gleiches Muster wie
+// migrateWeeksUpdatedAt(). Bestandsprojekte bekommen 0 und gelten damit als
+// "kein Honorar hinterlegt" — die Honorar-Maske verlangt dann eine Eingabe,
+// bevor sie rechnet.
+function migrateAddProjectHonorar(){
+  const cols = db.prepare("SELECT name FROM pragma_table_info('projects')").all().map(r => r.name);
+  if(cols.includes('honorar')) return;
+  db.exec('ALTER TABLE projects ADD COLUMN honorar REAL NOT NULL DEFAULT 0');
+  console.log('Projekte-Tabelle um honorar ergänzt.');
+}
+
+// migrateAddProjectStatusAuthor: ergänzt die Spalten `status_author` und
+// `status_at` in der Tabelle `projects` — Verfasser (Anzeigename zum
+// Zeitpunkt des Schreibens) und Zeitstempel des Wochenkommentars. Bewusst
+// der Anzeigename und nicht die user_id: der Kommentar ist ein historischer
+// Eintrag, er soll auch nach dem Löschen oder Umbenennen eines Kontos noch
+// aussagen, wer ihn damals verfasst hat. Idempotent, gleiches Muster wie
+// migrateAddProjectHonorar(). Bestandskommentare bekommen leere Werte und
+// werden in der Oberfläche als "unbekannt" ausgewiesen — der Verfasser ist
+// rückwirkend nicht ermittelbar.
+function migrateAddProjectStatusAuthor(){
+  const cols = db.prepare("SELECT name FROM pragma_table_info('projects')").all().map(r => r.name);
+  if(cols.includes('status_author')) return;
+  db.exec("ALTER TABLE projects ADD COLUMN status_author TEXT NOT NULL DEFAULT ''");
+  db.exec("ALTER TABLE projects ADD COLUMN status_at TEXT NOT NULL DEFAULT ''");
+  console.log('Projekt-Tabelle um status_author/status_at ergänzt.');
+}
+
+// migrateAddProjectAuftragsstatus: rüstet die Spalte `auftragsstatus` nach
+// (idempotentes ALTER TABLE, gleiches Muster wie
+// migrateAddProjectBesprochen()). Bestandszeilen bekommen über den
+// Spalten-Default 'beauftragt' — der Altbestand ist beauftragte Arbeit, und
+// jeder andere Anfangswert hätte laufende Projekte rückwirkend zu Akquise
+// erklärt (siehe DEFAULT_AUFTRAGSSTATUS).
+function migrateAddProjectAuftragsstatus(){
+  const cols = db.prepare("SELECT name FROM pragma_table_info('projects')").all().map(r => r.name);
+  if(!cols.includes('auftragsstatus')){
+    db.exec("ALTER TABLE projects ADD COLUMN auftragsstatus TEXT NOT NULL DEFAULT 'beauftragt'");
+    console.log('Projekt-Tabelle um auftragsstatus ergänzt.');
+  }
+}
+
+// migrateUsersDepartment: ergänzt die Spalten `department`/`initials` in
+// bestehenden users-Tabellen (idempotent; neue DBs haben sie bereits).
+function migrateUsersDepartment(){
+  const cols = db.prepare("SELECT name FROM pragma_table_info('users')").all().map(r => r.name);
+  if(!cols.includes('department')){
+    db.exec("ALTER TABLE users ADD COLUMN department TEXT NOT NULL DEFAULT ''");
+    console.log('Benutzer-Tabelle um department ergänzt.');
+  }
+  if(!cols.includes('initials')){
+    db.exec("ALTER TABLE users ADD COLUMN initials TEXT NOT NULL DEFAULT ''");
+    console.log('Benutzer-Tabelle um initials ergänzt.');
+  }
+  // capacity_hours: vertragliche Wochenstunden. Bis dahin kannte die
+  // Auslastungsrechnung keine Teilzeit — sie maß jede Person an einer vollen
+  // Stelle, eine halbe Stelle erschien deshalb dauerhaft unterbeschäftigt
+  // (in js/load/load.js ausdrücklich als offener Punkt vermerkt). 0 bedeutet
+  // "nicht gepflegt" und wird wie eine volle Stelle behandelt, damit
+  // Bestandskonten ihr bisheriges Bild behalten.
+  if(!cols.includes('capacity_hours')){
+    db.exec('ALTER TABLE users ADD COLUMN capacity_hours REAL NOT NULL DEFAULT 0');
+    console.log('Benutzer-Tabelle um capacity_hours ergänzt.');
+  }
+}
+
+// dedupeUserPersonIds: person_id musste bisher nur je Abteilung eindeutig
+// sein (alte people-Tabelle); jetzt identifiziert person_id global einen
+// Benutzer, daher müssen Bestandskollisionen vor dem UNIQUE INDEX aufgelöst
+// werden. Alle bis auf die erste Zeile je Kollision bekommen "_<id>" angehängt.
+function dedupeUserPersonIds(){
+  const dupes = db.prepare(`SELECT person_id, COUNT(*) c FROM users WHERE person_id != '' GROUP BY person_id HAVING c > 1`).all();
+  dupes.forEach(d => {
+    const rows = db.prepare('SELECT id FROM users WHERE person_id = ? ORDER BY id').all(d.person_id);
+    rows.slice(1).forEach(r => {
+      const newId = d.person_id + '_' + r.id;
+      db.prepare('UPDATE users SET person_id = ? WHERE id = ?').run(newId, r.id);
+      console.warn(`Person-ID-Kollision behoben: Benutzer #${r.id} bekommt "${newId}" statt "${d.person_id}" (bitte in der Benutzerverwaltung prüfen).`);
+    });
+  });
+}
+
+// ensureUserPersonIdUniqueIndex: löst zuerst Bestandskollisionen auf (siehe
+// dedupeUserPersonIds) und legt danach den UNIQUE-Index an (idempotent,
+// überspringt leere person_id-Werte per partiellem Index).
+function ensureUserPersonIdUniqueIndex(){
+  dedupeUserPersonIds();
+  db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_users_person_id_unique ON users(person_id) WHERE person_id != ''`);
+}
+
+// migrateRetirePeopleTablesIntoUsers: löst das alte, abteilungsbezogene
+// Projektbeteiligte-Schema (people/person_roles/person_absences) endgültig ab,
+// nachdem es durch die globalen User-Accounts (users/user_roles/user_absences)
+// ersetzt wurde. Idempotent: läuft nur, solange die Tabelle `people` noch
+// existiert. person_absences wird bewusst NICHT übernommen (enthielt bereits
+// vorher keine sinnvollen Daten, siehe serializeGlobalPeople-Altcode), und für
+// historische people-Zeilen ohne passenden User wird KEIN Platzhalter-User
+// angelegt (würde die Benutzerliste mit nicht-loginfähigen Karteileichen
+// verschmutzen) — stattdessen wird einmalig auf der Konsole protokolliert.
+function migrateRetirePeopleTablesIntoUsers(){
+  const stillExists = db.prepare("SELECT COUNT(*) c FROM sqlite_master WHERE type='table' AND name='people'").get().c > 0;
+  if(!stillExists) return;
+  console.log('Migriere altes Projektbeteiligte-Schema (people/person_roles/person_absences) …');
+  const legacyPeople = db.prepare('SELECT * FROM people').all();
+  const legacyRoles = db.prepare('SELECT * FROM person_roles').all();
+  let merged = 0; const unmatched = [];
+  db.exec('BEGIN');
+  try {
+    legacyPeople.forEach(p => {
+      const user = db.prepare('SELECT id FROM users WHERE department = ? AND person_id = ?').get(p.department, p.person_id);
+      if(!user){ unmatched.push(p.department + '/' + p.person_id + ' (' + p.full_name + ')'); return; }
+      legacyRoles.filter(r => r.department === p.department && r.person_id === p.person_id)
+        .forEach(r => db.prepare('INSERT OR IGNORE INTO user_roles (user_id, role, role_order) VALUES (?,?,?)').run(user.id, r.role, r.role_order));
+      merged++;
+    });
+    db.exec('DROP TABLE people; DROP TABLE person_roles; DROP TABLE person_absences;');
+    db.exec('COMMIT');
+    console.log(`Migration abgeschlossen: ${merged} Personen-Rollen übernommen. ${unmatched.length} alte Einträge ohne passenden Benutzer (nicht automatisch migrierbar):`);
+    unmatched.forEach(u => console.log('  - ' + u));
+  } catch(err){ db.exec('ROLLBACK'); console.error('Migration fehlgeschlagen:', err.message); throw err; }
+}
+
+// ---------- Auth: Passwort-Hashing ----------
+
+// hashPassword: erzeugt Salt + scrypt-Hash für ein neues/geändertes Passwort.
+function hashPassword(password){
+  const salt = crypto.randomBytes(16).toString('hex');
+  const hash = crypto.scryptSync(password, salt, 64).toString('hex');
+  return { hash, salt };
+}
+
+// verifyPassword: prüft ein eingegebenes Passwort gegen gespeicherten Salt+Hash
+// (zeitkonstanter Vergleich gegen Timing-Angriffe).
+function verifyPassword(password, salt, expectedHash){
+  const hash = crypto.scryptSync(password, salt, 64);
+  const expected = Buffer.from(expectedHash, 'hex');
+  return hash.length === expected.length && crypto.timingSafeEqual(hash, expected);
+}
+
+// bootstrapInitialAdmin: legt beim allerersten Start (users-Tabelle leer) ein
+// Admin-Konto mit zufällig generiertem Passwort an (kein Hardcoded-Passwort im
+// Code). Läuft danach nie wieder (Guard: COUNT(*) > 0). Das Klartext-Passwort
+// wird einmalig auf die Konsole ausgegeben und zusätzlich nach
+// sessions/INITIAL_ADMIN_PASSWORD.txt geschrieben (liegt außerhalb von
+// public/, wird also nie von express.static ausgeliefert).
+function bootstrapInitialAdmin(){
+  const row = db.prepare('SELECT COUNT(*) AS c FROM users').get();
+  if(row.c > 0) return;
+  const password = crypto.randomBytes(15).toString('base64url');
+  const { hash, salt } = hashPassword(password);
+  const now = new Date().toISOString();
+  db.prepare('INSERT INTO users (username, display_name, role, password_hash, password_salt, must_change_password, created_at, updated_at) VALUES (?,?,?,?,?,1,?,?)')
+    .run('admin', 'Administrator', 'admin', hash, salt, now, now);
+  const msg = 'Erstmaliges Admin-Konto angelegt.\n  Benutzername: admin\n  Passwort:     ' + password + '\n  (Bitte nach dem ersten Login sofort ändern.)';
+  console.log(msg);
+  try {
+    fs.writeFileSync(path.join(SESSIONS_DIR, 'INITIAL_ADMIN_PASSWORD.txt'), msg + '\n', 'utf8');
+  } catch(err){
+    console.error('Konnte INITIAL_ADMIN_PASSWORD.txt nicht schreiben:', err);
+  }
+}
+
 // Migration beim Serverstart ausführen
 migrateLegacySchema();
 migrateWeeksUpdatedAt();
+migrateRemoveDepartmentPartition();
+migrateBackfillProjectGewerkeAusTags();
+migrateAddProjectUid();
+migrateAddProjectBesprochen();
+migrateAddProjectHonorar();
+migrateAddProjectStatusAuthor();
+migrateAddProjectAuftragsstatus();
+migrateAddProjectGroesse();
+migrateAddProjectUpdatedAt();
+migrateAddProtokollQuelle();
+migrateAddProtokollPunktErstelltAm();
+migrateAddProtokollPunktStatus();
+migrateAddProtokollPunktEntfaelltNaechstes();
+migrateUsersDepartment();
+ensureSandboxWeek();
+ensureUserPersonIdUniqueIndex();
+migrateRetirePeopleTablesIntoUsers();
+// migrateAbsencesCreatedBy: ergänzt die Spalte created_by in bestehenden
+// Datenbanken (idempotent). Altbestand behält 0 und ist damit nur von der
+// betroffenen Person selbst oder von Administratoren löschbar.
+(function migrateAbsencesCreatedBy(){
+  try {
+    const cols = db.prepare("SELECT name FROM pragma_table_info('user_absences')").all().map(r => r.name);
+    if(!cols.includes('created_by')){
+      db.exec("ALTER TABLE user_absences ADD COLUMN created_by INTEGER NOT NULL DEFAULT 0");
+      console.log('Migriert: user_absences.created_by ergänzt.');
+    }
+  } catch(err){
+    console.error('Migration user_absences.created_by fehlgeschlagen:', err.message);
+  }
+})();
+
+bootstrapInitialAdmin();
+
+// Abgelaufene Sitzungen beim Start entfernen. Sie wurden bisher nur ignoriert,
+// blieben aber für immer in der Tabelle stehen — und damit auch in jedem
+// Backup-Snapshot.
+try {
+  const removed = db.prepare('DELETE FROM user_sessions WHERE expires_at <= ?').run(new Date().toISOString());
+  if(removed && removed.changes) console.log('Abgelaufene Sitzungen entfernt:', removed.changes);
+} catch(err){
+  console.error('Aufräumen der Sitzungen fehlgeschlagen:', err.message);
+}
+
+// ---------- Auth: Sessions, Middleware, Endpunkte ----------
+
+const SESSION_COOKIE = 'puebersicht_session';
+// Gültigkeitsdauer einer Anmeldung. Vorgabe 30 Tage, firmenweit über den
+// Schlüssel 'sessionTage' pflegbar (siehe sessionMaxAgeMs()).
+const DEFAULT_SESSION_TAGE = 30;
+
+// sessionMaxAgeMs: aktuelle Gültigkeitsdauer in Millisekunden. Wirkt auf neu
+// erzeugte Sitzungen; bestehende behalten ihr gespeichertes expires_at.
+function sessionMaxAgeMs(){
+  return readAppSetting('sessionTage') * 24 * 60 * 60 * 1000;
+}
+
+// parseCookies: minimaler handgeschriebener Cookie-Parser (kein cookie-parser-
+// Paket — Projekt-Konvention: nur express+cors als npm-Abhängigkeiten).
+function parseCookies(req){
+  const header = req.headers.cookie || '';
+  const out = {};
+  header.split(';').forEach(part => {
+    const idx = part.indexOf('=');
+    if(idx === -1) return;
+    const k = part.slice(0, idx).trim();
+    const v = part.slice(idx + 1).trim();
+    if(k) out[k] = decodeURIComponent(v);
+  });
+  return out;
+}
+
+// setSessionCookie / clearSessionCookie: setzen bzw. löschen das Session-Cookie
+// (HttpOnly, SameSite=Lax, 30 Tage Laufzeit, Secure nur bei HTTPS-Requests).
+function setSessionCookie(res, token, req){
+  const secure = req && req.secure ? '; Secure' : '';
+  res.setHeader('Set-Cookie', `${SESSION_COOKIE}=${encodeURIComponent(token)}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${Math.floor(sessionMaxAgeMs()/1000)}${secure}`);
+}
+
+function clearSessionCookie(res){
+  res.setHeader('Set-Cookie', `${SESSION_COOKIE}=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0`);
+}
+
+// attachUser: liest das Session-Cookie, lädt (falls gültig) Session+User und
+// setzt req.user entsprechend (oder null). Läuft für JEDEN Request (auch vor
+// dem statischen Datei-Ausliefern), damit spätere Routen sich stets auf
+// req.user verlassen können. Aktualisiert nebenbei last_seen_at der Session.
+function attachUser(req, res, next){
+  req.user = null;
+  const cookies = parseCookies(req);
+  const token = cookies[SESSION_COOKIE];
+  if(!token) return next();
+  const row = db.prepare(`
+    SELECT s.expires_at AS expires_at, u.id AS id, u.username AS username,
+           u.display_name AS display_name, u.email AS email, u.role AS role,
+           u.person_id AS person_id, u.active AS active,
+           u.must_change_password AS must_change_password, u.department AS department
+    FROM user_sessions s JOIN users u ON u.id = s.user_id
+    WHERE s.token = ?
+  `).get(token);
+  if(!row || !row.active || row.expires_at <= new Date().toISOString()) return next();
+  req.user = {
+    id: row.id,
+    username: row.username,
+    displayName: row.display_name,
+    email: row.email,
+    role: row.role,
+    personId: row.person_id,
+    mustChangePassword: !!row.must_change_password,
+    // department: das eigene Gewerk des Kontos — der Wochenbericht schlägt es
+    // als Vorauswahl vor (js/wochenbericht/wochenbericht.js), damit man nicht
+    // jedes Mal manuell das eigene Gewerk wählen muss.
+    department: row.department || ''
+  };
+  try {
+    db.prepare('UPDATE user_sessions SET last_seen_at = ? WHERE token = ?').run(new Date().toISOString(), token);
+  } catch(err){
+    console.error('Konnte last_seen_at nicht aktualisieren:', err);
+  }
+  next();
+}
+// (Registrierung via app.use(attachUser) erfolgt bewusst weiter oben, direkt
+// nach express.json() und vor express.static — siehe dort.)
+
+// requireAuth / requireRole: Middleware-Fabriken für spätere Phasen, die damit
+// bestehende Routen absichern. In dieser Phase werden sie auf KEINE bestehende
+// Route angewendet.
+function requireAuth(req, res, next){
+  if(!req.user) return res.status(401).json({ ok:false, error:'Nicht angemeldet.' });
+  // Die Kiosk-Rolle (Wandtafel-Konto) ist überall, wo requireAuth genügte,
+  // bewusst AUSGESCHLOSSEN — sie darf nichts schreiben und nichts lesen, was
+  // die Wandtafel nicht selbst braucht. Die wenigen Routen, die sie braucht,
+  // nutzen requireAuthOderKiosk statt requireAuth.
+  if(req.user.role === 'kiosk') return res.status(403).json({ ok:false, error:'Dieses Konto hat nur Lesezugriff für die Wandtafel.' });
+  next();
+}
+// requireAuthOderKiosk: wie requireAuth, lässt zusätzlich die Kiosk-Rolle zu —
+// ausschließlich für die wenigen Routen, die ein Kiosk-Konto selbst braucht:
+// die lesenden Routen, die die Wandtafel beim Laden aufruft (GET /load-all,
+// /app-settings, /holidays, /honorar-config), /logout (ein Kiosk-Konto darf
+// sich abmelden können, auch wenn die Oberfläche dort aktuell keinen Knopf
+// dafür zeigt) sowie /change-password und /change-email (auf das EIGENE
+// Konto beschränkt — jedes neu angelegte Konto, auch ein Kiosk-Konto, trägt
+// must_change_password und MUSS sein Passwort beim ersten Login ändern
+// können, sonst bliebe der erzwungene Dialog für immer unerfüllbar).
+function requireAuthOderKiosk(req, res, next){
+  if(!req.user) return res.status(401).json({ ok:false, error:'Nicht angemeldet.' });
+  next();
+}
+function requireRole(role){
+  return function(req, res, next){
+    if(!req.user) return res.status(401).json({ ok:false, error:'Nicht angemeldet.' });
+    if(req.user.role !== role) return res.status(403).json({ ok:false, error:'Keine Berechtigung.' });
+    next();
+  };
+}
+
+// Route: Login — prüft Benutzername/Passwort, legt bei Erfolg eine neue Session
+// an und setzt das Session-Cookie. Liefert bei falschem Benutzernamen, falschem
+// Passwort oder inaktivem Konto absichtlich dieselbe Fehlermeldung (kein
+// Username-Enumeration-Unterschied).
+// loginAttempts: Fehlversuche je Absender-Adresse (nur im Arbeitsspeicher,
+// kein Zustand in der Datenbank). Nach den eingestellten Fehlversuchen ist
+// die Anmeldung für die eingestellte Dauer gesperrt — ohne diese Bremse kann ein
+// Passwort beliebig oft durchprobiert werden.
+const loginAttempts = new Map();
+// Vorgaben der Anmeldebremse; firmenweit über 'loginMaxVersuche' und
+// 'loginSperreMinuten' pflegbar (siehe loginMaxAttempts()/loginBlockMs()).
+const DEFAULT_LOGIN_MAX_ATTEMPTS = 10;
+const DEFAULT_LOGIN_BLOCK_MINUTEN = 10;
+function loginMaxAttempts(){ return readAppSetting('loginMaxVersuche'); }
+function loginBlockMs(){ return readAppSetting('loginSperreMinuten') * 60 * 1000; }
+
+// Schlüssel aus Benutzername UND Absender-Adresse: Nur nach der Adresse zu
+// sperren würde im Büro alle hinter derselben Leitung aussperren, sobald sich
+// eine Person zehnmal vertippt. So ist immer nur das betroffene Konto von
+// dieser Stelle aus gebremst.
+function loginClientKey(req, username){
+  const ip = String((req.headers['x-forwarded-for'] || '').split(',')[0].trim() || req.socket.remoteAddress || 'unbekannt');
+  return String(username || '').toLowerCase() + '|' + ip;
+}
+
+function loginIsBlocked(key){
+  const entry = loginAttempts.get(key);
+  if(!entry) return false;
+  if(Date.now() - entry.first > loginBlockMs()){ loginAttempts.delete(key); return false; }
+  return entry.count >= loginMaxAttempts();
+}
+
+function loginNoteFailure(key){
+  const entry = loginAttempts.get(key);
+  if(!entry || Date.now() - entry.first > loginBlockMs()) loginAttempts.set(key, { count: 1, first: Date.now() });
+  else entry.count++;
+}
+
+app.post('/login', (req, res) => {
+  const { username, password } = req.body || {};
+  if(!username || !password) return res.status(400).json({ ok:false, error:'Benutzername und Passwort erforderlich.' });
+  const clientKey = loginClientKey(req, username);
+  if(loginIsBlocked(clientKey)){
+    return res.status(429).json({ ok:false, error:'Zu viele Fehlversuche. Bitte in einigen Minuten erneut versuchen.' });
+  }
+  const row = db.prepare('SELECT * FROM users WHERE username = ?').get(username);
+  // Auch bei unbekanntem Benutzernamen einmal hashen: Sonst verrät die
+  // Antwortzeit (scrypt läuft bewusst langsam), welche Konten es gibt.
+  const salt = row ? row.password_salt : 'unbekannt';
+  const expected = row ? row.password_hash : crypto.scryptSync('x', 'unbekannt', 64).toString('hex');
+  const passwordOk = verifyPassword(password, salt, expected);
+  if(!row || !row.active || !passwordOk){
+    loginNoteFailure(clientKey);
+    return res.status(401).json({ ok:false, error:'Benutzername oder Passwort falsch.' });
+  }
+  loginAttempts.delete(clientKey);
+  const token = crypto.randomBytes(32).toString('hex');
+  const now = new Date().toISOString();
+  const expiresAt = new Date(Date.now() + sessionMaxAgeMs()).toISOString();
+  db.prepare('INSERT INTO user_sessions (token, user_id, created_at, last_seen_at, expires_at) VALUES (?,?,?,?,?)')
+    .run(token, row.id, now, now, expiresAt);
+  setSessionCookie(res, token, req);
+  res.json({
+    ok: true,
+    user: {
+      id: row.id,
+      username: row.username,
+      displayName: row.display_name,
+      role: row.role,
+      personId: row.person_id,
+      mustChangePassword: !!row.must_change_password
+    }
+  });
+});
+
+// Route: Logout — löscht die Session des aktuellen Cookies und leert das Cookie.
+app.post('/logout', requireAuthOderKiosk, (req, res) => {
+  const cookies = parseCookies(req);
+  const token = cookies[SESSION_COOKIE];
+  if(token) db.prepare('DELETE FROM user_sessions WHERE token = ?').run(token);
+  clearSessionCookie(res);
+  res.json({ ok:true });
+});
+
+// Route: liefert den aktuell angemeldeten Benutzer (oder null) — Basis für das
+// clientseitige Login-Overlay.
+app.get('/whoami', (req, res) => {
+  res.json({ ok:true, user: req.user || null });
+});
+
+// Route: Passwort ändern — verlangt immer das aktuelle Passwort (auch bei
+// erzwungenem must_change_password), neues Passwort muss mind. 8 Zeichen haben.
+app.post('/change-password', requireAuthOderKiosk, (req, res) => {
+  const { currentPassword, newPassword } = req.body || {};
+  if(!currentPassword || !newPassword) return res.status(400).json({ ok:false, error:'Aktuelles und neues Passwort erforderlich.' });
+  if(newPassword.length < 8) return res.status(400).json({ ok:false, error:'Neues Passwort muss mindestens 8 Zeichen haben.' });
+  const row = db.prepare('SELECT * FROM users WHERE id = ?').get(req.user.id);
+  if(!row || !verifyPassword(currentPassword, row.password_salt, row.password_hash)){
+    return res.status(401).json({ ok:false, error:'Aktuelles Passwort falsch.' });
+  }
+  const { hash, salt } = hashPassword(newPassword);
+  db.prepare('UPDATE users SET password_hash = ?, password_salt = ?, must_change_password = 0, updated_at = ? WHERE id = ?')
+    .run(hash, salt, new Date().toISOString(), row.id);
+  res.json({ ok:true });
+});
+
+// Route: eigene E-Mail-Adresse ändern — im Unterschied zu Anzeigename, Rolle
+// und Personen-Zuordnung (weiterhin nur PATCH /admin/users/:id) pflegt jedes
+// Konto seine E-Mail selbst, deshalb hier statt in der Admin-Benutzerverwaltung.
+// Kein Formatzwang (wie auch beim Admin-Pfad) — nur eine leere Eingabe wird
+// abgelehnt, das Leeren des Feldes geschieht wie gehabt über die
+// Benutzerverwaltung.
+app.post('/change-email', requireAuthOderKiosk, (req, res) => {
+  const { email } = req.body || {};
+  const trimmed = String(email || '').trim();
+  if(!trimmed) return res.status(400).json({ ok:false, error:'E-Mail-Adresse erforderlich.' });
+  db.prepare('UPDATE users SET email = ?, updated_at = ? WHERE id = ?')
+    .run(trimmed, new Date().toISOString(), req.user.id);
+  res.json({ ok:true, email: trimmed });
+});
+
+// ---------- Admin-Benutzerverwaltung ----------
+//
+// Alle Routen dieses Abschnitts sind `requireRole('admin')`-geschützt und
+// dienen dem Abschnitt Benutzerverwaltung des Bereichs Admin. Sie legen
+// Benutzerkonten an, ändern sie, setzen Passwörter zurück und löschen Konten
+// (Soft-Delete standardmäßig, Hard-Delete nur ohne Referenzen in
+// project_files/project_file_reviewers/project_file_comments).
+
+// parseCapacityHours: prüft die vertraglichen Wochenstunden eines Kontos.
+// Leer/undefiniert ergibt 0 = "nicht gepflegt"; das Frontend rechnet dann mit
+// einer vollen Stelle, damit Bestandskonten ihr bisheriges Auslastungsbild
+// behalten. Rückgabe: Zahl 0–80 oder null bei unbrauchbarer Eingabe.
+function parseCapacityHours(value){
+  if(value === undefined || value === null || value === '') return 0;
+  const n = Number(value);
+  if(!Number.isFinite(n) || n < 0 || n > 80) return null;
+  return n;
+}
+
+// generateRandomPassword: erzeugt ein zufälliges Klartext-Passwort für neu
+// angelegte Accounts bzw. einen Passwort-Reset (gleiche Methode wie
+// bootstrapInitialAdmin).
+function generateRandomPassword(){
+  return crypto.randomBytes(15).toString('base64url');
+}
+
+// serializeUserRow: wandelt eine users-Zeile in die öffentliche Repräsentation
+// um (OHNE password_hash/password_salt).
+function serializeUserRow(row){
+  return {
+    id: row.id,
+    username: row.username,
+    displayName: row.display_name,
+    email: row.email,
+    role: row.role,
+    personId: row.person_id,
+    department: row.department,
+    initials: row.initials,
+    capacityHours: Number(row.capacity_hours) || 0,
+    active: !!row.active,
+    mustChangePassword: !!row.must_change_password,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+// loadUserRolesByUserId: Batch-Query aller user_roles, gruppiert nach user_id
+// (analog zum bestehenden Muster in loadGlobalPeople() für person_roles) —
+// vermeidet eine Einzelabfrage pro Zeile in GET /admin/users bzw. GET /users.
+function loadUserRolesByUserId(){
+  const rows = db.prepare('SELECT * FROM user_roles ORDER BY role_order').all();
+  const byUser = {};
+  rows.forEach(r => { (byUser[r.user_id] = byUser[r.user_id] || []).push(r.role); });
+  return byUser;
+}
+
+// Route: Liste aller Benutzer (ohne Passwortfelder), sortiert nach Benutzername.
+app.get('/admin/users', requireRole('admin'), (req, res) => {
+  try {
+    const rows = db.prepare('SELECT * FROM users ORDER BY username').all();
+    const rolesByUser = loadUserRolesByUserId();
+    res.json({ ok: true, users: rows.map(r => Object.assign(serializeUserRow(r), { roles: rolesByUser[r.id] || [] })) });
+  } catch(err){
+    console.error('Admin-Benutzerliste fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Abwesenheiten eines einzelnen Benutzers, sortiert nach Start-Datum.
+// GET /admin/users liefert bewusst keine Abwesenheiten mit (würde die Liste
+// unnötig aufblähen) — das Bearbeiten-Modal in admin-users.js lädt sie beim
+// Öffnen separat über diese Route nach.
+app.get('/admin/users/:id/absences', requireRole('admin'), (req, res) => {
+  const id = Number(req.params.id);
+  try {
+    const rows = db.prepare('SELECT id, start, end, type, note FROM user_absences WHERE user_id = ? ORDER BY start').all(id);
+    res.json({ ok: true, absences: rows });
+  } catch(err){
+    console.error('Abwesenheiten laden fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Legt einen neuen Benutzer an. Passwort entweder explizit (mind. 8
+// Zeichen) oder automatisch generiert (generatePassword: true); in jedem Fall
+// muss der neue Account beim ersten Login sein Passwort ändern. `personId`
+// wird 1:1 vom Client übernommen (Berechnung/Vorschau via personIdForName()
+// passiert clientseitig).
+app.post('/admin/users', requireRole('admin'), (req, res) => {
+  const { username, displayName, email, role, personId, department, initials, capacityHours, roles, password, generatePassword } = req.body || {};
+  if(!username || !String(username).trim()) return res.status(400).json({ ok: false, error: 'Benutzername erforderlich.' });
+  if(!displayName || !String(displayName).trim()) return res.status(400).json({ ok: false, error: 'Anzeigename erforderlich.' });
+  const finalRole = role ? String(role) : 'member';
+  if(!VALID_ROLES.has(finalRole)) return res.status(400).json({ ok: false, error: 'Ungültige Rolle.' });
+  if(typeof department !== 'string' || !VALID_DEPARTMENTS.has(department)){
+    return res.status(400).json({ ok: false, error: 'Ungültige oder fehlende Abteilung.' });
+  }
+  const roleList = Array.isArray(roles) ? roles : [];
+  for(const r of roleList){
+    if(!VALID_DISCIPLINE_ROLES.has(r)) return res.status(400).json({ ok: false, error: 'Ungültige Rolle: ' + r });
+  }
+  // Ein Kiosk-Konto hat keine Fachrolle — es erscheint in keinem
+  // Projektboard und wird keiner Rolle zugeordnet, die Felder wären also
+  // ohnehin wirkungslos; ihr Setzen wird deshalb zurückgewiesen statt
+  // stillschweigend ignoriert.
+  if(finalRole === 'kiosk' && roleList.length > 0){
+    return res.status(400).json({ ok: false, error: 'Ein Kiosk-Konto kann keine Fachrolle haben.' });
+  }
+  // capacityHours: vertragliche Wochenstunden (Teilzeit). 0 bzw. keine
+  // Angabe heißt "nicht gepflegt" — das Frontend rechnet dann mit einer
+  // vollen Stelle weiter.
+  const capacity = parseCapacityHours(capacityHours);
+  if(capacity === null) return res.status(400).json({ ok: false, error: 'Wochenstunden müssen zwischen 0 und 80 liegen.' });
+
+  let plainPassword;
+  if(generatePassword === true){
+    plainPassword = generateRandomPassword();
+  } else if(typeof password === 'string' && password){
+    if(password.length < 8) return res.status(400).json({ ok: false, error: 'Passwort muss mindestens 8 Zeichen haben.' });
+    plainPassword = password;
+  } else {
+    return res.status(400).json({ ok: false, error: 'Passwort erforderlich (manuell oder generatePassword).' });
+  }
+
+  const { hash, salt } = hashPassword(plainPassword);
+  const now = new Date().toISOString();
+  try {
+    const info = db.prepare(`INSERT INTO users
+      (username, display_name, email, role, person_id, department, initials, capacity_hours, password_hash, password_salt, active, must_change_password, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, 1, ?, ?)`)
+      .run(String(username).trim(), String(displayName).trim(), String(email || ''), finalRole, String(personId || ''), department, String(initials || ''), capacity, hash, salt, now, now);
+    const insRole = db.prepare('INSERT INTO user_roles (user_id, role, role_order) VALUES (?, ?, ?)');
+    roleList.forEach((r, idx) => insRole.run(info.lastInsertRowid, r, idx));
+    const row = db.prepare('SELECT * FROM users WHERE id = ?').get(info.lastInsertRowid);
+    const result = { ok: true, user: Object.assign(serializeUserRow(row), { roles: roleList }) };
+    if(generatePassword === true) result.generatedPassword = plainPassword;
+    res.json(result);
+  } catch(err){
+    if(err && String(err.message || '').includes('person_id')){
+      return res.status(409).json({ ok: false, error: 'Person-ID bereits vergeben.' });
+    }
+    if(err && String(err.message || '').includes('UNIQUE')){
+      return res.status(409).json({ ok: false, error: 'Benutzername bereits vergeben.' });
+    }
+    console.error('Benutzer anlegen fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Aktualisiert einen bestehenden Benutzer (nur die übergebenen Felder).
+// Schützt einen Admin davor, sich selbst zu deaktivieren oder zu degradieren.
+app.patch('/admin/users/:id', requireRole('admin'), (req, res) => {
+  const id = Number(req.params.id);
+  const row = db.prepare('SELECT * FROM users WHERE id = ?').get(id);
+  if(!row) return res.status(404).json({ ok: false, error: 'Benutzer nicht gefunden.' });
+
+  const { displayName, email, role, active, personId, department, initials, capacityHours, roles } = req.body || {};
+  if(role !== undefined && !VALID_ROLES.has(String(role))){
+    return res.status(400).json({ ok: false, error: 'Ungültige Rolle.' });
+  }
+  if(department !== undefined && !VALID_DEPARTMENTS.has(department)){
+    return res.status(400).json({ ok: false, error: 'Ungültige Abteilung.' });
+  }
+  let capacity;
+  if(capacityHours !== undefined){
+    capacity = parseCapacityHours(capacityHours);
+    if(capacity === null) return res.status(400).json({ ok: false, error: 'Wochenstunden müssen zwischen 0 und 80 liegen.' });
+  }
+  let roleList;
+  if(roles !== undefined){
+    roleList = Array.isArray(roles) ? roles : [];
+    for(const r of roleList){
+      if(!VALID_DISCIPLINE_ROLES.has(r)) return res.status(400).json({ ok: false, error: 'Ungültige Rolle: ' + r });
+    }
+  }
+  // Ein Kiosk-Konto hat keine Fachrolle — geprüft gegen die Rolle UND die
+  // Fachrollen-Liste, wie sie nach diesem PATCH jeweils gelten würden (eines
+  // von beiden kann unverändert bleiben, wenn es im Body fehlt).
+  const effectiveRole = role !== undefined ? String(role) : row.role;
+  if(effectiveRole === 'kiosk'){
+    const effectiveRoles = roles !== undefined
+      ? roleList
+      : db.prepare('SELECT role FROM user_roles WHERE user_id = ?').all(id).map(r => r.role);
+    if(effectiveRoles.length > 0){
+      return res.status(400).json({ ok: false, error: 'Ein Kiosk-Konto kann keine Fachrolle haben.' });
+    }
+  }
+  const isSelf = req.user.id === id;
+  const wouldDeactivate = active !== undefined && !active;
+  // Degradierung schließt jeden Wechsel WEG von admin ein, nicht nur zu
+  // 'member' — sonst gäbe es für den Selbstschutz eine Kiosk-förmige Lücke.
+  const wouldDemote = role !== undefined && row.role === 'admin' && role !== 'admin';
+  if(isSelf && (wouldDeactivate || wouldDemote)){
+    return res.status(400).json({ ok: false, error: 'Sie können sich nicht selbst deaktivieren oder degradieren.' });
+  }
+
+  const fields = [];
+  const values = [];
+  if(displayName !== undefined){ fields.push('display_name = ?'); values.push(String(displayName)); }
+  if(email !== undefined){ fields.push('email = ?'); values.push(String(email)); }
+  if(role !== undefined){ fields.push('role = ?'); values.push(role); }
+  if(active !== undefined){ fields.push('active = ?'); values.push(active ? 1 : 0); }
+  if(personId !== undefined){ fields.push('person_id = ?'); values.push(String(personId)); }
+  if(department !== undefined){ fields.push('department = ?'); values.push(department); }
+  if(initials !== undefined){ fields.push('initials = ?'); values.push(String(initials)); }
+  if(capacity !== undefined){ fields.push('capacity_hours = ?'); values.push(capacity); }
+  const now = new Date().toISOString();
+  fields.push('updated_at = ?'); values.push(now);
+  values.push(id);
+  try {
+    db.prepare(`UPDATE users SET ${fields.join(', ')} WHERE id = ?`).run(...values);
+    if(roleList !== undefined){
+      db.prepare('DELETE FROM user_roles WHERE user_id = ?').run(id);
+      const insRole = db.prepare('INSERT INTO user_roles (user_id, role, role_order) VALUES (?, ?, ?)');
+      roleList.forEach((r, idx) => insRole.run(id, r, idx));
+    }
+    // Deaktivierung erzwingt sofortigen Logout (alle Sessions löschen).
+    if(wouldDeactivate){
+      db.prepare('DELETE FROM user_sessions WHERE user_id = ?').run(id);
+    }
+    const updated = db.prepare('SELECT * FROM users WHERE id = ?').get(id);
+    const updatedRoles = roleList !== undefined ? roleList : (loadUserRolesByUserId()[id] || []);
+    res.json({ ok: true, user: Object.assign(serializeUserRow(updated), { roles: updatedRoles }) });
+  } catch(err){
+    if(err && String(err.message || '').includes('person_id')){
+      return res.status(409).json({ ok: false, error: 'Person-ID bereits vergeben.' });
+    }
+    console.error('Benutzer aktualisieren fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Setzt das Passwort eines Benutzers auf ein neues Zufallspasswort
+// zurück, erzwingt eine Passwortänderung beim nächsten Login und löscht alle
+// bestehenden Sessions (erzwingt Neuanmeldung).
+app.post('/admin/users/:id/reset-password', requireRole('admin'), (req, res) => {
+  const id = Number(req.params.id);
+  const row = db.prepare('SELECT * FROM users WHERE id = ?').get(id);
+  if(!row) return res.status(404).json({ ok: false, error: 'Benutzer nicht gefunden.' });
+  const plainPassword = generateRandomPassword();
+  const { hash, salt } = hashPassword(plainPassword);
+  const now = new Date().toISOString();
+  try {
+    db.prepare('UPDATE users SET password_hash = ?, password_salt = ?, must_change_password = 1, updated_at = ? WHERE id = ?')
+      .run(hash, salt, now, id);
+    db.prepare('DELETE FROM user_sessions WHERE user_id = ?').run(id);
+    res.json({ ok: true, generatedPassword: plainPassword });
+  } catch(err){
+    console.error('Passwort zurücksetzen fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Löscht einen Benutzer. Standardmäßig Soft-Delete (active = 0 +
+// Sessions löschen, erzwingt Logout); mit `?hard=1` endgültiges Löschen,
+// sofern der Benutzer nirgends referenziert wird (project_files.uploaded_by_user_id,
+// project_file_reviewers.user_id, project_file_comments.user_id — diese Tabellen
+// sind schon angelegt, aber aktuell noch leer). Ein Admin kann sich selbst
+// weder soft- noch hard-löschen.
+app.delete('/admin/users/:id', requireRole('admin'), (req, res) => {
+  const id = Number(req.params.id);
+  const row = db.prepare('SELECT * FROM users WHERE id = ?').get(id);
+  if(!row) return res.status(404).json({ ok: false, error: 'Benutzer nicht gefunden.' });
+  if(req.user.id === id) return res.status(400).json({ ok: false, error: 'Sie können Ihren eigenen Account nicht löschen.' });
+
+  const hard = req.query.hard === '1';
+  try {
+    if(hard){
+      const referenced = db.prepare(`SELECT
+          (SELECT COUNT(*) FROM project_files WHERE uploaded_by_user_id = ?) +
+          (SELECT COUNT(*) FROM project_file_reviewers WHERE user_id = ?) +
+          (SELECT COUNT(*) FROM project_file_comments WHERE user_id = ?) AS c`)
+        .get(id, id, id);
+      if(referenced.c > 0){
+        return res.status(409).json({ ok: false, error: 'Benutzer wird noch referenziert und kann nicht endgültig gelöscht werden.' });
+      }
+      // user_sessions dieses Users werden durch ON DELETE CASCADE automatisch mitgelöscht.
+      db.prepare('DELETE FROM users WHERE id = ?').run(id);
+      return res.json({ ok: true, hard: true });
+    }
+    const now = new Date().toISOString();
+    db.prepare('UPDATE users SET active = 0, updated_at = ? WHERE id = ?').run(now, id);
+    db.prepare('DELETE FROM user_sessions WHERE user_id = ?').run(id);
+    res.json({ ok: true, hard: false });
+  } catch(err){
+    console.error('Benutzer löschen fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
 
 // Route: Speichert eine komplette Woche (als JSON-Objekt) für eine Abteilung
-app.post('/save-week', (req, res) => {
-  const { department, week, baseUpdatedAt } = req.body || {};
+app.post('/save-week', requireAuth, (req, res) => {
+  const { week, baseUpdatedAt } = req.body || {};
   if(!week || typeof week.label !== 'string' || !week.label) return res.status(400).json({ ok: false, error: 'Missing week or label' });
-  const dept = departmentKey(department);
+  // Auftragsstatus prüfen, BEVOR irgendetwas geschrieben wird: /save-week ist
+  // der einzige Schreibweg für Projektdaten, ein unbekannter Wert bliebe also
+  // dauerhaft stehen (siehe findInvalidAuftragsstatus()).
+  const badStatus = findInvalidAuftragsstatus(week);
+  if(badStatus){
+    return res.status(400).json({
+      ok: false,
+      error: 'Unbekannter Auftragsstatus "' + badStatus.wert + '" am Projekt '
+        + ((badStatus.nr ? badStatus.nr + ' ' : '') + badStatus.name).trim()
+        + '. Erlaubt: ' + Array.from(VALID_AUFTRAGSSTATUS).join(', ') + '.'
+    });
+  }
   try {
     // Revisions-/Konflikt-Check: Mit `baseUpdatedAt` meldet der Client die
     // Version, auf der seine lokalen Daten beruhen. Ist die Woche auf dem
@@ -1215,8 +3036,23 @@ app.post('/save-week', (req, res) => {
     // überspringen die Prüfung. Der Check läuft synchron vor dem Schreiben,
     // daher gibt es im Prozess keine Race-Condition zwischen Prüfung und
     // Transaktion.
+    // Sperr-Status serverseitig durchsetzen: Eine gesperrte Sitzung darf NUR
+    // über /unlock-week (requireRole('admin')) wieder geöffnet werden. Das
+    // Sperren selbst (false -> true) bleibt jedem erlaubt, weil es die
+    // Auto-Sperre des Clients (applyAutoLock(), public/js/weeks.js) beim
+    // normalen Speichern mitschreibt. Ohne diese Prüfung wäre die Sperre reine
+    // Client-Logik: ein beliebiges Mitglied könnte die Woche mit locked:false
+    // zurückschreiben und die Admin-Grenze umgehen.
+    const lockRow = db.prepare('SELECT locked FROM weeks WHERE label = ?').get(String(week.label));
+    if(lockRow && lockRow.locked && !week.locked && !(req.user && req.user.role === 'admin')){
+      return res.status(403).json({
+        ok: false,
+        error: 'Die Sitzung "' + week.label + '" ist gesperrt. Nur Administratoren können sie wieder öffnen.'
+      });
+    }
+
     if(typeof baseUpdatedAt === 'string'){
-      const row = db.prepare('SELECT updated_at FROM weeks WHERE department = ? AND label = ?').get(dept, String(week.label));
+      const row = db.prepare('SELECT updated_at FROM weeks WHERE label = ?').get(String(week.label));
       if(row){
         if(baseUpdatedAt !== row.updated_at){
           return res.status(409).json({
@@ -1241,8 +3077,8 @@ app.post('/save-week', (req, res) => {
     }
     // `updatedAt` zurückgeben, damit der Client seine lokale Revisions-Basis
     // aktualisieren kann (verhindert falsche Eigen-Konflikte beim nächsten Save).
-    const updatedAt = saveWeekRelational(dept, week);
-    console.log('Saved week:', dept + ' / ' + week.label);
+    const updatedAt = saveWeekRelational(week);
+    console.log('Saved week:', week.label);
     return res.json({ ok: true, updatedAt: updatedAt || new Date().toISOString() });
   } catch(err){
     console.error('Save week error', err);
@@ -1250,31 +3086,26 @@ app.post('/save-week', (req, res) => {
   }
 });
 
-// Route: Speichert die globale Personenliste einer Abteilung (als JSON-Array)
-app.post('/save-people', (req, res) => {
-  const { department, people } = req.body || {};
-  if(!Array.isArray(people)) return res.status(400).json({ ok: false, error: 'Missing people array' });
-  const dept = departmentKey(department);
-  try {
-    serializeGlobalPeople(dept, people);
-    console.log('Saved people:', dept, '(' + people.length + ' Personen)');
-    return res.json({ ok: true });
-  } catch(err){
-    console.error('Save people error', err);
-    return res.status(500).json({ ok: false, error: String(err) });
-  }
-});
-
-// Route: Löscht eine Woche einer Abteilung (fehlende Woche wird toleriert)
-app.post('/delete-week', (req, res) => {
-  const { department, label } = req.body || {};
+// Route: Löscht eine Woche (fehlende Woche wird toleriert)
+app.post('/delete-week', requireRole('admin'), (req, res) => {
+  const { label } = req.body || {};
   if(!label) return res.status(400).json({ ok: false, error: 'Missing label' });
-  const dept = departmentKey(department);
+  if(label === SANDBOX_WEEK_LABEL) return res.status(400).json({ ok: false, error: 'Die Planung-Sandbox ist keine Sitzung und kann hier nicht gelöscht werden.' });
   try {
-    const row = db.prepare('SELECT 1 FROM weeks WHERE department = ? AND label = ?').get(dept, String(label));
+    const row = db.prepare('SELECT 1 FROM weeks WHERE label = ?').get(String(label));
     const existed = !!row;
-    deleteWeekData(dept, String(label));
-    console.log('Deleted week:', dept + ' / ' + label, existed ? '' : '(nicht vorhanden)');
+    // In einer Transaktion: deleteWeekData() räumt 18 Tabellen leer. Bricht
+    // eines der DELETEs ab, blieben sonst Waisen-Zeilen zurück, die eine
+    // später gleichnamig angelegte Sitzung wieder einsammeln würde.
+    db.exec('BEGIN');
+    try {
+      deleteWeekData(String(label));
+      db.exec('COMMIT');
+    } catch(err){
+      try { db.exec('ROLLBACK'); } catch(e){ /* keine offene Transaktion */ }
+      throw err;
+    }
+    console.log('Deleted week:', label, existed ? '' : '(nicht vorhanden)');
     return res.json({ ok: true, deleted: existed });
   } catch(err){
     console.error('Delete week error', err);
@@ -1282,53 +3113,2276 @@ app.post('/delete-week', (req, res) => {
   }
 });
 
-// Route: Lädt alle Wochen plus globale Personenliste einer Abteilung.
-// Liefert strukturierte JSON-Objekte (aus den relationalen Tabellen
-// zusammengesetzt); nach Label sortiert.
-app.get('/load-all', (req, res) => {
+// Route: Entsperrt eine gesperrte Woche (Admin-only — ersetzt die bisher rein
+// clientseitige Entsperr-Logik). Setzt `locked = 0` und schreibt eine neue
+// Revision (`updated_at`), damit der Client seine lokale Sync-Basis
+// aktualisieren kann (gleiche Konvention wie bei /save-week).
+app.post('/unlock-week', requireRole('admin'), (req, res) => {
+  const { label } = req.body || {};
+  if(!label) return res.status(400).json({ ok: false, error: 'Missing label' });
+  if(label === SANDBOX_WEEK_LABEL) return res.status(400).json({ ok: false, error: 'Die Planung-Sandbox ist keine Sitzung und wird nie gesperrt.' });
   try {
-    const dept = departmentKey(req.query.department);
-    const weeks = loadWeeks(dept);
-    const people = loadGlobalPeople(dept);
-    res.json({ ok: true, weeks, people });
+    const row = db.prepare('SELECT 1 FROM weeks WHERE label = ?').get(String(label));
+    if(!row) return res.status(404).json({ ok: false, error: 'Sitzung nicht gefunden.' });
+    const updatedAt = new Date().toISOString();
+    db.prepare('UPDATE weeks SET locked = 0, updated_at = ? WHERE label = ?').run(updatedAt, String(label));
+    console.log('Unlocked week:', label);
+    return res.json({ ok: true, updatedAt });
+  } catch(err){
+    console.error('Unlock week error', err);
+    return res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Lädt alle Wochen (jetzt eine einzige globale Reihe) plus die
+// firmenweite Personenliste. Liefert strukturierte JSON-Objekte (aus den
+// relationalen Tabellen zusammengesetzt); nach Label sortiert.
+app.get('/load-all', requireAuthOderKiosk, (req, res) => {
+  try {
+    const allWeeks = loadWeeks();
+    // Die reservierte Sandbox-"Sitzung" (Planung, siehe SANDBOX_WEEK_LABEL)
+    // ist keine echte Sitzung — sie wird separat als sandboxPlans
+    // ausgeliefert, statt in weeks[] zu landen. So kommt sie clientseitig
+    // strukturell nie in db.weeks an und kann dort auch nicht versehentlich
+    // in Board/Wochenbericht/Auslastung/Sitzungsverwaltung auftauchen.
+    const weeks = allWeeks.filter(w => w.label !== SANDBOX_WEEK_LABEL);
+    const sandbox = allWeeks.find(w => w.label === SANDBOX_WEEK_LABEL);
+    const sandboxPlans = sandbox ? sandbox.projects : [];
+    const sandboxUpdatedAt = sandbox ? sandbox.updatedAt : '';
+    const people = loadGlobalPeople();
+    res.json({ ok: true, weeks, people, sandboxPlans, sandboxUpdatedAt });
   } catch(err){
     console.error('Load error', err);
     res.status(500).json({ ok: false, error: String(err) });
   }
 });
 
-// Route: CSV-Export. Erzeugt einen ZIP mit einer übersichtlichen CSV je
-// logischer Entität (Wochen, Personen, Sitzungsteilnehmer, Projekte,
-// Zuordnungen, Leistungsphasen, Pläne/TODOs/Meilensteine) der angegebenen
-// Abteilung. Das Trennzeichen kann über `?sep=` gesetzt werden (Standard: ';').
-app.get('/export-csv', (req, res) => {
+// ---------- Dashboard ----------
+
+// heuteIsoLokal / isoPlusTageLokal: Datum als YYYY-MM-TT in der ZEITZONE DES
+// SERVERS, nicht in UTC.
+//
+// new Date().toISOString().slice(0,10) rechnet nach UTC um: In deutscher
+// Sommerzeit (UTC+2) liefert es zwischen 00:00 und 02:00 Ortszeit noch den
+// Vortag. Termine von heute galten in diesem Fenster als überfällig, und die
+// Abwesenheitsliste ließ eine heute beginnende Abwesenheit aus. Voraussetzung
+// ist, dass der Server auf die Zeitzone des Büros gestellt ist — im
+// Docker-Container also TZ=Europe/Berlin.
+// Parameter: (isoPlusTageLokal) n = Tage in die Zukunft, auch negativ.
+// Rückgabe: String.
+function heuteIsoLokal(){
+  return isoPlusTageLokal(0);
+}
+function isoPlusTageLokal(n){
+  const d = new Date();
+  d.setDate(d.getDate() + (Number(n) || 0));
+  const m = String(d.getMonth() + 1).padStart(2, '0');
+  const t = String(d.getDate()).padStart(2, '0');
+  return d.getFullYear() + '-' + m + '-' + t;
+}
+
+// weekSortKeyServer: serverseitige Portierung von weekSortKey()
+// (public/js/utils.js) — wird NUR im Fallback von /my-dashboard gebraucht,
+// wenn die applyAutoLock()-Invariante (genau eine entsperrte Woche je
+// Abteilung) ausnahmsweise verletzt ist (0 oder >1 entsperrte Wochen).
+function weekSortKeyServer(label){
+  const m = String(label || '').match(/KW\s*(\d+)[^\d]+(\d{4})/i);
+  if(m){
+    const kw = m[1].padStart(2, '0');
+    return `${m[2]}-${kw}`;
+  }
+  return String(label || '').toLowerCase();
+}
+
+// Route: persönliches Dashboard des angemeldeten Benutzers — liefert die
+// offenen TODOs des eigenen person_id in der aktuell entsperrten (firmenweit
+// globalen) Sitzung, ausstehende Datei-Freigaben sowie `colleagueAbsences`
+// (aktuelle/anstehende Abwesenheiten aller anderen aktiven Nutzer, siehe
+// loadGlobalPeople()). Jede Aufgabe bekommt zusätzlich die Tags ihres
+// Projekts (`tags: string[]`, ggf. leer) mit — separat nachgeladen aus
+// project_tags, gruppiert nach project_id (siehe Kommentar unten), NICHT per
+// JOIN (würde bei mehreren Tags Aufgaben-Zeilen verdoppeln).
+app.get('/my-dashboard', requireAuth, (req, res) => {
   try {
-    const dept = departmentKey(req.query.department);
-    const sep = String(req.query.sep || ';');
-    CSV_SEP = (sep.length === 1) ? sep : ';';
-    const files = buildExportCsvs(dept);
-    const zip = buildZip(files);
-    const filename = 'Projektuebersicht_' + dept + '_' + new Date().toISOString().slice(0,10) + '.zip';
-    res.setHeader('Content-Type', 'application/zip');
-    res.setHeader('Content-Disposition', 'attachment; filename="' + filename + '"');
-    res.setHeader('Content-Length', String(zip.length));
-    res.send(zip);
-    console.log('CSV-Export:', dept, '(' + files.length + ' Dateien, ' + zip.length + ' Bytes)');
+    // Normalfall: applyAutoLock() garantiert genau eine entsperrte Woche
+    // (jetzt firmenweit global, nicht mehr je Abteilung).
+    const unlocked = db.prepare('SELECT label FROM weeks WHERE locked = 0').all();
+    let weekLabel = null;
+    if(unlocked.length === 1){
+      weekLabel = unlocked[0].label;
+    } else {
+      // Fallback (0 oder >1 entsperrte Wochen, sollte normalerweise nicht
+      // vorkommen): jüngste Woche nach weekSortKeyServer() wählen.
+      const all = db.prepare('SELECT label FROM weeks').all();
+      if(all.length > 0){
+        weekLabel = all.map(r => r.label)
+          .sort((a, b) => weekSortKeyServer(b).localeCompare(weekSortKeyServer(a)))[0];
+      }
+    }
+    let tasks = [];
+    if(weekLabel && req.user.personId){
+      tasks = db.prepare(`
+        SELECT t.todo_id AS todoId, t.title AS title, t.start AS start, t.end AS end,
+               t.progress AS progress, t.project_id AS projectId, p.nr AS projectNr, p.name AS projectName
+        FROM plan_todos t
+        JOIN plan_todo_assignees a
+          ON a.week_label = t.week_label
+         AND a.project_id = t.project_id AND a.todo_id = t.todo_id
+        JOIN projects p
+          ON p.week_label = t.week_label
+         AND p.project_id = t.project_id
+        WHERE t.week_label = ? AND t.done = 0 AND a.person_id = ?
+      `).all(weekLabel, req.user.personId);
+      // Sortierung nach Fälligkeit aufsteigend, leere Werte ans Ende.
+      tasks.sort((a, b) => {
+        if(!a.end && !b.end) return 0;
+        if(!a.end) return 1;
+        if(!b.end) return -1;
+        return a.end < b.end ? -1 : (a.end > b.end ? 1 : 0);
+      });
+      // Tags der zugehörigen Projekte nachladen: project_tags hat keine
+      // todo_id, ein direkter JOIN würde also bei mehreren Tags pro Projekt
+      // die TODO-Zeile vervielfachen. Separate, nach (week_label, project_id)
+      // gruppierte Abfrage stattdessen (gleiches Muster wie beim Zusammenbau
+      // der Projekte in loadWeeks()). project_id ist nur ein internes
+      // Zuordnungsfeld für diese Nachladung und wird vor der Antwort wieder
+      // entfernt (kein Teil der bisherigen /my-dashboard-Antwortform).
+      const projectIds = [...new Set(tasks.map(t => t.projectId))];
+      if(projectIds.length > 0){
+        const placeholders = projectIds.map(() => '?').join(',');
+        const tagRows = db.prepare(`
+          SELECT project_id AS projectId, tag FROM project_tags
+          WHERE week_label = ? AND project_id IN (${placeholders})
+          ORDER BY tag_order
+        `).all(weekLabel, ...projectIds);
+        const tagsByProject = {};
+        tagRows.forEach(r => { (tagsByProject[r.projectId] || (tagsByProject[r.projectId] = [])).push(r.tag); });
+        tasks.forEach(t => { t.tags = tagsByProject[t.projectId] || []; });
+      }
+      tasks.forEach(t => { delete t.projectId; });
+    }
+
+    // ---------- Termine der eigenen Projekte ----------
+    //
+    // Nicht dasselbe wie `tasks` oben: Dort stehen die Aufgaben, die der
+    // Person PERSÖNLICH zugewiesen sind — auch in Projekten, mit denen sie
+    // sonst nichts zu tun hat. Hier stehen die Termine der PROJEKTE, denen
+    // sie zugeordnet ist (project_assign), unabhängig davon, wer die einzelne
+    // Aufgabe erledigt. Eine Projektleitung muss wissen, wann im eigenen
+    // Projekt etwas fällig wird, auch wenn ein anderer es abarbeitet.
+    //
+    // Doppelungen werden unterdrückt: Was schon unter `tasks` steht,
+    // erscheint hier nicht noch einmal (siehe eigeneTodoIds).
+    //
+    // Der Zeitraum endet nach 21 Tagen. Ohne Grenze stünden Termine aus einem
+    // Jahr in der Liste und die dringenden gingen darin unter; überfällige
+    // bleiben dagegen ohne Altersgrenze stehen, denn eine Frist verfällt
+    // nicht dadurch, dass sie lange gerissen ist.
+    const HORIZONT_TAGE = 21;
+    let projectDates = [];
+    if(weekLabel && req.user.personId){
+      const grenzeIso = isoPlusTageLokal(HORIZONT_TAGE);
+      const heuteIso = heuteIsoLokal();
+
+      // Projekte, denen die Person in irgendeiner Rolle zugeordnet ist.
+      // state 1 = Hauptverantwortung, 2 = Unterstützung; 0 kommt in der
+      // Tabelle nicht vor (cycleAssign() löscht den Eintrag stattdessen),
+      // wird aber sicherheitshalber ausgeschlossen.
+      const meineProjekte = db.prepare(`
+        SELECT DISTINCT a.project_id AS projectId
+        FROM project_assign a
+        WHERE a.week_label = ? AND a.person_id = ? AND a.state IN (1, 2)
+      `).all(weekLabel, req.user.personId).map(r => r.projectId);
+
+      if(meineProjekte.length > 0){
+        const platzhalter = meineProjekte.map(() => '?').join(',');
+        const eigeneTodoIds = new Set(tasks.map(t => t.todoId));
+
+        // Aufgaben: offen, mit Fälligkeit, in den eigenen Projekten.
+        const todos = db.prepare(`
+          SELECT t.todo_id AS id, t.title AS titel, t.end AS datum, t.progress AS progress,
+                 t.project_id AS projectId, p.nr AS projectNr, p.name AS projectName
+          FROM plan_todos t
+          JOIN projects p ON p.week_label = t.week_label AND p.project_id = t.project_id
+          WHERE t.week_label = ? AND t.done = 0 AND t.end != ''
+            AND t.project_id IN (${platzhalter})
+        `).all(weekLabel, ...meineProjekte);
+
+        // Meilensteine: sie tragen kein Erledigt-Kennzeichen, deshalb zählt
+        // allein das Datum.
+        const milestones = db.prepare(`
+          SELECT m.milestone_id AS id, m.name AS titel, m.date AS datum,
+                 m.project_id AS projectId, p.nr AS projectNr, p.name AS projectName
+          FROM plan_milestones m
+          JOIN projects p ON p.week_label = m.week_label AND p.project_id = m.project_id
+          WHERE m.week_label = ? AND m.date != ''
+            AND m.project_id IN (${platzhalter})
+        `).all(weekLabel, ...meineProjekte);
+
+        // Zuständige je Aufgabe nachladen — getrennt, weil ein JOIN über
+        // plan_todo_assignees die Aufgabenzeile bei mehreren Zuständigen
+        // vervielfachen würde (gleiches Muster wie bei den Tags oben).
+        const namen = {};
+        db.prepare(`
+          SELECT a.todo_id AS todoId, a.project_id AS projectId, a.person_id AS personId
+          FROM plan_todo_assignees a
+          WHERE a.week_label = ? AND a.project_id IN (${platzhalter})
+        `).all(weekLabel, ...meineProjekte).forEach(r => {
+          const key = r.projectId + '|' + r.todoId;
+          (namen[key] || (namen[key] = [])).push(r.personId);
+        });
+        // Namen der Zuständigen: aus week_people der Sitzung, NICHT aus
+        // loadGlobalPeople(). Die globale Liste enthält nur Personen mit
+        // Benutzerkonto; die Teilnehmerliste einer Sitzung führt dagegen
+        // jede Person, die dort mitarbeitet. Ohne diesen Weg stand in der
+        // Terminliste "p_ap" statt "Alexander Plum".
+        const personenNamen = {};
+        db.prepare(`
+          SELECT person_id AS id, name, full_name AS fullName
+          FROM week_people WHERE week_label = ?
+        `).all(weekLabel).forEach(w => {
+          personenNamen[w.id] = w.fullName || w.name || w.id;
+        });
+
+        projectDates = todos.map(t => ({
+          art: 'aufgabe',
+          id: t.id,
+          titel: t.titel,
+          datum: t.datum,
+          progress: t.progress,
+          projectNr: t.projectNr,
+          projectName: t.projectName,
+          zustaendig: (namen[t.projectId + '|' + t.id] || [])
+            .map(pid => personenNamen[pid] || pid),
+          selbst: eigeneTodoIds.has(t.id),
+        })).concat(milestones.map(m => ({
+          art: 'meilenstein',
+          id: m.id,
+          titel: m.titel,
+          datum: m.datum,
+          projectNr: m.projectNr,
+          projectName: m.projectName,
+          zustaendig: [],
+          selbst: false,
+        })));
+
+        projectDates = projectDates
+          // Was bereits unter "Meine Aufgaben" steht, hier nicht wiederholen.
+          .filter(d => !d.selbst)
+          .filter(d => d.datum <= grenzeIso)
+          .sort((a, b) => (a.datum < b.datum ? -1 : (a.datum > b.datum ? 1 : 0)));
+
+        // Der Server liefert auch gleich die Einordnung mit, damit Browser
+        // und PDF/Export nicht jeweils eigene Stichtage rechnen.
+        projectDates.forEach(d => {
+          d.ueberfaellig = d.datum < heuteIso;
+          d.heute = d.datum === heuteIso;
+        });
+      }
+    }
+
+    const pendingReviews = db.prepare(`
+      SELECT f.id AS fileId, f.project_nr AS projectNr,
+             f.project_name AS projectName, f.original_filename AS originalFilename,
+             COALESCE(NULLIF(u.display_name, ''), u.username) AS uploadedBy,
+             f.created_at AS createdAt
+      FROM project_file_reviewers r
+      JOIN project_files f ON f.id = r.file_id
+      LEFT JOIN users u ON u.id = f.uploaded_by_user_id
+      WHERE r.user_id = ? AND r.decision = 'pending'
+      ORDER BY f.created_at DESC
+    `).all(req.user.id);
+
+    // Abwesenheiten der Kollegen: firmenweite Personenliste (loadGlobalPeople(),
+    // keine Abteilungstrennung mehr), gefiltert auf Abwesenheiten, die heute
+    // laufen oder innerhalb der nächsten 14 Tage beginnen — der Aufrufer selbst
+    // wird per person_id ausgeschlossen. Sortiert nach Startdatum; `current`
+    // markiert eine heute laufende Abwesenheit fürs Hervorheben im Dashboard.
+    const todayIso = heuteIsoLokal();
+    const horizonIso = isoPlusTageLokal(14);
+    const colleagueAbsences = [];
+    loadGlobalPeople().forEach(person => {
+      if(person.id && person.id === req.user.personId) return;
+      (person.absences || []).forEach(a => {
+        if(!a.start || !a.end) return;
+        if(a.end < todayIso || a.start > horizonIso) return;
+        colleagueAbsences.push({
+          personId: person.id,
+          name: person.fullName || person.name,
+          type: a.type,
+          note: a.note,
+          start: a.start,
+          end: a.end,
+          current: a.start <= todayIso && todayIso <= a.end,
+        });
+      });
+    });
+    colleagueAbsences.sort((a, b) => (a.start < b.start ? -1 : (a.start > b.start ? 1 : 0)));
+
+    res.json({ ok: true, weekLabel, tasks, projectDates, pendingReviews, colleagueAbsences });
   } catch(err){
-    console.error('CSV-Export fehlgeschlagen:', err);
-    if(!res.headersSent) res.status(500).json({ ok: false, error: String(err) });
+    console.error('Dashboard-Fehler', err);
+    res.status(500).json({ ok: false, error: String(err) });
   }
 });
 
+// ---------- Datei-Upload, Freigabe, Kommentare ----------
+//
+// Dateien werden über project_nr allein mit Projekten verknüpft, NICHT über
+// (week_label, project_id) — project_id wird bei jedem Wochen-Klon neu
+// generiert (cloneWeek(), public/js/weeks.js), project_nr bleibt über den
+// gesamten Projektlebenszyklus stabil und identifiziert seit der Zusammen-
+// führung gleichnummeriger Projekte über ehemalige Abteilungsgrenzen hinweg
+// eindeutig das eine logische Projekt. Ein Projekt ohne project_nr kann daher
+// keine Dateien erhalten.
+//
+// Sicherheitskritisch: original_filename/project_nr/project_name/filename
+// (Client-Eingaben) werden NIEMALS in einen Dateisystempfad eingesetzt. Der
+// Pfad setzt sich ausschließlich aus einer serverseitig erzeugten UUID
+// (stored_name) zusammen; original_filename dient nur als Anzeige-/
+// Download-Header-Wert.
+
+// UPLOADS_DIR: Basisverzeichnis für hochgeladene Projektdateien
+// ein Unterordner (lazy angelegt, siehe uploadDirFor()).
+const UPLOADS_DIR = path.join(SESSIONS_DIR, 'uploads');
+
+// uploadDirFor: liefert (und legt bei Bedarf an) das Upload-Verzeichnis einer
+// Abteilung. Parameter department MUSS bereits gegen VALID_DEPARTMENTS
+// geprüft sein (nur dann sind ausschließlich 'ELT'/'HLS'/'ARCH' möglich).
+function uploadDirFor(){
+  if(!fs.existsSync(UPLOADS_DIR)) fs.mkdirSync(UPLOADS_DIR, { recursive: true });
+  return UPLOADS_DIR;
+}
+
+// extractFileExtension: extrahiert per Whitelist-Regex eine kurze
+// alphanumerische Dateiendung aus einem (nicht vertrauenswürdigen)
+// Dateinamen. Kein Treffer (z. B. kein Punkt, zu lange/exotische Endung) →
+// leerer String, kein Fehler.
+function extractFileExtension(filename){
+  const m = String(filename || '').match(/\.([a-zA-Z0-9]{1,8})$/);
+  return m ? m[1].toLowerCase() : '';
+}
+
+// serializeFileRow: wandelt eine project_files-Zeile (ggf. mit JOIN-Feldern)
+// in die öffentliche Repräsentation für GET /project-files um.
+function serializeFileRow(row){
+  return {
+    id: row.id,
+    projectNr: row.project_nr,
+    projectName: row.project_name,
+    originalFilename: row.original_filename,
+    contentType: row.content_type,
+    sizeBytes: row.size_bytes,
+    status: row.status,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    uploadedBy: row.uploadedBy,
+    // Uploader-ID mitgeben: Der Client kann den "Löschen"-Knopf sonst nicht
+    // an dieselbe Regel binden, die der Server durchsetzt (Uploader, solange
+    // die Datei offen ist — oder Admin).
+    uploadedByUserId: row.uploaded_by_user_id,
+  };
+}
+
+// Route: Liste aller aktiven Benutzer (ohne Passwortfelder, ohne inaktive
+// Konten) — für die Prüfer-Auswahl beim Datei-Upload. Bewusst für JEDEN
+// eingeloggten Benutzer zugänglich (requireAuth, nicht requireRole('admin')),
+// da jeder Uploader Prüfer auswählen muss; getrennt von GET /admin/users
+// (admin-only, zeigt zusätzlich inaktive Konten + mehr Felder).
+app.get('/users', requireAuth, (req, res) => {
+  try {
+    // role != 'kiosk': das Wandtafel-Konto ist kein Teammitglied — es soll
+    // weder im Datei-Freigabe-Prüfer-Auswahlfeld noch in der
+    // abteilungsübergreifenden Besetzung zur Wahl stehen.
+    const rows = db.prepare("SELECT id, username, display_name, email, person_id, department, initials FROM users WHERE active = 1 AND role != 'kiosk' ORDER BY display_name, username").all();
+    const rolesByUser = loadUserRolesByUserId();
+    res.json({ ok: true, users: rows.map(r => ({
+      id: r.id, username: r.username, displayName: r.display_name, email: r.email,
+      personId: r.person_id, department: r.department, initials: r.initials,
+      roles: rolesByUser[r.id] || [],
+    })) });
+  } catch(err){
+    console.error('Benutzerliste fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Abwesenheit für einen Benutzer anlegen. Bewusst NICHT admin-only und
+// bewusst auch für FREMDE Konten erlaubt: In der Praxis trägt die
+// Projektleitung Urlaube ihres Teams mit ein. Wer den Eintrag angelegt hat,
+// wird in created_by festgehalten — das Löschen ist dadurch nachvollziehbar
+// eingeschränkt (siehe DELETE-Route unten).
+app.post('/users/:id/absences', requireAuth, (req, res) => {
+  const id = Number(req.params.id);
+  const user = db.prepare('SELECT id FROM users WHERE id = ?').get(id);
+  if(!user) return res.status(404).json({ ok: false, error: 'Benutzer nicht gefunden.' });
+  const { start, end, type, note } = req.body || {};
+  if(!start || !String(start).trim() || !end || !String(end).trim()){
+    return res.status(400).json({ ok: false, error: 'Start- und Enddatum erforderlich.' });
+  }
+  try {
+    const absenceId = crypto.randomUUID();
+    db.prepare('INSERT INTO user_absences (user_id, id, start, end, type, note, created_by) VALUES (?, ?, ?, ?, ?, ?, ?)')
+      .run(id, absenceId, String(start), String(end), String(type || ''), String(note || ''), req.user.id);
+    res.json({ ok: true, absence: { id: absenceId, start: String(start), end: String(end), type: String(type || ''), note: String(note || '') } });
+  } catch(err){
+    console.error('Abwesenheit anlegen fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Abwesenheit löschen (idempotent — auch ok, wenn nichts gelöscht wurde).
+// Erlaubt für: die betroffene Person selbst, wer den Eintrag angelegt hat, und
+// Administratoren. Ohne diese Prüfung konnte jedes angemeldete Konto fremde
+// Urlaube entfernen und damit unbemerkt die Ressourcenplanung verfälschen.
+app.delete('/users/:id/absences/:absenceId', requireAuth, (req, res) => {
+  try {
+    const targetUserId = Number(req.params.id);
+    const row = db.prepare('SELECT created_by FROM user_absences WHERE user_id = ? AND id = ?')
+      .get(targetUserId, req.params.absenceId);
+    if(row){
+      const istAdmin = req.user.role === 'admin';
+      const istBetroffener = req.user.id === targetUserId;
+      const istErsteller = row.created_by && row.created_by === req.user.id;
+      if(!istAdmin && !istBetroffener && !istErsteller){
+        return res.status(403).json({
+          ok: false,
+          error: 'Diese Abwesenheit wurde von einer anderen Person eingetragen. Nur sie selbst, die betroffene Person oder ein Administrator kann sie entfernen.'
+        });
+      }
+    }
+    db.prepare('DELETE FROM user_absences WHERE user_id = ? AND id = ?').run(targetUserId, req.params.absenceId);
+    res.json({ ok: true });
+  } catch(err){
+    console.error('Abwesenheit löschen fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Datei-Upload für ein Projekt. Roher Binär-Body (wie /import), Metadaten
+// als Query-Parameter, da der Body ausschließlich die Datei selbst enthält.
+app.post('/project-files', requireAuth, express.raw({ type: '*/*', limit: '200mb' }), (req, res) => {
+  try {
+    const projectNr = String(req.query.projectNr || '');
+    if(!projectNr) return res.status(400).json({ ok: false, error: 'Projekt hat keine Projektnummer.' });
+    const projectName = String(req.query.projectName || '');
+
+    const buf = req.body;
+    if(!Buffer.isBuffer(buf) || buf.length === 0){
+      return res.status(400).json({ ok: false, error: 'Keine Datei empfangen' });
+    }
+
+    let filename = '';
+    try { filename = decodeURIComponent(String(req.query.filename || '')); }
+    catch(e){ filename = String(req.query.filename || ''); }
+    const ext = extractFileExtension(filename);
+
+    // Reviewer-Parameter: Komma-getrennte IDs -> Zahlen -> nur existierende,
+    // aktive Benutzer -> Uploader (kein Self-Review) entfernen.
+    const rawReviewerIds = String(req.query.reviewers || '')
+      .split(',')
+      .map(s => Number(s.trim()))
+      .filter(n => Number.isInteger(n) && n > 0);
+    const activeUsers = db.prepare('SELECT id FROM users WHERE active = 1').all().map(r => r.id);
+    const activeSet = new Set(activeUsers);
+    const reviewerIds = Array.from(new Set(rawReviewerIds))
+      .filter(id => activeSet.has(id) && id !== req.user.id);
+    if(reviewerIds.length === 0){
+      return res.status(400).json({ ok: false, error: 'Mindestens ein Prüfer erforderlich.' });
+    }
+
+    const id = crypto.randomUUID();
+    const storedName = id + (ext ? '.' + ext : '');
+    const dir = uploadDirFor();
+    fs.writeFileSync(path.join(dir, storedName), buf);
+
+    const contentType = req.headers['content-type'] || 'application/octet-stream';
+    const now = new Date().toISOString();
+
+    db.exec('BEGIN');
+    try {
+      db.prepare(`INSERT INTO project_files
+          (id, project_nr, project_name, original_filename, stored_name, content_type, size_bytes, uploaded_by_user_id, status, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?)`)
+        .run(id, projectNr, projectName, filename || storedName, storedName, contentType, buf.length, req.user.id, now, now);
+      const insReviewer = db.prepare(`INSERT INTO project_file_reviewers (file_id, user_id, decision, decided_at, note) VALUES (?, ?, 'pending', '', '')`);
+      reviewerIds.forEach(uid => insReviewer.run(id, uid));
+      db.exec('COMMIT');
+    } catch(err){
+      db.exec('ROLLBACK');
+      // Bereits geschriebene Datei bei Fehler wieder entfernen (best effort).
+      fs.unlink(path.join(dir, storedName), () => {});
+      throw err;
+    }
+
+    console.log('Datei hochgeladen:', projectNr, '-', filename || storedName);
+    res.json({
+      ok: true,
+      file: {
+        id, projectNr, projectName,
+        originalFilename: filename || storedName,
+        contentType, sizeBytes: buf.length, status: 'pending', createdAt: now,
+        uploadedBy: req.user.displayName,
+      }
+    });
+  } catch(err){
+    console.error('Datei-Upload fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Liste aller Dateien eines Projekts (project_nr), inkl. Uploader-Name,
+// Prüferstatus je Prüfer und Kommentaranzahl.
+app.get('/project-files', requireAuth, (req, res) => {
+  try {
+    const projectNr = String(req.query.projectNr || '');
+    const rows = db.prepare(`
+      SELECT f.*, COALESCE(NULLIF(u.display_name, ''), u.username) AS uploadedBy
+      FROM project_files f
+      LEFT JOIN users u ON u.id = f.uploaded_by_user_id
+      WHERE f.project_nr = ?
+      ORDER BY f.created_at DESC
+    `).all(projectNr);
+    const reviewerStmt = db.prepare(`
+      SELECT r.user_id AS userId, COALESCE(NULLIF(u.display_name, ''), u.username) AS displayName, r.decision AS decision
+      FROM project_file_reviewers r
+      LEFT JOIN users u ON u.id = r.user_id
+      WHERE r.file_id = ?
+    `);
+    const commentCountStmt = db.prepare('SELECT COUNT(*) AS c FROM project_file_comments WHERE file_id = ?');
+    const files = rows.map(row => {
+      const out = serializeFileRow(row);
+      out.reviewers = reviewerStmt.all(row.id);
+      out.commentCount = commentCountStmt.get(row.id).c;
+      return out;
+    });
+    res.json({ ok: true, files });
+  } catch(err){
+    console.error('Dateiliste fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Datei-Download. Der Dateisystempfad besteht ausschließlich aus der
+// (server-seitig erzeugten) stored_name-UUID — original_filename fließt NUR
+// in den Content-Disposition-Header ein (zweites res.download()-Argument),
+// niemals in den Pfad.
+app.get('/project-files/:id/download', requireAuth, (req, res) => {
+  try {
+    const row = db.prepare('SELECT * FROM project_files WHERE id = ?').get(req.params.id);
+    if(!row) return res.status(404).json({ ok: false, error: 'Datei nicht gefunden.' });
+    const filePath = path.join(UPLOADS_DIR, row.stored_name);
+    res.download(filePath, row.original_filename, (err) => {
+      if(err && !res.headersSent){
+        console.error('Datei-Download fehlgeschlagen:', err);
+        res.status(404).json({ ok: false, error: 'Datei nicht gefunden.' });
+      }
+    });
+  } catch(err){
+    console.error('Datei-Download fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Freigabe-Entscheidung eines Prüfers. Nur möglich, solange der
+// Gesamtstatus der Datei noch nicht terminal (approved/rejected) ist, und nur
+// für Benutzer, die tatsächlich als Prüfer für diese Datei eingetragen sind.
+// Neuberechnung des Gesamtstatus: eine Ablehnung blockiert sofort; erst wenn
+// ALLE Prüfer zugestimmt haben, gilt die Datei als freigegeben.
+app.post('/project-files/:id/review', requireAuth, (req, res) => {
+  try {
+    const fileRow = db.prepare('SELECT * FROM project_files WHERE id = ?').get(req.params.id);
+    if(!fileRow) return res.status(404).json({ ok: false, error: 'Datei nicht gefunden.' });
+
+    const { decision, note } = req.body || {};
+    if(decision !== 'approved' && decision !== 'rejected'){
+      return res.status(400).json({ ok: false, error: 'Ungültige Entscheidung.' });
+    }
+
+    const reviewerRow = db.prepare('SELECT * FROM project_file_reviewers WHERE file_id = ? AND user_id = ?').get(fileRow.id, req.user.id);
+    if(!reviewerRow) return res.status(403).json({ ok: false, error: 'Sie sind für diese Datei nicht als Prüfer eingetragen.' });
+
+    if(fileRow.status === 'approved' || fileRow.status === 'rejected'){
+      return res.status(409).json({ ok: false, error: 'Über diese Datei wurde bereits abschließend entschieden.' });
+    }
+
+    const now = new Date().toISOString();
+    db.prepare('UPDATE project_file_reviewers SET decision = ?, decided_at = ?, note = ? WHERE file_id = ? AND user_id = ?')
+      .run(decision, now, String(note || ''), fileRow.id, req.user.id);
+
+    const allDecisions = db.prepare('SELECT decision FROM project_file_reviewers WHERE file_id = ?').all(fileRow.id).map(r => r.decision);
+    let newStatus = 'pending';
+    if(allDecisions.some(d => d === 'rejected')) newStatus = 'rejected';
+    else if(allDecisions.length > 0 && allDecisions.every(d => d === 'approved')) newStatus = 'approved';
+
+    db.prepare('UPDATE project_files SET status = ?, updated_at = ? WHERE id = ?').run(newStatus, now, fileRow.id);
+    console.log('Datei-Freigabe:', fileRow.id, '-', req.user.username, '->', decision, '(Gesamtstatus:', newStatus + ')');
+    res.json({ ok: true, status: newStatus });
+  } catch(err){
+    console.error('Freigabe-Entscheidung fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Kommentare einer Datei lesen (chronologisch aufsteigend).
+app.get('/project-files/:id/comments', requireAuth, (req, res) => {
+  try {
+    const rows = db.prepare(`
+      SELECT c.id AS id, c.user_id AS userId, COALESCE(NULLIF(u.display_name, ''), u.username) AS displayName,
+             c.body AS body, c.created_at AS createdAt
+      FROM project_file_comments c
+      LEFT JOIN users u ON u.id = c.user_id
+      WHERE c.file_id = ?
+      ORDER BY c.created_at ASC
+    `).all(req.params.id);
+    res.json({ ok: true, comments: rows });
+  } catch(err){
+    console.error('Kommentare laden fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Kommentar zu einer Datei hinzufügen. Jeder eingeloggte Benutzer darf
+// kommentieren, nicht nur die eingetragenen Prüfer.
+app.post('/project-files/:id/comments', requireAuth, (req, res) => {
+  try {
+    const fileRow = db.prepare('SELECT id FROM project_files WHERE id = ?').get(req.params.id);
+    if(!fileRow) return res.status(404).json({ ok: false, error: 'Datei nicht gefunden.' });
+    const body = String((req.body || {}).body || '').trim();
+    if(!body) return res.status(400).json({ ok: false, error: 'Kommentartext erforderlich.' });
+    const id = crypto.randomUUID();
+    const now = new Date().toISOString();
+    db.prepare('INSERT INTO project_file_comments (id, file_id, user_id, body, created_at) VALUES (?, ?, ?, ?, ?)')
+      .run(id, fileRow.id, req.user.id, body, now);
+    res.json({ ok: true, comment: { id, userId: req.user.id, displayName: req.user.displayName, body, createdAt: now } });
+  } catch(err){
+    console.error('Kommentar anlegen fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Datei löschen. Erlaubt für den Uploader, solange die Datei noch
+// 'pending' ist, oder jederzeit für Admins. Löscht zuerst die DB-Zeile
+// (inkl. abhängiger Prüfer-/Kommentar-Zeilen — explizit statt sich auf eine
+// FK-CASCADE zu verlassen, da project_file_reviewers/project_file_comments
+// keine deklarierten FOREIGN KEY-Constraints auf project_files haben), dann
+// best-effort die physische Datei.
+app.delete('/project-files/:id', requireAuth, (req, res) => {
+  try {
+    const row = db.prepare('SELECT * FROM project_files WHERE id = ?').get(req.params.id);
+    if(!row) return res.status(404).json({ ok: false, error: 'Datei nicht gefunden.' });
+
+    const isOwnerAndPending = (req.user.id === row.uploaded_by_user_id) && row.status === 'pending';
+    const isAdmin = req.user.role === 'admin';
+    if(!isOwnerAndPending && !isAdmin){
+      return res.status(403).json({ ok: false, error: 'Keine Berechtigung, diese Datei zu löschen.' });
+    }
+
+    db.exec('BEGIN');
+    try {
+      db.prepare('DELETE FROM project_file_comments WHERE file_id = ?').run(row.id);
+      db.prepare('DELETE FROM project_file_reviewers WHERE file_id = ?').run(row.id);
+      db.prepare('DELETE FROM project_files WHERE id = ?').run(row.id);
+      db.exec('COMMIT');
+    } catch(err){
+      db.exec('ROLLBACK');
+      throw err;
+    }
+    fs.unlink(path.join(UPLOADS_DIR, row.stored_name), (err) => {
+      if(err) console.error('Physische Datei konnte nicht gelöscht werden:', err);
+    });
+    console.log('Datei gelöscht:', row.id, '-', row.original_filename);
+    res.json({ ok: true });
+  } catch(err){
+    console.error('Datei löschen fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// ---------- Protokolle (Besprechungsprotokolle je Projekt) ----------
+//
+// Verknüpft über project_nr (siehe Tabellendefinition oben), nicht über
+// week_label/project_id. Speichermuster: eigene Routen, aber "ganzes Objekt
+// ersetzen" wie saveWeekRelational()/deleteWeekData() (Zeilen löschen, neu
+// einfügen, in einer Transaktion) statt vieler kleiner Einzel-Feld-Routen —
+// Punkte und Teilnehmer werden ohnehin gemeinsam in einer Sitzung bearbeitet.
+
+// loadProtokollDetail: baut ein volles Protokoll (Kopfdaten + Teilnehmer +
+// Punkte) für die Antwort von GET/POST/PUT zusammen. Parameter: id.
+// Rückgabe: Objekt oder null, wenn nicht gefunden.
+function loadProtokollDetail(id){
+  const row = db.prepare(`SELECT p.*, u.display_name AS verfasser_name
+    FROM project_protokolle p LEFT JOIN users u ON u.id = p.verfasser_user_id
+    WHERE p.id = ?`).get(id);
+  if(!row) return null;
+  const teilnehmer = db.prepare('SELECT * FROM protokoll_teilnehmer WHERE protokoll_id = ? ORDER BY array_order').all(row.id)
+    .map(t => ({ id: t.id, name: t.name, firma: t.firma, anwesend: !!t.anwesend }));
+
+  // vorherigeWerte: Thema/Text des UNMITTELBAR vorangegangenen Protokolls
+  // (chronologisch davor, per nummer), je stamm_id — Grundlage für
+  // themaGeaendert/textGeaendert unten (Eriks Wunsch): ein fortgeschriebener
+  // Punkt (neu=0), dessen Thema oder Text sich gegenüber der letzten Fassung
+  // geändert hat, soll das erkennbar machen, aber nur AN DEM GEÄNDERTEN FELD
+  // (gelb), nicht an der ganzen Zeile wie bei einem echten neuen Punkt
+  // (.is-neu) — ein neuer Punkt hat ohnehin keine Vorfassung zum Vergleichen.
+  const prevRow = db.prepare(`SELECT id FROM project_protokolle
+    WHERE project_nr = ? AND nummer < ? ORDER BY nummer DESC LIMIT 1`).get(row.project_nr, row.nummer);
+  const vorherigeWerte = new Map();
+  if(prevRow){
+    db.prepare('SELECT stamm_id, thema, text FROM protokoll_punkte WHERE protokoll_id = ?').all(prevRow.id)
+      .forEach(p => vorherigeWerte.set(p.stamm_id, { thema: p.thema, text: p.text }));
+  }
+
+  const punkte = db.prepare('SELECT * FROM protokoll_punkte WHERE protokoll_id = ? ORDER BY array_order').all(row.id)
+    .map(p => {
+      const vorher = !p.neu ? vorherigeWerte.get(p.stamm_id) : null;
+      return { id: p.id, nummer: p.nummer, gruppe: p.gruppe, neu: !!p.neu, thema: p.thema, text: p.text,
+        zustaendig: p.zustaendig, termin: p.termin, status: p.status || 'offen', erstelltAm: p.erstellt_am || '',
+        entfaelltNaechstes: !!p.entfaellt_naechstes,
+        themaGeaendert: !!(vorher && vorher.thema !== p.thema),
+        textGeaendert: !!(vorher && vorher.text !== p.text) };
+    });
+  return {
+    id: row.id, projectNr: row.project_nr, projectName: row.project_name, nummer: row.nummer,
+    datum: row.datum, betreff: row.betreff, ort: row.ort, verfasserName: row.verfasser_name || '',
+    weekLabel: row.week_label, quelleDateiname: row.quelle_dateiname || '',
+    createdAt: row.created_at, updatedAt: row.updated_at,
+    teilnehmer, punkte
+  };
+}
+
+// Route: Liste aller Protokolle eines Projekts (Zusammenfassung je Protokoll
+// für die Listenansicht — offene/erledigte Punkte, Teilnehmerzahl —, nicht
+// die vollen Punkte/Teilnehmer, das liefert erst GET /:id).
+app.get('/project-protokolle', requireAuth, (req, res) => {
+  try {
+    const projectNr = String(req.query.projectNr || '');
+    if(!projectNr) return res.status(400).json({ ok: false, error: 'Projekt hat keine Projektnummer.' });
+    const rows = db.prepare(`SELECT p.*, u.display_name AS verfasser_name
+      FROM project_protokolle p LEFT JOIN users u ON u.id = p.verfasser_user_id
+      WHERE p.project_nr = ? ORDER BY p.nummer DESC`).all(projectNr);
+    const protokolle = rows.map(row => {
+      const punkte = db.prepare('SELECT status FROM protokoll_punkte WHERE protokoll_id = ?').all(row.id);
+      const teilnehmerCount = db.prepare('SELECT COUNT(*) AS c FROM protokoll_teilnehmer WHERE protokoll_id = ?').get(row.id).c;
+      const offenCount = punkte.filter(p => p.status === 'offen').length;
+      return {
+        id: row.id, nummer: row.nummer, datum: row.datum, betreff: row.betreff, ort: row.ort,
+        verfasserName: row.verfasser_name || '', createdAt: row.created_at,
+        offenCount, erledigtCount: punkte.length - offenCount, teilnehmerCount
+      };
+    });
+    res.json({ ok: true, protokolle });
+  } catch(err){
+    console.error('Protokolle laden fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+app.get('/project-protokolle/:id', requireAuth, (req, res) => {
+  try {
+    const protokoll = loadProtokollDetail(req.params.id);
+    if(!protokoll) return res.status(404).json({ ok: false, error: 'Protokoll nicht gefunden.' });
+    res.json({ ok: true, protokoll });
+  } catch(err){
+    console.error('Protokoll laden fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: neues Protokoll anlegen. nummer wird serverseitig vergeben
+// (MAX(nummer)+1 je project_nr, sonst 1); Teilnehmer kommen vorbelegt vom
+// Client (siehe js/plan/plan-protokoll.js); offene Punkte des zuletzt
+// angelegten Protokolls desselben Projekts werden KOPIERT (neue id, gleiche
+// stamm_id/nummer, neu=0) — das "Fortschreiben". Im allerersten Protokoll
+// eines Projekts gibt es nichts zu kopieren, dort sind zwangsläufig alle
+// später hinzugefügten Punkte neu.
+// legeProtokollAn: die gemeinsame Anlege-Logik für ein neues Protokoll —
+// genutzt sowohl von POST /project-protokolle (manuelles Anlegen) als auch
+// von POST /project-protokolle/import (Datei-Import, siehe unten). Beide
+// Wege sollen ein Protokoll auf exakt dieselbe Art in die Sitzungsfolge
+// einreihen: nummer fortlaufend je project_nr, offene Punkte des zuletzt
+// angelegten Protokolls desselben Projekts kopiert (das "Fortschreiben",
+// siehe CLAUDE.md "### Protokolle"). Der Import hängt danach zusätzlich
+// erkannte Punkte an (`zusatzPunkte`) — beim manuellen Anlegen ist dieses
+// Array einfach leer.
+// Parameter: { projectNr, projectName, weekLabel, datum, betreff, ort,
+// verfasserUserId, teilnehmer, zusatzPunkte, quelleDateiname,
+// quelleStoredName } — die letzten beiden bleiben leer für ein normal
+// angelegtes Protokoll. Läuft in einer eigenen Transaktion. Rückgabe: die
+// neue Protokoll-`id`. Wirft bei einem Fehler (Aufrufer fangen und in eine
+// HTTP-Antwort übersetzen).
+// VALID_PROTOKOLL_PUNKT_STATUS: der Status eines Punkts — 'offen' (läuft
+// weiter, wird fortgeschrieben), 'erledigt' (abgeschlossen) oder 'info'
+// (rein informativ, keine eigene Handlung nötig — z. B. eine bereits
+// zur Kenntnis genommene Mitteilung). Nur 'offen' wird beim Anlegen des
+// nächsten Protokolls fortgeschrieben (legeProtokollAn()); sowohl
+// 'erledigt' als auch 'info' laufen nicht weiter mit, aus demselben Grund:
+// beides ist nichts mehr, worauf jemand noch reagieren muss.
+const VALID_PROTOKOLL_PUNKT_STATUS = new Set(['offen', 'erledigt', 'info']);
+// PROTOKOLL_PUNKT_MARKER: erkennt einen Zeilenanfang wie "1.1", "TOP 3",
+// "Punkt 2.4" oder "1." als Beginn eines neuen Punkts; der Rest der Zeile
+// wird dessen Thema. Ein Regex-Satz für mehrere gängige Schreibweisen, kein
+// Anspruch auf Vollständigkeit — siehe erkennePunkteAusText().
+const PROTOKOLL_PUNKT_MARKER = /^\s*(?:top|punkt)?\s*(\d+(?:\.\d+)*)[.\):]?\s+(.+)$/i;
+// PROTOKOLL_LABEL_MUSTER: Label-Muster, die INNERHALB eines erkannten
+// Punkttexts nach Zuständig/Termin suchen — nur bei eindeutigem Treffer
+// übernommen (siehe erkennePunkteAusText()).
+// Nicht-gierig bis zum nächsten Satzende, Zeilenende ODER dem nächsten
+// bekannten Label — sonst reißt z. B. "Zuständig: Firma Muster. Termin: …"
+// (beides auf einer Zeile, ohne Komma dazwischen) den Termin-Teil mit in den
+// Zuständig-Treffer hinein. Ein Punkt gilt nur als Satzende, wenn ihm keine
+// Ziffer folgt — sonst würde ein Datum wie "15.10.2026" beim ersten Punkt
+// abgeschnitten.
+const PROTOKOLL_LABEL_STOP = '(?=[,;]|\\.(?!\\d)|$|\\s*(?:zust[äa]ndig|verantwortlich|termin|frist)\\s*:)';
+const PROTOKOLL_LABEL_MUSTER = [
+  { feld: 'zustaendig', regex: new RegExp('(?:zust[äa]ndig|verantwortlich)\\s*:\\s*([^,;]+?)' + PROTOKOLL_LABEL_STOP, 'i') },
+  { feld: 'termin', regex: new RegExp('(?:termin|frist)\\s*:\\s*([^,;]+?)' + PROTOKOLL_LABEL_STOP, 'i') }
+];
+
+// erkennePunkteAusText: reines String-Processing ohne I/O (kein Netzwerk,
+// keine KI) — teilt einen aus PDF/Word extrahierten Freitext heuristisch in
+// Protokoll-Punkte auf. Siehe CLAUDE.md "### Protokolle" für die Begründung
+// jeder Regel. Erkennt PROTOKOLL_PUNKT_MARKER-Zeilen als neue Punkte, alles
+// dazwischen wird deren Text; findet sich darin ein PROTOKOLL_LABEL_MUSTER,
+// wird der Wert herausgelöst statt im Fließtext zu bleiben. `gruppe` wird
+// bewusst NIE geraten — jeder erkannte Punkt landet in "Ohne Gruppe", der
+// Nutzer ordnet in der ohnehin vorhandenen Detailansicht selbst zu. Findet
+// sich im ganzen Text kein einziger Marker (keine erkennbare Nummerierung),
+// greift ein Fallback: jeder nicht-leere Absatz (durch Leerzeile getrennt)
+// wird ein eigener Punkt — liefert immer ein Grundgerüst statt eines leeren
+// Protokolls. `nummer` hier ist rein informationell (die im Quelldokument
+// gefundene Nummer) — angezeigt wird sie ohnehin nie aus der Datenbank,
+// sondern immer frisch aus Gruppe+Reihenfolge errechnet
+// (berechneProtokollNummern(), public/js/plan/plan-protokoll.js).
+// Parameter: text (String). Rückgabe: Array von
+// { nummer, gruppe, thema, text, zustaendig, termin, erledigt }.
+function erkennePunkteAusText(text){
+  const zeilen = String(text || '').split(/\r?\n/).map(z => z.trim());
+
+  const treffer = [];
+  let aktuell = null;
+  zeilen.forEach(zeile => {
+    if(!zeile) return;
+    const m = zeile.match(PROTOKOLL_PUNKT_MARKER);
+    if(m){
+      if(aktuell) treffer.push(aktuell);
+      aktuell = { nummer: m[1], thema: m[2].trim(), textZeilen: [], zustaendig: '', termin: '', erledigt: false };
+    } else if(aktuell){
+      aktuell.textZeilen.push(zeile);
+    }
+  });
+  if(aktuell) treffer.push(aktuell);
+
+  if(treffer.length === 0){
+    return String(text || '').split(/\r?\n\s*\r?\n/)
+      .map(a => a.replace(/\s+/g, ' ').trim())
+      .filter(Boolean)
+      .map(a => ({
+        nummer: '', gruppe: '', thema: a.slice(0, 60), text: a.length > 60 ? a : '',
+        zustaendig: '', termin: '', erledigt: false
+      }));
+  }
+
+  return treffer.map(t => {
+    // Labels wie "Zuständig:"/"Termin:" stehen bei kurzen Punkten oft in
+    // derselben Zeile wie das Thema (ein Word-Absatz je Punkt), nicht in
+    // einer eigenen Folgezeile — deshalb wird über Thema UND die
+    // nachfolgenden Zeilen gemeinsam gesucht, nicht nur über Letztere.
+    let thema = t.thema;
+    let restText = t.textZeilen.join(' ').replace(/\s+/g, ' ').trim();
+    PROTOKOLL_LABEL_MUSTER.forEach(({ feld, regex }) => {
+      let lm = thema.match(regex);
+      if(lm){
+        t[feld] = lm[1].trim();
+        thema = thema.replace(lm[0], '').trim();
+        return;
+      }
+      lm = restText.match(regex);
+      if(lm){
+        t[feld] = lm[1].trim();
+        restText = restText.replace(lm[0], '').trim();
+      }
+    });
+    // Entfernen eines Labels aus der Mitte des Themas kann einen
+    // verwaisten Satzpunkt zurücklassen ("…abzuschließen. ." statt
+    // "…abzuschließen.") — am Ende auf einen einzigen Punkt einkürzen.
+    thema = thema.replace(/[.\s]+$/, m => (m.indexOf('.') !== -1 ? '.' : '')).trim();
+    const erledigt = /\berledigt\b|\bgeschlossen\b/i.test(restText) || /\berledigt\b|\bgeschlossen\b/i.test(thema);
+    return { nummer: t.nummer, gruppe: '', thema, text: restText,
+      zustaendig: t.zustaendig, termin: t.termin, erledigt };
+  });
+}
+
+// ---------- KI-gestützte Erkennung (ChatGPT/Claude) für den Protokoll-Import ----------
+//
+// Alternative zu erkennePunkteAusText() oben: statt starrer Regex-Muster
+// liest ein Sprachmodell den Text und liefert dieselbe Punkt-Form zurück.
+// Bewusst zusätzlich zur Heuristik, nicht statt ihr — siehe CLAUDE.md
+// "### Protokolle": ohne hinterlegten Schlüssel oder bei jedem Fehler
+// (Netzwerk, falscher Schlüssel, Zeitüberschreitung, unerwartete Antwort)
+// fällt der Aufrufer (POST /project-protokolle/import) automatisch auf
+// erkennePunkteAusText() zurück — der Import funktioniert immer, auch ohne
+// Internetzugang des Servers. Beide Anbieter laufen über das in Node bereits
+// global verfügbare fetch() — keine neue npm-Abhängigkeit.
+
+const KI_MAX_TEXT_LAENGE = 40000; // ~10k Tokens; deckelt Kosten/Dauer bei
+  // einer versehentlich riesigen Datei, reicht für jedes normale Protokoll.
+const KI_TIMEOUT_MS_CLOUD = 45000;
+// Ein lokal laufender Server (LM Studio, Ollama) rechnet auf der eigenen
+// Maschine, oft ohne oder mit begrenzter GPU-Beschleunigung — eine einzelne
+// Antwort kann mehrere Minuten dauern, weit jenseits dessen, was bei einer
+// Cloud-API schon ein Hänger wäre. Mit dem kurzen, einheitlichen Timeout
+// brach die Anfrage bei Erik vorzeitig ab ("This operation was aborted"),
+// obwohl LM Studio nachweislich weiterrechnete und fertig geworden wäre
+// ("läuft aber durch"). Ein kurzer, einheitlicher Timeout hätte lokale
+// Modelle damit praktisch unbenutzbar gemacht. Ursprünglich 300000 (5 min),
+// dann 900000 (15 min) — beide brachen bei Erik immer noch ab, vor allem
+// seit der Prompt jetzt für jeden erkannten Punkt echten Fließtext erzeugt
+// (also deutlich mehr Tokens generiert als die frühere, kaputte Fassung,
+// die oft fast leer blieb): bei ~12.000 generierten Tokens auf seiner
+// Hardware lief LM Studio selbst nachweislich sauber bis zum Ende durch
+// (vom eigenen "Fertig"-Zustand im LM-Studio-Fenster bestätigt), nur die
+// eigene AbortController-Schranke hier griff vorher. Auf 30 Minuten
+// angehoben, mit entsprechendem Headroom bei LOKAL_DISPATCHER (unten).
+// Der Import zeigt währenddessen den Ladehinweis im Dialog
+// (#protokollImportLoading, plan-protokoll.js), das lange Warten ist also
+// sichtbar, kein scheinbares Hängenbleiben.
+const KI_TIMEOUT_MS_LOKAL = 1800000;
+
+// LOKAL_DISPATCHER: Node's globales fetch() läuft intern über undici, dessen
+// eigener Standard-Agent Verbindungen nach headersTimeout/bodyTimeout = 5
+// Minuten von sich aus kappt — UNABHÄNGIG vom eigenen AbortController unten.
+// Solange KI_TIMEOUT_MS_LOKAL ebenfalls bei 5 Minuten lag, fiel das nicht
+// auf: beide Zeitgeber liefen praktisch gleichzeitig ab, und man sah immer
+// den eigenen, sauberen "This operation was aborted"-Abbruch. Nach dem
+// Anheben auf 15 Minuten griff undicis eigenes 5-Minuten-Limit als Erstes —
+// bei Erik reproduzierbar als "fetch failed", obwohl LM Studio selbst
+// nachweislich sauber durchlief. Ein eigener Agent mit angehobenem Limit
+// ist die einzige Möglichkeit, das zu umgehen: fetch() selbst bietet dafür
+// keine Option, nur das (nicht standardisierte, aber von Node übernommene)
+// `dispatcher`-Feld in den Request-Optionen. Nur für lokale Ziele
+// verwendet — eine Cloud-API bleibt beim kurzen KI_TIMEOUT_MS_CLOUD (45s),
+// weit unter undicis Vorgabewert, dort besteht das Problem gar nicht.
+const LOKAL_DISPATCHER = new UndiciAgent({
+  headersTimeout: KI_TIMEOUT_MS_LOKAL + 10000,
+  bodyTimeout: KI_TIMEOUT_MS_LOKAL + 10000
+});
+
+// KI_SYSTEM_PROMPT wurde NICHT nach Stil-/Rechtschreibkonvention geglättet,
+// sondern bewusst wortgleich zu der Fassung übernommen, die gegen ein
+// echtes, mehrstufig nummeriertes Besprechungsprotokoll (PromanX/Phenix-
+// Format: "01" Kapitel, "01.0" Unterkapitel, "01.0 01.03" der eigentliche
+// Punkt) tatsächlich funktioniert hat — gegen Eriks lokales LM-Studio-Modell
+// erwies sich das Ergebnis als erstaunlich instabil gegenüber minimalen
+// Formulierungsänderungen: dieselbe Aufgabe lieferte je nach Umformulierung
+// zwischen 0 und 11 erkannten Punkten, mal mit vollem Text, mal mit
+// durchgehend LEEREM "text" (reproduzierbar bei temperature:0, also keine
+// bloße Zufallsstreuung). Ursache war u. a. eine vorangestellte, allgemein
+// gehaltene "erfinde nichts, lass im Zweifel leer"-Anweisung, die das
+// Modell offenbar dazu brachte, aus Vorsicht auch "text" leer zu lassen,
+// obwohl der Inhalt eindeutig im Dokument stand — das genaue Gegenteil des
+// gemeldeten Fehlers ("kopiert die Texte nicht mit, erstellt nur die
+// Überschriften"). Eine zweite, von Erik angestoßene Runde ergänzte GENAU
+// EINE weitere, chirurgisch kurze Anweisung — mehrere eigenständige Punkte
+// unter derselben Überschrift einzeln auszugeben, UND mehrere aufeinander-
+// folgende, je datierte Textabsätze desselben Punkts (eine im Quelldokument
+// selbst geführte Revisionshistorie über mehrere Besprechungen) zu einem
+// zusammenhängenden "text" zusammenzuführen, statt sie als eigene, von
+// ihrem Thema abgetrennte Punkte auszugeben — und bestand denselben
+// Stabilitätstest (reales Dokument, temperature:0): korrekt erkannte
+// Punkte mit vollständig zusammengeführtem Text statt verwaister, themenloser
+// Fragmente. Jede WEITERE Ergänzung darüber hinaus (z. B. eine explizite
+// Teilnehmer-Anleitung) hat in denselben Tests dagegen zuverlässig wieder
+// zur Regression geführt — deshalb bleibt "teilnehmer" bewusst ungeleitet,
+// das Schema allein genügt dafür. Ein eigener Blindgang dabei: gegen einen
+// künstlich verkürzten Testausschnitt OHNE die echte Teilnehmer-/Verteiler-
+// Tabelle des Dokuments geriet das Modell beim Versuch, "teilnehmer" trotzdem
+// zu befüllen, in eine Wiederholungsschleife (tausendfach dasselbe Namens-
+// Fragment, bis das Token-Limit die Antwort mitten im JSON abschnitt) — mit
+// der echten Tabelle (wie jeder reale Import sie tatsächlich schickt) trat
+// das nicht wieder auf, lief sogar spürbar schneller durch. frequency_penalty/
+// presence_penalty unten bleiben trotzdem als zusätzliches Sicherheitsnetz
+// gegen genau solche Wiederholungsschleifen bestehen.
+const KI_SYSTEM_PROMPT = 'Extrahiere ALLE Besprechungspunkte aus diesem Protokoll-Text, auch wenn es viele sind. '
+  + 'Das Dokument ist mehrstufig nummeriert (z.B. "01" Kapitel, "01.0" Unterkapitel, "01.0 01.03" der echte Punkt mit Text). '
+  + 'Nur Zeilen mit eigenem Fließtext darunter werden ein Punkt - reine Kapitelüberschriften ohne Text NICHT. '
+  + 'Stehen unter einer Überschrift mehrere eigene Punkte, gib jeden einzeln aus. Folgen auf einen Punkt weitere '
+  + 'Absätze ohne neue eigene Nummer, gehören sie zu diesem Punkt dazu - auch wenn ein spaeterer Absatz einen '
+  + 'anderen Status zeigt, bleibt es EIN Punkt mit dem Status des letzten Absatzes. '
+  + '"status" ist offen, erledigt oder info - info wenn der Text den Punkt selbst so kennzeichnet (z.B. das Wort '
+  + '"Info" direkt beim Punkt) oder der Punkt rein informativ ohne eigene Handlung ist, erledigt nur bei '
+  + 'ausdruecklicher Erledigt-/Geschlossen-Kennzeichnung, sonst offen. '
+  + 'Gib fuer jeden Punkt nummer, thema, text, zustaendig, termin, status, gruppe (leer lassen wenn unklar) zurueck. Erfinde nichts.';
+
+// readUserAiKey/writeUserAiKey: Schlüssel+URL liegen PERSÖNLICH je Konto in
+// user_ai_keys (siehe CREATE TABLE weiter oben bei den übrigen User-Kind-
+// Tabellen), nicht firmenweit in app_settings — jeder Nutzer verwaltet
+// seinen eigenen Zugang unter Einstellungen → Mein Konto
+// (js/settings/settings.js), genau wie E-Mail und Passwort. Klartext in der
+// SQLite-Datei, wie jeder andere Wert dort auch.
+function readUserAiKey(userId, provider){
+  const row = db.prepare('SELECT api_key, api_url FROM user_ai_keys WHERE user_id = ? AND provider = ?').get(userId, provider);
+  return { apiKey: row ? row.api_key : '', apiUrl: row ? row.api_url : '' };
+}
+
+function writeUserAiKey(userId, provider, patch){
+  const bestehend = readUserAiKey(userId, provider);
+  const apiKey = Object.prototype.hasOwnProperty.call(patch, 'apiKey') ? String(patch.apiKey || '') : bestehend.apiKey;
+  const apiUrl = Object.prototype.hasOwnProperty.call(patch, 'apiUrl') ? String(patch.apiUrl || '') : bestehend.apiUrl;
+  db.prepare(`INSERT INTO user_ai_keys (user_id, provider, api_key, api_url) VALUES (?, ?, ?, ?)
+    ON CONFLICT(user_id, provider) DO UPDATE SET api_key = excluded.api_key, api_url = excluded.api_url`)
+    .run(userId, provider, apiKey, apiUrl);
+}
+
+// istLoopbackHost: gemeinsame Grundlage für istGueltigeAiUrl() (URL-Prüfung
+// beim Speichern) und fetchMitTimeout() (Timeout-Wahl beim Aufruf) — beide
+// müssen dieselbe Vorstellung von "läuft auf der eigenen Maschine" teilen.
+function istLoopbackHost(hostname){
+  return hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '::1' || hostname === '[::1]';
+}
+
+// istGueltigeAiUrl: https wird grundsätzlich verlangt (der Schlüssel reist
+// sonst im Klartext über ein Netz, das nicht die eigene Maschine ist) — mit
+// EINER Ausnahme: http auf dem Loopback. Ein lokal laufender Server wie
+// LM Studio oder Ollama bietet praktisch nie ein TLS-Zertifikat für
+// localhost an; ihn auszuschließen hätte den naheliegendsten Anwendungsfall
+// einer eigenen API-URL — ein kostenloses, lokales Modell statt eines
+// kostenpflichtigen Cloud-Zugangs — unmöglich gemacht. Der Klartext
+// verlässt dabei nie die eigene Maschine, das Risiko besteht also nicht.
+// Rückgabe: bool.
+function istGueltigeAiUrl(url){
+  let parsed;
+  try { parsed = new URL(url); } catch(e){ return false; }
+  if(parsed.protocol === 'https:') return true;
+  return parsed.protocol === 'http:' && istLoopbackHost(parsed.hostname);
+}
+
+async function fetchMitTimeout(url, options){
+  let istLokal = false;
+  try { istLokal = istLoopbackHost(new URL(url).hostname); } catch(e){ /* ungültige URL: Vorgabe bleibt Cloud-Timeout */ }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), istLokal ? KI_TIMEOUT_MS_LOKAL : KI_TIMEOUT_MS_CLOUD);
+  try {
+    const fetchOptions = Object.assign({}, options, { signal: controller.signal });
+    if(istLokal) fetchOptions.dispatcher = LOKAL_DISPATCHER;
+    return await fetch(url, fetchOptions);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// normalisierePunktAusKi: eine KI-Antwortzeile in dieselbe Form wie ein
+// erkennePunkteAusText()-Punkt bringen — beide Aufrufer (POST-Route,
+// legeProtokollAn) müssen nicht wissen, woher ein Punkt stammt.
+function normalisierePunktAusKi(p){
+  return {
+    nummer: String((p && p.nummer) || ''),
+    gruppe: String((p && p.gruppe) || ''),
+    thema: String((p && p.thema) || ''),
+    text: String((p && p.text) || ''),
+    zustaendig: String((p && p.zustaendig) || ''),
+    termin: String((p && p.termin) || ''),
+    status: VALID_PROTOKOLL_PUNKT_STATUS.has(p && p.status) ? p.status : 'offen'
+  };
+}
+
+// normalisiereTeilnehmerAusKi: Gegenstück zu normalisierePunktAusKi() für
+// das zweite KI_PUNKT_SCHEMA-Feld. "anwesend" defaultet — anders als
+// "erledigt" oben — auf true, nicht auf false: eine erkannte Person gilt als
+// anwesend, außer der Prompt weist das Modell ausdrücklich an, sie als
+// entschuldigt/abwesend zu kennzeichnen (dieselbe Grundannahme wie beim
+// manuellen "+ Teilnehmer" in der Detailansicht, js/plan/plan-protokoll.js).
+function normalisiereTeilnehmerAusKi(t){
+  return {
+    name: String((t && t.name) || ''),
+    firma: String((t && t.firma) || ''),
+    anwesend: !(t && t.anwesend === false)
+  };
+}
+
+const KI_PUNKT_SCHEMA = {
+  type: 'object',
+  properties: {
+    punkte: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          nummer: { type: 'string' },
+          gruppe: { type: 'string' },
+          thema: { type: 'string' },
+          text: { type: 'string' },
+          zustaendig: { type: 'string' },
+          termin: { type: 'string' },
+          status: { type: 'string', enum: ['offen', 'erledigt', 'info'] }
+        },
+        required: ['nummer', 'gruppe', 'thema', 'text', 'zustaendig', 'termin', 'status'],
+        additionalProperties: false
+      }
+    },
+    teilnehmer: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          firma: { type: 'string' },
+          anwesend: { type: 'boolean' }
+        },
+        required: ['name', 'firma', 'anwesend'],
+        additionalProperties: false
+      }
+    }
+  },
+  required: ['punkte', 'teilnehmer'],
+  additionalProperties: false
+};
+
+const KI_DEFAULT_URL = {
+  chatgpt: 'https://api.openai.com/v1/chat/completions',
+  claude: 'https://api.anthropic.com/v1/messages'
+};
+
+// normalisiereAiUrl: wer eine eigene API-URL hinterlegt, tippt bei einem
+// lokalen Server wie LM Studio/Ollama erfahrungsgemäß nur die Basisadresse
+// (z. B. "http://localhost:1234"), nicht den vollen Completions-Pfad —
+// beide Tools bewerben sich selbst über genau diese kurze Adresse. Ohne
+// diese Ergänzung landet die Anfrage dort auf "/" statt auf
+// "/v1/chat/completions" (bzw. "/v1/messages" bei Claude): der lokale
+// Server antwortet trotzdem mit HTTP 200, aber mit einem Text, der keine
+// gültige Chat-Completion ist — reproduzierbar mit Eriks eigenem Fehler
+// ("Received request: POST to /" in LM Studios Log). Nur ein FEHLENDER
+// oder leerer Pfad wird ergänzt; ein ausdrücklich angegebener Pfad (z. B.
+// ein Firmen-Proxy mit eigener Route) bleibt unangetastet.
+function normalisiereAiUrl(apiUrl, defaultUrl){
+  if(!apiUrl) return defaultUrl;
+  try {
+    const parsed = new URL(apiUrl);
+    if(!parsed.pathname || parsed.pathname === '/'){
+      parsed.pathname = new URL(defaultUrl).pathname;
+      return parsed.toString();
+    }
+    return apiUrl;
+  } catch(e){
+    return apiUrl;
+  }
+}
+
+async function erkennePunkteMitChatGPT(text, apiKey, apiUrl){
+  const zielUrl = normalisiereAiUrl(apiUrl, KI_DEFAULT_URL.chatgpt);
+  let istLokal = false;
+  try { istLokal = istLoopbackHost(new URL(zielUrl).hostname); } catch(e){ /* ungültige URL: bleibt false */ }
+
+  const body = {
+    model: 'gpt-4o-mini',
+    messages: [
+      { role: 'system', content: KI_SYSTEM_PROMPT },
+      { role: 'user', content: text }
+    ],
+    response_format: { type: 'json_schema', json_schema: { name: 'protokoll_punkte', strict: true, schema: KI_PUNKT_SCHEMA } },
+    // Ohne eigenes max_tokens bricht mancher lokale Server (anders als die
+    // echte OpenAI-API, die hier großzügig ist) die Antwort bei einem langen
+    // Protokoll mit vielen Punkten vorzeitig ab, sobald ein internes
+    // Standardlimit erreicht ist — die JSON-Antwort bleibt dabei gültig,
+    // enthält aber nur die ersten paar Punkte statt aller.
+    max_tokens: 16000,
+    // temperature:0 macht die Erkennung reproduzierbar — bei Streuung (dem
+    // Standardwert) lieferte ein und dieselbe Anfrage an Eriks lokales
+    // Modell je nach Lauf 0 bis 11 erkannte Punkte, was Fehlersuche und
+    // Nutzervertrauen gleichermaßen unmöglich macht. Für diese Aufgabe
+    // (Fakten aus einem Text ziehen) ist Kreativität ohnehin unerwünscht.
+    temperature: 0,
+    // Sicherheitsnetz gegen Wiederholungsschleifen: bei einem Testlauf ohne
+    // echte Teilnehmerdaten im Text geriet Eriks lokales Modell beim
+    // Befüllen von "teilnehmer" in eine Endlosschleife (dasselbe
+    // Namens-Fragment tausendfach), bis max_tokens die Antwort mitten im
+    // JSON abschnitt — mit echten Teilnehmerdaten (wie jeder reale Import
+    // sie liefert) trat das nicht auf, aber diese beiden Parameter machen
+    // eine erneute Schleife unabhängig vom Dokumentinhalt unwahrscheinlicher.
+    frequency_penalty: 0.4,
+    presence_penalty: 0.2
+  };
+  // Manche lokale Server laden standardmäßig ein Reasoning-Modell (z. B.
+  // Qwen3 in LM Studio), das vor jeder Antwort ausführlich "denkt" — für
+  // diese Aufgabe direkt gegen ein echtes LM-Studio-Setup gemessen: 260 von
+  // 264 Tokens (98,5 %) fürs Denken, 15s statt 0,4s für eine triviale
+  // Anfrage; bei einem langen Besprechungsprotokoll mit vielen Punkten
+  // reicht das leicht über jeden vertretbaren Timeout hinaus, obwohl das
+  // Modell am Ende korrekt "durchläuft". reasoning_effort:'none' schaltet
+  // das Denken ab (ebenfalls live verifiziert — mit dem echten System-
+  // Prompt und Schema unten korrekt und in Sekunden statt Minuten). Nur
+  // für lokale Ziele gesetzt: die echte OpenAI-API für gpt-4o-mini (kein
+  // Reasoning-Modell) kennt den Parameter nicht und soll ihn nie sehen.
+  if(istLokal) body.reasoning_effort = 'none';
+
+  const res = await fetchMitTimeout(zielUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + apiKey },
+    body: JSON.stringify(body)
+  });
+  if(!res.ok){
+    const body = await res.text().catch(() => '');
+    throw new Error('ChatGPT antwortete mit HTTP ' + res.status + (body ? ': ' + body.slice(0, 200) : ''));
+  }
+  const data = await res.json();
+  const content = data && data.choices && data.choices[0] && data.choices[0].message && data.choices[0].message.content;
+  if(!content) throw new Error('ChatGPT lieferte keine Antwort.');
+  let parsed;
+  try { parsed = JSON.parse(content); } catch(e){ throw new Error('ChatGPT-Antwort war kein gültiges JSON.'); }
+  if(!Array.isArray(parsed.punkte)) throw new Error('ChatGPT-Antwort hatte nicht die erwartete Form.');
+  return {
+    punkte: parsed.punkte.map(normalisierePunktAusKi),
+    teilnehmer: Array.isArray(parsed.teilnehmer) ? parsed.teilnehmer.map(normalisiereTeilnehmerAusKi) : []
+  };
+}
+
+async function erkennePunkteMitClaude(text, apiKey, apiUrl){
+  const res = await fetchMitTimeout(normalisiereAiUrl(apiUrl, KI_DEFAULT_URL.claude), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' },
+    body: JSON.stringify({
+      model: 'claude-haiku-4-5-20251001',
+      // wie beim ChatGPT-Pfad: ein langes Protokoll mit vielen Punkten
+      // braucht mehr als das ursprüngliche Minimum, sonst bricht die
+      // Antwort vor dem letzten Punkt ab.
+      max_tokens: 8192,
+      // Wie beim ChatGPT-Pfad: reproduzierbares Ergebnis statt Streuung
+      // zwischen Läufen (siehe Begründung bei KI_SYSTEM_PROMPT oben).
+      temperature: 0,
+      system: KI_SYSTEM_PROMPT,
+      messages: [{ role: 'user', content: text }],
+      tools: [{
+        name: 'protokoll_punkte',
+        description: 'Die aus dem Text erkannten Besprechungspunkte.',
+        input_schema: KI_PUNKT_SCHEMA
+      }],
+      tool_choice: { type: 'tool', name: 'protokoll_punkte' }
+    })
+  });
+  if(!res.ok){
+    const body = await res.text().catch(() => '');
+    throw new Error('Claude antwortete mit HTTP ' + res.status + (body ? ': ' + body.slice(0, 200) : ''));
+  }
+  const data = await res.json();
+  const toolUse = Array.isArray(data.content) ? data.content.find(b => b.type === 'tool_use') : null;
+  if(!toolUse || !toolUse.input || !Array.isArray(toolUse.input.punkte)){
+    throw new Error('Claude-Antwort hatte nicht die erwartete Form.');
+  }
+  return {
+    punkte: toolUse.input.punkte.map(normalisierePunktAusKi),
+    teilnehmer: Array.isArray(toolUse.input.teilnehmer) ? toolUse.input.teilnehmer.map(normalisiereTeilnehmerAusKi) : []
+  };
+}
+
+async function erkennePunkteMitKI(text, userId, provider){
+  const { apiKey, apiUrl } = readUserAiKey(userId, provider);
+  if(!apiKey) throw new Error('Kein API-Schlüssel hinterlegt.');
+  const gekuerzterText = text.length > KI_MAX_TEXT_LAENGE ? text.slice(0, KI_MAX_TEXT_LAENGE) : text;
+  if(provider === 'chatgpt') return erkennePunkteMitChatGPT(gekuerzterText, apiKey, apiUrl);
+  if(provider === 'claude') return erkennePunkteMitClaude(gekuerzterText, apiKey, apiUrl);
+  throw new Error('Unbekannter Anbieter: ' + provider);
+}
+
+// textZuSicheremHtml: wandelt reinen Klartext (PDF/Word-Extraktion oder
+// KI-Erkennung, erkennePunkteAusText()/erkennePunkteMitKI() oben) in
+// dasselbe sanitizeStatusHtml()-taugliche HTML, das ein von Hand getippter
+// Protokoll-Punkt über sein contenteditable-Feld ohnehin schon erzeugt
+// (richtextFeldHtml(), public/js/utils.js) — protokoll_punkte.text gilt seit
+// der Umstellung auf contenteditable (Eriks Wunsch nach echter statt mit
+// Sternchen markierter Fett-/Kursivschrift) client-seitig immer als
+// bereits-sicheres HTML; ohne dieses Escaping würde ein im Originaldokument
+// vorkommendes "<"/">" beim Rendern als Markup fehlinterpretiert statt als
+// Text angezeigt. Gegenstück zu esc() in public/js/utils.js.
+function textZuSicheremHtml(s){
+  return String(s == null ? '' : s)
+    .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;').replace(/'/g, '&#39;')
+    .replace(/\r\n|\r|\n/g, '<br>');
+}
+
+function legeProtokollAn(opts){
+  const {
+    projectNr, projectName, weekLabel, datum, betreff, ort, verfasserUserId,
+    teilnehmer, zusatzPunkte, quelleDateiname, quelleStoredName
+  } = opts;
+
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+  let nummer = 1;
+
+  db.exec('BEGIN');
+  try {
+    const maxRow = db.prepare('SELECT MAX(nummer) AS m FROM project_protokolle WHERE project_nr = ?').get(projectNr);
+    nummer = (maxRow && maxRow.m) ? maxRow.m + 1 : 1;
+
+    db.prepare(`INSERT INTO project_protokolle
+        (id, project_nr, project_name, nummer, datum, betreff, ort, verfasser_user_id, week_label,
+         quelle_dateiname, quelle_stored_name, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+      .run(id, projectNr, projectName, nummer, String(datum), String(betreff || ''), String(ort || ''),
+        verfasserUserId, weekLabel, String(quelleDateiname || ''), String(quelleStoredName || ''), now, now);
+
+    const insTeilnehmer = db.prepare(`INSERT INTO protokoll_teilnehmer
+      (id, protokoll_id, name, firma, anwesend, array_order) VALUES (?, ?, ?, ?, ?, ?)`);
+    (Array.isArray(teilnehmer) ? teilnehmer : []).forEach((t, idx) => {
+      const name = String((t && t.name) || '').trim();
+      if(!name) return;
+      insTeilnehmer.run(crypto.randomUUID(), id, name, String((t && t.firma) || ''), (t && t.anwesend) ? 1 : 0, idx);
+    });
+
+    const insPunkt = db.prepare(`INSERT INTO protokoll_punkte
+        (id, protokoll_id, stamm_id, nummer, gruppe, neu, thema, text, zustaendig, termin, erledigt, erstellt_am, status, entfaellt_naechstes, array_order)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    let order = 0;
+
+    const prevRow = db.prepare(`SELECT id FROM project_protokolle
+      WHERE project_nr = ? AND id != ? ORDER BY nummer DESC LIMIT 1`).get(projectNr, id);
+    if(prevRow){
+      // Fortschreiben (Eriks Wunsch, Nachtrag zur ursprünglichen Regel "nur
+      // offen läuft weiter"): 'offen' und 'info' laufen unbegrenzt weiter;
+      // 'erledigt' bekommt noch GENAU EINE Gnadenrunde — eine Kopie, die
+      // selbst entfaellt_naechstes=0 trägt (also hier zum ersten Mal als
+      // erledigt auftaucht oder zwischenzeitlich von Hand wieder auf
+      // erledigt gesetzt wurde), läuft noch einmal mit; eine Kopie, die
+      // bereits entfaellt_naechstes=1 trägt (schon einmal fortgeschrieben),
+      // bleibt hier liegen. Die neue Kopie selbst bekommt entfaellt_naechstes
+      // NUR gesetzt, wenn ihre Quelle 'erledigt' war — das ist der Hinweis
+      // "entfällt im nächsten Protokoll" in genau diesem einen Protokoll;
+      // offen/info-Kopien tragen 0 und laufen so unbegrenzt weiter.
+      const vorherigePunkte = db.prepare(`SELECT * FROM protokoll_punkte
+        WHERE protokoll_id = ? ORDER BY array_order`).all(prevRow.id);
+      const fortzuschreiben = vorherigePunkte.filter(p =>
+        p.status === 'offen' || p.status === 'info' || (p.status === 'erledigt' && !p.entfaellt_naechstes));
+      // erstellt_am wandert UNVERÄNDERT mit (wie stamm_id) — ein fortgeschriebener
+      // Punkt wurde hier nicht neu erstellt, nur übernommen.
+      fortzuschreiben.forEach(p => {
+        insPunkt.run(crypto.randomUUID(), id, p.stamm_id, p.nummer, p.gruppe, 0, p.thema, p.text, p.zustaendig, p.termin, 0,
+          p.erstellt_am || '', p.status, p.status === 'erledigt' ? 1 : 0, order++);
+      });
+    }
+
+    // Zusätzlich erkannte/übergebene Punkte (Import) — immer neu=1, frische
+    // stamm_id, hinter den fortgeschriebenen Punkten einsortiert. erstellt_am
+    // ist das Datum DIESES Protokolls — hier entstehen diese Punkte zum
+    // ersten Mal im System, unabhängig davon, ob das importierte Dokument
+    // selbst älter ist. status kommt bei der KI-Erkennung direkt vom Modell
+    // (normalisierePunktAusKi() hat ihn schon gegen VALID_PROTOKOLL_PUNKT_STATUS
+    // geprüft); die Textmuster-Heuristik (erkennePunkteAusText()) kennt
+    // weiterhin nur das ältere, boolesche erledigt (kein 'info' — sie liest
+    // reinen Regex-Textmustern, keine Bedeutung) — dafür hier der Rückfall
+    // auf das alte Verhalten, falls kein gültiger status mitkommt.
+    (Array.isArray(zusatzPunkte) ? zusatzPunkte : []).forEach(p => {
+      const status = VALID_PROTOKOLL_PUNKT_STATUS.has(p.status) ? p.status : (p.erledigt ? 'erledigt' : 'offen');
+      // entfaellt_naechstes=0: ein importierter/neu erkannter Punkt taucht
+      // hier zum ersten Mal auf, unabhängig vom erkannten status — selbst
+      // ein als 'erledigt' erkannter Punkt bekommt dadurch noch seine
+      // Gnadenrunde im nächsten Protokoll, statt sofort stillschweigend zu
+      // verschwinden.
+      insPunkt.run(crypto.randomUUID(), id, crypto.randomUUID(), String(p.nummer || ''), String(p.gruppe || ''), 1,
+        String(p.thema || ''), textZuSicheremHtml(p.text || ''), String(p.zustaendig || ''), String(p.termin || ''),
+        status === 'erledigt' ? 1 : 0, String(datum), status, 0, order++);
+    });
+
+    db.exec('COMMIT');
+  } catch(err){
+    db.exec('ROLLBACK');
+    throw err;
+  }
+
+  console.log('Protokoll angelegt:', projectNr, '- Nr.', nummer);
+  return id;
+}
+
+app.post('/project-protokolle', requireAuth, (req, res) => {
+  try {
+    const projectNr = String(req.query.projectNr || '');
+    if(!projectNr) return res.status(400).json({ ok: false, error: 'Projekt hat keine Projektnummer.' });
+    const { datum, betreff, ort, teilnehmer } = req.body || {};
+    if(!datum) return res.status(400).json({ ok: false, error: 'Datum erforderlich.' });
+
+    const id = legeProtokollAn({
+      projectNr, projectName: String(req.query.projectName || ''), weekLabel: String(req.query.weekLabel || ''),
+      datum, betreff, ort, verfasserUserId: req.user.id, teilnehmer, zusatzPunkte: []
+    });
+    res.json({ ok: true, protokoll: loadProtokollDetail(id) });
+  } catch(err){
+    console.error('Protokoll anlegen fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: externes Protokoll hochladen und automatisch in Punkte umwandeln.
+// Raw-Binär-Body wie POST /project-files. Extrahiert den Text (PDF via
+// pdf-parse, Word via mammoth), teilt ihn heuristisch in Punkte auf
+// (erkennePunkteAusText()) und legt darüber ein ganz normales Protokoll an
+// (legeProtokollAn() — dieselbe Fortschreiben-Logik wie beim manuellen
+// Anlegen; die erkannten Punkte kommen zusätzlich dazu, als neu=1). Die
+// Original-Datei bleibt unter UPLOADS_DIR gespeichert und über
+// GET /project-protokolle/:id/quelldatei abrufbar — Erkennung ist ein
+// Entwurf, keine Garantie, siehe CLAUDE.md "### Protokolle".
+app.post('/project-protokolle/import', requireAuth, express.raw({ type: '*/*', limit: '50mb' }), async (req, res) => {
+  try {
+    const projectNr = String(req.query.projectNr || '');
+    if(!projectNr) return res.status(400).json({ ok: false, error: 'Projekt hat keine Projektnummer.' });
+    if(!req.query.datum) return res.status(400).json({ ok: false, error: 'Datum erforderlich.' });
+
+    const buf = req.body;
+    if(!Buffer.isBuffer(buf) || buf.length === 0){
+      return res.status(400).json({ ok: false, error: 'Keine Datei empfangen.' });
+    }
+
+    let filename = '';
+    try { filename = decodeURIComponent(String(req.query.filename || '')); }
+    catch(e){ filename = String(req.query.filename || ''); }
+    const ext = extractFileExtension(filename);
+
+    let text = '';
+    if(ext === 'pdf'){
+      text = await extrahierePdfText(buf);
+    } else if(ext === 'docx'){
+      const result = await mammoth.extractRawText({ buffer: buf });
+      text = result.value || '';
+    } else {
+      return res.status(400).json({ ok: false, error: 'Nur PDF- und Word-Dateien (.pdf, .docx) werden unterstützt.' });
+    }
+
+    // Teilnehmer kommen NUR aus der KI-Erkennung (siehe KI_SYSTEM_PROMPT) —
+    // erkennePunkteAusText() ist reines Regex und kann keine Teilnehmerliste
+    // von Fließtext unterscheiden, deshalb bleibt teilnehmerAusDokument beim
+    // Textmuster-Pfad und bei jedem KI-Fehlschlag (Rückfall) leer; die
+    // Person trägt sie dann wie schon bisher von Hand in der Detailansicht
+    // nach. Bewusst KEIN Merge mit dem letzten Protokoll dieses Projekts
+    // (anders als neuesProtokoll()'s Vorbelegung) — der Import soll genau
+    // zeigen, was im hochgeladenen Dokument steht, nicht zwei Quellen
+    // vermischen.
+    let zusatzPunkte, teilnehmerAusDokument = [], erkennungsart = 'textmuster', erkennungshinweis = '';
+    const gewuenschterAnbieter = req.query.erkennung;
+    if(gewuenschterAnbieter === 'chatgpt' || gewuenschterAnbieter === 'claude'){
+      try {
+        const ergebnis = await erkennePunkteMitKI(text, req.user.id, gewuenschterAnbieter);
+        zusatzPunkte = ergebnis.punkte;
+        teilnehmerAusDokument = ergebnis.teilnehmer;
+        erkennungsart = gewuenschterAnbieter;
+      } catch(err){
+        console.warn('KI-Erkennung fehlgeschlagen, Rückfall auf Textmuster:', err.message);
+        erkennungshinweis = err.message;
+        zusatzPunkte = erkennePunkteAusText(text);
+      }
+    } else {
+      zusatzPunkte = erkennePunkteAusText(text);
+    }
+
+    const storedName = crypto.randomUUID() + (ext ? '.' + ext : '');
+    fs.writeFileSync(path.join(uploadDirFor(), storedName), buf);
+
+    const id = legeProtokollAn({
+      projectNr, projectName: String(req.query.projectName || ''), weekLabel: String(req.query.weekLabel || ''),
+      datum: req.query.datum, betreff: req.query.betreff, ort: req.query.ort,
+      verfasserUserId: req.user.id, teilnehmer: teilnehmerAusDokument, zusatzPunkte,
+      quelleDateiname: filename || storedName, quelleStoredName: storedName
+    });
+
+    console.log('Protokoll importiert:', projectNr, '-', zusatzPunkte.length, 'Punkte,', teilnehmerAusDokument.length, 'Teilnehmer erkannt aus', filename, '(' + erkennungsart + ')');
+    res.json({ ok: true, protokoll: loadProtokollDetail(id), erkannteAnzahl: zusatzPunkte.length,
+      erkannteTeilnehmerAnzahl: teilnehmerAusDokument.length, erkennungsart, erkennungshinweis });
+  } catch(err){
+    console.error('Protokoll-Import fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Original-Datei eines importierten Protokolls herunterladen —
+// Gegenstück zu GET /project-files/:id/download. 404, wenn das Protokoll
+// nicht importiert wurde (quelle_stored_name leer, siehe legeProtokollAn()).
+app.get('/project-protokolle/:id/quelldatei', requireAuth, (req, res) => {
+  try {
+    const row = db.prepare('SELECT quelle_dateiname, quelle_stored_name FROM project_protokolle WHERE id = ?').get(req.params.id);
+    if(!row || !row.quelle_stored_name){
+      return res.status(404).json({ ok: false, error: 'Keine Quelldatei vorhanden.' });
+    }
+    res.download(path.join(UPLOADS_DIR, row.quelle_stored_name), row.quelle_dateiname || row.quelle_stored_name);
+  } catch(err){
+    console.error('Quelldatei-Download fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Protokoll speichern — ersetzt Teilnehmer- und Punkte-Zeilen komplett
+// (löschen + neu einfügen, wie deleteWeekData()/serializeWeek()). nummer,
+// gruppe, thema, text, zustaendig, termin, erledigt sind reine Anzeige-/
+// Bearbeitungsfelder und werden immer vom Client übernommen. stamm_id/neu
+// dagegen NIE vom Client vertraut: für einen Punkt mit bekannter id werden
+// sie aus der bisherigen Zeile übernommen, ein Punkt ohne id ist neu
+// (frische stamm_id, neu=1).
+app.put('/project-protokolle/:id', requireAuth, (req, res) => {
+  try {
+    const row = db.prepare('SELECT * FROM project_protokolle WHERE id = ?').get(req.params.id);
+    if(!row) return res.status(404).json({ ok: false, error: 'Protokoll nicht gefunden.' });
+    const { datum, betreff, ort, teilnehmer, punkte } = req.body || {};
+    if(!datum) return res.status(400).json({ ok: false, error: 'Datum erforderlich.' });
+
+    const now = new Date().toISOString();
+    db.exec('BEGIN');
+    try {
+      db.prepare('UPDATE project_protokolle SET datum = ?, betreff = ?, ort = ?, updated_at = ? WHERE id = ?')
+        .run(String(datum), String(betreff || ''), String(ort || ''), now, row.id);
+
+      db.prepare('DELETE FROM protokoll_teilnehmer WHERE protokoll_id = ?').run(row.id);
+      const insTeilnehmer = db.prepare(`INSERT INTO protokoll_teilnehmer
+        (id, protokoll_id, name, firma, anwesend, array_order) VALUES (?, ?, ?, ?, ?, ?)`);
+      (Array.isArray(teilnehmer) ? teilnehmer : []).forEach((t, idx) => {
+        const name = String((t && t.name) || '').trim();
+        if(!name) return;
+        insTeilnehmer.run(crypto.randomUUID(), row.id, name, String((t && t.firma) || ''), (t && t.anwesend) ? 1 : 0, idx);
+      });
+
+      const bestehende = new Map();
+      db.prepare('SELECT id, stamm_id, neu, erstellt_am, entfaellt_naechstes FROM protokoll_punkte WHERE protokoll_id = ?').all(row.id)
+        .forEach(p => bestehende.set(p.id, p));
+
+      db.prepare('DELETE FROM protokoll_punkte WHERE protokoll_id = ?').run(row.id);
+      const insPunkt = db.prepare(`INSERT INTO protokoll_punkte
+          (id, protokoll_id, stamm_id, nummer, gruppe, neu, thema, text, zustaendig, termin, erledigt, erstellt_am, status, entfaellt_naechstes, array_order)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+      // erstellt_am ist wie stamm_id/neu serverseitig maßgeblich, nie vom
+      // Client übernommen: ein bekannter Punkt behält sein ursprüngliches
+      // Datum, ein neu hinzugefügter bekommt das Datum DIESES Protokolls
+      // (der gerade gespeicherte `datum`-Wert oben) — der Moment, in dem er
+      // zum ersten Mal gespeichert wird. status wird dagegen VOM CLIENT
+      // übernommen (offen/erledigt/info, über ein <select> gewählt) — anders
+      // als neu/stamm_id/erstellt_am ist das kein Herkunfts-, sondern ein
+      // jederzeit frei änderbares Inhaltsfeld, wie thema oder zustaendig.
+      // erledigt bleibt als reine Ableitung von status bestehen (siehe
+      // migrateAddProtokollPunktStatus()). entfaellt_naechstes ist wie
+      // stamm_id/neu/erstellt_am serverseitig maßgeblich und NIE vom Client
+      // übernommen — es ist kein frei editierbares Inhaltsfeld, sondern wird
+      // ausschließlich von legeProtokollAn() beim Fortschreiben gesetzt
+      // (siehe dort); ein hier bearbeiteter bekannter Punkt behält also
+      // seinen bisherigen Wert unverändert, ein neuer startet bei 0.
+      (Array.isArray(punkte) ? punkte : []).forEach((p, idx) => {
+        const bekannt = p && p.id ? bestehende.get(p.id) : null;
+        const pid = bekannt ? bekannt.id : crypto.randomUUID();
+        const stammId = bekannt ? bekannt.stamm_id : crypto.randomUUID();
+        const neu = bekannt ? bekannt.neu : 1;
+        const erstelltAm = bekannt ? (bekannt.erstellt_am || '') : String(datum);
+        const entfaelltNaechstes = bekannt ? bekannt.entfaellt_naechstes : 0;
+        const status = VALID_PROTOKOLL_PUNKT_STATUS.has(p && p.status) ? p.status : 'offen';
+        // text trägt wie der Wochen-Kommentar Formatierungs-HTML und wird
+        // an der Schreibstelle bereinigt (sanitizeFormatHtml()); thema und
+        // zustaendig sind reine Textfelder und werden beim Anzeigen escaped.
+        insPunkt.run(pid, row.id, stammId, String((p && p.nummer) || ''), String((p && p.gruppe) || ''), neu,
+          String((p && p.thema) || ''), sanitizeFormatHtml(p && p.text), String((p && p.zustaendig) || ''),
+          String((p && p.termin) || ''), status === 'erledigt' ? 1 : 0, erstelltAm, status, entfaelltNaechstes, idx);
+      });
+
+      db.exec('COMMIT');
+    } catch(err){
+      db.exec('ROLLBACK');
+      throw err;
+    }
+
+    res.json({ ok: true, protokoll: loadProtokollDetail(row.id) });
+  } catch(err){
+    console.error('Protokoll speichern fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Protokoll löschen — Auth genügt (kein admin-only), dieselbe
+// Berechtigungsstufe wie das Löschen einer Aufgabe/eines Meilensteins.
+// Idempotent wie DELETE /users/:id/absences/:absenceId (kein Fehler, wenn
+// bereits gelöscht).
+app.delete('/project-protokolle/:id', requireAuth, (req, res) => {
+  try {
+    const row = db.prepare('SELECT id FROM project_protokolle WHERE id = ?').get(req.params.id);
+    if(!row) return res.json({ ok: true });
+    db.exec('BEGIN');
+    try {
+      db.prepare('DELETE FROM protokoll_punkte WHERE protokoll_id = ?').run(row.id);
+      db.prepare('DELETE FROM protokoll_teilnehmer WHERE protokoll_id = ?').run(row.id);
+      db.prepare('DELETE FROM project_protokolle WHERE id = ?').run(row.id);
+      db.exec('COMMIT');
+    } catch(err){
+      db.exec('ROLLBACK');
+      throw err;
+    }
+    console.log('Protokoll gelöscht:', row.id);
+    res.json({ ok: true });
+  } catch(err){
+    console.error('Protokoll löschen fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// ---------- Aufgaben-Vorlagen je Leistungsphase (lph_templates) ----------
+
+// VALID_LPHS: gültige Leistungsphasen-Schlüssel (muss zu LPHS in
+// public/js/globals.js passen). Dient nur der Eingabeprüfung der
+// Vorlagen-Routen — die Fortschrittswerte in project_lph werden bewusst NICHT
+// gegen diese Liste geprüft (dort sind historisch gewachsene Schlüssel aus
+// Altdaten möglich).
+const VALID_LPHS = new Set(['LPH 1','LPH 2','LPH 3','LPH 4','LPH 5','LPH 6','LPH 7','LPH 8','LPH 9','W+M']);
+
+// serializeTemplateRow: DB-Zeile -> öffentliche JSON-Form.
+function serializeTemplateRow(row){
+  return {
+    id: row.id,
+    lph: row.lph,
+    title: row.title,
+    offsetDays: row.offset_days,
+    durationDays: row.duration_days,
+    sortOrder: row.sort_order,
+  };
+}
+
+// Route: alle Vorlagen lesen (jeder angemeldete Nutzer darf Vorlagen
+// einfügen, daher nur requireAuth — nur das Pflegen ist Admin-Sache).
+app.get('/lph-templates', requireAuth, (req, res) => {
+  try {
+    const rows = db.prepare('SELECT * FROM lph_templates ORDER BY lph, sort_order, title').all();
+    res.json({ ok: true, templates: rows.map(serializeTemplateRow) });
+  } catch(err){
+    console.error('Vorlagen laden fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: neue Vorlagen-Aufgabe anlegen. Admin-only (firmenweite Konfiguration).
+app.post('/lph-templates', requireRole('admin'), (req, res) => {
+  try {
+    const { lph, title, offsetDays, durationDays } = req.body || {};
+    if(!VALID_LPHS.has(String(lph))){
+      return res.status(400).json({ ok: false, error: 'Unbekannte Leistungsphase.' });
+    }
+    const cleanTitle = String(title || '').trim();
+    if(!cleanTitle) return res.status(400).json({ ok: false, error: 'Titel fehlt.' });
+    const offset = Number.isFinite(Number(offsetDays)) ? Math.max(0, Math.trunc(Number(offsetDays))) : 0;
+    const duration = Number.isFinite(Number(durationDays)) ? Math.max(1, Math.trunc(Number(durationDays))) : 1;
+    // sort_order: ans Ende der jeweiligen Leistungsphase anhängen
+    const maxRow = db.prepare('SELECT MAX(sort_order) AS m FROM lph_templates WHERE lph = ?').get(String(lph));
+    const sortOrder = (maxRow && Number.isFinite(maxRow.m) ? maxRow.m : -1) + 1;
+    const id = crypto.randomUUID();
+    db.prepare(`INSERT INTO lph_templates (id, lph, title, offset_days, duration_days, sort_order)
+      VALUES (?, ?, ?, ?, ?, ?)`).run(id, String(lph), cleanTitle, offset, duration, sortOrder);
+    res.json({ ok: true, template: serializeTemplateRow({
+      id, lph: String(lph), title: cleanTitle, offset_days: offset, duration_days: duration, sort_order: sortOrder
+    })});
+  } catch(err){
+    console.error('Vorlage anlegen fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Vorlagen-Aufgabe löschen. Admin-only. Idempotent (bereits gelöscht
+// ist kein Fehler). Bereits eingefügte TODOs bleiben unberührt (siehe
+// Tabellen-Kommentar bei lph_templates).
+app.delete('/lph-templates/:id', requireRole('admin'), (req, res) => {
+  try {
+    db.prepare('DELETE FROM lph_templates WHERE id = ?').run(String(req.params.id));
+    res.json({ ok: true });
+  } catch(err){
+    console.error('Vorlage löschen fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// ---------- Honorar-Konfiguration (Anteile je LPH + Stundensatz) ----------
+
+// ---------- Firmenweite Einstellungen (app_settings) ----------
+//
+// APP_SETTING_DEFS ist die EINE Stelle, an der ein Schlüssel definiert wird:
+// Vorgabewert, Typ und Prüfung. readAppSettings() liefert daraus stets ein
+// vollständiges Objekt (fehlende oder unbrauchbare Zeilen fallen auf die
+// Vorgabe zurück), PUT /app-settings schreibt nur bekannte Schlüssel.
+//
+// Alle Werte hier waren vorher Konstanten im Code — teils im Server
+// (Backups, Sitzungsdauer, Anmeldebremse), teils im Frontend (Aufwands-
+// vorlage, Ampel-Schwellen, Balkenskala, Arbeitsstunden je Tag). Sie sind
+// nicht deshalb hierher gewandert, weil sie sich oft ändern, sondern weil
+// sie die Zahlen ALLER Nutzer verschieben und ihre Pflege damit eine
+// Administrationsaufgabe ist, kein Eingriff in den Quelltext.
+
+// DEFAULT_AUFWAND_VORLAGE: firmenweite Gewichtung je Leistungsphase und
+// Rolle (0,0–1,0). Sie greift für jedes Projekt, dessen Aufwandsmaske für
+// diese Phase/Rolle keinen eigenen Wert trägt — also für die meisten. LPH 9
+// steht bewusst auf 0: die Faktoren sind fachlich nicht abgestimmt, und ein
+// erfundener Wert flösse unbemerkt in die Auslastung ein.
+const DEFAULT_AUFWAND_VORLAGE = {
+  'LPH 1': { 'Planung': 0.4, 'Projektleitung': 0.2, 'Bauüberwachung': 0 },
+  'LPH 2': { 'Planung': 0.4, 'Projektleitung': 0.2, 'Bauüberwachung': 0 },
+  'LPH 3': { 'Planung': 1.0, 'Projektleitung': 0.3, 'Bauüberwachung': 0 },
+  'LPH 4': { 'Planung': 0.0, 'Projektleitung': 0.3, 'Bauüberwachung': 0 },
+  'LPH 5': { 'Planung': 1.0, 'Projektleitung': 0.4, 'Bauüberwachung': 0 },
+  'LPH 6': { 'Planung': 0.2, 'Projektleitung': 0.7, 'Bauüberwachung': 0.3 },
+  'LPH 7': { 'Planung': 0.1, 'Projektleitung': 0.3, 'Bauüberwachung': 0.5 },
+  'LPH 8': { 'Planung': 0,   'Projektleitung': 0.2, 'Bauüberwachung': 1.0 },
+  'LPH 9': { 'Planung': 0,   'Projektleitung': 0,   'Bauüberwachung': 0 }
+};
+
+// num / int: Prüf-Helfer für APP_SETTING_DEFS. Beide liefern null, wenn der
+// Wert unbrauchbar ist — readAppSettings() nimmt dann die Vorgabe, und
+// PUT /app-settings antwortet mit 400.
+function settingNumber(min, max){
+  return v => {
+    const n = Number(v);
+    return Number.isFinite(n) && n >= min && n <= max ? n : null;
+  };
+}
+function settingInt(min, max){
+  return v => {
+    const n = Number(v);
+    return Number.isInteger(n) && n >= min && n <= max ? n : null;
+  };
+}
+
+const APP_SETTING_DEFS = {
+  // Honorar/Terminplan
+  stundensatz:            { def: 135,  parse: settingNumber(1, 100000),
+                            label: 'Stundensatz (€)' },
+  arbeitsstundenProTag:   { def: 8,    parse: settingNumber(1, 24),
+                            label: 'Arbeitsstunden je Person und Werktag' },
+  // Auslastung
+  vollzeitStundenProWoche:{ def: 40,   parse: settingNumber(1, 80),
+                            label: 'Wochenstunden einer vollen Stelle' },
+  auslastungSchwelleGelb: { def: 0.75, parse: settingNumber(0.05, 5),
+                            label: 'Ampel gelb ab' },
+  auslastungSchwelleRot:  { def: 1.0,  parse: settingNumber(0.05, 5),
+                            label: 'Ampel rot ab' },
+  aufwandVorlage:         { def: DEFAULT_AUFWAND_VORLAGE, json: true, parse: parseAufwandVorlage,
+                            label: 'Aufwand je Leistungsphase und Rolle' },
+  // Die Auslastung rechnet in STUNDEN: offener Honorarwert der amtierenden
+  // Phase geteilt durch den Stundensatz, verteilt auf die verbleibenden
+  // Wochen. Projekte ohne hinterlegtes Honorar — im Bestand die Mehrheit —
+  // brauchen dafür einen Ersatz: Ihre Größe wird als Zahl zwischen 0 und 1
+  // am Projekt gepflegt und mit diesem Referenzhonorar multipliziert. 1,0
+  // entspricht also einem Projekt in Höhe des Referenzwerts.
+  referenzHonorar:        { def: 250000, parse: settingNumber(1000, 100000000),
+                            label: 'Referenzhonorar für die Projektgröße' },
+  // Verteilzeitraum: Über wie viele Wochen die offenen Stunden verteilt
+  // werden, solange das Projekt keinen Terminplan hat, aus dem sich ein
+  // Ende ergibt. Ohne einen solchen Horizont wäre die Wochenlast nicht
+  // bestimmt — dieselben Reststunden bedeuten über vier Wochen etwas ganz
+  // anderes als über vierzig.
+  verteilzeitraumWochen:  { def: 12,   parse: settingInt(1, 260),
+                            label: 'Verteilzeitraum ohne Terminplan (Wochen)' },
+  // Sitzungen
+  autoLockAktiv:          { def: 1,    parse: settingInt(0, 1),
+                            label: 'Ältere Sitzungen automatisch sperren' },
+  // Feiertage: das Bundesland bestimmt, welche gesetzlichen Feiertage
+  // vorgeschlagen werden (holidaysForYear()). Gemerkt, damit es nicht bei
+  // jedem Jahr neu gewählt werden muss.
+  feiertagBundesland:     { def: 'NW', parse: parseBundesland,
+                            label: 'Bundesland für die Feiertage' },
+  // Betrieb
+  maxBackups:             { def: DEFAULT_MAX_BACKUPS, parse: settingInt(1, 500),
+                            label: 'Aufbewahrte automatische Backups' },
+  sessionTage:            { def: DEFAULT_SESSION_TAGE, parse: settingInt(1, 365),
+                            label: 'Gültigkeit einer Anmeldung (Tage)' },
+  loginMaxVersuche:       { def: DEFAULT_LOGIN_MAX_ATTEMPTS, parse: settingInt(1, 100),
+                            label: 'Fehlversuche bis zur Anmeldesperre' },
+  loginSperreMinuten:     { def: DEFAULT_LOGIN_BLOCK_MINUTEN, parse: settingInt(1, 1440),
+                            label: 'Dauer der Anmeldesperre (Minuten)' },
+};
+
+// parseAufwandVorlage: prüft die Aufwands-Matrix. Erlaubt sind nur bekannte
+// Leistungsphasen und Rollen, Werte von 0 bis 1. Nicht genannte Phasen oder
+// Rollen fehlen anschließend schlicht — das Frontend behandelt eine fehlende
+// Angabe als Faktor 1,0 (voller Aufwand), damit Auslastung nicht
+// stillschweigend verschwindet. Rückgabe: geprüftes Objekt oder null.
+function parseAufwandVorlage(value){
+  let obj = value;
+  if(typeof obj === 'string'){
+    try { obj = JSON.parse(obj); } catch(e){ return null; }
+  }
+  if(!obj || typeof obj !== 'object' || Array.isArray(obj)) return null;
+  const out = {};
+  for(const [lph, roles] of Object.entries(obj)){
+    if(!VALID_LPHS.has(lph)) return null;
+    if(!roles || typeof roles !== 'object' || Array.isArray(roles)) return null;
+    const cleanRoles = {};
+    for(const [role, v] of Object.entries(roles)){
+      if(!VALID_DISCIPLINE_ROLES.has(role)) return null;
+      const n = Number(v);
+      if(!Number.isFinite(n) || n < 0 || n > 1) return null;
+      cleanRoles[role] = n;
+    }
+    out[lph] = cleanRoles;
+  }
+  return out;
+}
+
+// parseBundesland: prüft ein Bundesland-Kürzel gegen GERMAN_STATES (weiter
+// unten definiert; die Prüfung läuft erst zur Anfragezeit).
+// Rückgabe: Kürzel oder null.
+function parseBundesland(value){
+  const v = String(value || '').toUpperCase();
+  return GERMAN_STATES[v] ? v : null;
+}
+
+// readAppSettings: liefert ALLE firmenweiten Einstellungen als fertiges
+// Objekt. Eine fehlende Zeile ist der Normalfall (die Vorgabe gilt); eine
+// unbrauchbare Zeile — etwa aus einem älteren Stand — fällt ebenfalls auf die
+// Vorgabe zurück, statt die Rechnung zu vergiften.
+// Keine Parameter. Rückgabe: Objekt über alle Schlüssel von APP_SETTING_DEFS.
+function readAppSettings(){
+  const rows = db.prepare('SELECT key, value FROM app_settings').all();
+  const stored = {};
+  rows.forEach(r => { stored[r.key] = r.value; });
+
+  const out = {};
+  for(const [key, def] of Object.entries(APP_SETTING_DEFS)){
+    if(!Object.prototype.hasOwnProperty.call(stored, key)){ out[key] = def.def; continue; }
+    const parsed = def.parse(stored[key]);
+    out[key] = parsed === null ? def.def : parsed;
+  }
+  return out;
+}
+
+// readAppSetting: ein einzelner Wert (Kurzform für die Aufrufer im Server).
+// Parameter: key. Rückgabe: geprüfter Wert bzw. Vorgabe.
+function readAppSetting(key){
+  const def = APP_SETTING_DEFS[key];
+  if(!def) return undefined;
+  const row = db.prepare('SELECT value FROM app_settings WHERE key = ?').get(key);
+  if(!row) return def.def;
+  const parsed = def.parse(row.value);
+  return parsed === null ? def.def : parsed;
+}
+
+// Route: alle firmenweiten Einstellungen lesen. Auth, nicht admin-only — das
+// Frontend RECHNET damit (Auslastung, Terminplan) und braucht sie deshalb bei
+// jedem Konto. Geändert werden dürfen sie nur von Administratoren, siehe PUT.
+app.get('/app-settings', requireAuthOderKiosk, (req, res) => {
+  try {
+    res.json({ ok: true, settings: readAppSettings() });
+  } catch(err){
+    console.error('Einstellungen laden fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// GET/PUT /my-ai-settings: die beiden KI-API-Schlüssel des ANGEMELDETEN
+// Kontos (req.user.id, nie eine vom Client mitgeschickte Kennung — exakt
+// wie /change-email/POST). Jeder Nutzer verwaltet seinen eigenen Zugang
+// unter Einstellungen → Mein Konto; kein admin-only mehr, siehe CLAUDE.md
+// "### Protokolle". GET liefert je Anbieter, OB ein Schlüssel gesetzt ist
+// (nie der Schlüssel selbst, wie ein Passwort) sowie die — nicht geheime —
+// apiUrl zum Weiterbearbeiten.
+app.get('/my-ai-settings', requireAuth, (req, res) => {
+  try {
+    const chatgpt = readUserAiKey(req.user.id, 'chatgpt');
+    const claude = readUserAiKey(req.user.id, 'claude');
+    res.json({
+      ok: true,
+      chatgpt: { configured: !!chatgpt.apiKey, apiUrl: chatgpt.apiUrl },
+      claude: { configured: !!claude.apiKey, apiUrl: claude.apiUrl }
+    });
+  } catch(err){
+    console.error('KI-Einstellungen laden fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+app.put('/my-ai-settings', requireAuth, (req, res) => {
+  try {
+    const body = (req.body && typeof req.body === 'object') ? req.body : {};
+    for(const provider of ['chatgpt', 'claude']){
+      const patch = body[provider];
+      if(!patch || typeof patch !== 'object') continue;
+      if(Object.prototype.hasOwnProperty.call(patch, 'apiUrl') && patch.apiUrl && !istGueltigeAiUrl(patch.apiUrl)){
+        return res.status(400).json({ ok: false, error: 'Die API-URL muss eine gültige https-Adresse sein (oder http auf localhost/127.0.0.1 für einen lokalen Server wie LM Studio/Ollama).' });
+      }
+      writeUserAiKey(req.user.id, provider, patch);
+    }
+    const chatgpt = readUserAiKey(req.user.id, 'chatgpt');
+    const claude = readUserAiKey(req.user.id, 'claude');
+    res.json({
+      ok: true,
+      chatgpt: { configured: !!chatgpt.apiKey, apiUrl: chatgpt.apiUrl },
+      claude: { configured: !!claude.apiKey, apiUrl: claude.apiUrl }
+    });
+  } catch(err){
+    console.error('KI-Einstellungen speichern fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// POST /my-ai-settings/test: "Neu verbinden" — prüft die GESPEICHERTE
+// Konfiguration des aufrufenden Kontos für einen Anbieter, indem
+// tatsächlich eine kurze, echte Anfrage über erkennePunkteMitKI() läuft
+// (dieselbe Funktion, die auch der Protokoll-Import nutzt — deckt damit
+// automatisch Timeout-Wahl, reasoning_effort-Behandlung für lokale Ziele
+// und URL-Normalisierung mit ab, ohne eigenen Testpfad pflegen zu müssen).
+app.post('/my-ai-settings/test', requireAuth, async (req, res) => {
+  try {
+    const provider = req.body && req.body.provider;
+    if(provider !== 'chatgpt' && provider !== 'claude'){
+      return res.status(400).json({ ok: false, error: 'Unbekannter Anbieter.' });
+    }
+    await erkennePunkteMitKI('1. Testpunkt. Zustaendig: Test. Termin: 01.01.2026', req.user.id, provider);
+    res.json({ ok: true });
+  } catch(err){
+    // Ein fehlgeschlagener Verbindungstest ist ein normales, erwartetes
+    // Ergebnis, kein Serverfehler — deshalb 200 mit ok:false statt 4xx/5xx,
+    // der Client unterscheidet Erfolg/Fehlschlag einheitlich über "ok".
+    res.json({ ok: false, error: err.message || String(err) });
+  }
+});
+
+// Route: firmenweite Einstellungen schreiben. Admin-only. Teilweise Updates
+// (nur die im Rumpf genannten Schlüssel werden geschrieben); unbekannte
+// Schlüssel und unbrauchbare Werte führen zu 400, bevor irgendetwas
+// geschrieben wird — sonst bliebe die Hälfte einer Maske liegen.
+app.put('/app-settings', requireRole('admin'), (req, res) => {
+  try {
+    const body = (req.body && typeof req.body === 'object') ? req.body : {};
+    const writes = [];
+    for(const [key, value] of Object.entries(body)){
+      const def = APP_SETTING_DEFS[key];
+      if(!def) return res.status(400).json({ ok:false, error: 'Unbekannte Einstellung: ' + key });
+      const parsed = def.parse(value);
+      if(parsed === null) return res.status(400).json({ ok:false, error: 'Unbrauchbarer Wert für „' + def.label + '".' });
+      writes.push([key, def.json ? JSON.stringify(parsed) : String(parsed)]);
+    }
+    // Gelb darf nicht über Rot liegen — sonst zeigte die Ampel nie Gelb.
+    const merged = Object.assign(readAppSettings(), Object.fromEntries(
+      writes.map(([k, v]) => [k, APP_SETTING_DEFS[k].parse(v)])
+    ));
+    if(merged.auslastungSchwelleGelb > merged.auslastungSchwelleRot){
+      return res.status(400).json({ ok:false, error: 'Die gelbe Schwelle muss unter der roten liegen.' });
+    }
+
+    db.exec('BEGIN');
+    try {
+      const stmt = db.prepare(`INSERT INTO app_settings (key, value) VALUES (?, ?)
+        ON CONFLICT(key) DO UPDATE SET value = excluded.value`);
+      writes.forEach(([k, v]) => stmt.run(k, v));
+      db.exec('COMMIT');
+    } catch(err){
+      db.exec('ROLLBACK');
+      throw err;
+    }
+    res.json({ ok: true, settings: readAppSettings() });
+  } catch(err){
+    console.error('Einstellungen speichern fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// ---------- Feiertage ----------
+
+// Gesetzliche Feiertage lassen sich vollstaendig BERECHNEN: Ein Teil liegt auf
+// festen Kalendertagen, der Rest haengt am Osterdatum. Deshalb holt diese
+// Anwendung sie nicht von einem Netzdienst — das haette eine Abhaengigkeit
+// von fremder Verfuegbarkeit und einem Internetzugang des Servers bedeutet,
+// den es im Buero-Netz nicht zwingend gibt. Berechnet ist das Ergebnis
+// jederzeit gleich, funktioniert offline und braucht kein weiteres Paket
+// (das Projekt kommt bewusst mit express und cors aus).
+//
+// Die errechneten Tage werden NICHT automatisch in die Tabelle geschrieben.
+// Ein Administrator laesst sie sich vorschlagen und uebernimmt sie bewusst —
+// Feiertage verschieben jeden gerechneten Terminplan, das soll nicht
+// unbemerkt im Hintergrund passieren.
+
+// GERMAN_STATES: die 16 Bundeslaender mit ihrem amtlichen Kuerzel.
+const GERMAN_STATES = {
+  BW: 'Baden-Württemberg',      BY: 'Bayern',
+  BE: 'Berlin',                 BB: 'Brandenburg',
+  HB: 'Bremen',                 HH: 'Hamburg',
+  HE: 'Hessen',                 MV: 'Mecklenburg-Vorpommern',
+  NI: 'Niedersachsen',          NW: 'Nordrhein-Westfalen',
+  RP: 'Rheinland-Pfalz',        SL: 'Saarland',
+  SN: 'Sachsen',                ST: 'Sachsen-Anhalt',
+  SH: 'Schleswig-Holstein',     TH: 'Thüringen',
+};
+
+// easterSunday: Ostersonntag eines Jahres nach der gregorianischen
+// Osterformel (Gauss/Meeus). Alle beweglichen Feiertage haengen daran.
+// Parameter: year (Zahl). Rueckgabe: Date (UTC-Mitternacht).
+function easterSunday(year){
+  const a = year % 19;
+  const b = Math.floor(year / 100);
+  const c = year % 100;
+  const d = Math.floor(b / 4);
+  const e = b % 4;
+  const f = Math.floor((b + 8) / 25);
+  const g = Math.floor((b - f + 1) / 3);
+  const h = (19 * a + b - d - g + 15) % 30;
+  const i = Math.floor(c / 4);
+  const k = c % 4;
+  const l = (32 + 2 * e + 2 * i - h - k) % 7;
+  const m = Math.floor((a + 11 * h + 22 * l) / 451);
+  const month = Math.floor((h + l - 7 * m + 114) / 31);
+  const day = ((h + l - 7 * m + 114) % 31) + 1;
+  return new Date(Date.UTC(year, month - 1, day));
+}
+
+// isoFromDate / shiftDays: kleine Datums-Helfer fuer die Berechnung. Gerechnet
+// wird durchgehend in UTC, damit keine Sommerzeit-Umstellung einen Tag
+// verschiebt.
+function isoFromDate(d){ return d.toISOString().slice(0, 10); }
+function shiftDays(d, n){ return new Date(d.getTime() + n * 86400000); }
+
+// bussUndBettag: Mittwoch vor dem 23. November (nur Sachsen).
+// Parameter: year. Rueckgabe: Date.
+function bussUndBettag(year){
+  let d = new Date(Date.UTC(year, 10, 22));   // 22.11.
+  while(d.getUTCDay() !== 3) d = shiftDays(d, -1);
+  return d;
+}
+
+// holidaysForYear: die gesetzlichen Feiertage eines Jahres in einem
+// Bundesland. Nicht enthalten sind die gemeindeabhaengigen Faelle
+// (Fronleichnam in Teilen von Sachsen und Thueringen, Mariä Himmelfahrt in
+// ueberwiegend katholischen Gemeinden Bayerns) — die haengen vom Wohnort ab
+// und lassen sich nicht aus dem Bundesland ableiten; sie koennen von Hand
+// ergaenzt werden.
+// Parameter: year (Zahl), state (Kuerzel aus GERMAN_STATES).
+// Rueckgabe: Array von { date, name }, nach Datum sortiert.
+function holidaysForYear(year, state){
+  const ostern = easterSunday(year);
+  const fest = (m, d) => isoFromDate(new Date(Date.UTC(year, m - 1, d)));
+  const ab = n => isoFromDate(shiftDays(ostern, n));
+
+  // Jeder Eintrag: [Datum, Bezeichnung, Bundeslaender oder null = bundesweit]
+  const alle = [
+    [fest(1, 1),   'Neujahr',                      null],
+    [fest(1, 6),   'Heilige Drei Könige',          ['BW','BY','ST']],
+    [fest(3, 8),   'Internationaler Frauentag',    ['BE','MV']],
+    [ab(-2),       'Karfreitag',                   null],
+    [ab(0),        'Ostersonntag',                 ['BB']],
+    [ab(1),        'Ostermontag',                  null],
+    [fest(5, 1),   'Tag der Arbeit',               null],
+    [ab(39),       'Christi Himmelfahrt',          null],
+    [ab(49),       'Pfingstsonntag',               ['BB']],
+    [ab(50),       'Pfingstmontag',                null],
+    [ab(60),       'Fronleichnam',                 ['BW','BY','HE','NW','RP','SL']],
+    [fest(8, 15),  'Mariä Himmelfahrt',            ['SL']],
+    [fest(9, 20),  'Weltkindertag',                ['TH']],
+    [fest(10, 3),  'Tag der Deutschen Einheit',    null],
+    [fest(10, 31), 'Reformationstag',              ['BB','HB','HH','MV','NI','SH','SN','ST','TH']],
+    [fest(11, 1),  'Allerheiligen',                ['BW','BY','NW','RP','SL']],
+    [isoFromDate(bussUndBettag(year)), 'Buß- und Bettag', ['SN']],
+    [fest(12, 25), '1. Weihnachtstag',             null],
+    [fest(12, 26), '2. Weihnachtstag',             null],
+  ];
+
+  return alle
+    .filter(([, , laender]) => laender === null || laender.includes(state))
+    .map(([date, name]) => ({ date, name }))
+    .sort((a, b) => a.date.localeCompare(b.date));
+}
+
+// Route: gesetzliche Feiertage eines Jahres vorschlagen. Auth (lesend, die
+// Berechnung verraet nichts). Jeder Eintrag traegt zusaetzlich `vorhanden`,
+// damit die Maske zeigen kann, was schon hinterlegt ist.
+app.get('/holidays/suggest', requireAuth, (req, res) => {
+  try {
+    const year = Number(req.query.year);
+    const state = String(req.query.state || readAppSetting('feiertagBundesland'));
+    if(!Number.isInteger(year) || year < 1970 || year > 2200){
+      return res.status(400).json({ ok:false, error:'Jahr muss zwischen 1970 und 2200 liegen.' });
+    }
+    if(!GERMAN_STATES[state]){
+      return res.status(400).json({ ok:false, error:'Unbekanntes Bundesland: ' + state });
+    }
+    const vorhanden = new Set(db.prepare('SELECT date FROM holidays').all().map(r => r.date));
+    const holidays = holidaysForYear(year, state).map(h => ({
+      date: h.date, name: h.name, vorhanden: vorhanden.has(h.date),
+    }));
+    res.json({ ok:true, year, state, stateName: GERMAN_STATES[state], holidays, states: GERMAN_STATES });
+  } catch(err){
+    console.error('Feiertage berechnen fehlgeschlagen:', err);
+    res.status(500).json({ ok:false, error: String(err) });
+  }
+});
+
+// Route: berechnete Feiertage uebernehmen. Admin-only. Bereits hinterlegte
+// Tage bleiben unveraendert — ein von Hand angepasster Name (etwa ein
+// Brueckentag, den jemand auf denselben Tag gelegt hat) soll nicht
+// ueberschrieben werden. Die Antwort meldet beides getrennt.
+app.post('/holidays/import', requireRole('admin'), (req, res) => {
+  try {
+    const year = Number((req.body || {}).year);
+    const state = String((req.body || {}).state || readAppSetting('feiertagBundesland'));
+    if(!Number.isInteger(year) || year < 1970 || year > 2200){
+      return res.status(400).json({ ok:false, error:'Jahr muss zwischen 1970 und 2200 liegen.' });
+    }
+    if(!GERMAN_STATES[state]){
+      return res.status(400).json({ ok:false, error:'Unbekanntes Bundesland: ' + state });
+    }
+    const liste = holidaysForYear(year, state);
+    const stmt = db.prepare('INSERT OR IGNORE INTO holidays (date, name) VALUES (?, ?)');
+    let angelegt = 0;
+    db.exec('BEGIN');
+    try {
+      liste.forEach(h => { angelegt += stmt.run(h.date, h.name).changes; });
+      db.exec('COMMIT');
+    } catch(err){
+      db.exec('ROLLBACK');
+      throw err;
+    }
+    res.json({ ok:true, angelegt, uebersprungen: liste.length - angelegt, gesamt: liste.length });
+  } catch(err){
+    console.error('Feiertage übernehmen fehlgeschlagen:', err);
+    res.status(500).json({ ok:false, error: String(err) });
+  }
+});
+
+
+// Route: Feiertage lesen. Auth — das Frontend rechnet damit in Werktagen.
+app.get('/holidays', requireAuthOderKiosk, (req, res) => {
+  try {
+    const rows = db.prepare('SELECT date, name FROM holidays ORDER BY date').all();
+    // Die Bundesländer kommen gleich mit: Der Server ist die eine Stelle, an
+    // der die Liste steht, und die Pflege-Maske braucht sie sofort — sonst
+    // hätte ihre Auswahl bis zum ersten Vorschlag nur einen Eintrag.
+    res.json({
+      ok: true,
+      holidays: rows.map(r => ({ date: r.date, name: r.name })),
+      states: GERMAN_STATES,
+    });
+  } catch(err){
+    console.error('Feiertage laden fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Feiertag anlegen oder umbenennen. Admin-only. Das Datum ist der
+// Primärschlüssel, ein zweites Anlegen desselben Tages ersetzt also nur den
+// Namen — das ist gewollt und erspart ein eigenes PATCH.
+app.post('/holidays', requireRole('admin'), (req, res) => {
+  try {
+    const { date, name } = req.body || {};
+    if(typeof date !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(date)){
+      return res.status(400).json({ ok:false, error:'Datum im Format JJJJ-MM-TT erforderlich.' });
+    }
+    const d = new Date(date + 'T00:00:00Z');
+    if(Number.isNaN(d.getTime()) || d.toISOString().slice(0,10) !== date){
+      return res.status(400).json({ ok:false, error:'Kein gültiges Datum.' });
+    }
+    const cleanName = String(name || '').trim().slice(0, 120);
+    db.prepare(`INSERT INTO holidays (date, name) VALUES (?, ?)
+      ON CONFLICT(date) DO UPDATE SET name = excluded.name`).run(date, cleanName);
+    res.json({ ok: true, holiday: { date, name: cleanName } });
+  } catch(err){
+    console.error('Feiertag anlegen fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Feiertag löschen. Admin-only, idempotent.
+app.delete('/holidays/:date', requireRole('admin'), (req, res) => {
+  try {
+    db.prepare('DELETE FROM holidays WHERE date = ?').run(String(req.params.date));
+    res.json({ ok: true });
+  } catch(err){
+    console.error('Feiertag löschen fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+
+// readStundensatz: liest den firmenweiten Stundensatz (Vorgabe und Prüfung
+// stehen in APP_SETTING_DEFS).
+function readStundensatz(){
+  // Ein Schlüssel, eine Definition: der Stundensatz steht seit der
+  // Einführung von APP_SETTING_DEFS dort (mit derselben Vorgabe 135) und
+  // wird weiterhin über /honorar-config gepflegt, weil er fachlich zur
+  // Honorar-Maske gehört.
+  return readAppSetting('stundensatz');
+}
+
+// Route: Honorar-Konfiguration lesen — Anteile je Leistungsphase und
+// Stundensatz. Auth (nicht admin-only): jeder angemeldete Nutzer darf einen
+// Terminplan rechnen lassen, nur das Pflegen der Sätze ist Admin-Sache.
+app.get('/honorar-config', requireAuthOderKiosk, (req, res) => {
+  try {
+    const rows = db.prepare('SELECT lph, percent FROM lph_honorar_anteile').all();
+    const anteile = {};
+    rows.forEach(r => { anteile[r.lph] = r.percent; });
+    res.json({ ok: true, anteile, stundensatz: readStundensatz() });
+  } catch(err){
+    console.error('Honorar-Konfiguration laden fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: Honorar-Konfiguration schreiben. Admin-only (firmenweite Vorgabe).
+// `anteile` ist ein vollständiger Ersatz (delete + insert in einer
+// Transaktion, gleiches Muster wie die Rollen in PATCH /admin/users/:id):
+// eine im Objekt fehlende Leistungsphase gilt damit als "kein Anteil".
+app.put('/honorar-config', requireRole('admin'), (req, res) => {
+  try {
+    const { anteile, stundensatz } = req.body || {};
+    if(anteile !== undefined && (typeof anteile !== 'object' || anteile === null)){
+      return res.status(400).json({ ok: false, error: 'anteile muss ein Objekt sein.' });
+    }
+    if(stundensatz !== undefined){
+      const v = Number(stundensatz);
+      if(!Number.isFinite(v) || v <= 0){
+        return res.status(400).json({ ok: false, error: 'Stundensatz muss größer als 0 sein.' });
+      }
+    }
+    // Vor dem Schreiben prüfen, damit eine einzelne unbrauchbare Zeile nicht
+    // die halbe Konfiguration überschreibt.
+    const clean = [];
+    if(anteile){
+      for(const [lph, pct] of Object.entries(anteile)){
+        if(!VALID_LPHS.has(lph)){
+          return res.status(400).json({ ok: false, error: 'Unbekannte Leistungsphase: ' + lph });
+        }
+        const v = Number(pct);
+        if(!Number.isFinite(v) || v < 0 || v > 100){
+          return res.status(400).json({ ok: false, error: 'Anteil für ' + lph + ' muss zwischen 0 und 100 liegen.' });
+        }
+        if(v > 0) clean.push([lph, v]);
+      }
+    }
+
+    db.exec('BEGIN');
+    try {
+      if(anteile){
+        db.prepare('DELETE FROM lph_honorar_anteile').run();
+        const ins = db.prepare('INSERT INTO lph_honorar_anteile (lph, percent) VALUES (?, ?)');
+        clean.forEach(([lph, v]) => ins.run(lph, v));
+      }
+      if(stundensatz !== undefined){
+        db.prepare(`INSERT INTO app_settings (key, value) VALUES ('stundensatz', ?)
+          ON CONFLICT(key) DO UPDATE SET value = excluded.value`).run(String(Number(stundensatz)));
+      }
+      db.exec('COMMIT');
+    } catch(err){
+      db.exec('ROLLBACK');
+      throw err;
+    }
+
+    const rows = db.prepare('SELECT lph, percent FROM lph_honorar_anteile').all();
+    const out = {};
+    rows.forEach(r => { out[r.lph] = r.percent; });
+    res.json({ ok: true, anteile: out, stundensatz: readStundensatz() });
+  } catch(err){
+    console.error('Honorar-Konfiguration speichern fehlgeschlagen:', err);
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+
 // Route: DB-Snapshot-Download. Erzeugt einen konsistenten Snapshot der
 // SQLite-Datenbank (auch mit WAL) und stellt ihn als .db-Datei zum Download
 // bereit (Backup für Archivierung/Wiederherstellung, z. B. per "DB Backup"-
 // Button im Menü). Die temporäre Datei wird nach dem Senden gelöscht.
-app.get('/backup', (req, res) => {
+// NUR ADMINS: Der Snapshot enthält die komplette Datenbank und damit auch
+// user_sessions.token im Klartext. Mit einem fremden Token könnte sich sonst
+// jedes Mitglied als Administrator ausgeben (Rechteausweitung) — deshalb ist
+// diese Route strenger abgesichert als der Rest der fachlichen Daten-Routen.
+app.get('/backup', requireRole('admin'), (req, res) => {
   const tmp = path.join(os.tmpdir(), 'projektuebersicht_backup_' + Date.now() + '.db');
   try {
     createDbSnapshot(tmp);
-    const filename = 'projektuebersicht_backup_' + new Date().toISOString().slice(0, 10) + '.db';
+    // heuteIsoLokal() statt toISOString(): Letzteres rechnet nach UTC um und
+    // datierte das Backup zwischen 0 und 2 Uhr Ortszeit auf den Vortag.
+    const filename = 'projektuebersicht_backup_' + heuteIsoLokal() + '.db';
     res.download(tmp, filename, () => fs.unlink(tmp, () => {}));
     console.log('DB-Backup-Download:', filename);
   } catch(err){
@@ -1343,7 +5397,7 @@ app.get('/backup', (req, res) => {
 // validiert das Schema und ersetzt den gesamten Datenbestand. VOR dem Import
 // wird der Zustand vor dem Import als frisches Backup gesichert, damit ein
 // versehentlicher Restore rückgängig gemacht werden kann.
-app.post('/import', express.raw({ type: '*/*', limit: '100mb' }), (req, res) => {
+app.post('/import', requireRole('admin'), express.raw({ type: '*/*', limit: '100mb' }), (req, res) => {
   const buf = req.body;
   if(!Buffer.isBuffer(buf) || buf.length === 0){
     return res.status(400).json({ ok: false, error: 'Keine Datei empfangen' });
@@ -1368,44 +5422,109 @@ app.post('/import', express.raw({ type: '*/*', limit: '100mb' }), (req, res) =>
 // Route: Healthcheck-Endpunkt für Docker/Überwachung
 app.get('/health', (req,res)=> res.json({ok:true}));
 
-// Route: Liefert die Hauptseite Test.html
+// Route: Liefert die Hauptseite App.html
 app.get('/', (req,res)=>{
-  res.sendFile(path.join(__dirname, 'public', 'Test.html'));
+  res.sendFile(path.join(__dirname, 'public', 'App.html'));
 });
 
 // Gültige Tab-Slugs für Deep-Link-Routen (muss zu TAB_SLUGS in js/globals.js passen)
-const VALID_TAB_SLUGS = new Set(['Projektübersicht','Auslastung','Projekte','Projektbeteiligte']);
+// 'Projekte' bleibt bewusst gültig, obwohl der gleichnamige Bereich in der
+// Projektliste aufgegangen ist: Weitergegebene Links sollen nicht mit 404
+// enden. Die Oberfläche leitet den Abschnitt auf die Projektliste um
+// (TAB_BY_SLUG in public/js/globals.js) und erzeugt ihn selbst nicht mehr.
+const VALID_TAB_SLUGS = new Set(['Projektübersicht','Wochenbericht','Auslastung','Projekte','Projektbeteiligte','Planung','MeineAufgaben','Wandtafel','Einstellungen','Admin']);
 // Slug der Projektplan-Seite (muss zu PLAN_SLUG in js/globals.js passen)
 const PLAN_SLUG = 'Projektplan';
 
-// Route: Deep-Links je Abteilung + Tab, z. B. "/HLS/Auslastung" oder
-// "/ELT/Projektübersicht". Liefert wie "/" die Hauptseite; unbekannte
-// Abteilungen/Tabs werden abgelehnt (404), damit keine Test.html auf beliebigen
-// Pfaden ausgeliefert wird.
-app.get('/:department/:tab', (req, res) => {
-  const { department, tab } = req.params;
-  if(!VALID_DEPARTMENTS.has(department)) return res.status(404).send('Nicht gefunden');
-  if(tab === PLAN_SLUG){
-    // Projektplan-Seite (GANTT), z. B. "/HLS/Projektplan?weekLabel=..."
-    return res.sendFile(path.join(__dirname, 'public', 'project-plan.html'));
-  }
-  if(!VALID_TAB_SLUGS.has(tab)) return res.status(404).send('Nicht gefunden');
-  res.sendFile(path.join(__dirname, 'public', 'Test.html'));
+// Route: alte Direktlinks auf die entfallene Datei admin-users.html. Sie war
+// bis zum Umbau eine eigene Seite mit nachgebauter Kopfzeile; die
+// Benutzerverwaltung ist heute ein Abschnitt des Bereichs „Admin" auf der
+// Hauptseite, damit die Seitenleiste stehen bleibt.
+app.get('/admin-users.html', (req, res) => {
+  res.redirect(301, '/Admin#benutzer');
 });
 
-// Route: Projektplan-Seite mit Projektname im Pfad, z. B.
-// "/HLS/Projektplan/Gymnasium%20Hemer?weekLabel=..." – das Pfad-Segment dient
-// nur der lesbaren Adresse, die Identifikation erfolgt über weekLabel/projNr.
-app.get('/:department/Projektplan/:projName', (req, res) => {
-  if(!VALID_DEPARTMENTS.has(req.params.department)) return res.status(404).send('Nicht gefunden');
-  res.sendFile(path.join(__dirname, 'public', 'project-plan.html'));
+// Route: alte Direktlinks auf die entfallene Datei project-plan.html. Sie
+// war bis zum Umbau ein eigenes Dokument; heute ist der Projektbereich der
+// Bereich #plan der Hauptseite. Die Parameter (weekLabel, projNr, projName)
+// bleiben erhalten, damit ein alter Link weiterhin dasselbe Projekt öffnet.
+app.get('/project-plan.html', (req, res) => {
+  const params = new URLSearchParams(req.query);
+  const projName = params.get('projName') || '';
+  params.delete('projName');
+  const qs = params.toString();
+  res.redirect(301, '/' + PLAN_SLUG + '/' + encodeURIComponent(projName) + (qs ? '?' + qs : ''));
+});
+
+// Route: alte Direktlinks auf den früheren Dateinamen Test.html — ein nie
+// umbenannter Platzhaltername aus der Frühphase des Projekts, inzwischen
+// App.html. Anders als bei admin-users.html/project-plan.html gibt es kein
+// anderes Ziel als "/" selbst: Test.html WAR die Hauptseite, nur unter einem
+// unpassenden Namen.
+app.get('/Test.html', (req, res) => {
+  res.redirect(301, '/');
+});
+
+// Route: Deep-Links je Tab, z. B. "/Auslastung" oder "/Projektübersicht"
+// (seit Entfernung der Abteilungstrennung nur noch ein Pfad-Segment, vorher
+// "/<Abteilung>/<Tab>"). Liefert wie "/" die Hauptseite; unbekannte Tabs
+// werden abgelehnt (404), damit keine App.html auf beliebigen Pfaden
+// ausgeliefert wird.
+app.get('/:tab', (req, res) => {
+  const { tab } = req.params;
+  if(tab === PLAN_SLUG){
+    // Projektbereich eines Projekts, z. B. "/Projektplan?weekLabel=..." —
+    // seit dem Umbau kein eigenes Dokument mehr, sondern der Bereich #plan
+    // der Hauptseite (applyUrlRoute() in public/js/ui.js wertet die Adresse
+    // clientseitig aus).
+    return res.sendFile(path.join(__dirname, 'public', 'App.html'));
+  }
+  if(!VALID_TAB_SLUGS.has(tab)) return res.status(404).send('Nicht gefunden');
+  res.sendFile(path.join(__dirname, 'public', 'App.html'));
+});
+
+// Route: Projektbereich mit Projektname im Pfad, z. B.
+// "/Projektplan/Gymnasium%20Hemer?weekLabel=..." – das Pfad-Segment dient nur
+// der lesbaren Adresse, die Identifikation erfolgt über weekLabel/projNr.
+app.get('/Projektplan/:projName', (req, res) => {
+  res.sendFile(path.join(__dirname, 'public', 'App.html'));
+});
+
+// Route: Weiterleitung alter, noch abteilungspräfixierter Projektplan-Links
+// ("/HLS/Projektplan/Foo?weekLabel=...") auf das neue Schema, damit alte
+// Lesezeichen nicht brechen. Muss VOR der generischen 2-Segment-Weiterleitung
+// stehen (3 Segmente sind eindeutig).
+app.get('/:legacyDept/Projektplan/:projName', (req, res) => {
+  if(!VALID_DEPARTMENTS.has(req.params.legacyDept)) return res.status(404).send('Nicht gefunden');
+  const qs = req.url.includes('?') ? req.url.slice(req.url.indexOf('?')) : '';
+  res.redirect(301, '/Projektplan/' + encodeURIComponent(req.params.projName) + qs);
+});
+
+// Route: Weiterleitung alter zweisegmentiger Deep-Links ("/ELT/Auslastung")
+// auf das neue einsegmentige Schema. Muss NACH "/Projektplan/:projName"
+// stehen, sonst würde z.B. "/Projektplan/Foo" hier fälschlich als
+// Abteilung="Projektplan" interpretiert.
+app.get('/:legacyDept/:tab', (req, res) => {
+  if(!VALID_DEPARTMENTS.has(req.params.legacyDept)) return res.status(404).send('Nicht gefunden');
+  const qs = req.url.includes('?') ? req.url.slice(req.url.indexOf('?')) : '';
+  res.redirect(301, '/' + encodeURIComponent(req.params.tab) + qs);
 });
 
 // Serverstart mit Fehlerbehandlung (z.B. Port bereits belegt)
 const server = app.listen(PORT, () => {
   console.log(`Projektübersicht server running on http://localhost:${PORT}`);
-  // Automatisches Datenbank-Backup beim Start (session/backups/, letzte MAX_BACKUPS)
+  // Automatisches Datenbank-Backup beim Start (sessions/backups/)
   runAutoBackup();
+  // Automatischer Sitzungswechsel: einmal jetzt (holt einen Wochenwechsel
+  // nach, der while der Server nicht lief passiert ist) und danach stündlich
+  // erneut — mehr als genug Auflösung für einen Wechsel, der genau einmal
+  // pro Woche eintritt. Muss NACH allen anderen Definitionen dieser Datei
+  // stehen (braucht u. a. APP_SETTING_DEFS/readAppSettings(), die erst
+  // weiter unten im Datei-Durchlauf definiert werden) — deshalb hier im
+  // app.listen()-Rückruf statt in der früheren Migrations-/Bootstrap-
+  // Reihenfolge weiter oben.
+  ensureCurrentWeekRollover();
+  setInterval(ensureCurrentWeekRollover, 60 * 60 * 1000);
 });
 server.on('error', (err) => {
   console.error('Server konnte nicht starten:', err.message);
@@ -1414,3 +5533,25 @@ server.on('error', (err) => {
   }
   process.exit(1);
 });
+
+// Sauberes Beenden auf Strg+C/Cmd+C (SIGINT) oder `kill` (SIGTERM): schließt
+// zuerst den HTTP-Server (keine neuen Verbindungen mehr, laufende werden zu
+// Ende bedient) und danach die Datenbank (sauberer WAL-Checkpoint statt
+// eines abrupten Abbruchs mitten im Schreiben). Ohne diesen Handler würde
+// Node ebenfalls beenden — kein anderer Code hier überschreibt das
+// Standardverhalten —, aber lautlos und ohne den Checkpoint.
+function shutdown(signal){
+  console.log(`\n${signal} empfangen, Server wird beendet…`);
+  // Sicherheitsnetz: eine offene Keep-Alive-Verbindung kann server.close()
+  // unbegrenzt blockieren (bekannte Node-Eigenheit) — nach 3s notfalls hart
+  // beenden, damit der Prozess in jedem Fall nur bis zum Tastendruck läuft.
+  const notbremse = setTimeout(() => process.exit(0), 3000);
+  notbremse.unref();
+  server.close(() => {
+    try { db.close(); } catch(e){ /* bereits geschlossen */ }
+    console.log('Server beendet.');
+    process.exit(0);
+  });
+}
+process.on('SIGINT', () => shutdown('SIGINT'));
+process.on('SIGTERM', () => shutdown('SIGTERM'));