diff --git a/.DS_Store b/.DS_Store
deleted file mode 100644
index fb9a51a..0000000
Binary files a/.DS_Store and /dev/null differ
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..ec99bcc
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,7 @@
+# SQLite-Datenbank (Laufzeitartefakt in sessions/)
+sessions/*.db
+sessions/*.db-wal
+sessions/*.db-shm
+
+# macOS-Artefakte
+.DS_Store
diff --git a/AGENTS.md b/AGENTS.md
deleted file mode 100644
index 093811d..0000000
--- a/AGENTS.md
+++ /dev/null
@@ -1,198 +0,0 @@
-# AGENTS.md
-
-## Overview
-
-Single-page app for tracking engineering projects across weekly sessions
-("Sitzungen"). Vanilla JS/HTML/CSS frontend + Node.js/Express server. No build
-step, no bundler, no tests. Data is persisted as semicolon-separated CSVs
-under `sessions/`.
-
-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`, `csv`, `server`, `gantt`) plus the
-  plan modules under `js/plan/` — NOT the full main module set.
-
-All UI strings/comments/CSV content are German. Preserve German in
-user-facing text.
-
-## File structure
-
-```
-.
-├── server.js                 # Express server + CSV API
-├── package.json             # deps: express, cors only
-├── docker-compose.yml       # at repo ROOT; build context ., dockerfile Docker/Dockerfile
-├── Docker/Dockerfile        # node:20-alpine
-├── .dockerignore
-├── .vscode/extensions.json
-├── public/
-│   ├── Test.html            # main app (served at /)
-│   ├── 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-Quelle
-│   │   ├── ui.js            # LocalStorage-UI-State, Header-Collapse, Theme
-│   │   ├── date-picker.js   # Datums-/Bereichspicker-Overlays
-│   │   ├── csv.js           # CSV-Parser/Serializer + weekSortKey, filenameForWeek
-│   │   ├── server.js        # baseUrl, sendCsvToServer, deleteCsvFromServer, blobToDataUrl
-│   │   ├── store.js         # save/syncAllToServer, switchDepartment, load, seed
-│   │   ├── weeks.js         # Wochen-Auswahl, -Erzeugung, -Klonen, Auto-Lock, -Löschung
-│   │   ├── 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)
-│   │   └── init.js          # renderAll/initUiState + Seiteneinstieg (nur Test.html)
-│   │   ├── board/           # tab-specific: Projektboard
-│   │   │   └── board.js     # Projektboard-Rendering, Status-Editor, Anwesenheit, Zuordnung
-│   │   ├── 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
-│   │   ├── 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)
-│   │   ├── plan-state.js    # PlanApp-Zustand, Datenladepath, savePlan, Toasts
-│   │   ├── 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-schedule.js # Kritischer Pfad, Auto-Schedule, Mail-Link
-│   ├── styles.css
-│   └── dein_bild.ico
-└── sessions/                # data; bind-mounted into Docker container
-    ├── ELT/  HLS/  ARCH/    # one folder per department
-```
-
-## Running
-
-```bash
-npm install
-npm start                 # http://localhost:3003, or PORT=3004 if occupied
-docker compose up --build # Docker variant (compose file is at repo root)
-```
-
-- PORT env var overrides default 3003 in `server.js`.
-- Frontend must be served over HTTP: `baseUrl()` in `js/server.js` uses
-  `window.location.origin` or falls back to `http://localhost:3003` when opened
-  via `file://` (then only seed/demo data loads).
-- Check `/health` returns `{ok:true}` after starting.
-
-## 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`;
-  anything else returns 404. Exception: `GET /<Dept>/Projektplan(/<ProjName>)?`
-  (`PLAN_SLUG`) serves `project-plan.html`, the GANTT view, 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=` → `{sessions:[{filename,content}], people}` with
-  `_people.csv` content in `people`; sessions sorted by filename.
-- `POST /save-csv {filename, csv, department}` → writes UTF-8 BOM CSV.
-- `POST /delete-csv {filename, department}`.
-- 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`.
-- `safeName()` strictly validates filenames (path traversal protection);
-  static assets get `Cache-Control: no-store`.
-- JSON body limit is 2 MB.
-
-## CSV format
-
-- Delimiter `;`, UTF-8 with BOM. Hand-editing is possible but risky; the parser
-  reconstructs objects from the fixed column layout.
-- Week files `<Label>.csv` (e.g. `KW_30___2026.csv` — `filenameForWeek()`
-  replaces non-word chars with `_`). Row layout is positional:
-  `WOCHE` (label, date, locked flag) → `PERSONEN` (`name|role|fullName` per
-  column) → header row → `ANWESENHEIT` → one row per project.
-- `_people.csv` per department: `NAME;Rollen;Voller Name;E-Mail;Abwesenheiten`
-  (absences as JSON). People are global per department; new people are copied
-  into the current week. Historical weeks keep their own person copies, so
-  deleting a global person leaves old sessions unaffected no matter what.
-- Don't change the column layout without updating both `weekToCsv()` and
-  `parseSessionCsv()` (`js/csv.js`), which must stay inverse of each other.
-
-## 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 → csv → server →
-    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 → csv →
-    server → gantt` plus the `js/plan/*` modules. It must NOT load modules that
-    touch main-only page elements (`store`, `weeks`, `board`, …, `init`).
-- 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`.
-- State: `let db = { weeks, currentWeek, globalPeople }` (in-memory only).
-- Project IDs are regenerated on every CSV load, so projects are addressed
-  cross-page by `department` + week `label` + `projNr` (+ readable projName path
-  segment) via URL params: `openProjectPlan()` builds
-  `/HLS/Projektplan/<ProjName>?weekLabel=…&projNr=…`, `findProjectForPlan`
-  resolves them.
-- Person IDs are stable across reloads via `personIdForName(name)` →
-  `p_<lowercased alnum>`.
-- `save()` debounces 500 ms then `syncAllToServer()` writes **all** weeks plus
-  `_people.csv` — not just the changed week. Exception: `js/plan/plan-state.js`
-  `savePlan()` bypasses `save()` and writes only the current week's CSV directly
-  via `sendCsvToServer()`.
-- `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.
-- 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.
-- 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.
-
-## 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.
-- User-provided status HTML is sanitized on render via a small whitelist
-  (`sanitizeStatusHtml` in `js/board/board.js`) to mitigate XSS.
-
-## Docker
-
-- `docker compose up --build` from the repo root. Compose maps `3003:3003`,
-  bind-mounts `./sessions:/app/sessions`, `restart: unless-stopped`.
-- Dockerfile: `node:20-alpine`, `npm ci --production`, runs as non-root `node`,
-  HEALTHCHECK on `/health`. `.dockerignore` excludes `Docker/*` (except
-  `Docker/Dockerfile`), `node_modules/`, `.git`, `npm-debug.log`.
-
-## Conventions & verification
-
-- Git repo; commits are German (e.g. "PDF Export von A4 auf A3 …"). Remote:
-  `http://192.168.3.187:3000/erik/projektuebersicht.git`.
-- No linter, formatter, typecheck, or test suite. Manual verification only:
-  start server, open `http://localhost:3003`, exercises the relevant tab,
-  confirm CSV changes in `sessions/`.
\ No newline at end of file
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..7248dbd
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,275 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Overview
+
+Single-page app for tracking engineering projects across weekly sessions
+("Sitzungen"). Vanilla JS/HTML/CSS frontend + Node.js/Express server. No build
+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.
+
+All UI strings/comments are German. Preserve German in
+user-facing text.
+
+## File structure
+
+```
+.
+├── server.js                 # Express server + SQLite API
+├── package.json             # deps: express, cors only
+├── 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 /)
+│   ├── 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
+│   │   ├── ui.js            # LocalStorage-UI-State, Header-Collapse, Theme
+│   │   ├── date-picker.js   # Datums-/Bereichspicker-Overlays
+│   │   ├── server.js        # baseUrl, sendWeekToServer, sendPeopleToServer, blobToDataUrl
+│   │   ├── store.js         # save/syncAllToServer, switchDepartment, load, seed
+│   │   ├── weeks.js         # Wochen-Auswahl, -Erzeugung, -Klonen, Auto-Lock, -Löschung
+│   │   ├── 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)
+│   │   ├── 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
+│   │   ├── 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
+│   │   ├── 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)
+│   │   ├── plan-state.js    # PlanApp-Zustand, Datenladepath, savePlan, Toasts
+│   │   ├── 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-schedule.js # Kritischer Pfad, Auto-Schedule, Mail-Link
+│   ├── styles.css
+│   └── dein_bild.ico
+└── sessions/                # SQLite-DB; bind-mounted into Docker container
+    └── projektuebersicht.db # node:sqlite database (WAL mode)
+```
+
+## Running
+
+```bash
+npm install
+npm start                 # http://localhost:3003, or PORT=3004 if occupied
+docker compose up --build # Docker variant (compose file is at repo root)
+```
+
+- PORT env var overrides default 3003 in `server.js`.
+- Frontend must be served over HTTP: `baseUrl()` in `js/server.js` uses
+  `window.location.origin` or falls back to `http://localhost:3003` when opened
+  via `file://` (then only seed/demo data loads).
+- Check `/health` returns `{ok:true}` after starting.
+
+## 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`;
+  anything else returns 404. Exception: `GET /<Dept>/Projektplan(/<ProjName>)?`
+  (`PLAN_SLUG`) serves `project-plan.html`, the GANTT view, 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,
+  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
+  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)
+  pass. On success it returns `{ok:true, updatedAt}` (the new revision), which
+  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
+  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
+  (`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`.
+- Static assets get `Cache-Control: no-store`.
+- JSON body limit is 2 MB.
+
+## Persistence (SQLite)
+
+- 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:
+  - `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!)
+  - `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.
+- 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
+  `sessions/projektuebersicht.db`.
+- Project/person IDs are stable across reloads; only week-level fields are
+  queryable columns.
+
+## 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 →
+    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`).
+- 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`.
+- State: `let db = { weeks, currentWeek, globalPeople }` (in-memory only).
+- Project/person IDs are stable across reloads because the server splits and
+  reassembles week objects deterministically (JSON IDs are kept in the DB
+  columns); projects are addressed cross-page by `department` + week `label` +
+  `projNr` (+ readable projName path segment) via URL params:
+  `openProjectPlan()` builds `/HLS/Projektplan/<ProjName>?weekLabel=…&projNr=…`,
+  `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
+  `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.
+- 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.
+- 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.
+
+## 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.
+- User-provided status HTML is sanitized on render via a small whitelist
+  (`sanitizeStatusHtml` in `js/board/board.js`) to mitigate XSS.
+
+## Docker
+
+- `docker compose up --build` from the repo root. Compose maps `3003:3003`,
+  bind-mounts `./sessions:/app/sessions`, `restart: unless-stopped`.
+- 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`.
+
+## Conventions & verification
+
+- Git repo; commits are German (e.g. "PDF Export von A4 auf A3 …"). Remote:
+  `http://192.168.3.187:3000/erik/projektuebersicht.git`.
+- No linter, formatter, typecheck, or test suite. Manual verification only:
+  start server, open `http://localhost:3003`, exercises the relevant tab,
+  confirm SQLite changes (the DB file `sessions/projektuebersicht.db` grows).
\ No newline at end of file
diff --git a/Docker/Dockerfile b/Docker/Dockerfile
index 794f429..f18a0b3 100644
--- a/Docker/Dockerfile
+++ b/Docker/Dockerfile
@@ -1,5 +1,7 @@
 # syntax=docker/dockerfile:1
-FROM node:20-alpine
+# node:22-alpine, weil node:sqlite (SQLite-Persistenz in server.js) erst ab
+# Node 22.13 (ohne Flag) stabil verfügbar ist.
+FROM node:22-alpine
 
 WORKDIR /app
 
@@ -11,7 +13,7 @@ RUN npm ci --production
 COPY server.js ./
 COPY public ./public
 
-# Sessions-Ordner fuer die CSV-Daten sicherstellen
+# Sessions-Ordner fuer die SQLite-Datenbank sicherstellen
 RUN mkdir -p /app/sessions && chown -R node:node /app
 
 USER node
diff --git a/README.md b/README.md
index e05c694..8197947 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,12 @@
 # Projektübersicht — README
 
 ## Übersicht
-Dieses Projekt ist eine lokale Single-Page-Webanwendung zur Verwaltung elektrotechnischer Projekte und Sitzungsübersichten. Die Anwendung besteht aus:
+Dieses Projekt ist eine lokale Weboberfläche zur Verwaltung von TGA-Projekten (Elektro, HLS, Architektur) über wöchentliche Sitzungen. Die Anwendung besteht aus:
 
-- einem Frontend in `Test.html`, `styles.css` und den JS-Modulen unter `public/js/`
-- einem einfachen Node.js-Server in `server.js`
-- einem Datenspeicher in CSV-Dateien unter `sessions/`
-- einem Docker-Setup unter `Docker/`
+- 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)
 
 ## Datei- und Komponentenübersicht
 
@@ -14,14 +14,19 @@ Dieses Projekt ist eine lokale Single-Page-Webanwendung zur Verwaltung elektrote
 - `server.js`
   - Node.js/Express-Server
   - dient als API für das Frontend
-  - stellt statische Dateien (`Test.html`, die Module unter `js/`, `styles.css`, etc.) bereit
+  - 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` → lädt alle CSV-Dateien aus dem aktiven `sessions/<DEPARTMENT>/`-Ordner inkl. `_people.csv`
-    - `POST /save-csv` → speichert eine CSV-Datei (Dateiname wird validiert)
-    - `POST /delete-csv` → löscht eine CSV-Datei
-    - `GET /health` → Gesundheitscheck
+    - `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
 
 - `package.json`
@@ -32,54 +37,54 @@ Dieses Projekt ist eine lokale Single-Page-Webanwendung zur Verwaltung elektrote
   - 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`):
-    `globals.js`, `utils.js`, `ui.js`, `date-picker.js`, `csv.js`, `server.js`, `store.js`, `weeks.js`,
-    `board.js`, `people.js`, `projects.js`, `load.js`, `gantt.js`, `showmode.js`, `tabs-auth.js`, `pdf.js`,
-    `init.js` sowie die Plan-Module unter `js/plan/` (`plan-state`, `plan-build-gantt`, `plan-gantt`,
-    `plan-drag`, `plan-modals`, `plan-schedule`).
+  - 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 zurück als CSV
+  - 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:
-    - `sessions/<DEPT>/<WEEK>.csv`
-    - `sessions/<DEPT>/_people.csv` (globale Personenliste pro Abteilung)
+    - 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 Benutzeroberfläche der Anwendung
+  - 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 und das Passwort-Modal
+  - 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/*`
+  - 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:20-alpine`
+  - 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 den Rest des Projekts in `/app`
+  - 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`
+- `docker-compose.yml` (im Projektstamm)
   - definiert den Service `projektuebersicht`
-  - baut das Image aus dem Projektstamm mit `Docker/Dockerfile`
+  - 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: `Docker/`, `node_modules/`, `npm-debug.log`, `.git`, `.gitignore`
+  - 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`
@@ -88,34 +93,25 @@ Dieses Projekt ist eine lokale Single-Page-Webanwendung zur Verwaltung elektrote
 - `AGENTS.md`
   - Projektnotizen / Dokumentation, aber nicht Teil des Anwendungslaufs
 
-## Speicherorte und Datenfluss
+## Persistenz und Datenfluss
 
 ### Speicherung
-- Alle persistierten Daten werden als CSV-Dateien in `sessions/` gespeichert.
-- Innerhalb von `sessions/` existieren Abteilungsordner:
-  - `sessions/ELT/`
-  - `sessions/HLS/`
-  - `sessions/ARCH/`
-- Jede Abteilung enthält mindestens:
-  - `_people.csv` → globale Personenliste mit Rollen und vollständigem Namen
-  - `KW_XX___YYYY.csv` oder vergleichbare Sitzungsdateien → Sitzungsdaten mit Projekten, Zuordnungen und Anwesenheit
+- 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`.
 
-### Wo wird der Server erstellt?
-- Der Server wird in `server.js` erstellt.
-- `server.js` startet einen Express-Server auf Port `3003` oder dem Wert von `process.env.PORT`.
-- Das Frontend ruft diesen Server über `window.location.origin` an.
+### 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 Dateien gespeichert?
-- Das Frontend schreibt über den Server in das Dateisystem.
-- In `js/store.js` ruft die Anwendung beim Speichern `/save-csv` auf.
-- Der Server legt CSV-Dateien unter `sessions/<DEPARTMENT>/` ab.
-- Beispiel:
-  - `sessions/ELT/KW_32___2026.csv`
-  - `sessions/ELT/_people.csv`
+### 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
+### Lokal mit Node.js (Node ≥ 22.13)
 ```bash
 npm install
 npm start
@@ -131,7 +127,7 @@ PORT=3004 npm start
 Im Projektstamm ausführen:
 
 ```bash
-docker compose -f Docker/docker-compose.yml up --build
+docker compose up --build
 ```
 
 Danach ist die Anwendung erreichbar unter:
@@ -141,8 +137,9 @@ http://localhost:3003
 ```
 
 ## Wichtige Hinweise
-- Der Server benötigt Lese-/Schreibzugriff auf `sessions/`.
-- Die Docker-Compose-Konfiguration 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 in separaten Unterordnern.
-- Die Passwortfunktion ist nur ein einfacher Client-Mechanismus im Frontend und kein echter Sicherheitsmechanismus.
-- Globale Personen werden in `_people.csv` verwaltet. Wird eine Person global gelöscht, bleibt sie in bereits existierenden Sitzungen sichtbar.
+- 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
diff --git a/public/.DS_Store b/public/.DS_Store
deleted file mode 100644
index 00ca3e3..0000000
Binary files a/public/.DS_Store and /dev/null differ
diff --git a/public/Test.html b/public/Test.html
index f47d169..771ce82 100644
--- a/public/Test.html
+++ b/public/Test.html
@@ -5,7 +5,7 @@
   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/csv.js, js/server.js, js/store.js, js/weeks.js, danach die
+  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
@@ -77,6 +77,15 @@
       <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>
 
@@ -108,7 +117,7 @@
     <div class="table-wrap">
       <table id="boardTable"></table>
     </div>
-    <div id="boardLegend" style="margin-top:16px; padding:12px; background:#f7fafc; border-radius:6px; font-size:12px;"></div>
+    <div id="boardLegend"></div>
   </div>
 
   <!-- LOAD -->
@@ -227,7 +236,6 @@
 <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/csv.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>
@@ -239,6 +247,9 @@
 <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/.DS_Store b/public/js/.DS_Store
deleted file mode 100644
index 97c9399..0000000
Binary files a/public/js/.DS_Store and /dev/null differ
diff --git a/public/js/backup.js b/public/js/backup.js
new file mode 100644
index 0000000..65ef7e1
--- /dev/null
+++ b/public/js/backup.js
@@ -0,0 +1,39 @@
+// -----------------------------
+// Projektübersicht — Datenbank-Backup (Download)
+// -----------------------------
+// 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
+// nutzt baseUrl() aus js/server.js. Ergänzt das automatische Backup, das der
+// Server beim Start in sessions/backups/ ablegt.
+
+// downloadBackup: fordert den DB-Snapshot an und startet den Download.
+// Kein Parameter, keine Rückgabe; Fehler werden über ein Alert gemeldet.
+async function downloadBackup(){
+  try {
+    const res = await fetch(baseUrl() + '/backup');
+    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_backup_'
+      + new Date().toISOString().slice(0, 10) + '.db';
+
+    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('DB-Backup fehlgeschlagen:', err);
+    alert('DB-Backup fehlgeschlagen: ' + (err.message || err));
+  }
+}
\ No newline at end of file
diff --git a/public/js/board/board.js b/public/js/board/board.js
index 3b18be7..129f4a7 100644
--- a/public/js/board/board.js
+++ b/public/js/board/board.js
@@ -53,7 +53,7 @@ function formatStatus(command, value){
 }
 
 // peopleByRole liegt jetzt im gemeinsamen Modul js/utils.js (benötigt auch
-// csv.js für die Projektplan-Seite, die board.js nicht lädt).
+// die Projektplan-Seite, die board.js nicht lädt).
 
 // roleClass: erzeugt CSS-Klassen für eine Rolle bzw. ein Rollen-Array
 // (Rollenname kleingeschrieben, Leerzeichen → Bindestrich). Parameter: `role`
@@ -85,7 +85,7 @@ function renderBoard(){
   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)}">${entry.person.name}</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>`;
@@ -146,7 +146,7 @@ function renderBoard(){
         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="${v}" ${inputAttr} placeholder="-">`;
+        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>`;
diff --git a/public/js/csv.js b/public/js/csv.js
index d6adf65..f2d7dce 100644
--- a/public/js/csv.js
+++ b/public/js/csv.js
@@ -1,351 +1,42 @@
 // -----------------------------
-// Projektübersicht — CSV-Serialisierung & Parsing
-// Hinweis: weekToCsv() und parseSessionCsv() sind invers zueinander.
-// Das Spaltenlayout darf nicht geändert werden, ohne beide Funktionen anzupassen.
+// Projektübersicht — CSV/ZIP-Export
 // -----------------------------
-// Diese Datei enthält das gesamte CSV-Handling (Serialisieren und Parsen) und
-// wird nach js/date-picker.js von beiden HTML-Einstiegspunkten geladen. Sie
-// stellt die globalen Funktionen weekToCsv/parseSessionCsv, das Personen-CSV
-// (globalPeopleToCsv/parseGlobalPeopleCsv) sowie Helfer wie weekSortKey und
-// decodeWeekLabel bereit. Hauptnutzer sind js/store.js (Laden/Speichern aller
-// Sitzungen), js/weeks.js (Wochen-Klonen) und js/plan/plan-state.js (savePlan),
-// die die CSV-Zeichenketten über js/server.js austauschen.
+// 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).
 
-// filenameForWeek: leitet aus dem Wochenlabel einen Dateinamen ab
-// (alle Nicht-Wort-Zeichen werden durch _ ersetzt) und hängt .csv an.
-// Parameter: label (String). Rückgabe: String wie 'KW_30___2026.csv'.
-function filenameForWeek(label){
-  return (label.replace(/[^\w]/g,'_'))+'.csv';
-}
-
-// csvEscape: maskiert ein CSV-Feld, falls es Sonderzeichen (;, ", Zeilenumbruch) enthält
-// Parameter: v (beliebiger Wert). Rückgabe: String, bei Bedarf in Anführungszeichen.
-function csvEscape(v){
-  const s = (v === null || v === undefined ? '' : String(v));
-  if(/[;"\n\r]/.test(s)) return '"' + s.replace(/"/g,'""') + '"';
-  return s;
-}
-
-// globalPeopleToCsv: serialisiert die globalen Personen (aller Abteilungen) als CSV-Text
-// Parameter: people (Array von Person-Objekten). Rückgabe: UTF-8-BOM-CSV-String.
-function globalPeopleToCsv(people){
-  const rows = [['NAME', 'Rollen', 'Voller Name', 'E-Mail', 'Abwesenheiten']];
-  people.slice().sort((a,b) => a.name.localeCompare(b.name)).forEach(p => {
-    const absences = Array.isArray(p.absences) ? JSON.stringify(p.absences) : '';
-    rows.push([p.name, (p.role || []).join(','), p.fullName || '', p.email || '', absences]);
-  });
-  return '\ufeff' + rows.map(r => r.map(csvEscape).join(';')).join('\n');
-}
-
-// parseGlobalPeopleCsv: parst den _people.csv-Inhalt zurück in Person-Objekte
-// Parameter: text (String). Rückgabe: Array von Person-Objekten (mit stabiler ID).
-function parseGlobalPeopleCsv(text){
-  if(!text) return [];
-  const rows = parseCsvText(text);
-  if(!rows.length) return [];
-  const people = [];
-  rows.slice(1).forEach(row => {
-    const name = (row[0] || '').trim();
-    if(!name) return;
-    const roles = String(row[1] || 'Planung').split(',').map(x => x.trim()).filter(Boolean);
-    const fullName = (row[2] || '').trim() || name;
-    const email = (row[3] || '').trim();
-    let absences = [];
-    if(row[4]){
+// 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 parsed = JSON.parse(row[4]);
-        if(Array.isArray(parsed)) absences = parsed;
-      } catch(e) {
-        // Ignoriere fehlerhafte JSON-Daten
-      }
+        const json = await res.json();
+        if(json && json.error) msg = json.error;
+      } catch(e){ /* Antwort war kein JSON */ }
+      throw new Error(msg);
     }
-    people.push({ id: personIdForName(name), name, fullName, email, role: roles, absences });
-  });
-  return people;
-}
+    const blob = await res.blob();
+    const filename = 'Projektuebersicht_' + dept + '_'
+      + new Date().toISOString().slice(0, 10) + '.zip';
 
-// weekToCsv: serialisiert eine komplette Sitzung (Woche) in das feste CSV-Spaltenlayout
-// Parameter: w (Wochen-Objekt mit label, date, locked, people, attendance, projects).
-// Rückgabe: UTF-8-BOM-CSV-String. Invers zu parseSessionCsv().
-function weekToCsv(w){
-  // allPeople enthält für das Board jede (Person, Rolle)-Kombination einmal.
-  const grouped = peopleByRole(w);
-  const allPeople = [];
-  ROLES.forEach(r => grouped[r].forEach(entry => allPeople.push(entry)));
-  const rows = [];
-  // Metadaten-Zeile: Label, Datum und Sperrstatus der Sitzung
-  rows.push(['WOCHE', w.label || '', w.date || '', w.locked ? '1' : '']);
-  // PERSONEN-Zeile: Pro Spalte Name|Rolle|Voller Name, damit beim Laden
-  // die Zuordnung pro Rolle eindeutig bleibt und der volle Name erhalten ist.
-  // Der volle Name wird immer als dritter Teil gespeichert (auch leer),
-  // damit er beim Bearbeiten nicht versehentlich verloren geht.
-  const peopleMeta = allPeople.map(e => `${e.person.name}|${e.role}|${e.person.fullName || ''}`);
-  rows.push(['PERSONEN', '', '', ...peopleMeta, ...LPHS.map(() => ''), '','','','','']);
-  rows.push(['Pr.-Nr.','Bezeichnung','Status', ...allPeople.map(e => e.person.name), ...LPHS, 'Gruppe','Index','Plan','Aufwand','Aktive Phasen']);
-  rows.push(['ANWESENHEIT','', ...allPeople.map(e => w.attendance && w.attendance[e.person.id] ? 'X' : ''), ...LPHS.map(() => ''),'','','','','']);
-  w.projects.forEach(p => {
-    const arr = [p.nr || '', p.name || '', p.status || ''];
-    allPeople.forEach(entry => {
-      const s = p.assign[assignKey(entry.person.id, entry.role)];
-      arr.push(s === 1 ? 'X' : s === 2 ? '(X)' : '');
-    });
-    LPHS.forEach(l => {
-      const v = p.lph[l];
-      arr.push(v !== undefined && v !== '' ? String(v).replace(/%/g,'') + '%' : '');
-    });
-    arr.push(p.group || '');
-    arr.push(p.order !== undefined ? String(p.order) : '');
-    arr.push(p.plan ? JSON.stringify(p.plan) : '');
-    arr.push(p.aufwandProLP ? JSON.stringify(p.aufwandProLP) : '');
-    arr.push(p.aktuelleLP ? JSON.stringify(p.aktuelleLP) : '');
-    rows.push(arr);
-  });
-  return '\ufeff' + rows.map(r => r.map(csvEscape).join(';')).join('\n');
-}
-
-
-// parseCsvText: entfernt ein (mehrfach kodiertes) BOM und zerlegt den Text in Zeilen-Arrays
-// Parameter: text (String). Rückgabe: Array aus Zeilen, jede ein Feld-Array.
-function parseCsvText(text){
-  // Manche ältere CSV-Dateien enthalten ein UTF-8-BOM gefolgt von einem
-  // literalen "" (dreifach kodiert). Beides am Anfang entfernen.
-  return text.replace(/^[\ufeff\u00EF\u00BB\u00BF]+/,'').split(/\r?\n/).filter(line => line.trim() !== '').map(parseCsvLine);
-}
-
-// Toleranter CSV-Zeilenparser. Versteht sauber gequotetes CSV (wie es
-// csvEscape/weekToCsv erzeugen). Semikolons innerhalb eines quoted Feldes sind
-// Feldinhalt und kein Trennzeichen – so bleibt weekToCsv()/parseSessionCsv()
-// auch bei Status-Texten, die mit ";" enden, invers.
-// parseCsvLine: zerlegt eine einzelne CSV-Zeile in ein Feld-Array
-// Parameter: line (String). Rückgabe: Array der Felder.
-function parseCsvLine(line){
-  const result = [];
-  let current = '';
-  let inQuotes = false;
-  let hasUnclosedQuotes = false;
-  let i = 0;
-  while(i < line.length){
-    const c = line[i];
-    const n = line[i+1];
-    if(inQuotes){
-      if(c === '"' && n === '"'){
-        current += '"'; i += 2;
-      } else if(c === '"' && (n === ';' || n === undefined)){
-        result.push(current);
-        current = '';
-        inQuotes = false;
-        i += (n === ';' ? 2 : 1);
-      } else {
-        current += c; i++;
-      }
-    } else {
-      if(c === ';'){
-        result.push(current);
-        current = ''; i++;
-      } else if(c === '"'){
-        inQuotes = true; i++;
-      } else {
-        current += c; i++;
-      }
-    }
+    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));
   }
-  if(inQuotes) hasUnclosedQuotes = true;
-  result.push(current);
-  if(hasUnclosedQuotes){
-    console.warn('CSV-Zeile enthält nicht geschlossene Anführungszeichen:', line.slice(0,80));
-  }
-  return result;
-}
-
-// decodeWeekLabel: rekonstruiert das Wochenlabel aus einem Dateinamen
-// (ersetzt _ durch Leerzeichen und ergänzt das Layout "KW XX / YYYY").
-// Parameter: filename (String). Rückgabe: Label-String.
-function decodeWeekLabel(filename){
-  const base = filename.replace(/\.csv$/i,'');
-  let label = base.replace(/_+/g,' ').trim();
-  if(/^KW \d+ \d+$/.test(label)){
-    label = label.replace(/^KW (\d+) (\d+)$/, 'KW $1 / $2');
-  }
-  return label || base;
-}
-
-// Erzeugt einen Sortierschlüssel aus einem Wochenlabel, sodass z.B.
-// "KW 9 / 2026" vor "KW 10 / 2026" kommt.
-// weekSortKey: liefert einen nach Jahr und Kalenderwoche sortierbaren Schlüssel
-// Parameter: label (String). Rückgabe: String (Jahr-KW) oder kleingeschriebenes Label.
-function weekSortKey(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();
-}
-
-
-// parseSessionCsv: parst die CSV-Zeilen einer Sitzung zurück in ein Wochen-Objekt
-// Parameter: filename (String), rows (Array von Feld-Arrays aus parseCsvText).
-// Rückgabe: Wochen-Objekt {id, label, date, people, projects, attendance, locked}
-// oder null bei leerer Eingabe. Invers zu weekToCsv().
-function parseSessionCsv(filename, rows){
-  if(!rows || rows.length === 0) return null;
-  let label, date, headerRowIdx = 0, attendanceRowIdx = 1, projectStartIdx = 2;
-  let locked = false;
-  let metaPeopleRow = null;
-  if(rows[0][0] === 'WOCHE'){
-    label = rows[0][1] || decodeWeekLabel(filename);
-    date = rows[0][2] || '';
-    locked = (rows[0][3] || '').trim() === '1';
-    if(rows[1] && rows[1][0] === 'PERSONEN'){
-      metaPeopleRow = rows[1];
-      headerRowIdx = 2; attendanceRowIdx = 3;
-    } else {
-      headerRowIdx = 1; attendanceRowIdx = 2;
-    }
-  } else {
-    label = decodeWeekLabel(filename);
-    date = '';
-  }
-  projectStartIdx = attendanceRowIdx + 1;
-
-  const header = rows[headerRowIdx];
-  if(!header || header.length < 4) return { id: uid(), label, date, people: [], projects: [], attendance: {} };
-
-  const lphStart = header.indexOf('LPH 1');
-  const groupIdx = header.indexOf('Gruppe');
-  const orderIdx = header.indexOf('Index');
-  const planIdx = header.indexOf('Plan');
-  const aufwandIdx = header.indexOf('Aufwand');
-  const aktiveIdx = header.indexOf('Aktive Phasen');
-  const peopleCols = header.slice(3, lphStart === -1 ? header.length : lphStart);
-
-  const people = [];
-  const colMap = [];
-  const personMeta = metaPeopleRow ? metaPeopleRow.slice(3, lphStart === -1 ? metaPeopleRow.length : lphStart) : [];
-  const personByName = {};
-  const nameOccurrences = {};
-  peopleCols.forEach((name, idx) => {
-    const n = (name || '').trim();
-    if(!n){ colMap.push(null); return; }
-
-    let roles = ['Planung'];
-    let fullName = n;
-    if(personMeta[idx]){
-      const parts = String(personMeta[idx]).split('|');
-      const rawRoles = parts[1] || '';
-      const parsedRoles = rawRoles.split(',').map(x => x.trim()).filter(x => ROLES.includes(x));
-      if(parsedRoles.length > 0) roles = parsedRoles;
-      // Voller Name ist alles ab dem zweiten Pipe; damit sind auch Pipe-Zeichen
-      // im Namen möglich. Leere Strings werden bewusst übernommen.
-      if(parts.length >= 3) fullName = parts.slice(2).join('|').trim();
-    } else {
-      const occurrence = nameOccurrences[n] || 0;
-      roles = [ROLES[Math.min(occurrence, ROLES.length - 1)]];
-      nameOccurrences[n] = occurrence + 1;
-    }
-
-    // Gleiche Person (gleiches Kürzel) wird im Board pro Rolle mehrfach
-    // dargestellt, soll aber im Datenmodell nur einmal existieren.
-    let person = personByName[n];
-    if(!person){
-      person = { id: personIdForName(n), name: n, fullName: fullName, role: [] };
-      personByName[n] = person;
-      people.push(person);
-    }
-    // Überschreibe den vollen Namen mit dem Wert aus der CSV; die CSV ist
-    // hier die führende Datenquelle für den vollständigen Namen.
-    person.fullName = fullName;
-    // Sammle alle bekannten Rollen der Person; die aktuelle Spaltenrolle
-    // wird für die Zuordnung über colMap verwendet.
-    roles.forEach(r => { if(!person.role.includes(r)) person.role.push(r); });
-
-    colMap.push({ person, role: roles[0] });
-  });
-
-  const projects = [];
-  for(let rIdx = projectStartIdx; rIdx < rows.length; rIdx++){
-    const row = rows[rIdx];
-    if(row.length < 4) continue;
-    const nr = row[0] || '';
-    const name = row[1] || '';
-    const status = row[2] || '';
-    if(!nr.trim() && !name.trim()) continue;
-
-    const assign = {};
-    peopleCols.forEach((_, i) => {
-      const entry = colMap[i];
-      if(!entry) return;
-      const v = (row[3+i] || '').trim();
-      const key = assignKey(entry.person.id, entry.role);
-      if(v === 'X') assign[key] = 1;
-      else if(v === '(X)') assign[key] = 2;
-    });
-
-    const lph = {};
-    if(lphStart !== -1){
-      LPHS.forEach((l, j) => {
-        const raw = row[lphStart + j];
-        if(raw !== undefined && raw !== ''){
-          const num = String(raw).replace(/%/g,'');
-          if(!isNaN(parseFloat(num)) && isFinite(num)) lph[l] = num;
-        }
-      });
-    }
-
-    let group = 'Aktive Projekte';
-    if(groupIdx >= 0 && row[groupIdx]) group = row[groupIdx].trim() || group;
-    else if(row.length > 3) group = row[row.length - 1].trim() || group;
-
-    let order = rIdx - projectStartIdx;
-    if(orderIdx >= 0 && row[orderIdx] !== undefined && row[orderIdx] !== ''){
-      const parsed = parseInt(row[orderIdx], 10);
-      if(!isNaN(parsed)) order = parsed;
-    }
-
-    let plan = null;
-    if(planIdx >= 0 && row[planIdx]){
-      try {
-        const parsed = JSON.parse(row[planIdx]);
-        if(parsed && typeof parsed === 'object') plan = parsed;
-      } catch(e) {
-        console.warn('Plan-Daten für Projekt konnten nicht geparst werden:', nr, name, e);
-      }
-    }
-
-    let aufwandProLP;
-    if(aufwandIdx >= 0 && row[aufwandIdx]){
-      try {
-        const parsed = JSON.parse(row[aufwandIdx]);
-        if(parsed && typeof parsed === 'object') aufwandProLP = parsed;
-      } catch(e) {
-        console.warn('LP-Aufwand für Projekt konnten nicht geparst werden:', nr, name, e);
-      }
-    }
-
-    let aktuelleLP;
-    if(aktiveIdx >= 0 && row[aktiveIdx]){
-      try {
-        const parsed = JSON.parse(row[aktiveIdx]);
-        if(Array.isArray(parsed)) aktuelleLP = parsed;
-        else if(typeof parsed === 'string') aktuelleLP = [parsed];
-      } catch(e) {
-        console.warn('Aktive Phasen für Projekt konnten nicht geparst werden:', nr, name, e);
-      }
-    }
-
-    projects.push({ id: uid(), nr, name, status, group, lph, assign, order, plan, aufwandProLP, aktuelleLP });
-  }
-
-  const attendance = {};
-  const attRow = rows[attendanceRowIdx];
-  if(attRow && attRow[0] === 'ANWESENHEIT'){
-    peopleCols.forEach((_, i) => {
-      const entry = colMap[i];
-      if(entry && (attRow[2+i] || '').trim() === 'X'){
-        attendance[entry.person.id] = true;
-      }
-    });
-  }
-
-  return { id: uid(), label, date, people, projects, attendance, locked };
 }
\ No newline at end of file
diff --git a/public/js/gantt.js b/public/js/gantt.js
index aa92673..a62cd53 100644
--- a/public/js/gantt.js
+++ b/public/js/gantt.js
@@ -335,8 +335,8 @@ function buildGanttHtml(projects, start, end, options = {}){
 function openProjectPlan(pid){
   const w = currentWeek(); if(!w) return;
   const p = w.projects.find(x => x.id === pid); if(!p) return;
-  // IDs sind nicht persistent (werden bei jedem CSV-Laden neu erzeugt).
-  // Daher werden stabile Werte (Label, Projekt-Nr.) in der URL übergeben.
+  // 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);
diff --git a/public/js/import.js b/public/js/import.js
new file mode 100644
index 0000000..41fdb92
--- /dev/null
+++ b/public/js/import.js
@@ -0,0 +1,67 @@
+// -----------------------------
+// Projektübersicht — Datenbank-Import (Backup-Wiederherstellung)
+// -----------------------------
+// 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.
+
+// 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;
+    return;
+  }
+  const input = document.createElement('input');
+  input.type = 'file';
+  input.accept = '.db,application/octet-stream,application/x-sqlite3';
+  input.onchange = () => {
+    const file = input.files && input.files[0];
+    if(!file){
+      requestedAction = null;
+      return;
+    }
+    uploadBackup(file);
+  };
+  input.click();
+  requestedAction = null;
+}
+
+// uploadBackup: lädt die gewählte .db-Datei als rohen Binär-Body an
+// POST /import und informiert über das Ergebnis. Bei Erfolg wird die Seite neu
+// geladen, damit das Frontend den wiederhergestellten Datenbestand zeigt.
+async function uploadBackup(file){
+  try {
+    const res = await fetch(baseUrl() + '/import', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/octet-stream' },
+      body: file
+    });
+    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);
+    }
+    alert('Datenbank-Backup erfolgreich wiederhergestellt.\nDie 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/people/people.js b/public/js/people/people.js
index 321b74b..cec167c 100644
--- a/public/js/people/people.js
+++ b/public/js/people/people.js
@@ -45,7 +45,7 @@ function addPerson(){
   document.getElementById('newPersonFullName').value='';
   document.getElementById('newPersonEmail').value='';
   document.querySelectorAll('input[name="newPersonRoles"]').forEach(el=>el.checked=false);
-  save(); renderPeople(); renderBoard();
+  save({people:true}); renderPeople(); renderBoard();
 }
 
 // delPerson: entfernt eine Person aus der globalen Liste. Bereits in
@@ -76,7 +76,7 @@ function delPerson(id){
     w.people = (w.people || []).filter(p=>p.id!==id);
   }
 
-  save(); renderPeople(); renderBoard();
+  save({people:true}); renderPeople(); renderBoard();
 }
 
 // editPerson: ändert Name/Vollname/Rolle sowohl global als auch in der
@@ -132,7 +132,7 @@ function editPerson(id,field,val){
         delete w.attendance[id];
       }
     }
-    save(); renderPeople(); renderBoard();
+    save({people:true}); renderPeople(); renderBoard();
     return;
   }
 
@@ -146,7 +146,7 @@ function editPerson(id,field,val){
     const localPerson = (w.people || []).find(p => p.id === id);
     if(localPerson) localPerson[field] = val;
   }
-  save(); renderPeople(); renderBoard();
+  save({people:true}); renderPeople(); renderBoard();
 }
 
 // togglePersonRole: fügt eine Rolle (`role`) zur Person `id` hinzu bzw. entfernt
@@ -172,7 +172,7 @@ function togglePersonRole(id, role, checked){
 
   if(globalPerson) updateRoles(globalPerson);
   if(localPerson) updateRoles(localPerson);
-  save(); renderPeople(); renderBoard();
+  save({people:true}); renderPeople(); renderBoard();
 }
 
 // renderPeople: baut die HTML-Liste der Personen für den Personen-Tab auf
@@ -324,7 +324,7 @@ function reorderPeople(){
       newPeople.forEach(p => { if(byId[p.id]) newWeekPeople.push(byId[p.id]); });
       if(newWeekPeople.length === w.people.length) w.people = newWeekPeople;
     }
-    save();
+    save({people:true});
   }
 }
 
@@ -348,7 +348,7 @@ function addAbsence(personId){
   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();
+  save({week:false, people:true});
   renderPeople();
   if(currentTab === 'gantt') renderGantt();
 }
@@ -361,7 +361,7 @@ function deleteAbsence(personId, absenceId){
   const person = people.find(p => p.id === personId);
   if(!person || !person.absences) return;
   person.absences = person.absences.filter(a => a.id !== absenceId);
-  save();
+  save({week:false, people:true});
   renderPeople();
   if(currentTab === 'gantt') renderGantt();
 }
\ No newline at end of file
diff --git a/public/js/plan/plan-drag.js b/public/js/plan/plan-drag.js
index ed2c916..3fdeecb 100644
--- a/public/js/plan/plan-drag.js
+++ b/public/js/plan/plan-drag.js
@@ -114,16 +114,20 @@
     const todos = Array.isArray(plan.todos) ? plan.todos : [];
     const milestones = Array.isArray(plan.milestones) ? plan.milestones : [];
     const todoIds = todos.map(t => t.id);
-    const milestoneIds = milestones.map(m => m.id);
 
     // Alle beweglichen Zeilen in aktueller DOM-Reihenfolge
     const rows = [...chart.querySelectorAll(DRAGGABLE_GANTT_ROW_SELECTOR)];
     const todoRowIds = rows.filter(r => r.classList.contains('gantt-todo')).map(r => r.dataset.todoId).filter(Boolean);
     const milestoneRowIds = rows.filter(r => r.classList.contains('gantt-milestone-row')).map(r => r.dataset.milestoneId).filter(Boolean);
 
-    // Sicherheitscheck: Anzahl muss stimmen
+    // Sicherheitscheck: Anzahl muss stimmen. Nicht jedes Meilenstein wird als
+    // eigene .gantt-milestone-row gerendert – nur die mit einer TODO-basierten
+    // 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(milestoneRowIds.length !== milestoneIds.length) 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 = [];
diff --git a/public/js/plan/plan-state.js b/public/js/plan/plan-state.js
index 5074d5a..b113434 100644
--- a/public/js/plan/plan-state.js
+++ b/public/js/plan/plan-state.js
@@ -66,20 +66,17 @@ window.PlanApp = {
 
   // bindToolbarButtons: verbindet die Toolbar-Buttons (TODO hinzufügen,
   // Auto-Schedule, Kritischer Pfad) mit ihren globalen Funktionen der
-  // anderen plan-Module.
+  // 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(){
-    const addTodoBtn = document.getElementById('addTodoBtn');
-    if(addTodoBtn) addTodoBtn.addEventListener('click', () => addTodo());
-    const autoScheduleBtn = document.getElementById('autoScheduleBtn');
-    if(autoScheduleBtn) autoScheduleBtn.addEventListener('click', () => autoScheduleTodos());
-    const criticalPathBtn = document.getElementById('criticalPathBtn');
-    if(criticalPathBtn) criticalPathBtn.addEventListener('click', () => toggleCriticalPath());
   }
 
   // loadPlanData: lädt alle Sitzungen und die globale Personenliste der
-  // Abteilung über die Server-API, 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().
+  // 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.';
@@ -90,12 +87,15 @@ window.PlanApp = {
       .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] = parseGlobalPeopleCsv(data.people);
-        const parsed = (data.sessions || []).map(s => ({ filename: s.filename, rows: parseCsvText(s.content) }));
-        parsed.forEach(s => {
-          const w = parseSessionCsv(s.filename, s.rows);
-          if(w) db.weeks.push(w);
-        });
+        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){
@@ -176,22 +176,43 @@ window.PlanApp = {
     }).join('');
   }
 
-  // Speichern: nur diese Sitzung; globale Personenliste nicht überschreiben
+  // 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;
   function savePlan(){
     if(!app.week || !app.project) return;
-    const filename = filenameForWeek(app.week.label);
-    const csv = weekToCsv(app.week);
-    sendCsvToServer(filename, csv).catch(err => console.error('Speichern fehlgeschlagen:', err));
+    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(); }
+      });
   }
 
   // saveGlobalPeople: schreibt die globale Personenliste der Abteilung als
-  // _people.csv auf den Server, aber nur wenn sie nicht leer ist.
+  // 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] || [];
-    if(people.length > 0){
-      const peopleCsv = globalPeopleToCsv(people);
-      sendCsvToServer('_people.csv', peopleCsv).catch(err => console.error('Speichern Personen fehlgeschlagen:', err));
-    }
+    sendPeopleToServer(people).catch(err => console.error('Speichern Personen fehlgeschlagen:', err));
   }
 
   // Person in der globalen Liste finden (dort werden Abwesenheiten gepflegt)
diff --git a/public/js/projects/projects.js b/public/js/projects/projects.js
index e155aed..668f299 100644
--- a/public/js/projects/projects.js
+++ b/public/js/projects/projects.js
@@ -62,6 +62,7 @@ function editProjectActiveLP(id, value){
 function renderProjects(){
   const w = currentWeek();
   if(!w) return;
+  const locked = isWeekLocked(w);
   let html="";
   const groups = {};
   w.projects.forEach(p=>{ (groups[p.group]||(groups[p.group]=[])).push(p); });
@@ -71,10 +72,10 @@ function renderProjects(){
 
   sortGroups(Object.keys(groups)).forEach(g=>{
     html += `<div class="section-title">${esc(g)}</div>`;
-    html += `<div class="projects-sortable" data-group="${g}" ondragover="handleDragOver(event)" ondrop="handleDrop(event)">`;
+    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" draggable="true" data-project-id="${p.id}" ondragstart="handleDragStart(event)" ondragend="handleDragEnd(event)">
-        <span class="drag-handle" style="cursor:grab;color:#999;margin-right:8px">⋮⋮</span>
+      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)">
diff --git a/public/js/server.js b/public/js/server.js
index 5359d1c..e7281a3 100644
--- a/public/js/server.js
+++ b/public/js/server.js
@@ -1,13 +1,15 @@
 // -----------------------------
-// Projektübersicht — Server-Kommunikation (CSV-API)
+// Projektübersicht — Server-Kommunikation (JSON-API)
 // -----------------------------
 // Diese Datei kapselt die HTTP-Kommunikation mit dem Express-Server (siehe
-// server.js im Projekt-Root) und wird nach js/csv.js von beiden
+// server.js im Projekt-Root) und wird nach js/date-picker.js von beiden
 // HTML-Einstiegspunkten geladen. Sie stellt baseUrl, blobToDataUrl,
-// sendCsvToServer und deleteCsvFromServer bereit. Genutzt wird sie von
-// js/store.js (syncAllToServer, Speichern/Löschen aller Wochen),
-// js/weeks.js (Wochen-Löschung) und js/plan/plan-state.js (savePlan schreibt
-// direkt die aktuelle Woche über sendCsvToServer).
+// 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).
 
 // 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.
@@ -31,24 +33,56 @@ function blobToDataUrl(blob){
   });
 }
 
-// sendCsvToServer: POSTet eine Speicherwoche im CSV-Format an <baseUrl>/save-csv
-// Parameter: filename (String), csvContent (String). Rückgabe: Promise mit Server-Antwort.
-function sendCsvToServer(filename, csvContent){
+// 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
+// lokalen Daten beruhen; meldet der Server 409 (conflict), wird ein Error
+// mit `err.conflict = true` und `err.updatedAt` geworfen, damit der Aufrufer
+// den Konflikt anzeigen kann.
+function sendWeekToServer(week){
   if(!window.fetch) return Promise.reject(new Error('fetch nicht verfügbar'));
-  return fetch(baseUrl() + '/save-csv',{
+  return fetch(baseUrl() + '/save-week',{
     method:'POST',
     headers:{'Content-Type':'application/json; charset=utf-8'},
-    body:JSON.stringify({filename,csv:csvContent,department:currentDepartment})
+    body:JSON.stringify({
+      week,
+      department:currentDepartment,
+      baseUpdatedAt:(week && week.updatedAt) ? week.updatedAt : undefined
+    })
+  }).then(r=>{
+    return r.json().then(json => {
+      if(r.ok && json) return json;
+      if(json && json.conflict){
+        const err = new Error(json.error || 'Konflikt: Sitzung wurde zwischenzeitlich geändert');
+        err.conflict = true;
+        err.label = (week && week.label) || '';
+        err.updatedAt = json.updatedAt;
+        throw err;
+      }
+      throw new Error('Server HTTP '+r.status);
+    });
+  });
+}
+
+// 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(); });
 }
 
-// deleteCsvFromServer: fordert das Löschen einer Speicherwoche über POST /delete-csv an
-// Parameter: filename (String). Rückgabe: Promise mit Server-Antwort.
-function deleteCsvFromServer(filename){
+// deleteWeekFromServer: fordert das Löschen einer Woche über POST /delete-week an
+// Parameter: label (String, das Wochen-Label). Rückgabe: Promise mit Server-Antwort.
+function deleteWeekFromServer(label){
   if(!window.fetch) return Promise.reject(new Error('fetch nicht verfügbar'));
-  return fetch(baseUrl() + '/delete-csv', {
+  return fetch(baseUrl() + '/delete-week', {
     method: 'POST',
     headers: {'Content-Type':'application/json; charset=utf-8'},
-    body: JSON.stringify({ filename, department: currentDepartment })
+    body: JSON.stringify({ label, department: currentDepartment })
   }).then(r=>{ if(!r.ok) throw new Error('Server HTTP '+r.status); return r.json(); });
-}
\ No newline at end of file
+}
diff --git a/public/js/store.js b/public/js/store.js
index a759592..c077d03 100644
--- a/public/js/store.js
+++ b/public/js/store.js
@@ -1,22 +1,44 @@
 // -----------------------------
 // Projektübersicht — Daten laden, Speichern, Abteilung wechseln
 // -----------------------------
-// Diese Datei bildet die Schnittstelle zum Server: Sie lädt alle Sitzungs-CSVs
+// 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).
-// Sie wird von `Test.html` nach `js/csv.js` und `js/server.js` geladen und stellt
+// 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.
 
-// save: synchronisiert die aktuellen Daten als CSV-Dateien zum Server.
-// Jede Sitzung wird als eigene CSV-Datei gespeichert. Personen und Rollen werden
-// in der Sitzungscsv selbst abgelegt.
-function save(){
+// 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(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).
+let dirtyWeeks = new Set();
+let dirtyPeople = false;
+
+// In-Flight-Schutz für syncAllToServer: läuft bereits ein Sync, wird kein
+// zweiter gestartet (sonst senden zwei Syncs dieselbe Woche mit gleicher
+// Revisions-Basis und der zweite bekäme einen scheinbaren 409-Konflikt).
+// Stattdessen wird ein Nachlauf-Sync eingereiht und nach Abschluss ausgeführt.
+let syncInFlight = false;
+let syncQueued = false;
+
 // 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.
@@ -25,33 +47,133 @@ function scheduleSessionSync(){
   saveSyncTimer = setTimeout(() => { syncAllToServer(); saveSyncTimer = null; }, 500);
 }
 
-// syncAllToServer: schreibt die gesamte Datenbank als CSV-Dateien zum Server.
-// Zuerst wird die globale Personenliste (`_people.csv`) gespeichert, danach jede
-// Sitzung einzeln über `filenameForWeek()`/`weekToCsv()` und `sendCsvToServer()`.
-// Gibt nichts zurück; Fehler werden nur per console.error protokolliert.
+// 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.
 function syncAllToServer(){
-  // Zuerst globale Personenliste speichern
-  saveGlobalPeopleToServer();
-  // Dann jede Sitzung speichern
-  db.weeks.forEach(w => {
-    const filename = filenameForWeek(w.label);
-    const csv = weekToCsv(w);
-    sendCsvToServer(filename, csv)
-      .then(res => { if(res && res.ok) console.log('Sitzung gespeichert:', filename); })
-      .catch(err => { console.error('Sitzung konnte nicht gespeichert werden:', filename, err.message || err); });
+  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);
+  weekLabels.forEach(label => {
+    const w = db.weeks.find(x => x.label === label);
+    if(!w){ dirtyWeeks.delete(label); return; }
+    jobs.push(sendWeekToServer(w)
+      .then(res => {
+        if(res && res.ok){
+          console.log('Sitzung gespeichert:', w.label);
+          // 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);
+        } else {
+          console.error('Sitzung konnte nicht gespeichert werden:', w.label, res && res.error ? res.error : 'unbekannter Fehler');
+        }
+      })
+      .catch(err => {
+        if(err && err.conflict){
+          dirtyWeeks.delete(label);
+          handleWeekConflict(w, err);
+        } else {
+          console.error('Sitzung konnte nicht gespeichert werden:', w.label, err.message || err);
+          // Label bleibt dirty -> der nächste Sync versucht es erneut.
+        }
+      }));
+  });
+
+  Promise.all(jobs).then(() => {
+    syncInFlight = false;
+    if(syncQueued){ syncQueued = false; syncAllToServer(); }
   });
 }
 
-// saveGlobalPeopleToServer: serialisiert die globale Personenliste der aktuellen
-// Abteilung per `globalPeopleToCsv()` und speichert sie als `_people.csv`.
-// Leere Personenlisten werden übersprungen (kein Schreibvorgang).
+// 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;
+}
+
+// handleWeekConflict: wird aufgerufen, wenn der Server eine zwischenzeitlich
+// geänderte Woche meldet (409). Nur diese eine Woche wird vom Server neu
+// geladen; andere lokal geänderte Wochen (dirtyWeeks) und die Personenliste
+// bleiben unangetastet und gehen nicht verloren.
+function handleWeekConflict(week, err){
+  const label = (week && week.label) || (err && err.label) || '';
+  alert('Achtung: ' + label + ' wurde zwischenzeitlich von einer anderen Person '
+      + 'geändert. Ihre Änderungen an dieser Sitzung wurden nicht gespeichert; '
+      + 'die aktuellen Daten dieser Sitzung werden geladen.');
+  if(label) reloadWeekFromServer(label);
+  else load();
+}
+
+// reloadWeekFromServer: lädt die aktuelle Abteilung 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())
+    .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);
+      if(idx >= 0){
+        if(fresh){
+          // Felder absichern (wie in load()), damit keine kaputten Daten crashen
+          if(!Array.isArray(fresh.people)) fresh.people = [];
+          if(!Array.isArray(fresh.projects)) fresh.projects = [];
+          if(!fresh.attendance) fresh.attendance = {};
+          db.weeks[idx] = fresh;
+        } else {
+          db.weeks.splice(idx, 1);
+        }
+        // Wurde die aktuelle Woche entfernt, auf die letzte verbleibende wechseln
+        if(!db.weeks.some(w => w.id === db.currentWeek)){
+          db.currentWeek = db.weeks.length ? db.weeks[db.weeks.length - 1].id : null;
+        }
+      }
+      renderAll();
+      showTab(currentTab);
+    })
+    .catch(err => {
+      console.error('Neu laden der Sitzung fehlgeschlagen:', err);
+      load();
+    });
+}
+
+// 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] || [];
-  if(people.length === 0) return;
-  const csv = globalPeopleToCsv(people);
-  sendCsvToServer('_people.csv', csv)
-    .then(res => { if(res && res.ok) console.log('Globale Personenliste gespeichert'); })
-    .catch(err => { console.error('Globale Personenliste konnte nicht gespeichert werden:', err.message || err); });
+  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');
+      }
+    })
+    .catch(err => {
+      console.error('Globale Personenliste konnte nicht gespeichert werden:', err.message || err);
+      // dirtyPeople bleibt true -> der nächste Sync versucht es erneut.
+    });
 }
 
 // switchDepartment: wechselt die aktive Abteilung (z.B. "ELT") und lädt deren
@@ -62,8 +184,10 @@ 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
-  // CSV der falschen Abteilung schreibt.
+  // Daten der falschen Abteilung schreibt.
   if(saveSyncTimer){ clearTimeout(saveSyncTimer); saveSyncTimer = null; }
+  dirtyWeeks.clear();
+  dirtyPeople = false;
   currentDepartment = dept;
   saveUiState();
   updateRouteUrl(dept, currentTab);
@@ -84,12 +208,17 @@ function switchDepartment(dept){
   load();
 }
 
-// load: liest alle CSV-Dateien der aktuellen Abteilung über `/load-all` vom
-// Server ein, parst Personen und Sitzungen (mit `parseSessionCsv()`) 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.
+// 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(){
+  // 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;
@@ -106,18 +235,20 @@ function load(){
     .then(data => {
       if(currentDepartment !== requestedDepartment) return;
       // Globale Personenliste laden
-      db.globalPeople[currentDepartment] = parseGlobalPeopleCsv(data.people);
+      db.globalPeople[currentDepartment] = Array.isArray(data.people) ? data.people : [];
 
-      const parsedSessions = (data.sessions || []).map(s => ({ filename: s.filename, rows: parseCsvText(s.content) }));
-
-      db.weeks = [];
-      parsedSessions.forEach(s => {
-        const w = parseSessionCsv(s.filename, s.rows);
-        if(w) db.weeks.push(w);
-      });
+      db.weeks = (Array.isArray(data.weeks) ? data.weeks : [])
+        .filter(w => w && typeof w.label === 'string')
+        .map(w => {
+          // Felder absichern, damit alte/kaputte Dokumente nicht crashen
+          if(!Array.isArray(w.people)) w.people = [];
+          if(!Array.isArray(w.projects)) w.projects = [];
+          if(!w.attendance) w.attendance = {};
+          return w;
+        });
 
       if(db.weeks.length === 0){
-        console.warn('Server lieferte 0 Sitzungsdateien. Es werden Beispieldaten (seed) angezeigt. Pruefen Sie, ob der Ordner sessions/ mitkopiert wurde.');
+        console.warn('Server lieferte 0 Sitzungen. Es werden Beispieldaten (seed) angezeigt. Pruefen Sie, ob die SQLite-Datenbank sessions/projektuebersicht.db existiert.');
         seed();
       }
       else {
diff --git a/public/js/tabs-auth.js b/public/js/tabs-auth.js
index ba9b382..35407dc 100644
--- a/public/js/tabs-auth.js
+++ b/public/js/tabs-auth.js
@@ -59,6 +59,7 @@ function confirmPassword(){
       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 {
diff --git a/public/js/utils.js b/public/js/utils.js
index 18e4e3a..962e2a9 100644
--- a/public/js/utils.js
+++ b/public/js/utils.js
@@ -5,7 +5,7 @@
 // ID-, Sortier- und Datumsfunktionen) und wird nach js/globals.js von beiden
 // HTML-Einstiegspunkten geladen. Sie stellt ausschließlich globale Funktionen
 // ohne eigenen Zustand bereit; genutzt wird sie praktisch von allen Modulen,
-// u. a. js/csv.js, js/board/board.js, js/load/load.js sowie den Plan-Modulen unter js/plan/*
+// u. a. js/board/board.js, js/load/load.js sowie den Plan-Modulen unter js/plan/*
 // (z. B. für ISO-Datumsformate und Werktage) und von js/gantt.js.
 
 // esc: einfache Escape-Funktion für Ausgabe in HTML
@@ -46,8 +46,7 @@ function sortGroups(arr){
 // peopleByRole: gruppiert Personen nach Rolle zurück in ein Objekt.
 // Parameter `target`: Woche(n) mit `people`-Array (oder undefined → aktuelle
 // Woche). Rückgabe: Objekt `{ Rolle: [{person, role}] }` mit Deduplizierung.
-// Liegt im gemeinsamen Modul, weil auch csv.js (weekToCsv für savePlan auf der
-// Projektplan-Seite) und pdf.js darauf zugreifen.
+// Liegt im gemeinsamen Modul, weil board/load/pdf auf sie zugreifen.
 function peopleByRole(target){
   const m = {}; ROLES.forEach(r=>m[r]=[]);
   const people = [];
@@ -73,6 +72,18 @@ function peopleByRole(target){
   return m;
 }
 
+// weekSortKey: liefert einen nach Jahr und Kalenderwoche sortierbaren Schlüssel,
+// sodass z.B. "KW 9 / 2026" vor "KW 10 / 2026" kommt.
+// Parameter: label (String). Rückgabe: String (Jahr-KW) oder kleingeschriebenes Label.
+function weekSortKey(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();
+}
+
 // Persistente ID fuer eine Person aus dem Kuerzel, damit Anwesenheit und
 // Zuordnungen auch nach einem Neuladen stabil bleiben.
 // Parameter: name (String). Rückgabe: String wie 'p_ab'.
diff --git a/public/js/weeks.js b/public/js/weeks.js
index acbef08..96c4987 100644
--- a/public/js/weeks.js
+++ b/public/js/weeks.js
@@ -31,9 +31,11 @@ function updateWeekDate(){
 // Kein Parameter; Rückgabe: das gefundene Woche-Objekt oder undefined.
 function currentWeek(){ return db.weeks.find(w=>w.id===db.currentWeek); }
 
-// switchWeek: setzt die aktuell gewählte Wochen-ID (`id`), speichert und
-// rendert die Ansicht neu. Keine Rückgabe.
-function switchWeek(id){ db.currentWeek = id; save(); renderAll(); }
+// switchWeek: setzt die aktuell gewählte Wochen-ID (`id`) und rendert die
+// Ansicht neu. Es werden keine Daten geändert, daher wird nicht gespeichert
+// (eine save() würde die Woche nur als dirty markieren und unnötig senden).
+// 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,
@@ -82,7 +84,11 @@ function applyAutoLock(){
   const sorted = [...db.weeks].sort((a,b) => weekSortKey(a.label).localeCompare(weekSortKey(b.label)));
   const latestId = sorted[sorted.length - 1].id;
   db.weeks.forEach(w => {
+    const wasLocked = !!w.locked;
     w.locked = (w.id !== latestId);
+    // Nur tatsächlich geänderte Lock-Zustände übertragen (beim bloßen Laden
+    // sind die Werte identisch und es wird nichts gesendet).
+    if(wasLocked !== w.locked) markWeekDirty(w.label);
   });
 }
 
@@ -124,9 +130,9 @@ function unlockCurrentWeek(skipAuth = false){
 }
 
 // deleteWeek: löscht die aktuell ausgewählte Sitzung (nur wenn mehr als 1
-// vorhanden) inkl. ihrer CSV-Datei auf dem Server. Parameter `skipAuth=true`
-// überspringt die Passwortabfrage. Danach wird die letzte verbleibende Woche
-// aktiviert und neu gerendert. Keine Rückgabe.
+// 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){
   if(db.weeks.length<=1){ alert("Mindestens eine Sitzung muss bestehen bleiben."); return; }
   if(!skipAuth && !isAuthenticated){
@@ -138,13 +144,13 @@ function deleteWeek(skipAuth = false){
   }
   if(!confirm("Diese Sitzung wirklich löschen?")) { requestedAction = null; return; }
   const current = currentWeek();
-  const filename = current ? filenameForWeek(current.label) : null;
-  if(filename){
-    console.log('Lösche CSV-Datei auf Server:', filename);
-    deleteCsvFromServer(filename).then(res=>{
-      if(res && res.ok){ console.log('CSV-Datei gelöscht:', filename); }
-      else { alert('CSV-Löschung fehlgeschlagen: ' + (res && res.error ? res.error : 'unbekannter Fehler')); }
-    }).catch(err=>{ alert('CSV-Löschung fehlgeschlagen: ' + (err.message || err)); });
+  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)));
diff --git a/public/main.v2.js b/public/main.v2.js
deleted file mode 100644
index ee22a9b..0000000
--- a/public/main.v2.js
+++ /dev/null
@@ -1,3279 +0,0 @@
-// -----------------------------
-// Projektübersicht — kommentierter Quellcode
-// Autor: (kommentiert automatisch)
-// Hinweis: Kommentare erklären die Struktur und Funktion der wichtigsten
-// Teile. Funktionaler Code wurde nicht verändert.
-// -----------------------------
-
-// Konstanten: Leistungsphasen, Rollen und LocalStorage-Key
-const LPHS = ["LPH 1","LPH 2","LPH 3","LPH 4","LPH 5","LPH 6","LPH 7","LPH 8", "W+M"]; // Spalten für Leistungsphasen
-const ROLES = ["Planung","Projektleitung","Bauüberwachung"]; // Gruppierung der Personen
-const GROUP_ORDER = ["Aktive Projekte","Kleine Projekte","In Anbahnung","Allgemein"]; // Reihenfolge der Projektgruppen
-const STORAGE = "projuebersicht_v1"; // Durch lokale UI-State-Persistenz genutzter Key
-const DEFAULT_DEPARTMENT = 'ELT';
-const DEFAULT_TAB = 'board';
-
-// Farbpalette für GANTT-Balken (eine pro Projekt, wiederholend)
-const GANTT_COLORS = ['#0071e3','#248a3d','#b25000','#7c3aed','#d70015','#0ca678','#d9480f','#5f3dc4'];
-
-// Passwortschutz: SHA256-Hash des erlaubten Passworts.
-// Wenn Sie das Passwort ändern möchten, generieren Sie den SHA256-Hash (https://emn178.github.io/online-tools/sha256.html)
-// des neuen Passworts und ersetzen Sie den Wert hier.
-const PROTECTED_PASSWORD_HASH = "107bab579e8500e459690cf48ba77de32be43cadb8421bbe79fad20a55b39b6f";
-
-// requestedAction speichert die Aktion, die nach erfolgreicher Passwort-Eingabe ausgeführt wird.
-let requestedAction = null;
-let saveSyncTimer = null;
-let isAuthenticated = false;
-
-// In-memory Datenbank: Sitzungen (weeks) und aktuell ausgewählte Sitzung
-let db = { weeks: [], currentWeek: null, globalPeople: {} };
-
-// Aktuelle Abteilung (ELT, HLS, ARCH). Daten werden in sessions/<DEPT>/ getrennt gespeichert.
-let currentDepartment = DEFAULT_DEPARTMENT;
-let currentTab = DEFAULT_TAB;
-const DEPARTMENTS = {
-  ELT:   { label: 'Elektro', icon: '' },
-  HLS:   { label: 'HLS', icon: '' },
-  ARCH:  { label: 'Architektur', icon: '' }
-};
-
-// departmentParam: gibt ein Query-String-Fragment fuer die aktuelle Abteilung zurueck.
-function departmentParam(){
-  return '?department=' + encodeURIComponent(currentDepartment);
-}
-
-function saveUiState(){
-  try {
-    const state = { department: currentDepartment, tab: currentTab };
-    window.localStorage.setItem(STORAGE, JSON.stringify(state));
-  } catch (err) {
-    console.warn('UI-State kann nicht gespeichert werden:', err);
-  }
-}
-
-function loadUiState(){
-  try {
-    const state = JSON.parse(window.localStorage.getItem(STORAGE) || '{}');
-    if(state.department && DEPARTMENTS[state.department]) currentDepartment = state.department;
-    // Tab wird nicht aus dem localStorage wiederhergestellt, damit nach dem
-    // Neuladen immer das Projektboard angezeigt wird.
-  } catch (err) {
-    console.warn('UI-State kann nicht geladen werden:', err);
-  }
-}
-
-// ---------- Datumshilfsfunktionen (GANTT) ----------
-
-function parseDateISO(d){
-  if(!d) return null;
-  const m = String(d).match(/^(\d{4})-(\d{2})-(\d{2})$/);
-  if(!m) return null;
-  const date = new Date(parseInt(m[1]), parseInt(m[2])-1, parseInt(m[3]));
-  if(isNaN(date.getTime())) return null;
-  return date;
-}
-
-function formatDateISO(d){
-  if(!d || isNaN(d.getTime())) return '';
-  const y = d.getFullYear();
-  const m = String(d.getMonth()+1).padStart(2,'0');
-  const day = String(d.getDate()).padStart(2,'0');
-  return `${y}-${m}-${day}`;
-}
-
-function addDays(d, n){
-  const res = new Date(d.getTime());
-  res.setDate(res.getDate() + n);
-  return res;
-}
-
-function daysBetween(a, b){
-  const ms = b.getTime() - a.getTime();
-  return Math.round(ms / (1000 * 60 * 60 * 24));
-}
-
-// workdaysBetween: Anzahl der Werktage (Mo–Fr) im Zeitraum inkl. Start- und Endtag.
-// Wochenendtage (Sa/So) werden nicht mitgezählt – z.B. für die Auslastung.
-function workdaysBetween(a, b){
-  if(!a || !b || b < a) return 0;
-  let count = 0;
-  let current = new Date(a.getTime());
-  while(current <= b){
-    const day = current.getDay();
-    if(day !== 0 && day !== 6) count++;
-    current = addDays(current, 1);
-  }
-  return count;
-}
-
-function formatDateDE(d){
-  if(!d || isNaN(d.getTime())) return '';
-  return `${String(d.getDate()).padStart(2,'0')}.${String(d.getMonth()+1).padStart(2,'0')}.${d.getFullYear()}`;
-}
-
-// ISO-Kalenderwoche nach https://en.wikipedia.org/wiki/ISO_week_date
-function getWeekNumber(d){
-  const date = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
-  const dayNum = date.getUTCDay() || 7;
-  date.setUTCDate(date.getUTCDate() + 4 - dayNum);
-  const yearStart = new Date(Date.UTC(date.getUTCFullYear(), 0, 1));
-  return Math.ceil((((date - yearStart) / 86400000) + 1) / 7);
-}
-
-// ---------- Datumsbereich-Picker ----------
-// Ein Kalender-Popup für Von+Bis: erster Klick setzt das Startdatum,
-// zweiter Klick das Enddatum (bei Klick vor dem Start wird getauscht).
-// Schreibt ISO-Werte in zwei (versteckte) Inputs und aktualisiert optional
-// ein Anzeige-Element. Verwendung: openRangePicker({ anchor, startInputId, endInputId, displayId, onApply })
-
-let rangePickerState = null;
-
-function openDatePicker(opts){
-  closeRangePicker();
-  const input = document.getElementById(opts.inputId);
-  if(!input) return;
-  const preValue = parseDateISO(input.value);
-  const today = new Date();
-  rangePickerState = {
-    opts: Object.assign({}, opts, { mode: 'single' }),
-    start: preValue,
-    end: preValue,
-    mode: 'single',
-    // Ansichtsmonat: vorhandener Wert, sonst heutiger Monat
-    viewYear: (preValue || today).getFullYear(),
-    viewMonth: (preValue || today).getMonth()
-  };
-
-  const pop = document.createElement('div');
-  pop.id = 'rangePickerPopup';
-  pop.className = 'range-picker';
-  document.body.appendChild(pop);
-
-  const anchorRect = opts.anchor ? opts.anchor.getBoundingClientRect() : { left: window.innerWidth/2 - 140, bottom: window.innerHeight/2 - 160 };
-  pop.style.left = Math.max(8, Math.min(anchorRect.left, window.innerWidth - 296)) + 'px';
-  pop.style.top = Math.min(anchorRect.bottom + 6, window.innerHeight - 340) + 'px';
-
-  renderRangePicker();
-
-  setTimeout(() => {
-    document.addEventListener('mousedown', rangePickerOutsideClick);
-  }, 0);
-}
-
-function openRangePicker(opts){
-  closeRangePicker();
-  const isSingle = (opts.mode || 'range') === 'single';
-  const startInput = document.getElementById(isSingle ? (opts.inputId || opts.startInputId) : opts.startInputId);
-  const endInput = isSingle ? null : document.getElementById(opts.endInputId);
-  if(!startInput || (!isSingle && !endInput)) return;
- 
-  const preStart = parseDateISO(startInput.value);
-  const preEnd = isSingle ? preStart : parseDateISO(endInput.value);
-  const today = new Date();
-  rangePickerState = {
-    opts: Object.assign({}, opts, { mode: isSingle ? 'single' : 'range' }),
-    start: preStart,
-    end: preEnd,
-    mode: isSingle ? 'single' : 'range',
-    // Ansichtsmonat: vorhandener Start, sonst heutiger Monat
-    viewYear: (preStart || today).getFullYear(),
-    viewMonth: (preStart || today).getMonth()
-  };
-
-  const pop = document.createElement('div');
-  pop.id = 'rangePickerPopup';
-  pop.className = 'range-picker';
-  document.body.appendChild(pop);
-
-  // Position: unterhalb des Ankers, innerhalb des Viewports halten
-  const anchorRect = opts.anchor ? opts.anchor.getBoundingClientRect() : { left: window.innerWidth/2 - 140, bottom: window.innerHeight/2 - 160 };
-  pop.style.left = Math.max(8, Math.min(anchorRect.left, window.innerWidth - 296)) + 'px';
-  pop.style.top = Math.min(anchorRect.bottom + 6, window.innerHeight - 340) + 'px';
-
-  renderRangePicker();
-
-  // Klick außerhalb schließt das Popup (ohne Übernahme)
-  setTimeout(() => {
-    document.addEventListener('mousedown', rangePickerOutsideClick);
-  }, 0);
-}
-
-function rangePickerOutsideClick(e){
-  const pop = document.getElementById('rangePickerPopup');
-  if(pop && !pop.contains(e.target)) closeRangePicker();
-}
-
-function closeRangePicker(){
-  const pop = document.getElementById('rangePickerPopup');
-  if(pop) pop.remove();
-  document.removeEventListener('mousedown', rangePickerOutsideClick);
-  rangePickerState = null;
-}
-
-function rangePickerNav(delta){
-  if(!rangePickerState) return;
-  let m = rangePickerState.viewMonth + delta;
-  let y = rangePickerState.viewYear;
-  if(m < 0){ m = 11; y--; }
-  if(m > 11){ m = 0; y++; }
-  rangePickerState.viewMonth = m;
-  rangePickerState.viewYear = y;
-  renderRangePicker();
-}
-
-function rangePickerSelect(iso){
-  if(!rangePickerState) return;
-  const d = parseDateISO(iso);
-  if(!d) return;
-  const st = rangePickerState;
-  if(st.mode === 'single'){
-    st.start = d;
-    st.end = d;
-    applyRangePicker();
-    return;
-  }
-  if(!st.start || (st.start && st.end)){
-    // Neuen Bereich beginnen
-    st.start = d;
-    st.end = null;
-  } else {
-    // Zweiter Klick: Ende setzen, bei Bedarf tauschen
-    if(d < st.start){ st.end = st.start; st.start = d; }
-    else st.end = d;
-    applyRangePicker();
-    return;
-  }
-  renderRangePicker();
-}
-
-function applyRangePicker(){
-  if(!rangePickerState) return;
-  const { opts, start, end } = rangePickerState;
-  const isSingle = (opts.mode || 'range') === 'single';
-  const startInput = document.getElementById(isSingle ? (opts.inputId || opts.startInputId) : opts.startInputId);
-  const endInput = isSingle ? null : document.getElementById(opts.endInputId);
-  const selected = start || end;
-  if(startInput) startInput.value = isSingle ? (selected ? formatDateISO(selected) : '') : (start ? formatDateISO(start) : '');
-  if(endInput) endInput.value = end ? formatDateISO(end) : (start ? formatDateISO(start) : '');
-  if(opts.displayId){
-    const disp = document.getElementById(opts.displayId);
-    if(disp){
-      const from = start ? formatDateDE(start) : '';
-      const to = end ? formatDateDE(end) : from;
-      disp.value = isSingle ? (from || '') : (from ? (from + ' – ' + to) : '');
-    }
-  }
-  const cb = opts.onApply;
-  closeRangePicker();
-  if(typeof cb === 'function') cb();
-}
-
-function renderRangePicker(){
-  const pop = document.getElementById('rangePickerPopup');
-  if(!pop || !rangePickerState) return;
-  const st = rangePickerState;
-  const monthNames = ['Januar','Februar','März','April','Mai','Juni','Juli','August','September','Oktober','November','Dezember'];
-  const first = new Date(st.viewYear, st.viewMonth, 1);
-  // Wochentag des Monatsersten, Montag = 0
-  const firstWeekday = (first.getDay() + 6) % 7;
-  const daysInMonth = new Date(st.viewYear, st.viewMonth + 1, 0).getDate();
-  const today = new Date();
-  const todayMid = new Date(today.getFullYear(), today.getMonth(), today.getDate());
- 
-  let hint;
-  if(st.mode === 'single') hint = 'Datum wählen';
-  else if(!st.start || (st.start && st.end)) hint = 'Startdatum wählen';
-  else hint = 'Enddatum wählen (Start: ' + formatDateDE(st.start) + ')';
-
-  let html = `<div class="range-picker-head">
-    <button type="button" class="secondary small" onclick="rangePickerNav(-1)">‹</button>
-    <span class="range-picker-title">${monthNames[st.viewMonth]} ${st.viewYear}</span>
-    <button type="button" class="secondary small" onclick="rangePickerNav(1)">›</button>
-  </div>
-  <div class="range-picker-hint">${hint}</div>
-  <div class="range-picker-grid">`;
-  ['Mo','Di','Mi','Do','Fr','Sa','So'].forEach(w => html += `<div class="range-picker-weekday">${w}</div>`);
-  for(let i = 0; i < firstWeekday; i++) html += '<div></div>';
-  for(let day = 1; day <= daysInMonth; day++){
-    const d = new Date(st.viewYear, st.viewMonth, day);
-    const iso = formatDateISO(d);
-    const classes = ['range-picker-day'];
-    if(d.getDay() === 0 || d.getDay() === 6) classes.push('weekend');
-    if(d.getTime() === todayMid.getTime()) classes.push('today');
-    if(st.start && d.getTime() === st.start.getTime()) classes.push('sel-start');
-    if(st.end && d.getTime() === st.end.getTime()) classes.push('sel-end');
-    if(st.start && st.end && d > st.start && d < st.end) classes.push('in-range');
-    html += `<div class="${classes.join(' ')}" onclick="rangePickerSelect('${iso}')">${day}</div>`;
-  }
-  html += '</div>';
-  html += `<div class="range-picker-footer">
-    <button type="button" class="secondary small" onclick="closeRangePicker()">Abbrechen</button>
-    ${st.mode !== 'single' && st.start && !st.end ? '<button type="button" class="small" onclick="rangePickerState.end = rangePickerState.start; applyRangePicker()">Nur dieser Tag</button>' : ''}
-  </div>`;
-  pop.innerHTML = html;
-}
-
-// ---------- Kollabierbarer Header ----------
-
-const HEADER_COLLAPSED_KEY = 'projuebersicht-header-collapsed';
-
-function loadHeaderState(){
-  let collapsed = true; // Default: Menü ist beim ersten Start geschlossen
-  try {
-    const stored = window.localStorage.getItem(HEADER_COLLAPSED_KEY);
-    if(stored !== null){
-      collapsed = stored === 'true';
-    }
-  } catch (err) {}
-  setHeaderCollapsed(collapsed, false);
-}
-
-function saveHeaderState(collapsed){
-  try {
-    window.localStorage.setItem(HEADER_COLLAPSED_KEY, collapsed ? 'true' : 'false');
-  } catch (err) {}
-}
-
-function setHeaderCollapsed(collapsed, persist){
-  const menu = document.getElementById('headerMenu');
-  const btn = document.querySelector('.header-bar .header-toggle');
-  const icon = document.querySelector('.header-bar .header-toggle-icon');
-  if(!menu) return;
-  if(collapsed){
-    menu.classList.remove('open');
-    menu.setAttribute('aria-hidden', 'true');
-    if(icon) icon.textContent = '☰';
-    if(btn) btn.setAttribute('aria-expanded', 'false');
-  } else {
-    menu.classList.add('open');
-    menu.setAttribute('aria-hidden', 'false');
-    if(icon) icon.textContent = '✕';
-    if(btn) btn.setAttribute('aria-expanded', 'true');
-  }
-  if(persist) saveHeaderState(collapsed);
-}
-
-function toggleHeader(){
-  const menu = document.getElementById('headerMenu');
-  const isOpen = menu && menu.classList.contains('open');
-  setHeaderCollapsed(isOpen, true);
-}
-
-// ---------- Theme (Light/Dark) ----------
-
-function applyThemeIcon(theme){
-  const icon = document.getElementById('themeIcon');
-  if(!icon) return;
-  icon.textContent = theme === 'dark' ? '☀️' : '🌙';
-}
-
-function loadTheme(){
-  let theme = 'auto';
-  try {
-    theme = window.localStorage.getItem('projuebersicht-theme') || 'auto';
-  } catch (err) {
-    console.warn('Theme kann nicht geladen werden:', err);
-  }
-  applyTheme(theme, false);
-}
-
-function saveTheme(theme){
-  try {
-    window.localStorage.setItem('projuebersicht-theme', theme);
-  } catch (err) {
-    console.warn('Theme kann nicht gespeichert werden:', err);
-  }
-}
-
-function effectiveTheme(theme){
-  if(theme === 'dark') return 'dark';
-  if(theme === 'light') return 'light';
-  return window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
-}
-
-function applyTheme(theme, persist){
-  const html = document.documentElement;
-  const eff = effectiveTheme(theme);
-  if(theme === 'dark') html.setAttribute('data-theme', 'dark');
-  else if(theme === 'light') html.setAttribute('data-theme', 'light');
-  else html.removeAttribute('data-theme');
-  applyThemeIcon(eff);
-  if(persist) saveTheme(theme);
-}
-
-function toggleTheme(){
-  const html = document.documentElement;
-  const currentAttr = html.getAttribute('data-theme');
-  const currentTheme = currentAttr || 'auto';
-  const currentEffective = effectiveTheme(currentTheme);
-  const next = currentEffective === 'dark' ? 'light' : 'dark';
-  applyTheme(next, true);
-}
-
-// Bei Änderung der Systemeinstellung im "Auto"-Modus sofort anpassen
-if(window.matchMedia){
-  window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', function(){
-    let theme = 'auto';
-    try {
-      theme = window.localStorage.getItem('projuebersicht-theme') || 'auto';
-    } catch (err) {}
-    applyTheme(theme, false);
-  });
-}
-
-// ---------- Persistence (CSV-only via localhost server) ----------
-
-// save: synchronisiert die aktuellen Daten als CSV-Dateien zum Server.
-// Jede Sitzung wird als eigene CSV-Datei gespeichert. Personen und Rollen werden
-// in der Sitzungscsv selbst abgelegt.
-function save(){
-  scheduleSessionSync();
-}
-
-function scheduleSessionSync(){
-  if(saveSyncTimer){ clearTimeout(saveSyncTimer); }
-  saveSyncTimer = setTimeout(() => { syncAllToServer(); saveSyncTimer = null; }, 500);
-}
-
-function syncAllToServer(){
-  // Zuerst globale Personenliste speichern
-  saveGlobalPeopleToServer();
-  // Dann jede Sitzung speichern
-  db.weeks.forEach(w => {
-    const filename = filenameForWeek(w.label);
-    const csv = weekToCsv(w);
-    sendCsvToServer(filename, csv)
-      .then(res => { if(res && res.ok) console.log('Sitzung gespeichert:', filename); })
-      .catch(err => { console.error('Sitzung konnte nicht gespeichert werden:', filename, err.message || err); });
-  });
-}
-
-function saveGlobalPeopleToServer(){
-  const people = db.globalPeople[currentDepartment] || [];
-  if(people.length === 0) return;
-  const csv = globalPeopleToCsv(people);
-  sendCsvToServer('_people.csv', csv)
-    .then(res => { if(res && res.ok) console.log('Globale Personenliste gespeichert'); })
-    .catch(err => { console.error('Globale Personenliste konnte nicht gespeichert werden:', err.message || err); });
-}
-
-// 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.
-function baseUrl(){
-  const origin = window.location.origin;
-  if(typeof origin === 'string' && /^https?:\/\//.test(origin)){
-    return origin;
-  }
-  return 'http://localhost:3003';
-}
-
-// switchDepartment: wechselt die aktive Abteilung und lädt deren Daten neu.
-function switchDepartment(dept){
-  if(!DEPARTMENTS[dept]) return;
-  currentDepartment = dept;
-  saveUiState();
-
-  // 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 CSV-Dateien vom Server ein und baut daraus die Datenbank auf.
-function load(){
-  if(!window.fetch){
-    alert('Ihr Browser unterstützt keine Netzwerk-Anfragen. Bitte verwenden Sie einen aktuellen Browser.');
-    seed(); return;
-  }
-  const url = baseUrl() + '/load-all' + departmentParam();
-  console.log('Loading from', url);
-  fetch(url)
-    .then(r => { if(!r.ok) throw new Error('Server HTTP '+r.status); return r.json(); })
-    .then(data => {
-      // Globale Personenliste laden
-      db.globalPeople[currentDepartment] = parseGlobalPeopleCsv(data.people);
-
-      const parsedSessions = (data.sessions || []).map(s => ({ filename: s.filename, rows: parseCsvText(s.content) }));
-
-      db.weeks = [];
-      parsedSessions.forEach(s => {
-        const w = parseSessionCsv(s.filename, s.rows);
-        if(w) db.weeks.push(w);
-      });
-
-      if(db.weeks.length === 0){
-        console.warn('Server lieferte 0 Sitzungsdateien. Es werden Beispieldaten (seed) angezeigt. Pruefen Sie, ob der Ordner sessions/ mitkopiert wurde.');
-        seed();
-      }
-      else {
-        db.weeks.sort((a,b) => weekSortKey(a.label).localeCompare(weekSortKey(b.label)));
-        applyAutoLock();
-        const latest = db.weeks[db.weeks.length - 1];
-        if(!db.currentWeek || !db.weeks.some(w => w.id === db.currentWeek)){
-          db.currentWeek = latest.id;
-        }
-        console.log(`Server-Load erfolgreich: ${db.weeks.length} Sitzung(en).`);
-      }
-      // Geschützte Tabs dürfen nicht ohne Passwort angezeigt werden, auch wenn
-      // sie im UI-State gespeichert waren.
-      if(currentTab === 'projects' || currentTab === 'people') currentTab = DEFAULT_TAB;
-      renderAll();
-      showTab(currentTab, true);
-  })
-  .catch(err => {
-    console.error('Laden vom Server fehlgeschlagen:', err);
-    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.';
-    alert(msg);
-    seed(); renderAll();
-  });
-}
-
-// CSV-Hilfsfunktionen ----------------------------------------
-
-function filenameForWeek(label){
-  return (label.replace(/[^\w]/g,'_'))+'.csv';
-}
-
-function csvEscape(v){
-  const s = (v === null || v === undefined ? '' : String(v));
-  if(/[;"\n\r]/.test(s)) return '"' + s.replace(/"/g,'""') + '"';
-  return s;
-}
-
-function globalPeopleToCsv(people){
-  const rows = [['NAME', 'Rollen', 'Voller Name', 'E-Mail', 'Abwesenheiten']];
-  people.slice().sort((a,b) => a.name.localeCompare(b.name)).forEach(p => {
-    const absences = Array.isArray(p.absences) ? JSON.stringify(p.absences) : '';
-    rows.push([p.name, (p.role || []).join(','), p.fullName || '', p.email || '', absences]);
-  });
-  return '\ufeff' + rows.map(r => r.map(csvEscape).join(';')).join('\n');
-}
-
-function parseGlobalPeopleCsv(text){
-  if(!text) return [];
-  const rows = parseCsvText(text);
-  if(!rows.length) return [];
-  const people = [];
-  rows.slice(1).forEach(row => {
-    const name = (row[0] || '').trim();
-    if(!name) return;
-    const roles = String(row[1] || 'Planung').split(',').map(x => x.trim()).filter(Boolean);
-    const fullName = (row[2] || '').trim() || name;
-    const email = (row[3] || '').trim();
-    let absences = [];
-    if(row[4]){
-      try {
-        const parsed = JSON.parse(row[4]);
-        if(Array.isArray(parsed)) absences = parsed;
-      } catch(e) {
-        // Ignoriere fehlerhafte JSON-Daten
-      }
-    }
-    people.push({ id: personIdForName(name), name, fullName, email, role: roles, absences });
-  });
-  return people;
-}
-
-// Persistente ID fuer eine Person aus dem Kuerzel, damit Anwesenheit und
-// Zuordnungen auch nach einem Neuladen stabil bleiben.
-function personIdForName(name){
-  return 'p_' + String(name).trim().toLowerCase().replace(/[^a-z0-9]/g,'_');
-}
-
-function weekToCsv(w){
-  // allPeople enthält für das Board jede (Person, Rolle)-Kombination einmal.
-  const grouped = peopleByRole(w);
-  const allPeople = [];
-  ROLES.forEach(r => grouped[r].forEach(entry => allPeople.push(entry)));
-  const rows = [];
-  // Metadaten-Zeile: Label, Datum und Sperrstatus der Sitzung
-  rows.push(['WOCHE', w.label || '', w.date || '', w.locked ? '1' : '']);
-  // PERSONEN-Zeile: Pro Spalte Name|Rolle|Voller Name, damit beim Laden
-  // die Zuordnung pro Rolle eindeutig bleibt und der volle Name erhalten ist.
-  // Der volle Name wird immer als dritter Teil gespeichert (auch leer),
-  // damit er beim Bearbeiten nicht versehentlich verloren geht.
-  const peopleMeta = allPeople.map(e => `${e.person.name}|${e.role}|${e.person.fullName || ''}`);
-  rows.push(['PERSONEN', '', '', ...peopleMeta, ...LPHS.map(() => ''), '','','','','']);
-  rows.push(['Pr.-Nr.','Bezeichnung','Status', ...allPeople.map(e => e.person.name), ...LPHS, 'Gruppe','Index','Plan','Aufwand','Aktive Phasen']);
-  rows.push(['ANWESENHEIT','', ...allPeople.map(e => w.attendance && w.attendance[e.person.id] ? 'X' : ''), ...LPHS.map(() => ''),'','','','','']);
-  w.projects.forEach(p => {
-    const arr = [p.nr || '', p.name || '', p.status || ''];
-    allPeople.forEach(entry => {
-      const s = p.assign[assignKey(entry.person.id, entry.role)];
-      arr.push(s === 1 ? 'X' : s === 2 ? '(X)' : '');
-    });
-    LPHS.forEach(l => {
-      const v = p.lph[l];
-      arr.push(v !== undefined && v !== '' ? String(v).replace(/%/g,'') + '%' : '');
-    });
-    arr.push(p.group || '');
-    arr.push(p.order !== undefined ? String(p.order) : '');
-    arr.push(p.plan ? JSON.stringify(p.plan) : '');
-    arr.push(p.aufwandProLP ? JSON.stringify(p.aufwandProLP) : '');
-    arr.push(p.aktuelleLP ? JSON.stringify(p.aktuelleLP) : '');
-    rows.push(arr);
-  });
-  return '\ufeff' + rows.map(r => r.map(csvEscape).join(';')).join('\n');
-}
-
-
-function parseCsvText(text){
-  // Manche ältere CSV-Dateien enthalten ein UTF-8-BOM gefolgt von einem
-  // literalen "" (dreifach kodiert). Beides am Anfang entfernen.
-  return text.replace(/^[\ufeff\u00EF\u00BB\u00BF]+/,'').split(/\r?\n/).filter(line => line.trim() !== '').map(parseCsvLine);
-}
-
-// Toleranter CSV-Zeilenparser. Versteht sowohl sauberes CSV als auch
-// das ältere Format, bei dem Felder nur ein öffnendes Anführungszeichen
-// hatten und das Semikolon innerhalb eines quoted Feldes gleichzeitig
-// als Trennzeichen diente.
-function parseCsvLine(line){
-  const result = [];
-  let current = '';
-  let inQuotes = false;
-  let hasUnclosedQuotes = false;
-  let i = 0;
-  while(i < line.length){
-    const c = line[i];
-    const n = line[i+1];
-    if(inQuotes){
-      if(c === '"' && n === '"'){
-        current += '"'; i += 2;
-      } else if(c === ';' && n === '"'){
-        // Altes Trennzeichen \";\\" innerhalb eines quoted Feldes
-        result.push(current);
-        current = '';
-        inQuotes = false;
-        i += 1;
-      } else if(c === '"' && (n === ';' || n === undefined)){
-        result.push(current);
-        current = '';
-        inQuotes = false;
-        i += (n === ';' ? 2 : 1);
-      } else {
-        current += c; i++;
-      }
-    } else {
-      if(c === ';'){
-        result.push(current);
-        current = ''; i++;
-      } else if(c === '"'){
-        inQuotes = true; i++;
-      } else {
-        current += c; i++;
-      }
-    }
-  }
-  if(inQuotes) hasUnclosedQuotes = true;
-  result.push(current);
-  if(hasUnclosedQuotes){
-    console.warn('CSV-Zeile enthält nicht geschlossene Anführungszeichen:', line.slice(0,80));
-  }
-  return result;
-}
-
-function decodeWeekLabel(filename){
-  const base = filename.replace(/\.csv$/i,'');
-  let label = base.replace(/_+/g,' ').trim();
-  if(/^KW \d+ \d+$/.test(label)){
-    label = label.replace(/^KW (\d+) (\d+)$/, 'KW $1 / $2');
-  }
-  return label || base;
-}
-
-// Erzeugt einen Sortierschlüssel aus einem Wochenlabel, sodass z.B.
-// "KW 9 / 2026" vor "KW 10 / 2026" kommt.
-function weekSortKey(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();
-}
-
-
-function parseSessionCsv(filename, rows){
-  if(!rows || rows.length === 0) return null;
-  let label, date, headerRowIdx = 0, attendanceRowIdx = 1, projectStartIdx = 2;
-  let locked = false;
-  let metaPeopleRow = null;
-  if(rows[0][0] === 'WOCHE'){
-    label = rows[0][1] || decodeWeekLabel(filename);
-    date = rows[0][2] || '';
-    locked = (rows[0][3] || '').trim() === '1';
-    if(rows[1] && rows[1][0] === 'PERSONEN'){
-      metaPeopleRow = rows[1];
-      headerRowIdx = 2; attendanceRowIdx = 3;
-    } else {
-      headerRowIdx = 1; attendanceRowIdx = 2;
-    }
-  } else {
-    label = decodeWeekLabel(filename);
-    date = '';
-  }
-  projectStartIdx = attendanceRowIdx + 1;
-
-  const header = rows[headerRowIdx];
-  if(!header || header.length < 4) return { id: uid(), label, date, people: [], projects: [], attendance: {} };
-
-  const lphStart = header.indexOf('LPH 1');
-  const groupIdx = header.indexOf('Gruppe');
-  const orderIdx = header.indexOf('Index');
-  const planIdx = header.indexOf('Plan');
-  const aufwandIdx = header.indexOf('Aufwand');
-  const aktiveIdx = header.indexOf('Aktive Phasen');
-  const peopleCols = header.slice(3, lphStart === -1 ? header.length : lphStart);
-
-  const people = [];
-  const colMap = [];
-  const personMeta = metaPeopleRow ? metaPeopleRow.slice(3, lphStart === -1 ? metaPeopleRow.length : lphStart) : [];
-  const personByName = {};
-  const nameOccurrences = {};
-  peopleCols.forEach((name, idx) => {
-    const n = (name || '').trim();
-    if(!n){ colMap.push(null); return; }
-
-    let roles = ['Planung'];
-    let fullName = n;
-    if(personMeta[idx]){
-      const parts = String(personMeta[idx]).split('|');
-      const rawRoles = parts[1] || '';
-      const parsedRoles = rawRoles.split(',').map(x => x.trim()).filter(x => ROLES.includes(x));
-      if(parsedRoles.length > 0) roles = parsedRoles;
-      // Voller Name ist alles ab dem zweiten Pipe; damit sind auch Pipe-Zeichen
-      // im Namen möglich. Leere Strings werden bewusst übernommen.
-      if(parts.length >= 3) fullName = parts.slice(2).join('|').trim();
-    } else {
-      const occurrence = nameOccurrences[n] || 0;
-      roles = [ROLES[Math.min(occurrence, ROLES.length - 1)]];
-      nameOccurrences[n] = occurrence + 1;
-    }
-
-    // Gleiche Person (gleiches Kürzel) wird im Board pro Rolle mehrfach
-    // dargestellt, soll aber im Datenmodell nur einmal existieren.
-    let person = personByName[n];
-    if(!person){
-      person = { id: personIdForName(n), name: n, fullName: fullName, role: [] };
-      personByName[n] = person;
-      people.push(person);
-    }
-    // Überschreibe den vollen Namen mit dem Wert aus der CSV; die CSV ist
-    // hier die führende Datenquelle für den vollständigen Namen.
-    person.fullName = fullName;
-    // Sammle alle bekannten Rollen der Person; die aktuelle Spaltenrolle
-    // wird für die Zuordnung über colMap verwendet.
-    roles.forEach(r => { if(!person.role.includes(r)) person.role.push(r); });
-
-    colMap.push({ person, role: roles[0] });
-  });
-
-  const projects = [];
-  for(let rIdx = projectStartIdx; rIdx < rows.length; rIdx++){
-    const row = rows[rIdx];
-    if(row.length < 4) continue;
-    const nr = row[0] || '';
-    const name = row[1] || '';
-    const status = row[2] || '';
-    if(!nr.trim() && !name.trim()) continue;
-
-    const assign = {};
-    peopleCols.forEach((_, i) => {
-      const entry = colMap[i];
-      if(!entry) return;
-      const v = (row[3+i] || '').trim();
-      const key = assignKey(entry.person.id, entry.role);
-      if(v === 'X') assign[key] = 1;
-      else if(v === '(X)') assign[key] = 2;
-    });
-
-    const lph = {};
-    if(lphStart !== -1){
-      LPHS.forEach((l, j) => {
-        const raw = row[lphStart + j];
-        if(raw !== undefined && raw !== ''){
-          const num = String(raw).replace(/%/g,'');
-          if(!isNaN(parseFloat(num)) && isFinite(num)) lph[l] = num;
-        }
-      });
-    }
-
-    let group = 'Aktive Projekte';
-    if(groupIdx >= 0 && row[groupIdx]) group = row[groupIdx].trim() || group;
-    else if(row.length > 3) group = row[row.length - 1].trim() || group;
-
-    let order = rIdx - projectStartIdx;
-    if(orderIdx >= 0 && row[orderIdx] !== undefined && row[orderIdx] !== ''){
-      const parsed = parseInt(row[orderIdx], 10);
-      if(!isNaN(parsed)) order = parsed;
-    }
-
-    let plan = null;
-    if(planIdx >= 0 && row[planIdx]){
-      try {
-        const parsed = JSON.parse(row[planIdx]);
-        if(parsed && typeof parsed === 'object') plan = parsed;
-      } catch(e) {
-        console.warn('Plan-Daten für Projekt konnten nicht geparst werden:', nr, name, e);
-      }
-    }
-
-    let aufwandProLP;
-    if(aufwandIdx >= 0 && row[aufwandIdx]){
-      try {
-        const parsed = JSON.parse(row[aufwandIdx]);
-        if(parsed && typeof parsed === 'object') aufwandProLP = parsed;
-      } catch(e) {
-        console.warn('LP-Aufwand für Projekt konnten nicht geparst werden:', nr, name, e);
-      }
-    }
-
-    let aktuelleLP;
-    if(aktiveIdx >= 0 && row[aktiveIdx]){
-      try {
-        const parsed = JSON.parse(row[aktiveIdx]);
-        if(Array.isArray(parsed)) aktuelleLP = parsed;
-        else if(typeof parsed === 'string') aktuelleLP = [parsed];
-      } catch(e) {
-        console.warn('Aktive Phasen für Projekt konnten nicht geparst werden:', nr, name, e);
-      }
-    }
-
-    projects.push({ id: uid(), nr, name, status, group, lph, assign, order, plan, aufwandProLP, aktuelleLP });
-  }
-
-  const attendance = {};
-  const attRow = rows[attendanceRowIdx];
-  if(attRow && attRow[0] === 'ANWESENHEIT'){
-    peopleCols.forEach((_, i) => {
-      const entry = colMap[i];
-      if(entry && (attRow[2+i] || '').trim() === 'X'){
-        attendance[entry.person.id] = true;
-      }
-    });
-  }
-
-  return { id: uid(), label, date, people, projects, attendance, locked };
-}
-
-// uid: generiert eine einfache, ausreichend eindeutige ID
-function uid(){ return Date.now().toString(36)+Math.random().toString(36).slice(2,7); }
-
-// assignKey: Schlüssel für Projektzuordnungen (Person + Rolle getrennt)
-function assignKey(personId, role){ return personId + '|' + role; }
-
-// sortGroups: sortiert Gruppen-Namen nach GROUP_ORDER, unbekannte ans Ende
-function sortGroups(arr){
-  return arr.sort((a,b)=>{
-    const ia=GROUP_ORDER.indexOf(a), ib=GROUP_ORDER.indexOf(b);
-    return (ia===-1?999:ia)-(ib===-1?999:ib);
-  });
-}
-
-// seed: initialisiert Beispiel-Daten (Personen + eine Woche mit Projekten)
-function seed(){
-  const people = [
-    {id:personIdForName('AP'), name:"AP", fullName:"Anton Peters", role:["Planung"]},
-    {id:personIdForName('SK'), name:"SK", fullName:"Stefan Krause", role:["Planung"]},
-    {id:personIdForName('AK'), name:"AK", fullName:"Alexander Klein", role:["Planung"]},
-    {id:personIdForName('ED'), name:"ED", fullName:"Eva Dreyer", role:["Planung"]},
-    {id:personIdForName('SE'), name:"SE", fullName:"Stefan Eschweiler", role:["Planung"]},
-    {id:personIdForName('THK'), name:"THK", fullName:"Thorsten H. Klein", role:["Projektleitung"]},
-    {id:personIdForName('SP'), name:"SP", fullName:"Sven Peschke", role:["Projektleitung"]},
-    {id:personIdForName('SG'), name:"SG", fullName:"Sandra Gloag", role:["Projektleitung"]},
-    {id:personIdForName('TW'), name:"TW", fullName:"Thorsten Wörster", role:["Projektleitung"]},
-    {id:personIdForName('RR'), name:"RR", fullName:"Robert Rahn", role:["Bauüberwachung"]},
-    {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));
-
-  const wid = uid();
-  db.weeks = [{
-    id: wid, label:"KW 30 / 2026", date:"2026-07-24", attendance:{}, people, projects: [
-      demoProj("18-4007","Janusz-Korczak-Gesamtsch. Bottrop","Aktive Projekte","LPH5 als Vorabzug raus. NW-Räume vorauss. August.",{"LPH 1":100,"LPH 2":100,"LPH 3":100,"LPH 5":100,"LPH 6":100,"LPH 7":100,"LPH 8":95}),
-      demoProj("21-4030","NSHV Köln Immobilienprüfung in Hof","Aktive Projekte","Thorsten W. klärt und übernimmt Schriftverkehr. LV liegt zur Sichtung bei T.W.",{"LPH 1":100,"LPH 2":100,"LPH 3":100,"LPH 5":100,"LPH 6":100}),
-      demoProj("22-4056","Gymnasium Hemer","Aktive Projekte","",{"LPH 1":100,"LPH 2":100,"LPH 3":100,"LPH 5":100,"LPH 6":100,"LPH 7":100,"LPH 8":90}),
-      demoProj("22-4066","DSW 21 – Umbau E-Mobilität","Aktive Projekte","Elt-Montagen ab KW 33.",{"LPH 1":100,"LPH 2":100,"LPH 3":100,"LPH 5":100,"LPH 6":100,"LPH 7":100,"LPH 8":20}),
-      demoProj("24-4043","S-K ODL-Heim Sanierung Krefeld","Aktive Projekte","Voraussichtlich LV-Abgabe.",{"LPH 1":100,"LPH 2":100,"LPH 3":100,"LPH 5":100}),
-    ]
-  }];
-  db.currentWeek = wid;
-  save();
-}
-
-// demoProj: Helfer zum Erzeugen eines Projekt-Objekts (für seed/Tests)
-function demoProj(nr,name,group,status,lph){
-  return {id:uid(), nr, name, group, status, lph: {...lph}, assign:{}, plan: null, aufwandProLP: undefined, aktuelleLP: undefined};
-}
-
-// ---------- Week management ----------
-
-// refreshWeekSelect: aktualisiert das Dropdown mit verfügbaren Sitzungen
-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('');
-}
-
-function formatWeekDate(dateString){
-  if(!dateString) return '';
-  const parts = dateString.split('-');
-  if(parts.length!==3) return dateString;
-  return `${parts[2]}.${parts[1]}.${parts[0]}`;
-}
-
-function updateWeekDate(){
-  const disp = document.getElementById('weekDateDisplay');
-  const w = currentWeek();
-  if(!disp) return;
-  disp.textContent = w?.date ? `Datum: ${formatWeekDate(w.date)}` : '';
-}
-
-// currentWeek: liefert das Woche-Objekt zur aktuellen Auswahl (oder undefined)
-function currentWeek(){ return db.weeks.find(w=>w.id===db.currentWeek); }
-
-// switchWeek: setzt die aktuelle Woche und rendert die Ansicht neu
-function switchWeek(id){ db.currentWeek = id; save(); renderAll(); }
-
-// newWeek: Dialog zur Erzeugung einer neuen Sitzung
-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
-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();
-}
-
-// 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.
-function applyAutoLock(){
-  if(db.weeks.length === 0) return;
-  const sorted = [...db.weeks].sort((a,b) => weekSortKey(a.label).localeCompare(weekSortKey(b.label)));
-  const latestId = sorted[sorted.length - 1].id;
-  db.weeks.forEach(w => {
-    w.locked = (w.id !== latestId);
-  });
-}
-
-// isWeekLocked: prüft, ob die aktuell ausgewählte Sitzung gesperrt ist
-function isWeekLocked(w){
-  return !!w && !!w.locked;
-}
-
-// guardWeekLocked: zeigt eine Warnung, wenn die aktuelle Sitzung gesperrt ist.
-// Wird von Bearbeitungsfunktionen verwendet, um versehentliche Änderungen an
-// historischen Sitzungen zu verhindern.
-function guardWeekLocked(){
-  const w = currentWeek();
-  if(isWeekLocked(w)){
-    alert('Diese Sitzung ist gesperrt. Bitte entsperren Sie sie zuerst.');
-    return true;
-  }
-  return false;
-}
-
-// unlockCurrentWeek: Entsperrt die aktuelle Sitzung nach Passwortprüfung
-function unlockCurrentWeek(skipAuth = false){
-  const w = currentWeek();
-  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;
-}
-
-// deleteWeek: löscht die aktuell ausgewählte Sitzung (wenn mehr als 1 vorhanden)
-function deleteWeek(skipAuth = false){
-  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();
-  const filename = current ? filenameForWeek(current.label) : null;
-  if(filename){
-    console.log('Lösche CSV-Datei auf Server:', filename);
-    deleteCsvFromServer(filename).then(res=>{
-      if(res && res.ok){ console.log('CSV-Datei gelöscht:', filename); }
-      else { alert('CSV-Löschung fehlgeschlagen: ' + (res && res.error ? res.error : 'unbekannter Fehler')); }
-    }).catch(err=>{ alert('CSV-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;
-}
-
-function deleteCsvFromServer(filename){
-  if(!window.fetch) return Promise.reject(new Error('fetch nicht verfügbar'));
-  return fetch(baseUrl() + '/delete-csv', {
-    method: 'POST',
-    headers: {'Content-Type':'application/json; charset=utf-8'},
-    body: JSON.stringify({ filename, department: currentDepartment })
-  }).then(r=>{ if(!r.ok) throw new Error('Server HTTP '+r.status); return r.json(); });
-}
-
-let currentStatusEditor = null;
-let currentStatusPid = null;
-
-function statusFocus(el, pid){
-  currentStatusEditor = el;
-  currentStatusPid = pid;
-}
-
-function statusBlur(el, pid){
-  const val = statusValueFromHtml(el.innerHTML);
-  editProj(pid, 'status', val);
-  if(currentStatusEditor === el){ currentStatusEditor = null; currentStatusPid = null; }
-}
-
-function statusValueFromHtml(html){
-  const tmp = document.createElement('div');
-  tmp.innerHTML = html;
-  const text = (tmp.textContent || tmp.innerText || '').replace(/\u00A0/g, ' ');
-  return text.trim() === '' ? '' : html;
-}
-
-function formatStatus(command, value){
-  if(!currentStatusEditor) return;
-  currentStatusEditor.focus();
-  document.execCommand(command, false, value || null);
-}
-
-// ---------- Board (Haupttabelle) ----------
-
-// peopleByRole: gruppiert Personen nach Rolle zurück in ein Objekt
-function peopleByRole(target){
-  const m = {}; ROLES.forEach(r=>m[r]=[]);
-  const people = [];
-  if(Array.isArray(target)){
-    target.forEach(w => { if(w && Array.isArray(w.people)) people.push(...w.people); });
-  } else if(target && Array.isArray(target.people)){
-    people.push(...target.people);
-  } else if(Array.isArray(currentWeek()?.people)){
-    people.push(...currentWeek().people);
-  }
-  const seen = new Set();
-  people.forEach(p=>{
-    const personRoles = Array.isArray(p.role) ? p.role : [p.role];
-    personRoles.forEach(role=>{
-      if(!m[role]) m[role]=[];
-      const key = `${p.id}|${role}`;
-      if(!seen.has(key)){
-        seen.add(key);
-        m[role].push({person:p, role});
-      }
-    });
-  });
-  return m;
-}
-
-function roleClass(role){
-  if(Array.isArray(role)){
-    return role.map(r=>'role-'+r.toLowerCase().replace(/\s+/g,'-')).join(' ');
-  }
-  return 'role-' + role.toLowerCase().replace(/\s+/g,'-');
-}
-
-// renderBoard: baut die HTML-Tabelle für das Board auf (Kopf, Zeilen, Zellen)
-function renderBoard(){
-  const w = currentWeek();
-  const locked = isWeekLocked(w);
-  const table = document.getElementById('boardTable');
-  const grouped = peopleByRole(w);
-
-  // 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)}">${entry.person.name}</th>`);
-  });
-  LPHS.forEach(l=> h2 += `<th class="rot">${l}</th>`);
-  h2 += `</tr>`;
-
-  // Projekte nach Gruppen (z.B. "Aktive Projekte") zusammenfassen
-  const groups = {};
-  w.projects.forEach(p=>{ (groups[p.group]||(groups[p.group]=[])).push(p); });
-  
-  // Projekte nach ihrer Reihenfolge sortieren
-  Object.keys(groups).forEach(g=>{
-    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
-  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="${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>`;
-    });
-
-  });
-
-  let lockNotice = '';
-  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>`;
-  }
-
-  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();
-}
-
-// Sanitizing: Erlaubt nur eine kleine Whitelist an HTML-Tags/Attributen,
-// damit Formatierung funktioniert, aber keine Skripte eingeschleust werden.
-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, child);
-          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 Farbe basierend auf Prozent (grün→rot)
-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
-// und setzt den top-Wert der zweiten Kopfzeile entsprechend, damit
-// beide sticky-Zeilen exakt aneinander anschließen (keine Lücke/Überlappung)
-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 eines Projektbeteiligten für die aktuelle Sitzung
-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();
-}
-
-// esc: einfache Escape-Funktion für Ausgabe in HTML
-function esc(s){ return (s||"").replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;'); }
-
-// cycleAssign: wechselt die Zuweisung einer Person zu einem Projekt (0→1→2→0)
-function cycleAssign(pid, personId, role){
-  if(guardWeekLocked()) return;
-  const p = currentWeek().projects.find(x=>x.id===pid);
-  const key = assignKey(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();
-}
-
-// editLph: setzt oder entfernt den Prozentwert einer Leistungsphase für ein Projekt
-function editLph(pid,lph,val){
-  if(guardWeekLocked()) return;
-  const p = currentWeek().projects.find(x=>x.id===pid);
-  val = val.trim();
-  if(val==="") delete p.lph[lph];
-  else p.lph[lph]=val.replace('%','');
-  save(); renderBoard();
-}
-
-// editProj: aktualisiert Felder eines Projekts; für Status wird zusätzlich
-// ein flag `statusState` gesetzt, wenn ein neuer Kommentar angelegt wird
-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 aus der aktuellen Sitzung
-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();
-}
-
-// ---------- Personen-Verwaltung (global pro Abteilung) ----------
-
-// 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(); 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;
-
-  // 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 (nur wenn nicht in Zuordnungen genutzt)
-  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;
-    }
-    w.people = (w.people || []).filter(p=>p.id!==id);
-  }
-
-  save(); renderPeople(); renderBoard();
-}
-
-// editPerson: ändert Name/Vollname/Rolle sowohl global als auch in der
-// aktuellen Sitzung. Historische Sitzungen bleiben unverändert.
-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(); 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(); renderPeople(); renderBoard();
-}
-
-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(); renderPeople(); renderBoard();
-}
-
-// renderPeople: baut die Liste der Personen für die UI
-function renderPeople(){
-  const people = db.globalPeople[currentDepartment] || [];
-  const locked = isWeekLocked(currentWeek());
-  let html = `<div class="people-sortable">`;
-  people.forEach(p=>{
-    const isOpen = personAbsenceOpen[p.id];
-    html += `<div class="person-card${isOpen ? ' open' : ''}" data-person-id="${p.id}">`;
-    html += `<div class="person-header" onclick="togglePersonAbsences('${p.id}')">
-      <span class="drag-handle" style="cursor:grab;color:#999;margin-right:8px" onclick="event.stopPropagation()" ondragstart="handlePersonDragStart(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>
-    </div>`;
-
-    // Aufklappbare Abwesenheiten
-    html += `<div class="person-absences" style="display:${isOpen ? 'block' : 'none'}">`;
-    const 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>`;
-    }
-    html += `</div></div>`;
-  });
-  html += `</div>`;
-  if(people.length===0) html = '<div class="hint">Keine Personen vorhanden.</div>';
-  document.getElementById('peopleList').innerHTML=html;
-}
-
-let personAbsenceOpen = {};
-
-function togglePersonAbsences(personId){
-  personAbsenceOpen[personId] = !personAbsenceOpen[personId];
-  renderPeople();
-}
-
-let draggedPerson = null;
-
-function getPersonCard(el){
-  return el && el.closest ? el.closest('.person-card') : null;
-}
-
-function handlePersonDragStart(event){
-  draggedPerson = getPersonCard(event.target);
-  if(!draggedPerson) return;
-  event.dataTransfer.effectAllowed = 'move';
-  draggedPerson.style.opacity = '0.5';
-}
-
-function handlePersonDragOver(event){
-  event.preventDefault();
-  event.dataTransfer.dropEffect = 'move';
-}
-
-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);
-  if(afterElement == null){
-    sortable.appendChild(draggedPerson);
-  } else {
-    sortable.insertBefore(draggedPerson, afterElement);
-  }
-  reorderPeople();
-}
-
-function handlePersonDragEnd(event){
-  const card = getPersonCard(event.target);
-  if(card) card.style.opacity = '1';
-  draggedPerson = null;
-}
-
-function reorderPeople(){
-  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;
-    save();
-  }
-}
-
-// ---------- Projekte (Listen-Ansicht) ----------
-
-// delProjectFromList: löscht ein Projekt in der Listen-Ansicht
-function delProjectFromList(id){
-  if(guardWeekLocked()) return;
-  if(!confirm("Projekt aus dieser Sitzung löschen?")) return;
-  const w = currentWeek();
-  w.projects = w.projects.filter(p=>p.id!==id);
-  save(); renderProjects(); renderBoard();
-}
-
-// editProjectField: ändert ein Feld eines Projekts (z.B. Name oder Gruppe)
-function editProjectField(id,field,val){
-  if(guardWeekLocked()) return;
-  const p = currentWeek().projects.find(x=>x.id===id);
-  if(p){ p[field]=val; save(); renderProjects(); renderBoard(); }
-}
-
-// editProjectActiveLP: setzt/hebt die amtierende Leistungsphase eines Projekts auf.
-function editProjectActiveLP(id, value){
-  if(guardWeekLocked()) return;
-  const p = currentWeek().projects.find(x=>x.id===id);
-  if(!p) return;
-  if(value) p.aktuelleLP = [value];
-  else delete p.aktuelleLP;
-  save(); renderProjects(); renderBoard(); renderLoad();
-}
-
-// renderProjects: baut die HTML-Liste der Projekte (gruppiert nach group, mit Drag-and-Drop)
-function renderProjects(){
-  const w = currentWeek();
-  if(!w) return;
-  let html="";
-  const groups = {};
-  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));
-  });
-
-  sortGroups(Object.keys(groups)).forEach(g=>{
-    html += `<div class="section-title">${esc(g)}</div>`;
-    html += `<div class="projects-sortable" data-group="${g}">`;
-    groups[g].forEach(p=>{
-      html += `<div class="person-list-item" draggable="true" data-project-id="${p.id}" ondragstart="handleDragStart(event)" ondragover="handleDragOver(event)" ondrop="handleDrop(event)" ondragend="handleDragEnd(event)">
-        <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)">
-          <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">
-          <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>`;
-    });
-    html += `</div>`;
-    if(groups[g].length===0) html+=`<div class="hint">Keine Projekte.</div>`;
-  });
-  document.getElementById('projectsList').innerHTML=html;
-}
-
-// Drag-and-Drop Handling für Projekte
-let draggedProject = null;
-
-function handleDragStart(event){
-  draggedProject = event.currentTarget;
-  event.dataTransfer.effectAllowed = 'move';
-  event.currentTarget.style.opacity = '0.5';
-}
-
-function handleDragOver(event){
-  event.preventDefault();
-  event.dataTransfer.dropEffect = 'move';
-}
-
-function handleDrop(event){
-  event.preventDefault();
-  if(!draggedProject || draggedProject === event.currentTarget) return;
-  const sortable = event.currentTarget.parentElement;
-  const afterElement = getDragAfterElement(sortable, event.clientY);
-  if(afterElement == null){
-    sortable.appendChild(draggedProject);
-  } else {
-    sortable.insertBefore(draggedProject, afterElement);
-  }
-  reorderProjects();
-}
-
-function handleDragEnd(event){
-  event.currentTarget.style.opacity = '1';
-  draggedProject = null;
-}
-
-function getDragAfterElement(container, y){
-  const draggableElements = [...container.querySelectorAll('.person-list-item:not([style*="opacity"])')];
-  return draggableElements.reduce((closest, child) => {
-    const box = child.getBoundingClientRect();
-    const offset = y - box.top - box.height / 2;
-    if(offset < 0 && offset > closest.offset){
-      return { offset: offset, element: child };
-    } else {
-      return closest;
-    }
-  }, { offset: Number.NEGATIVE_INFINITY }).element;
-}
-
-function reorderProjects(){
-  if(guardWeekLocked()) return;
-  const w = currentWeek();
-  const sortables = document.querySelectorAll('.projects-sortable');
-  sortables.forEach(sortable => {
-    const group = sortable.dataset.group;
-    const items = sortable.querySelectorAll('[data-project-id]');
-    items.forEach((item, index) => {
-      const projectId = item.dataset.projectId;
-      const project = w.projects.find(p => p.id === projectId);
-      if(project){
-        project.order = index;
-        project.group = group;
-      }
-    });
-  });
-  save();
-  renderProjects();
-  renderBoard();
-}
-
-// ---------- Auslastung (Load) ----------
-
-// ---------- Aufwand je Leistungsphase (LP) ----------
-//
-// Datenmodell je Projekt (rollen- und leistungsphasenspezifisch):
-//   pr.aufwandProLP = {
-//     'LPH 1': { Planung: 0.4, Projektleitung: 0.6, Bauüberwachung: 0.0 },
-//     ...
-//   }                                   // Gewichtungsfaktor je Rolle (0.0–1.0)
-//   pr.aktuelleLP   = ['LPH 6']         // aktuell amtierende Phase (max. 1)
-//
-// Es zählt genau eine amtierende Phase je Projekt ("Nur amtierende Einzelphase",
-// Absprache mit dem Auftraggeber). Altdaten mit mehreren aktiven Phasen
-// verwenden deterministisch die erste aktive Phase der Liste.
-//
-// Berechnungslogik:
-//   Auslastung(Mitarbeiter) = Σ Faktor der amtierenden LP je Projekt,
-//   in dem der Mitarbeiter (in seiner Rolle) zugewiesen ist.
-// Der Faktor zählt 1:1 – die Zuordnungsart (Haupt/Optional) skaliert nicht.
-// Leere Matrix-Felder zählen bei gesetzter aktiver LP mit dem Standard-Faktor
-// 1,0; ohne gesetzte aktive LP zählt das Projekt 0 (nicht eingerechnet).
-// "In Anbahnung" wird nicht eingerechnet.
-//
-// HINWEIS (Fachplaner-Fragen, bewusst NICHT eigenständig entschieden):
-// - Ampel-Schwellen (50 % / 75 % des Maximalwerts) sind PLATZHALTER und müssen
-//   fachlich abgestimmt werden.
-// - Mitarbeiterkapazität (Teilzeit/Vollzeit) existiert nicht – offener Punkt.
-//
-// AUFWAND_LPS: Phasen des Aufwandsmodells (LPH 1–8; "W+M" ist bewusst nicht
-// enthalten, entspricht der Entscheidung "LP-Schema: lp1-8").
-const AUFWAND_LPS = LPHS.slice(0, 8);
-
-// LP_AUFWAND_VORLAGE: Standardwerte der Maske "Aufwand je Leistungsphase".
-// Vorbefüllung beim Anlegen neuer Projekte sowie beim Öffnen der Maske für
-// bestehende Projekte, die in einzelnen Feldern keine Werte haben – beim
-// Speichern werden sie übernommen. Werte 0.0–1.0 je Rolle; 0 = kein Aufwand.
-// Nicht gelistete Phasen/Rollen bleiben leer und zählen als Standard-Faktor 1,0.
-// Hier im Code anpassen.
-const LP_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 }
-};
-
-// PLATZHALTER! Ampel-Schwellen als Anteil des Maximalwerts LOAD_BAR_MAX
-// (gelb ab 50 %, rot ab 75 %). Müssen vom Fachplaner bestätigt werden.
-const THRESHOLD_RATIO_CRITICAL = 0.75;
-const THRESHOLD_RATIO_ELEVATED  = 0.50;
-
-function lpActiveList(pr){
-  const a = pr && pr.aktuelleLP;
-  if(Array.isArray(a)) return a.filter(l => AUFWAND_LPS.includes(l));
-  if(typeof a === 'string' && AUFWAND_LPS.includes(a)) return [a];
-  return [];
-}
-
-// aufwandMatrixWert: Rollenwert eines Projekts für eine Leistungsphase
-// (Gewichtungsfaktor, 0,0–1,0). Liefert null, wenn keine (rollenspezifische) Matrix
-// bzw. kein Wert für diese Phase/Rolle hinterlegt ist. 0 ist ein gültiger Wert.
-function aufwandMatrixWert(projekt, lp, rolle){
-  const m = projekt && projekt.aufwandProLP;
-  const entry = (m && typeof m === 'object') ? m[lp] : undefined;
-  if(!entry || typeof entry !== 'object' || Array.isArray(entry)) return null;
-  const v = parseFloat(entry[rolle]);
-  return isNaN(v) ? null : v;
-}
-
-// berechneAuslastung: zentrale Auslastungsberechnung einer Zuordnung
-// (Person/Rolle) zu einem Projekt für die amtierende Leistungsphase.
-// Ohne gesetzte aktive LP zählt das Projekt 0 (nicht eingerechnet).
-// Mit aktiver LP: Liegt aufwandProLP[aktuelleLP][rolle] vor, zählt dieser
-// Faktor 1:1 – die Zuordnungsart (Haupt/Optional) skaliert bewusst nicht mehr.
-// Fehlt der Matrix-Wert, gilt der Standard-Faktor 1,0.
-// "In Anbahnung" wird nicht eingerechnet.
-function berechneAuslastung(mitarbeiter, projekt, aktuelleLP, rolle, status){
-  if(!projekt || projekt.group === 'In Anbahnung') return { load: 0, anbahnung: true };
-  if(!aktuelleLP) return { load: 0 };
-  const wert = aufwandMatrixWert(projekt, aktuelleLP, rolle);
-  if(wert !== null) return { load: wert };
-  return { load: 1.0 };
-}
-
-// faktorFormat: formatiert einen Auslastungs-Faktor in deutscher Notation
-// (Komma, max. 2 Nachkommastellen), z. B. 1.1 → "1,10". 1,0 = 100 % Kapazität.
-function faktorFormat(x){
-  const n = Math.round((x || 0) * 100) / 100;
-  return n.toFixed(2).replace('.', ',');
-}
-
-// loadAmpelColor: Ampel-Farbe relativ zum Maximalwert (gelb ab 50 %,
-// rot ab 75 % von LOAD_BAR_MAX; PLATZHALTER).
-function loadAmpelColor(x){
-  return x >= LOAD_BAR_MAX * THRESHOLD_RATIO_CRITICAL ? '#c53030' : x >= LOAD_BAR_MAX * THRESHOLD_RATIO_ELEVATED ? '#d69e2e' : '#2f855a';
-}
-function pdfLoadAmpelColor(x){
-  return x >= LOAD_BAR_MAX * THRESHOLD_RATIO_CRITICAL ? '#D70015' : x >= LOAD_BAR_MAX * THRESHOLD_RATIO_ELEVATED ? '#B25000' : '#248A3D';
-}
-
-// ---------- LP-Aufwand Eingabemaske ----------
-
-let lpModalProjectId = null;
-
-// lpRowsHtml: erzeugt die Aufwand-Maske als Matrix-Tabelle.
-// Zeilen = Leistungsphasen (LPH 1–8), Spalten = Rollen (Planung/Projektleitung/
-// Bauüberwachung). Die amtierende Leistungsphase wird pro Projekt im Tab
-// "Projekte" gewählt (renderProjects / editProjectActiveLP).
-// prefix: 'lp' = Bearbeiten-Modal, 'np' = Neues-Projekt-Modal (eindeutige IDs).
-// Leere Felder werden mit den Standardwerten aus LP_AUFWAND_VORLAGE vorbefüllt.
-// Die Feld-IDs bleiben identisch, damit collectLpRows() unverändert funkioniert.
-function lpRowsHtml(p, prefix){
-  const head = ROLES.map(r => `<th>${esc(r)}</th>`).join('');
-  const rows = AUFWAND_LPS.map(l => {
-    const idx = l.replace(/[^\d]/g,'');
-    const row = (p.aufwandProLP && typeof p.aufwandProLP[l] === 'object') ? p.aufwandProLP[l] : {};
-    const cells = ROLES.map((r, ri) => {
-      const raw = row[r];
-      const vorlage = LP_AUFWAND_VORLAGE && LP_AUFWAND_VORLAGE[l] ? LP_AUFWAND_VORLAGE[l][r] : undefined;
-      const base = (raw !== undefined && raw !== null && raw !== '') ? raw
-                : (vorlage !== undefined && vorlage !== null && vorlage !== '') ? vorlage : '';
-      const val = base !== '' ? String(parseFloat(base)).replace('.', ',') : '';
-      return `<td><input type="text" inputmode="decimal" id="${prefix}Val${idx}R${ri}" value="${val}" placeholder="1,0"></td>`;
-    }).join('');
-    return `<tr><th class="lp-lph">${l}</th>${cells}</tr>`;
-  }).join('');
-  return `<table class="lp-matrix">
-    <thead><tr><th class="lp-lph">Leistungsphase</th>${head}</tr></thead>
-    <tbody>${rows}</tbody>
-  </table>`;
-}
-
-// collectLpRows: liest die Aufwand-Maske aus und validiert die Werte (0–1).
-// Rückgabe: { aufwand, hasValue } oder null bei Eingabefehler.
-function collectLpRows(prefix){
-  const aufwand = {};
-  let hasValue = false;
-  for(const l of AUFWAND_LPS){
-    const idx = l.replace(/[^\d]/g,'');
-    const entry = {};
-    let rowHasValue = false;
-    let invalid = false;
-    for(let ri = 0; ri < ROLES.length; ri++){
-      const r = ROLES[ri];
-      const input = document.getElementById(prefix + 'Val' + idx + 'R' + ri);
-      if(!input) continue;
-      const raw = input.value.trim().replace(',', '.');
-      if(raw === '') continue;
-      const v = parseFloat(raw);
-      if(isNaN(v) || v < 0 || v > 1){
-        alert('Bitte Werte zwischen 0 und 1 eintragen (z. B. 0,4) – oder das Feld leer lassen. (' + l + ', ' + r + ')');
-        invalid = true;
-        break;
-      }
-      entry[r] = v;
-      rowHasValue = true;
-    }
-    if(invalid) return null;
-    if(rowHasValue){ aufwand[l] = entry; hasValue = true; }
-  }
-  return { aufwand, hasValue };
-}
-
-// applyLpRows: übernimmt das Ergebnis von collectLpRows auf ein Projekt.
-// Die Maske ist mit den Standardwerten (LP_AUFWAND_VORLAGE) vorbefüllt;
-// Felder ohne Vorbefüllung, die leer bleiben, zählen bei gesetzter aktiver LP
-// später als Standard-Faktor 1,0; ohne aktive LP zählt das Projekt 0.
-// Die amtierende Leistungsphase wird separat über den Tab "Projekte" gesetzt.
-function applyLpRows(p, lp){
-  if(!lp) return false;
-  p.aufwandProLP = lp.hasValue ? lp.aufwand : undefined;
-  return true;
-}
-
-function openLpModal(pid){
-  if(guardWeekLocked()) return;
-  const p = currentWeek().projects.find(x=>x.id===pid);
-  if(!p) return;
-  lpModalProjectId = pid;
-  const titleEl = document.getElementById('lpModalProject');
-  if(titleEl) titleEl.textContent = (p.nr ? p.nr + ' – ' : '') + (p.name || '');
-  const rowsEl = document.getElementById('lpModalRows');
-  if(rowsEl) rowsEl.innerHTML = lpRowsHtml(p, 'lp');
-  document.getElementById('lpModal').style.display = 'flex';
-}
-
-function closeLpModal(){
-  document.getElementById('lpModal').style.display = 'none';
-  lpModalProjectId = null;
-}
-
-function saveLpModal(){
-  if(guardWeekLocked()) return;
-  const p = currentWeek().projects.find(x=>x.id===lpModalProjectId);
-  if(!p) return;
-  const lp = collectLpRows('lp');
-  if(lp === null) return;
-  if(applyLpRows(p, lp)) save();
-  renderBoard(); renderProjects(); renderLoad();
-  closeLpModal();
-}
-
-// ---------- Neues Projekt (mit LP-Aufwand beim Anlegen) ----------
-
-function openNewProjModal(){
-  if(guardWeekLocked()) return;
-  document.getElementById('newProjNr').value = '';
-  document.getElementById('newProjName').value = '';
-  document.getElementById('newProjGroup').value = 'Aktive Projekte';
-  const lpSel = document.getElementById('newProjActiveLP');
-  if(lpSel){
-    lpSel.innerHTML = '<option value="">Keine</option>' + AUFWAND_LPS.map(l => `<option value="${l}">${l}</option>`).join('');
-    lpSel.value = '';
-  }
-  const rowsEl = document.getElementById('newProjLpRows');
-  if(rowsEl) rowsEl.innerHTML = lpRowsHtml({ aufwandProLP: {}, aktuelleLP: [] }, 'np');
-  document.getElementById('newProjModal').style.display = 'flex';
-}
-
-function closeNewProjModal(){
-  document.getElementById('newProjModal').style.display = 'none';
-}
-
-function saveNewProj(){
-  if(guardWeekLocked()) return;
-  const nr = document.getElementById('newProjNr').value.trim();
-  const name = document.getElementById('newProjName').value.trim();
-  if(!name){ alert("Bitte Projektbezeichnung eingeben."); return; }
-  const group = document.getElementById('newProjGroup').value;
-  const activeLP = document.getElementById('newProjActiveLP').value;
-  const lp = collectLpRows('np');
-  if(lp === null) return;
-  const w = currentWeek();
-  const nextOrder = w.projects
-    .filter(p=>p.group===group)
-    .reduce((max,p)=> Math.max(max, p.order!==undefined ? p.order : 0), -1) + 1;
-  const pr = {id:uid(),nr,name,group,status:'',lph:{},assign:{}, statusState: undefined, order: nextOrder, plan: null};
-  if(activeLP) pr.aktuelleLP = [activeLP];
-  applyLpRows(pr, lp);
-  w.projects.push(pr);
-  save(); renderProjects(); renderBoard();
-  closeNewProjModal();
-}
-
-// LOAD_BAR_MAX: Maximalwert der Balken-Skala im Auslastungs-Tab (und im
-// PDF-Export). 1,0 = 100 % Kapazität; Werte > 1,0 = Überlastung (rot).
-const LOAD_BAR_MAX = 8;
-
-// renderLoad: berechnet die Belastung der Personen auf Basis des
-// rollenspezifischen LP-Gewichtungsfaktors je amtierender Phase (0,0–1,0,
-// Standard 1,0). Leere Matrix-Werte zählen bei gesetzter aktiver LP als 1,0;
-// ohne gesetzte aktive LP zählt das Projekt 0 (nicht eingerechnet).
-// Ampel: Schwellen relativ zum Maximalwert LOAD_BAR_MAX
-// (gelb ab 50 %, rot ab 75 % – PLATZHALTER).
-// Balken: Skala auf das feste Maximum LOAD_BAR_MAX (Standard 8).
-function renderLoad(){
-  const scope = document.getElementById('loadScope').value;
-  const barMax = LOAD_BAR_MAX;
-  const selectedWeek = currentWeek();
-  const weeks = scope==='all' ? db.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 stats = {};
-  ROLES.forEach(r=>{
-    grouped[r].forEach(entry=>{
-      stats[assignKey(entry.person.id, r)] = {load:0,projects:{},anbahnung:0};
-    });
-  });
-
-  weeks.forEach(w=>{
-    w.projects.forEach(pr=>{
-      const aktivePhase = lpActiveList(pr)[0];
-      Object.keys(pr.assign).forEach(aKey=>{
-        const s = stats[aKey];
-        if(!s) return;
-        const st = pr.assign[aKey];
-        const rolle = aKey.slice(aKey.indexOf('|') + 1);
-        const al = berechneAuslastung(null, pr, aktivePhase, rolle, st);
-        if(al.anbahnung){
-          if(st===1 || st===2) s.anbahnung++;
-          return;
-        }
-        if(al.load > 0){
-          s.load += al.load;
-          s.projects[pr.name] = (s.projects[pr.name]||0)+1;
-        }
-      });
-    });
-  });
-
-  // Hochgerechnete Auslastung: durchschnittliche Wochenlast als Faktor
-  // der Kapazität (1,0 = 100 %). Werte > 1,0 = Überlastung.
-  const nWeeks = Math.max(1, weeks.length);
-  const weekAvg = k => stats[k].load / nWeeks;
-  let html="";
-  ROLES.forEach(r=>{
-    html += `<div class="load-row"><div class="load-row-title">${r}</div>`;
-    if(grouped[r].length===0){
-      html += `<div class="hint">Keine Personen.</div>`;
-    }
-    grouped[r].forEach(entry=>{
-      const s = stats[assignKey(entry.person.id, r)];
-      const avg = weekAvg(assignKey(entry.person.id, r));
-      // Balken relativ zur einstellbaren Skala (Standard 8); Überlastung > 1,0
-      // bleibt über die Ampel-Farbe sichtbar, der Zahlenwert bleibt ungedeckelt.
-      const pct = Math.min(100, Math.round(avg / barMax * 100));
-      const detail = Object.keys(s.projects).map(k=>`<div><span>${esc(k)}</span><b>${s.projects[k]}×</b></div>`).join('') || '<div class="hint">keine Zuordnung</div>';
-      const anbahnungBadge = (s.anbahnung && s.anbahnung>0) ? `<span style="font-size:11px;color:#3182ce;font-weight:normal;margin-left:0px">(${s.anbahnung} in Anbahnung)</span>` : '';
-      html += `<div class="load-card">
-        <h3>${esc(entry.person.fullName)} <span style="font-size:11px;color:#888;font-weight:normal">(${r})</span></h3>
-        <h3>${anbahnungBadge}</h3>
-        <div class="load-num">${faktorFormat(avg)}</div>
-        <div class="bar" style="height:10px;margin-top:6px" title="Skala: 0 – ${faktorFormat(barMax)}"><div style="width:${pct}%;background:${loadAmpelColor(avg)}"></div></div>
-        <div class="load-detail">${detail}</div>
-      </div>`;
-    });
-    html += `</div>`;
-  });
-  document.getElementById('loadGrid').innerHTML=html;
-}
-
-// ---------- GANTT / Projektplan ----------
-
-let ganttModalProjectId = null;
-
-function ensurePlan(p){
-  if(!p.plan) p.plan = { start:'', end:'', todos:[], milestones:[], people:[], progress:0 };
-  // Alte Meilensteine bleiben erhalten; neu sind todos die primären Planungselemente.
-  if(!Array.isArray(p.plan.todos)) p.plan.todos = [];
-  if(!Array.isArray(p.plan.milestones)) p.plan.milestones = [];
-  return p.plan;
-}
-
-// Beteiligte eines Projekts aus dem Board ableiten (Haupt + Optional)
-// week optional: wenn die Funktion nicht im Kontext der aktuellen Hauptseite
-// aufgerufen wird (z.B. Projektplan-Seite), muss die passende Woche übergeben
-// werden, damit die Personenliste korrekt aufgelöst wird.
-function projectAssignees(p, week = null){
-  const w = week || currentWeek();
-  const people = w ? (w.people || []) : [];
-  const globalList = db.globalPeople[currentDepartment] || [];
-  const result = [];
-  people.forEach(person => {
-    const globalPerson = globalList.find(gp => gp.id === person.id);
-    const email = globalPerson ? globalPerson.email : '';
-
-    (person.role || ['Planung']).forEach(role => {
-      const key = assignKey(person.id, role);
-      if(p.assign && p.assign[key]){
-        result.push({ person, role, state: p.assign[key], email});
-      }
-    });
-  });
-  return result;
-}
-
-function projectColor(p){
-  const idx = Math.abs(String(p.id).split('').reduce((a,c)=>a+c.charCodeAt(0),0)) % GANTT_COLORS.length;
-  return GANTT_COLORS[idx];
-}
-
-function ganttRangeFromProjects(projects, padDays = 7){
-  let min = null, max = null;
-  projects.forEach(p => {
-    const plan = p.plan;
-    if(!plan) return;
-    [plan.start, plan.end].forEach(d => {
-      const date = parseDateISO(d);
-      if(!date) return;
-      if(!min || date < min) min = date;
-      if(!max || date > max) max = date;
-    });
-    (plan.milestones || []).forEach(m => {
-      const date = parseDateISO(m.date);
-      if(!date) return;
-      if(!min || date < min) min = date;
-      if(!max || date > max) max = date;
-    });
-    (plan.todos || []).forEach(t => {
-      [t.start, t.end].forEach(d => {
-        const date = parseDateISO(d);
-        if(!date) return;
-        if(!min || date < min) min = date;
-        if(!max || date > max) max = date;
-      });
-    });
-  });
-  // Urlaub berücksichtigen
-  (db.globalPeople[currentDepartment] || []).forEach(person => {
-    (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; }
-      if(e){ if(!min || e < min) min = e; if(!max || e > max) max = e; }
-    });
-  });
-  if(!min || !max){
-    const today = new Date();
-    min = new Date(today.getFullYear(), today.getMonth(), 1);
-    max = addDays(min, 90);
-  }
-  return { start: addDays(min, -padDays), end: addDays(max, padDays) };
-}
-
-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();
-}
-
-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) });
-}
-
-function buildGanttHtml(projects, start, end, options = {}){
-  const { showVacation = true, editable = false, highlightProjectId = null, pxPerDay = null } = options;
-  const totalDays = Math.max(1, daysBetween(start, end) + 1);
-
-  function timeline(content){
-    return `<div class="gantt-timeline">${content}</div>`;
-  }
-
-  function dragAttrs(type, attrs){
-    if(!editable) return '';
-    let s = ` data-gantt-type="${type}" draggable="false"`;
-    for(const [k,v] of Object.entries(attrs)){
-      s += ` data-gantt-${k}="${esc(String(v))}"`;
-    }
-    return s;
-  }
-
-  function resizeHandles(){
-    if(!editable) return '';
-    return `<span class="gantt-resize gantt-resize-left" data-resize="left"></span><span class="gantt-resize gantt-resize-right" data-resize="right"></span>`;
-  }
-
-  // Kopfzeile: Monate und Tage
-  let headerMonths = '<div class="gantt-row gantt-header">';
-  headerMonths += '<div class="gantt-label">Projekt</div>';
-  let monthsHtml = '';
-  let current = new Date(start.getTime());
-  let lastMonth = -1;
-  let monthCells = [];
-  for(let i = 0; i < totalDays; i++){
-    if(current.getMonth() !== lastMonth){
-      monthCells.push({ month: current.getMonth(), year: current.getFullYear(), startIdx: i });
-      lastMonth = current.getMonth();
-    }
-    current = addDays(current, 1);
-  }
-  monthCells.forEach((m, idx) => {
-    const next = monthCells[idx + 1];
-    const span = next ? next.startIdx - m.startIdx : totalDays - m.startIdx;
-    const names = ['Jan','Feb','Mär','Apr','Mai','Jun','Jul','Aug','Sep','Okt','Nov','Dez'];
-    monthsHtml += `<div class="gantt-month" style="left:${(m.startIdx/totalDays*100).toFixed(4)}%;width:${(span/totalDays*100).toFixed(4)}%">${names[m.month]} ${m.year}</div>`;
-  });
-  headerMonths += timeline(monthsHtml) + '</div>';
-
-  let headerWeeks = '<div class="gantt-row gantt-days">';
-  headerWeeks += '<div class="gantt-label"></div>';
-  let weeksHtml = '';
-  current = new Date(start.getTime());
-  let lastWeek = -1;
-  let lastYear = -1;
-  let weekStartIdx = 0;
-  const weekCells = [];
-  for(let i = 0; i < totalDays; i++){
-    const cw = getWeekNumber(current);
-    const cy = current.getFullYear();
-    if(cw !== lastWeek || cy !== lastYear){
-      if(lastWeek !== -1){
-        weekCells.push({ week: lastWeek, year: lastYear, startIdx: weekStartIdx, endIdx: i - 1 });
-      }
-      weekStartIdx = i;
-      lastWeek = cw;
-      lastYear = cy;
-    }
-    current = addDays(current, 1);
-  }
-  if(lastWeek !== -1){
-    weekCells.push({ week: lastWeek, year: lastYear, startIdx: weekStartIdx, endIdx: totalDays - 1 });
-  }
-  weekCells.forEach(w => {
-    const span = w.endIdx - w.startIdx + 1;
-    weeksHtml += `<div class="gantt-day gantt-week" style="left:${(w.startIdx/totalDays*100).toFixed(4)}%;width:${(span/totalDays*100).toFixed(4)}%"><span>KW ${w.week}</span></div>`;
-  });
-  headerWeeks += timeline(weeksHtml) + '</div>';
-
-  // Raster-Overlay: Wochenenden schattieren und Heute-Linie markieren.
-  // Liegt als eine Ebene hinter allen Zeilen (erste Chart-Kindnode),
-  // damit nicht jede Zeile eigene Tageszellen braucht.
-  let gridHtml = '<div class="gantt-grid-overlay">';
-  current = new Date(start.getTime());
-  let weekendStartIdx = null;
-  for(let i = 0; i <= totalDays; i++){
-    const isWeekend = i < totalDays && (current.getDay() === 0 || current.getDay() === 6);
-    if(isWeekend && weekendStartIdx === null) weekendStartIdx = i;
-    if(!isWeekend && weekendStartIdx !== null){
-      const span = i - weekendStartIdx;
-      gridHtml += `<div class="gantt-grid-weekend" style="left:${(weekendStartIdx/totalDays*100).toFixed(4)}%;width:${(span/totalDays*100).toFixed(4)}%"></div>`;
-      weekendStartIdx = null;
-    }
-    current = addDays(current, 1);
-  }
-  const today = new Date();
-  const todayMid = new Date(today.getFullYear(), today.getMonth(), today.getDate());
-  if(todayMid >= start && todayMid <= end){
-    const todayIdx = daysBetween(start, todayMid);
-    gridHtml += `<div class="gantt-grid-today" style="left:${((todayIdx + 0.5)/totalDays*100).toFixed(4)}%" title="Heute: ${formatDateDE(todayMid)}"></div>`;
-  }
-  gridHtml += '</div>';
-
-  let body = gridHtml + headerMonths + headerWeeks;
-
-  // Urlaubszeilen
-  if(showVacation){
-    let allPeople = db.globalPeople[currentDepartment] || [];
-    // Optional: nur Urlaub bestimmter Personen anzeigen
-    if(options.vacationPeople && Array.isArray(options.vacationPeople)){
-      const allowed = new Set(options.vacationPeople);
-      allPeople = allPeople.filter(person => allowed.has(person.id));
-    }
-    // Pro Person eine Zeile: alle Abwesenheiten als Balken in derselben Timeline
-    allPeople.forEach(person => {
-      let barsHtml = '';
-      (person.absences || []).forEach(a => {
-        const s = parseDateISO(a.start), e = parseDateISO(a.end);
-        if(!s || !e || e < start || s > end) return;
-        const rowStart = s < start ? start : s;
-        const rowEnd = e > end ? end : e;
-        const offset = daysBetween(start, rowStart);
-        const span = daysBetween(rowStart, rowEnd) + 1;
-        barsHtml += `<div class="gantt-bar vacation"${dragAttrs('vacation',{person: person.id, absence: a.id, start: formatDateISO(s), end: formatDateISO(e)})} style="left:${(offset/totalDays*100).toFixed(4)}%;width:${(span/totalDays*100).toFixed(4)}%" title="${esc(a.type || 'Abwesenheit')}: ${formatDateDE(s)}–${formatDateDE(e)}${a.note ? ' – ' + esc(a.note) : ''}">${resizeHandles()}</div>`;
-      });
-      if(!barsHtml) return; // keine Abwesenheit im sichtbaren Zeitraum -> keine Zeile
-      body += `<div class="gantt-row gantt-vacation">`;
-      body += `<div class="gantt-label" title="${esc(person.fullName || person.name)}"><span class="gantt-vacation-dot"></span> ${esc(person.name)}</div>`;
-      body += timeline(barsHtml);
-      body += `</div>`;
-    });
-  }
-
-  // Projektzeilen
-  projects.slice().sort((a,b) => (a.order||0)-(b.order||0)).forEach(p => {
-    const plan = p.plan;
-    const color = projectColor(p);
-    const milestones = plan && Array.isArray(plan.milestones) ? plan.milestones : [];
-    body += `<div class="gantt-row gantt-project${highlightProjectId === p.id ? ' highlighted' : ''}">`;
-    body += `<div class="gantt-label">${esc(p.nr ? p.nr + ' ' : '')}${esc(p.name)}</div>`;
-
-    let rowContent = '';
-
-    // Projekt-Balken
-    const s = plan ? parseDateISO(plan.start) : null, e = plan ? parseDateISO(plan.end) : null;
-    if(s && e){
-      const barStart = s < start ? start : s;
-      const barEnd = e > end ? end : e;
-      if(barEnd >= start && barStart <= end){
-        const offset = daysBetween(start, barStart);
-        const span = daysBetween(barStart, barEnd) + 1;
-        const progress = Math.max(0, Math.min(100, plan && parseFloat(plan.progress) ? parseFloat(plan.progress) : 0));
-        rowContent += `<div class="gantt-bar project"${dragAttrs('project',{project: p.id, start: formatDateISO(s), end: formatDateISO(e)})} style="left:${(offset/totalDays*100).toFixed(4)}%;width:${(span/totalDays*100).toFixed(4)}%;background:${color}">`;
-        rowContent += `${resizeHandles()}<div class="gantt-progress" style="width:${progress}%"></div>`;
-        rowContent += `<span class="gantt-bar-label">${esc(p.name)}</span>`;
-        rowContent += `</div>`;
-      }
-    }
-
-    // Meilensteine: nur die nicht positionierten (keine position) in der Projektzeile anzeigen.
-    // Positionierte Meilensteine werden vom Aufrufer (z.B. Projektplan) als separate Zeilen eingefügt.
-    milestones.forEach((m, mIdx) => {
-      if(options.showTodos && m.position) return;
-      const d = parseDateISO(m.date);
-      if(!d || d < start || d > end) return;
-      const offset = daysBetween(start, d);
-      rowContent += `<div class="gantt-milestone"${dragAttrs('milestone',{project: p.id, index: mIdx, date: formatDateISO(d)})} style="left:${(offset/totalDays*100).toFixed(4)}%" title="${esc(m.name)}: ${formatDateDE(d)}"></div>`;
-      rowContent += `<div class="gantt-milestone-label" style="left:${(offset/totalDays*100).toFixed(4)}%">${esc(m.name || '')}</div>`;
-    });
-
-    body += timeline(rowContent) + `</div>`;
-  });
-
-  // pxPerDay setzt eine feste Breite pro Tag, damit das Diagramm bei hohem
-  // Zoom breiter als der Container wird und horizontal gescrollt werden kann.
-  let chartStyle = '';
-  if(pxPerDay){
-    chartStyle = ` style="min-width:${(220 + Math.ceil(totalDays * pxPerDay)).toFixed(0)}px"`;
-  }
-  return `<div class="gantt-chart"${chartStyle}>${body}</div>`;
-}
-
-// ---------- Projektplan-Seite (TODOs + GANTT) ----------
-
-function openProjectPlan(pid){
-  const w = currentWeek(); if(!w) return;
-  const p = w.projects.find(x => x.id === pid); if(!p) return;
-  // IDs sind nicht persistent (werden bei jedem CSV-Laden neu erzeugt).
-  // Daher werden stabile Werte (Label, Projekt-Nr., Name) in der URL übergeben.
-  const url = new URL('project-plan.html', window.location.href);
-  url.searchParams.set('department', currentDepartment);
-  url.searchParams.set('weekLabel', w.label);
-  url.searchParams.set('projNr', p.nr || '');
-  url.searchParams.set('projName', p.name || '');
-  window.open(url.toString(), '_blank');
-}
-
-// Diese Funktion wird von project-plan.html aufgerufen, um das aktuelle
-// Wochen-/Projekt-Objekt im Hauptfenster zu finden.
-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) };
-}
-
-// ---------- Urlaub / Abwesenheiten ----------
-
-function addAbsence(personId){
-  if(guardWeekLocked()) return;
-  const people = db.globalPeople[currentDepartment] || [];
-  const person = 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();
-  renderPeople();
-  if(currentTab === 'gantt') renderGantt();
-}
-
-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();
-  renderPeople();
-  if(currentTab === 'gantt') renderGantt();
-}
-
-// ---------- Tabs (Navigation) ----------
-
-// 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;
-  }
-  currentTab = t;
-  saveUiState();
-
-  ['board','projects','load','people'].forEach(x=>{
-    const el = document.getElementById(x);
-    if(el) el.style.display=(x===t?'block':'none');
-  });
-  document.querySelectorAll('.tab').forEach(el=>el.classList.toggle('active',el.dataset.tab===t));
-  if(t==='board' && currentWeek())   renderBoard();
-  if(t==='projects') renderProjects();
-  if(t==='load')    renderLoad();
-  if(t==='people')  renderPeople();
-}
-
-// ---------- 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){
-    const action = requestedAction;
-    requestedAction = null;
-    document.getElementById('passwordModal').style.display='none';
-    setTimeout(() => {
-      if(action?.type==='tab') showTab(action.tab, true);
-      else if(action?.type==='deleteWeek') deleteWeek(true);
-      else if(action?.type==='unlockWeek') unlockCurrentWeek(true);
-    }, 100);
-  } else {
-    alert("Falsches Passwort!");
-    document.getElementById('passwordInput').value='';
-    document.getElementById('passwordInput').focus();
-  }
-}
-function closePasswordModal(){
-  document.getElementById('passwordModal').style.display='none';
-  requestedAction = null;
-}
-
-
-// ---------- Export PDF (pdfmake) ----------
-// Erzeugt ein Vektor-PDF: Deckblatt, Projektübersicht nach Gruppen,
-// Anwesenheit und Auslastung. Format durchgehend A4 quer.
-// Ersetzt die frühere jsPDF/html2canvas-Rasterlösung.
-
-const PDF_ROLE_BG = {
-  'Planung':        '#D4F5E0',
-  'Projektleitung': '#FFDBDB',
-  'Bauüberwachung': '#CBEEFF'
-};
-const PDF_NEUTRAL_BG  = '#F0F0F2';
-const PDF_ALT_ROW_BG  = '#FAFAFC';
-const PDF_BORDER      = '#a6a6ad';
-const PDF_ASSIGN_MAIN = '#248A3D';
-const PDF_ASSIGN_OPT  = '#D18B00';
-
-
-// --- Seitengeometrie (A3 quer, in pt) ---
-const PDF_PAGE_W   = 1190.55;                              // A3 quer, vorher A4: 841.89
-const PDF_MARGIN_X = 20;
-const PDF_PAD_X    = 2;
-const PDF_LINE_W   = 0.8;
-const PDF_USABLE_W = PDF_PAGE_W - PDF_MARGIN_X * 2;        // 1150,55
-
-
-const PDF_STYLES = {
-  h1:       { fontSize: 20, bold: true,  color: '#1D1D1F' },
-  h2:       { fontSize: 10, bold: true,  color: '#1D1D1F' },
-  th:       { fontSize: 7,  bold: true,  color: '#1D1D1F', fillColor: PDF_NEUTRAL_BG },
-  thSub:    { fontSize: 6.5, bold: true, color: '#1D1D1F' },
-  td:       { fontSize: 7,  color: '#1D1D1F' },
-  tdCenter: { fontSize: 7,  color: '#1D1D1F', alignment: 'center' }
-};
-
-function pdfRoleBg(role, fallback){
-  return PDF_ROLE_BG[role] || fallback || '#FFFFFF';
-}
-
-function pdfTableLayout(){
-  return {
-    hLineWidth: () => PDF_LINE_W,
-    vLineWidth: () => PDF_LINE_W,
-    hLineColor: () => PDF_BORDER,
-    vLineColor: () => PDF_BORDER,
-    paddingLeft:   () => PDF_PAD_X,
-    paddingRight:  () => PDF_PAD_X,
-    paddingTop:    () => 2,
-    paddingBottom: () => 2
-  };
-}
-
-// pdfStatusText: wandelt das Status-HTML in eine pdfmake-Textstruktur um.
-// Erhält Zeilenumbrüche (<br>, Block-Ende von <p>/<div>) sowie die vom
-// Sanitizing erlaubten Auszeichnungen (bold, italic, underline, color).
-// Rückgabe: Objekt mit text-Array, direkt als Zellinhalt verwendbar.
-function pdfStatusText(htmlStatus){
-  if(!htmlStatus) return { text: '', style: 'td' };
-
-  const root = document.createElement('div');
-  root.innerHTML = htmlStatus;
-
-  const parts = [];
-
-  // pushNewline: fügt einen Umbruch ein, vermeidet aber führende
-  // und doppelte Leerzeilen.
-  function pushNewline(){
-    if(parts.length === 0) return;
-    const last = parts[parts.length - 1];
-    if(typeof last.text === 'string' && last.text.endsWith('\n')) return;
-    parts.push({ text: '\n' });
-  }
-
-  const BLOCK = new Set(['P', 'DIV']);
-
-  function walk(node, inh){
-    for(const child of node.childNodes){
-
-      // Textknoten
-      if(child.nodeType === 3){
-        // Nur Zeichen normalisieren, die im HTML keine Bedeutung haben.
-        // Echte Umbrüche kommen ausschliesslich aus BR/Blockenden.
-        const t = child.nodeValue
-          .replace(/\u00A0/g, ' ')
-          .replace(/[\r\n\t]+/g, ' ');
-        if(t === '') continue;
-        // Reine Whitespace-Knoten zwischen Blöcken überspringen
-        if(/^\s+$/.test(t) && (parts.length === 0
-            || (typeof parts[parts.length-1].text === 'string'
-                && parts[parts.length-1].text.endsWith('\n')))) continue;
-        parts.push(Object.assign({ text: t }, inh));
-        continue;
-      }
-
-      if(child.nodeType !== 1) continue;
-
-      const tag = child.tagName.toUpperCase();
-
-      if(tag === 'BR'){
-        parts.push({ text: '\n' });
-        continue;
-      }
-
-      // Auszeichnungen vererben
-      const own = Object.assign({}, inh);
-      if(tag === 'B' || tag === 'STRONG') own.bold = true;
-      if(tag === 'I' || tag === 'EM')     own.italics = true;
-      if(tag === 'U')                     own.decoration = 'underline';
-
-      // Farbe / Fettung aus style bzw. font color
-      const st = child.getAttribute && child.getAttribute('style');
-      if(st){
-        const mCol = st.match(/(?:^|;)\s*color\s*:\s*([^;]+)/i);
-        if(mCol){
-          const c = pdfNormalizeColor(mCol[1].trim());
-          if(c) own.color = c;
-        }
-        const mFw = st.match(/(?:^|;)\s*font-weight\s*:\s*([^;]+)/i);
-        if(mFw){
-          const v = mFw[1].trim().toLowerCase();
-          if(v === 'bold' || v === 'bolder' || parseInt(v, 10) >= 600) own.bold = true;
-          if(v === 'normal' || parseInt(v, 10) < 600) own.bold = false;
-        }
-      }
-      if(tag === 'FONT' && child.getAttribute('color')){
-        const c = pdfNormalizeColor(child.getAttribute('color'));
-        if(c) own.color = c;
-      }
-
-      if(BLOCK.has(tag)){
-        pushNewline();
-        walk(child, own);
-        pushNewline();
-      } else {
-        walk(child, own);
-      }
-    }
-  }
-
-  walk(root, {});
-
-  // Führende und schliessende Umbrüche entfernen
-  while(parts.length && parts[0].text === '\n') parts.shift();
-  while(parts.length && parts[parts.length-1].text === '\n') parts.pop();
-
-  if(parts.length === 0) return { text: '', style: 'td' };
-  return { text: parts, style: 'td' };
-}
-
-// pdfNormalizeColor: pdfmake akzeptiert Hex und benannte Farben,
-// aber kein rgb(). Wandelt rgb()/rgba() in Hex um.
-function pdfNormalizeColor(v){
-  if(!v) return null;
-  v = String(v).trim();
-  const m = v.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/i);
-  if(m){
-    const hex = n => Math.max(0, Math.min(255, parseInt(n,10)))
-      .toString(16).padStart(2,'0');
-    return '#' + hex(m[1]) + hex(m[2]) + hex(m[3]);
-  }
-  if(/^#[0-9a-f]{3}$/i.test(v)){
-    return '#' + v[1]+v[1] + v[2]+v[2] + v[3]+v[3];
-  }
-  if(/^#[0-9a-f]{6}$/i.test(v)) return v;
-  // Benannte Farben durchlassen (pdfmake kennt die CSS-Namen)
-  if(/^[a-z]+$/i.test(v)) return v.toLowerCase();
-  return null;
-}
-
-// loadLogoPng: lädt dein_bild.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');
-    if(!res.ok) return null;
-    const blob = await res.blob();
-    const url  = URL.createObjectURL(blob);
-    try {
-      const img = await new Promise((resolve, reject) => {
-        const i = new Image();
-        i.onload  = () => resolve(i);
-        i.onerror = () => reject(new Error('Icon nicht dekodierbar'));
-        i.src = url;
-      });
-      const cv = document.createElement('canvas');
-      cv.width = cv.height = size;
-      const ctx = cv.getContext('2d');
-      const scale = Math.min(size / img.width, size / img.height);
-      const dw = img.width * scale, dh = img.height * scale;
-      ctx.drawImage(img, (size - dw) / 2, (size - dh) / 2, dw, dh);
-      return cv.toDataURL('image/png');
-    } finally {
-      URL.revokeObjectURL(url);
-    }
-  } catch(e){
-    console.warn('Logo nicht ladbar:', e);
-    return null;
-  }
-}
-
-// pdfHeaderRows: die zwei Kopfzeilen der Projekttabelle als pdfmake-Zellenarrays.
-// Achtung: Nach colSpan:n folgen exakt n-1 leere {}; unter rowSpan-Zellen
-// steht in der Folgezeile ebenfalls {}. Verstöße brechen das Layout still.
-function pdfHeaderRows(grouped){
-  const h1 = [
-    { text: 'Pr.-Nr.',     rowSpan: 2, style: 'th' },
-    { text: 'Bezeichnung', rowSpan: 2, style: 'th' },
-    { text: 'Status',      rowSpan: 2, style: 'th' }
-  ];
-  const h2 = [ {}, {}, {} ];
-
-  ROLES.forEach(r => {
-    const list = grouped[r] || [];
-    const span = Math.max(1, list.length);
-    h1.push({ text: r, colSpan: span, style: 'th',
-              fillColor: pdfRoleBg(r, PDF_NEUTRAL_BG), alignment: 'center' });
-    for(let i = 1; i < span; i++) h1.push({});
-
-    if(list.length === 0){
-      h2.push({ text: '–', style: 'thSub', alignment: 'center',
-                fillColor: pdfRoleBg(r, PDF_ALT_ROW_BG) });
-    } else {
-      list.forEach(e => h2.push({
-        text: e.person.name, style: 'thSub', alignment: 'center',
-        fillColor: pdfRoleBg(r, PDF_ALT_ROW_BG)
-      }));
-    }
-  });
-
-  h1.push({ text: 'Leistungsphasen (%)', colSpan: LPHS.length,
-            style: 'th', alignment: 'center' });
-  for(let i = 1; i < LPHS.length; i++) h1.push({});
-  LPHS.forEach(l => h2.push({ text: String(l), style: 'thSub',
-                              alignment: 'center', fillColor: PDF_ALT_ROW_BG }));
-
-  return [h1, h2];
-}
-
-// pdfProjectRow: eine Projektzeile als pdfmake-Zellenarray.
-function pdfProjectRow(p, allPeople, alt){
-  const base = alt ? PDF_ALT_ROW_BG : null;
-  const row = [
-    { text: p.nr || '',   style: 'td', fillColor: base, noWrap: true },
-    { text: p.name || '', style: 'td', fillColor: base },
-    Object.assign(pdfStatusText(p.status), { fillColor: base })
-  ];
-
-  allPeople.forEach(entry => {
-    const s   = (p.assign || {})[assignKey(entry.person.id, entry.role)] || 0;
-    const txt = s === 1 ? 'X' : s === 2 ? '(X)' : '';
-    const bg  = s === 1 ? PDF_ASSIGN_MAIN
-              : s === 2 ? PDF_ASSIGN_OPT
-              : pdfRoleBg(entry.role, base || '#FFFFFF');
-    row.push({
-      text: txt, style: 'tdCenter', fillColor: bg,
-      color: (s === 1 || s === 2) ? '#FFFFFF' : '#1D1D1F',
-      bold: s === 1
-    });
-  });
-
-  LPHS.forEach(l => {
-    const raw = (p.lph && p.lph[l] !== undefined && p.lph[l] !== '')
-      ? String(p.lph[l]).replace(/%/g, '') : '';
-    row.push({ text: raw ? raw + '%' : '', style: 'tdCenter', fillColor: base });
-  });
-
-  return row;
-}
-
-// pdfGroupTitleRow: Gruppenüberschrift über die volle Tabellenbreite.
-function pdfGroupTitleRow(groupName, colCount){
-  const row = [{
-    text: groupName || '', colSpan: colCount, bold: true,
-    fillColor: PDF_NEUTRAL_BG, fontSize: 8, color: '#1D1D1F',
-    margin: [3, 3, 3, 3]
-  }];
-  for(let i = 1; i < colCount; i++) row.push({});
-  return row;
-}
-
-// pdfColumnWidths: verteilt die tatsächlich verfügbare Breite.
-// Berücksichtigt Padding und Linienstärke, die pdfmake ZUSÄTZLICH
-// zur angegebenen Spaltenbreite rechnet. Gibt ausschliesslich
-// numerische Breiten zurück - kein '*', damit nichts überläuft.
-function pdfColumnWidths(allPeople){
-  const nPeople = allPeople.length;
-  const nLph    = LPHS.length;
-  const nCols   = 3 + nPeople + nLph;
-
-  // Overhead, den pdfmake on top der Spaltenbreiten aufschlägt
-  const overhead = nCols * PDF_PAD_X * 2 + (nCols + 1) * PDF_LINE_W;
-  let budget = PDF_USABLE_W - overhead;
-
-  // Schmale Spalten: schrumpfen bei Bedarf, aber nicht unter Minimum
-  let wNr     = 40;
-  let wPerson = 15;
-  let wLph    = 19;
-
-  const fixed = () => wNr + nPeople * wPerson + nLph * wLph;
-
-  // Zielraum für Bezeichnung + Status
-  const TEXT_MIN = 150;
-
-  if(budget - fixed() < TEXT_MIN){
-    // 1. Personen- und LPH-Spalten stufenweise verschmälern
-    while(budget - fixed() < TEXT_MIN && (wPerson > 11 || wLph > 15)){
-      if(wLph    > 15) wLph--;
-      if(wPerson > 11) wPerson -= 0.5;
-    }
-    if(budget - fixed() < TEXT_MIN && wNr > 30) wNr = 30;
-  }
-
-  let textSpace = budget - fixed();
-  if(textSpace < 60){
-    console.warn('PDF: Zu viele Spalten für A4 quer. '
-      + 'Verbleibend für Bezeichnung/Status: ' + Math.round(textSpace) + ' pt.');
-    textSpace = 60;
-  }
-
-  // Bezeichnung erhält 60 %, Status 40 %
-  const wName   = Math.floor(textSpace * 0.40);
-  const wStatus = Math.floor(textSpace * 0.60);
-
-  return [wNr, wName, wStatus]
-    .concat(new Array(nPeople).fill(wPerson))
-    .concat(new Array(nLph).fill(wLph));
-}
-
-// pdfCheckWidth: prüft, ob die Tabelle in den Satzspiegel passt.
-function pdfCheckWidth(allPeople){
-  const widths   = pdfColumnWidths(allPeople);
-  const nCols    = widths.length;
-  const overhead = nCols * PDF_PAD_X * 2 + (nCols + 1) * PDF_LINE_W;
-  const total    = widths.reduce((a, b) => a + b, 0) + overhead;
-  if(total > PDF_USABLE_W + 0.5){
-    console.warn('PDF: Tabellenbreite ' + Math.round(total)
-      + ' pt > verfügbar ' + Math.round(PDF_USABLE_W) + ' pt.');
-    return false;
-  }
-  return true;
-}
-
-// pdfAttendanceBlock: Anwesenheitsübersicht.
-function pdfAttendanceBlock(w){
-  const att = w.attendance || {};
-  const fmt = p => p.name + ' (' + (p.fullName || p.name) + ')';
-  const present = (w.people || []).filter(p =>  att[p.id]).map(fmt).join(', ');
-  const absent  = (w.people || []).filter(p => !att[p.id]).map(fmt).join(', ');
-  return [
-    { text: 'Anwesenheit', style: 'h2', margin: [0, 0, 0, 6] },
-    { text: [{ text: 'Anwesend: ', bold: true }, present || '—'],
-      fontSize: 9, margin: [0, 0, 0, 3] },
-    { text: [{ text: 'Abwesend: ', bold: true }, absent || '—'], fontSize: 9 }
-  ];
-}
-
-// pdfLoadSection: Auslastungsübersicht inkl. Balken (als Canvas-Rechtecke).
-function pdfLoadSection(w, grouped){
-  const stats = {};
-  ROLES.forEach(r => (grouped[r] || []).forEach(e => {
-    stats[assignKey(e.person.id, r)] = { load:0, anbahnung:0, projects:{} };
-  }));
-
-  (w.projects || []).forEach(pr => {
-    const aktivePhase = lpActiveList(pr)[0];
-    Object.keys(pr.assign || {}).forEach(aKey => {
-      const s = stats[aKey];
-      if(!s) return;
-      const st = pr.assign[aKey];
-      const rolle = aKey.slice(aKey.indexOf('|') + 1);
-      const al = berechneAuslastung(null, pr, aktivePhase, rolle, st);
-      if(al.anbahnung){
-        s.anbahnung++;
-        return;
-      }
-      if(al.load > 0){
-        s.load += al.load;
-        s.projects[pr.name] = (s.projects[pr.name] || 0) + 1;
-      }
-    });
-  });
-
-  const BAR_W = 140;
-  const barMax = LOAD_BAR_MAX;
-  const body = [[
-    { text: 'Rolle',              style: 'th' },
-    { text: 'Kürzel',             style: 'th' },
-    { text: 'Auslastung',         style: 'th' },
-    { text: 'Auslastung (Faktor)',style: 'th' },
-    { text: 'Projektdetails',     style: 'th' }
-  ]];
-
-  ROLES.forEach(r => (grouped[r] || []).forEach(entry => {
-    const s    = stats[assignKey(entry.person.id, r)];
-    const load = s.load;                     // aktuelle Sitzung = 1 Woche
-    // Balken relativ zur einstellbaren Skala (Standard 8); die Ampel-Farbe
-    // und der Zahlenwert bleiben ungedeckelt (Überlastung > 1,0).
-    const col  = pdfLoadAmpelColor(load);
-    const det  = Object.keys(s.projects)
-      .map(k => k + ' (' + s.projects[k] + '\u00D7)').join(', ') || '—';
-
-    body.push([
-      { text: r, style: 'td' },
-      { text: entry.person.name, style: 'td', bold: true },
-      { text: faktorFormat(load), style: 'tdCenter' },
-      { stack: [
-          { canvas: [
-              { type:'rect', x:0, y:0, w:BAR_W, h:7, color:'#F0F0F0' },
-              { type:'rect', x:0, y:0, w:Math.max(0, BAR_W * Math.min(1, load / barMax)),
-                h:7, color:col }
-          ]},
-          { text: faktorFormat(load), fontSize: 6, color: '#6E6E73',
-            alignment: 'right', width: BAR_W, margin: [0, 1, 0, 0] }
-        ], margin: [3, 3, 3, 3] },
-      { text: s.anbahnung
-          ? [ det, { text: '\nIn Anbahnung: ' + s.anbahnung, color: '#0071E3' } ]
-          : det,
-        style: 'td', fontSize: 6.5 }
-    ]);
-  }));
-
-  return [
-    { text: 'Auslastung der Projektbeteiligten (aktuelle Sitzung)',
-      style: 'h2', margin: [0, 0, 0, 6] },
-    { table: { headerRows: 1, widths: [80, 40, 45, BAR_W + 6, '*'], body },
-      layout: pdfTableLayout() },
-    { text: 'Rollenbezogener Gewichtungsfaktor je Leistungsphase. Aktueller Wert: '
-          + faktorFormat(LOAD_BAR_MAX),
-      fontSize: 6.5, color: '#6E6E73', margin: [0, 4, 0, 0] }
-  ];
-}
-
-// exportPDF: Hauptfunktion. Erzeugt und lädt das PDF.
-async function exportPDF(){
-  if(!window.pdfMake){
-    alert('PDF-Export nicht verfügbar: pdfmake wurde nicht geladen. '
-        + 'Bitte Internetverbindung bzw. Skript-Einbindung prüfen.');
-    return;
-  }
-  const w = currentWeek();
-  if(!w) return;
-
-  try {
-    const grouped   = peopleByRole(w);
-    const allPeople = [];
-    ROLES.forEach(r => (grouped[r] || []).forEach(e => {
-      // role explizit setzen, falls peopleByRole sie nicht mitliefert
-      allPeople.push({ person: e.person, role: e.role || r });
-    }));
-
-    pdfCheckWidth(allPeople);
-
-    const logo     = await loadLogoPng();
-    const colCount = 3 + allPeople.length + LPHS.length;
-    const widths   = pdfColumnWidths(allPeople);
-
-    // --- Deckblatt ---
-    const cover = [];
-    if(logo){
-      cover.push({ image: logo, width: 130, alignment: 'center',
-                   margin: [0, 0, 0, 24] });
-    }
-    cover.push(
-      { text: 'Projektübersicht ' + DEPARTMENTS[currentDepartment].label,
-        style: 'h1', alignment: 'center', margin: [0, 0, 0, 10] },
-      { text: w.label || '', fontSize: 13, color: '#6E6E73',
-        alignment: 'center', margin: [0, 0, 0, 30] }
-    );
-    if(w.date){
-      cover.push({ text: 'Datum: ' + formatWeekDate(w.date), fontSize: 9,
-                   color: '#6E6E73', alignment: 'center', margin: [0, 0, 0, 8] });
-    }
-    cover.push({ text: 'Erstellt am ' + new Date().toLocaleDateString('de-DE'),
-                 fontSize: 8, color: '#6E6E73', alignment: 'center',
-                 margin: [0, 30, 0, 0] });
-
-    const content = [{ stack: cover, margin: [0, 170, 0, 0], pageBreak: 'after' }];
-
-    // --- Projektgruppen ---
-    const groups = {};
-    (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)));
-
-    sortGroups(Object.keys(groups)).forEach(groupName => {
-      const projects = groups[groupName];
-      if(!projects || !projects.length) return;
-
-      // Kopfzeilen MÜSSEN pro Tabelle neu erzeugt werden:
-      // pdfmake mutiert Zellobjekte (rowSpan/colSpan, _span, _inlines).
-      // Wiederverwendung derselben Referenzen führt zu leeren Kopfzeilen
-      // in allen Tabellen ab der zweiten.
-      const header = pdfHeaderRows(grouped);
-
-      const body = [ pdfGroupTitleRow(groupName, colCount), header[0], header[1] ];
-      projects.forEach((p, i) => body.push(pdfProjectRow(p, allPeople, i % 2 === 0)));
-
-      content.push({
-        table: { headerRows: 3, widths: widths, body: body, dontBreakRows: true },
-        layout: pdfTableLayout(),
-        margin: [0, 0, 0, 14],
-        pageBreak: 'after'
-      });
-    });
-
-    // --- Anwesenheit / Auslastung ---
-    //content.push({ text: '', pageBreak: 'before' });
-    pdfAttendanceBlock(w).forEach(b => content.push(b));
-    content.push({ text: '', margin: [0, 14, 0, 0] });
-    pdfLoadSection(w, grouped).forEach(b => content.push(b));
-
-    const doc = {
-      pageSize: 'A3',
-      pageOrientation: 'landscape',
-      pageMargins: [PDF_MARGIN_X, 25, PDF_MARGIN_X, 30],
-      defaultStyle: { font: 'Roboto', fontSize: 7, color: '#1D1D1F' },
-      styles: PDF_STYLES,
-      footer: (page, count) => page === 1 ? '' : {
-        text: (w.label || '') + ' · Seite ' + page + ' von ' + count,
-        alignment: 'right', fontSize: 6.5, color: '#6E6E73',
-        margin: [0, 8, PDF_MARGIN_X, 0]
-      },
-      info: {
-        title: 'Projektübersicht ' + (w.label || ''),
-        creator: 'Projektboard'
-      },
-      content: content
-    };
-
-    const filename = 'Projektuebersicht_'
-      + String(w.label || 'Sitzung').replace(/[^\w]/g, '_') + '.pdf';
-    pdfMake.createPdf(doc).download(filename);
-
-  } catch(err){
-    console.error('PDF-Export fehlgeschlagen:', err);
-    alert('PDF-Export fehlgeschlagen: ' + (err.message || err));
-  }
-}
-
-// sendCsvToServer: POSTet CSV an <baseUrl>/save-csv
-function blobToDataUrl(blob){
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onloadend = () => resolve(reader.result);
-    reader.onerror = reject;
-    reader.readAsDataURL(blob);
-  });
-}
-
-function sendCsvToServer(filename, csvContent){
-  if(!window.fetch) return Promise.reject(new Error('fetch nicht verfügbar'));
-  return fetch(baseUrl() + '/save-csv',{
-    method:'POST',
-    headers:{'Content-Type':'application/json; charset=utf-8'},
-    body:JSON.stringify({filename,csv:csvContent,department:currentDepartment})
-  }).then(r=>{ if(!r.ok) throw new Error('Server HTTP '+r.status); return r.json(); });
-}
-
-// ---------- Show Mode ----------
-
-let showModeActive = false;
-let showModeTimer = null;
-let showModeResumeTimer = null;
-let showModePaused = false;
-let showModeOriginal = { department: DEFAULT_DEPARTMENT, tab: DEFAULT_TAB };
-const SHOW_MODE_SLIDE_DURATION = 10000; // 10 Sekunden pro Slide
-const SHOW_MODE_PAUSE_DURATION = 60000; // 1 Minute Pause
-const SHOW_MODE_SEQUENCE = [
-  { dept: 'ELT',  view: 'board' },
-  { dept: 'ELT',  view: 'load' },
-  { dept: 'HLS',  view: 'board' },
-  { dept: 'HLS',  view: 'load' },
-  { dept: 'ARCH', view: 'board' },
-  { dept: 'ARCH', view: 'load' }
-];
-let showModeIndex = 0;
-
-function startShowMode(){
-  if(showModeActive) return;
-  showModeActive = true;
-  showModePaused = false;
-  showModeOriginal = { department: currentDepartment, tab: currentTab };
-  showModeIndex = 0;
-
-  const overlay = document.getElementById('showModeOverlay');
-  if(overlay) overlay.style.display = 'flex';
-
-  // Menü schließen, falls offen
-  setHeaderCollapsed(true, false);
-
-  showModeNextSlide();
-}
-
-function stopShowMode(){
-  showModeActive = false;
-  showModePaused = false;
-  clearTimeout(showModeTimer);
-  clearTimeout(showModeResumeTimer);
-
-  const overlay = document.getElementById('showModeOverlay');
-  if(overlay) overlay.style.display = 'none';
-
-  // Ursprünglichen Zustand wiederherstellen
-  currentTab = showModeOriginal.tab;
-  if(currentDepartment !== showModeOriginal.department){
-    switchDepartment(showModeOriginal.department);
-  } else {
-    showTab(currentTab, true);
-    renderAll();
-  }
-}
-
-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);
-}
-
-function resumeShowMode(){
-  if(!showModeActive) return;
-  showModePaused = false;
-  clearTimeout(showModeResumeTimer);
-  const pausedEl = document.getElementById('showModePaused');
-  if(pausedEl) pausedEl.style.display = 'none';
-  showModeNextSlide();
-}
-
-function showModeNextSlide(){
-  if(!showModeActive || showModePaused) return;
-
-  const slide = SHOW_MODE_SEQUENCE[showModeIndex % SHOW_MODE_SEQUENCE.length];
-  showModeIndex++;
-
-  const titleEl = document.getElementById('showModeTitle');
-  if(titleEl){
-    const deptLabel = DEPARTMENTS[slide.dept] ? DEPARTMENTS[slide.dept].label : slide.dept;
-    titleEl.textContent = `${deptLabel} – ${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>';
-  }
-
-  // Wechsle Department und View in der Hauptansicht, dann kopiere ins Overlay.
-  // Da switchDepartment asynchron lädt, müssen wir auf den Abschluss warten.
-  if(currentDepartment !== slide.dept){
-    // Temporär currentTab setzen, damit nach dem Laden der richtige Tab aktiv ist.
-    currentTab = slide.view;
-    switchDepartment(slide.dept);
-    // Warte bis Daten geladen sind, dann rendern und kopieren
-    waitForLoadThenRender(slide.view);
-  } else {
-    showTab(slide.view, true);
-    renderAll();
-    requestAnimationFrame(() => {
-      requestAnimationFrame(() => {
-        copyCurrentViewToShowMode();
-        scheduleNextShowModeSlide();
-      });
-    });
-  }
-}
-
-function waitForLoadThenRender(view){
-  let attempts = 0;
-  const check = setInterval(() => {
-    attempts++;
-    // Wenn Wochen geladen sind oder nach Seed gefallen ist
-    if(db.weeks.length > 0 || attempts > 30){
-      clearInterval(check);
-      showTab(view, true);
-      renderAll();
-      // Kurze Verzögerung, damit das DOM aktualisiert ist, bevor kopiert wird
-      requestAnimationFrame(() => {
-        requestAnimationFrame(() => {
-          copyCurrentViewToShowMode();
-          scheduleNextShowModeSlide();
-        });
-      });
-    }
-  }, 200);
-}
-
-function scheduleNextShowModeSlide(){
-  if(!showModeActive || showModePaused) return;
-  clearTimeout(showModeTimer);
-  showModeTimer = setTimeout(() => {
-    showModeNextSlide();
-  }, SHOW_MODE_SLIDE_DURATION);
-}
-
-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 beendet Show Mode
-document.addEventListener('keydown', function(e){
-  if(showModeActive && e.key === 'Escape'){
-    stopShowMode();
-  }
-});
-
-
-// ---------- Init / Start ----------
-
-// renderAll: Convenience um UI-Elemente zu initialisieren
-function renderAll(){
-  refreshWeekSelect();
-  updateWeekDate();
-  renderBoard();
-  const activeTab = document.querySelector('.tab.active')?.dataset.tab || currentTab;
-  if(activeTab === 'load') renderLoad();
-  else if(activeTab === 'projects') renderProjects();
-  else if(activeTab === 'people') renderPeople();
-}
-
-function initUiState(){
-  loadUiState();
-  loadTheme();
-  loadHeaderState();
-  document.querySelectorAll('.dept-tab').forEach(btn => {
-    btn.classList.toggle('active', btn.dataset.dept === currentDepartment);
-  });
-  const info = DEPARTMENTS[currentDepartment];
-  document.title = 'Projektübersicht ' + info.label;
-  const titleEl = document.getElementById('pageTitle');
-  if(titleEl) titleEl.textContent = info.icon + ' Projektübersicht ' + info.label;
-
-  const tab = ['board','load','projects','people'].includes(currentTab) ? currentTab : DEFAULT_TAB;
-  // Beim initialen Start niemals einen passwortgeschützten Tab direkt anzeigen.
-  const safeTab = (tab === 'projects' || tab === 'people') ? DEFAULT_TAB : tab;
-  showTab(safeTab, true);
-}
-
-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 nur auf der Hauptseite (Projektboard).
-// Andere Seiten (z.B. Projektplan) laden main.v2.js nur für die Hilfsfunktionen.
-if(document.getElementById('board')){
-  initUiState();
-  switchDepartment(currentDepartment);
-}
diff --git a/public/project-plan.html b/public/project-plan.html
index 9a79fe7..ee1ac42 100644
--- a/public/project-plan.html
+++ b/public/project-plan.html
@@ -6,7 +6,7 @@
   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/csv.js, js/server.js
+  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,
@@ -318,7 +318,6 @@
 <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/csv.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>
diff --git a/public/project-plan.js b/public/project-plan.js
deleted file mode 100644
index be906a1..0000000
--- a/public/project-plan.js
+++ /dev/null
@@ -1,1528 +0,0 @@
-// Projektplan-Seite: TODOs und Meilensteine direkt im GANTT-Diagramm.
-// Daten werden über denselben Server wie das Hauptfenster geladen.
-
-(function(){
-  const params = new URLSearchParams(location.search);
-  const department = params.get('department') || 'ELT';
-  const weekLabel = params.get('weekLabel');
-  const projNr = params.get('projNr') || '';
-  const projName = params.get('projName') || '';
-
-  let planWeek = null;
-  let planProject = null;
-  // px pro Tag für die GANTT-Zoomstufe (null = an Containerbreite anpassen)
-  let planGanttPxPerDay = 14;
-  let criticalPathActive = false;
-
-  function init(){
-    loadTheme(); // Theme aus localStorage / System übernehmen
-    if(!weekLabel || !projName){
-      document.getElementById('planTitle').textContent = 'Fehler';
-      document.getElementById('planSubtitle').textContent = 'Kein Projekt ausgewählt.';
-      return;
-    }
-    currentDepartment = department; // global aus main.v2.js
-    bindToolbarButtons();
-    loadPlanData();
-  }
-
-  function bindToolbarButtons(){
-    const addTodoBtn = document.getElementById('addTodoBtn');
-    if(addTodoBtn) addTodoBtn.addEventListener('click', () => addTodo());
-    const autoScheduleBtn = document.getElementById('autoScheduleBtn');
-    if(autoScheduleBtn) autoScheduleBtn.addEventListener('click', () => autoScheduleTodos());
-    const criticalPathBtn = document.getElementById('criticalPathBtn');
-    if(criticalPathBtn) criticalPathBtn.addEventListener('click', () => toggleCriticalPath());
-  }
-
-  function loadPlanData(){
-    if(!window.fetch){
-      document.getElementById('planSubtitle').textContent = 'Netzwerk nicht verfügbar.';
-      return;
-    }
-    const url = baseUrl() + '/load-all?department=' + encodeURIComponent(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[department] = parseGlobalPeopleCsv(data.people);
-        const parsed = (data.sessions || []).map(s => ({ filename: s.filename, rows: parseCsvText(s.content) }));
-        parsed.forEach(s => {
-          const w = parseSessionCsv(s.filename, s.rows);
-          if(w) db.weeks.push(w);
-        });
-        db.weeks.sort((a,b) => weekSortKey(a.label).localeCompare(weekSortKey(b.label)));
-        planWeek = db.weeks.find(w => w.label === weekLabel);
-        if(!planWeek){
-          document.getElementById('planTitle').textContent = 'Nicht gefunden';
-          document.getElementById('planSubtitle').textContent = 'Sitzung "' + esc(weekLabel) + '" konnte nicht geladen werden.';
-          return;
-        }
-        planProject = planWeek.projects.find(p => (p.nr || '') === projNr && (p.name || '') === projName);
-        if(!planProject){
-          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;
-      });
-  }
-
-  function ensurePlanLocal(){
-    if(!planProject.plan) planProject.plan = { start:'', end:'', todos:[], milestones:[], people:[], progress:0 };
-    if(!Array.isArray(planProject.plan.todos)) planProject.plan.todos = [];
-    // Migration alter Einzel-Abhängigkeiten zu Array
-    planProject.plan.todos.forEach(t => {
-      if(!Array.isArray(t.dependsOn)){
-        t.dependsOn = t.dependsOn ? [t.dependsOn] : [];
-      }
-      if(!Array.isArray(t.assignees)) t.assignees = [];
-      if(t.progress === undefined) t.progress = t.done ? 100 : 0;
-    });
-    return planProject.plan;
-  }
-
-  function isLocked(){
-    return !!planWeek.locked;
-  }
-
-  function renderPlanPage(){
-    const p = planProject;
-    const plan = ensurePlanLocal();
-    document.getElementById('planTitle').textContent = (p.nr ? p.nr + ' – ' : '') + p.name;
-    document.getElementById('planSubtitle').textContent = planWeek.label + (planWeek.date ? ' · ' + formatWeekDate(planWeek.date) : '');
-
-    // GANTT inkl. TODOs
-    const addMilestoneBtn = document.getElementById('addMilestoneBtn');
-    const locked = isLocked();
-    if(addMilestoneBtn) addMilestoneBtn.style.display = locked ? 'none' : '';
-
-    fitPlanGanttRange();
-  }
-
-  // ---------- Drag-and-Drop für TODO- und Meilenstein-Zeilen direkt im GANTT ----------
-
-  let ganttTodoDrag = null;
-  const DRAGGABLE_GANTT_ROW_SELECTOR = '.gantt-row.gantt-todo, .gantt-row.gantt-milestone-row';
-
-  function initGanttTodoDrag(){
-    const container = document.getElementById('planGanttContainer');
-    if(!container) return;
-    container.addEventListener('mousedown', onGanttTodoMouseDown);
-    document.addEventListener('mousemove', onGanttTodoMouseMove);
-    document.addEventListener('mouseup', onGanttTodoMouseUp);
-  }
-
-  function onGanttTodoMouseDown(e){
-    if(isLocked()) return;
-    const handle = e.target.closest('.gantt-todo-drag');
-    if(!handle) return;
-    const row = handle.closest(DRAGGABLE_GANTT_ROW_SELECTOR);
-    if(!row) return;
-
-    e.preventDefault();
-    e.stopPropagation();
-
-    ganttTodoDrag = {
-      row,
-      startY: e.clientY,
-      moved: false
-    };
-    row.classList.add('dragging');
-  }
-
-  function onGanttTodoMouseMove(e){
-    if(!ganttTodoDrag) return;
-    const chart = ganttTodoDrag.row.closest('.gantt-chart');
-    if(!chart) return;
-
-    const dy = e.clientY - ganttTodoDrag.startY;
-    if(Math.abs(dy) > 3) ganttTodoDrag.moved = true;
-    if(!ganttTodoDrag.moved) return;
-
-    const afterElement = getGanttRowDragAfterElement(chart, e.clientY);
-    if(ganttTodoDrag.row && afterElement == null){
-      chart.appendChild(ganttTodoDrag.row);
-    } else if(ganttTodoDrag.row && afterElement && afterElement !== ganttTodoDrag.row){
-      chart.insertBefore(ganttTodoDrag.row, afterElement);
-    }
-  }
-
-  function onGanttTodoMouseUp(e){
-    if(!ganttTodoDrag) return;
-    const drag = ganttTodoDrag;
-    ganttTodoDrag = null;
-    drag.row.classList.remove('dragging');
-    if(drag.moved){
-      reorderPlanRows();
-    }
-  }
-
-  function getGanttRowDragAfterElement(chart, y){
-    const draggableElements = [...chart.querySelectorAll(DRAGGABLE_GANTT_ROW_SELECTOR + ':not(.dragging)')];
-    return draggableElements.reduce((closest, child) => {
-      const box = child.getBoundingClientRect();
-      const offset = y - box.top - box.height / 2;
-      if(offset < 0 && offset > closest.offset){
-        return { offset: offset, element: child };
-      } else {
-        return closest;
-      }
-    }, { offset: Number.NEGATIVE_INFINITY }).element;
-  }
-
-  function reorderPlanRows(){
-    if(isLocked()) return;
-    const chart = document.querySelector('#planGanttContainer .gantt-chart');
-    if(!chart) return;
-    const plan = ensurePlanLocal();
-    const todos = Array.isArray(plan.todos) ? plan.todos : [];
-    const milestones = Array.isArray(plan.milestones) ? plan.milestones : [];
-    const todoIds = todos.map(t => t.id);
-    const milestoneIds = milestones.map(m => m.id);
-
-    // Alle beweglichen Zeilen in aktueller DOM-Reihenfolge
-    const rows = [...chart.querySelectorAll(DRAGGABLE_GANTT_ROW_SELECTOR)];
-    const todoRowIds = rows.filter(r => r.classList.contains('gantt-todo')).map(r => r.dataset.todoId).filter(Boolean);
-    const milestoneRowIds = rows.filter(r => r.classList.contains('gantt-milestone-row')).map(r => r.dataset.milestoneId).filter(Boolean);
-
-    // Sicherheitscheck: Anzahl muss stimmen
-    if(todoRowIds.length !== todoIds.length) return;
-    if(milestoneRowIds.length !== milestoneIds.length) return;
-
-    // TODOs neu ordnen
-    const newTodos = [];
-    todoRowIds.forEach(id => {
-      const t = todos.find(x => x.id === id);
-      if(t) newTodos.push(t);
-    });
-    plan.todos = newTodos;
-
-    // Meilenstein-Positionen neu berechnen
-    // Regeln:
-    // - Steht der Meilenstein direkt vor einer TODO -> before:todoId
-    // - Steht er direkt nach einer TODO -> after:todoId
-    // - Steht er ganz am Anfang (vor erster TODO) oder es gibt keine TODO -> '' (oben in Projektzeile)
-    // - Steht er ganz am Ende (nach letzter TODO) -> after:lastTodoId
-    rows.forEach((row, idx) => {
-      if(!row.classList.contains('gantt-milestone-row')) return;
-      const msId = row.dataset.milestoneId;
-      const ms = milestones.find(m => m.id === msId);
-      if(!ms) return;
-
-      let position = '';
-      const prevRow = rows[idx - 1];
-      const nextRow = rows[idx + 1];
-
-      if(prevRow && prevRow.classList.contains('gantt-todo')){
-        position = 'after:' + prevRow.dataset.todoId;
-      } else if(nextRow && nextRow.classList.contains('gantt-todo')){
-        position = 'before:' + nextRow.dataset.todoId;
-      } else if(prevRow && prevRow.classList.contains('gantt-milestone-row')){
-        // Zwei Meilensteine hintereinander: beziehe dich auf die nächste TODO danach oder letzte davor
-        // Suche nächste TODO nach diesem Block
-        let nextTodoId = null;
-        for(let i = idx + 1; i < rows.length; i++){
-          if(rows[i].classList.contains('gantt-todo')){ nextTodoId = rows[i].dataset.todoId; break; }
-        }
-        if(nextTodoId){
-          position = 'before:' + nextTodoId;
-        } else {
-          // Keine TODO danach -> letzte TODO davor suchen
-          let prevTodoId = null;
-          for(let i = idx - 1; i >= 0; i--){
-            if(rows[i].classList.contains('gantt-todo')){ prevTodoId = rows[i].dataset.todoId; break; }
-          }
-          if(prevTodoId) position = 'after:' + prevTodoId;
-        }
-      }
-      ms.position = position;
-    });
-
-    savePlan();
-    renderPlanGantt();
-  }
-
-  function renderProjectAssignees(){
-    const assignees = projectAssignees(planProject, planWeek);
-    if(assignees.length === 0) return '<span class="hint">Keine Zuordnungen im Projektboard.</span>';
-    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>`;
-    }).join('');
-  }
-
-  // --------- Mail-Link für alle zugeordneten Personen ----------
-  window.todoMail = function() {
-    if (!planProject || !planWeek) {
-      console.warn('Kein aktuelles Projekt/keine aktuelle Woche gefunden – Mail kann nicht erstellt werden.');
-      return;
-    }
-
-    const assignees = projectAssignees(planProject, planWeek);
-
-    const empfaengerListe = assignees
-      .map(a => a.email || (a.person && a.person.email) || '')
-      .filter(email => email && email.trim() !== '');
-
-    const eindeutigeEmpfaenger = [...new Set(empfaengerListe)];
-
-    if (eindeutigeEmpfaenger.length === 0) {
-      console.warn('Keine gültigen E-Mail-Adressen der zugeordneten Personen gefunden.');
-      return;
-    }
-
-    const empfaenger = eindeutigeEmpfaenger.join(',');
-
-    const titleEl = document.getElementById('planTitle');
-    const projektname = titleEl ? titleEl.textContent.trim() : 'Projekt';
-    const seitenLink = window.location.href;
-    const betreff = 'Neue Aufgaben im Projekt ' + projektname;
-
-    const nachricht =
-      'Guten Tag,\n\n' +
-      'es wurden neue Aufgaben im Projekt ' + projektname + ' hinzugefügt.\n\n' +
-      'Link zum Projekt:\n' +
-      seitenLink + '\n\n' +
-      'Mit freundlichen Grüßen';
-
-    const mailtoLink =
-      'mailto:' + encodeURIComponent(empfaenger).replace(/%2C/g, ',') +
-      '?subject=' + encodeURIComponent(betreff) +
-      '&body=' + encodeURIComponent(nachricht);
-
-    if (mailtoLink.length > 1800) {
-      console.warn('mailto-Link ist sehr lang (' + mailtoLink.length + ' Zeichen) – manche Mail-Clients könnten ihn abschneiden.');
-    }
-
-    window.location.href = mailtoLink;
-  };
-
-  // ---------- Meilenstein-Modal ----------
-
-  let currentMilestoneIndex = null;
-
-  window.openMilestoneModal = function(index){
-    if(isLocked()) return;
-    const plan = ensurePlanLocal();
-    if(!Array.isArray(plan.milestones)) plan.milestones = [];
-    // Migration alter Meilensteine
-    plan.milestones.forEach(m => { if(!Array.isArray(m.dependsOn)) m.dependsOn = []; });
-    currentMilestoneIndex = index;
-
-    const isNew = index === null || plan.milestones[index] === undefined;
-    const currentMs = isNew ? null : plan.milestones[index];
-    document.getElementById('milestoneEditName').value = isNew ? '' : (currentMs.name || '');
-    document.getElementById('milestoneEditDate').value = isNew ? '' : (currentMs.date || '');
-
-    const positionSelect = document.getElementById('milestoneEditPosition');
-    if(positionSelect){
-      const currentPosition = currentMs && currentMs.position ? currentMs.position : '';
-      const defaultAfterTodo = isNew && plan.todos && plan.todos.length > 0 ? plan.todos[plan.todos.length - 1].id : null;
-      let opts = '<option value="">Oben in der Projektzeile</option>';
-      if(plan.todos && plan.todos.length > 0){
-        plan.todos.forEach(t => {
-          const beforeVal = 'before:' + t.id;
-          const afterVal = 'after:' + t.id;
-          const beforeSel = currentPosition === beforeVal ? 'selected' : '';
-          let afterSel = currentPosition === afterVal ? 'selected' : '';
-          if(isNew && defaultAfterTodo === t.id && !currentPosition) afterSel = 'selected';
-          opts += `<option value="${esc(beforeVal)}" ${beforeSel}>Vor: ${esc(t.title || 'TODO')}</option>`;
-          opts += `<option value="${esc(afterVal)}" ${afterSel}>Nach: ${esc(t.title || 'TODO')}</option>`;
-        });
-      }
-      positionSelect.innerHTML = opts;
-    }
-
-    const dependsOnList = document.getElementById('milestoneEditDependsOn');
-    if(dependsOnList){
-      const currentDeps = currentMs && Array.isArray(currentMs.dependsOn) ? currentMs.dependsOn : [];
-      let listHtml = '';
-
-      // Andere Meilensteine als Vorgänger anbieten
-      if(plan.milestones.length > 1){
-        listHtml += '<div class="todo-depends-group"><b>Meilensteine</b></div>';
-        plan.milestones.forEach(m => {
-          if(currentMs && m.id === currentMs.id) return;
-          const mId = 'm_' + m.id;
-          const checked = currentDeps.includes(mId) ? 'checked' : '';
-          listHtml += `<label class="todo-depends-item"><input type="checkbox" value="${esc(mId)}" ${checked}> 🚩 ${esc(m.name || 'Meilenstein')} (${formatDateDE(parseDateISO(m.date))})</label>`;
-        });
-      }
-
-      // TODOs als Vorgänger anbieten
-      if(plan.todos && plan.todos.length > 0){
-        listHtml += '<div class="todo-depends-group"><b>Aufgaben</b></div>';
-        (plan.todos || []).forEach(t => {
-          const checked = currentDeps.includes(t.id) ? 'checked' : '';
-          const datesStr = (t.start || t.end) ? ` (${formatDateDE(parseDateISO(t.start))}–${formatDateDE(parseDateISO(t.end))})` : '';
-          listHtml += `<label class="todo-depends-item"><input type="checkbox" value="${esc(t.id)}" ${checked}> ${esc(t.title || 'TODO')}${datesStr}</label>`;
-        });
-      }
-      if(listHtml === '') listHtml = '<span class="hint">Keine anderen Aufgaben oder Meilensteine vorhanden.</span>';
-      dependsOnList.innerHTML = listHtml;
-    }
-
-    document.getElementById('milestoneModal').style.display = 'flex';
-    document.getElementById('milestoneEditName').focus();
-  }
-
-  window.closeMilestoneModal = function(){
-    document.getElementById('milestoneModal').style.display = 'none';
-    currentMilestoneIndex = null;
-  };
-
-  window.saveMilestoneEdit = function(){
-    if(isLocked()) return;
-    const name = document.getElementById('milestoneEditName').value.trim();
-    const date = document.getElementById('milestoneEditDate').value;
-    if(!name || !date){ alert('Bitte Name und Datum angeben.'); return; }
-
-    const dependsOnList = document.getElementById('milestoneEditDependsOn');
-    const dependsOn = dependsOnList ? Array.from(dependsOnList.querySelectorAll('input[type="checkbox"]:checked')).map(cb => cb.value).filter(Boolean) : [];
-
-    const positionSelect = document.getElementById('milestoneEditPosition');
-    const position = positionSelect ? positionSelect.value : '';
-
-    const plan = ensurePlanLocal();
-    if(!Array.isArray(plan.milestones)) plan.milestones = [];
-
-    if(currentMilestoneIndex === null){
-      plan.milestones.push({ id: uid(), name, date, dependsOn, position });
-    } else if(plan.milestones[currentMilestoneIndex]){
-      const m = plan.milestones[currentMilestoneIndex];
-      m.name = name;
-      m.date = date;
-      m.dependsOn = dependsOn;
-      m.position = position;
-    }
-    plan.milestones.sort((a,b) => parseDateISO(a.date) - parseDateISO(b.date));
-    savePlan();
-    closeMilestoneModal();
-    renderPlanGantt();
-  };
-
-  // Entfernt eine gelöschte ID aus allen dependsOn-Listen (TODOs und Meilensteine)
-  function removeDependencyRefs(plan, deletedId){
-    (plan.todos || []).forEach(t => {
-      if(Array.isArray(t.dependsOn)) t.dependsOn = t.dependsOn.filter(id => id !== deletedId);
-    });
-    (plan.milestones || []).forEach(m => {
-      if(Array.isArray(m.dependsOn)) m.dependsOn = m.dependsOn.filter(id => id !== deletedId);
-    });
-  }
-
-  window.deleteMilestoneEdit = function(){
-    if(isLocked()) return;
-    if(currentMilestoneIndex === null){ closeMilestoneModal(); return; }
-    if(!confirm('Meilenstein löschen?')) return;
-    const plan = ensurePlanLocal();
-    if(plan.milestones && plan.milestones[currentMilestoneIndex]){
-      const deletedId = 'm_' + plan.milestones[currentMilestoneIndex].id;
-      plan.milestones.splice(currentMilestoneIndex, 1);
-      removeDependencyRefs(plan, deletedId);
-      savePlan();
-    }
-    closeMilestoneModal();
-    renderPlanGantt();
-  };
-
-  window.addPlanMilestone = function(){
-    openMilestoneModal(null);
-  };
-
-  // ---------- TODO-Modal ----------
-
-  let currentTodoIndex = null;
-
-  window.openTodoModal = function(index){
-    if(isLocked()) return;
-    const plan = ensurePlanLocal();
-    if(!Array.isArray(plan.todos)) plan.todos = [];
-    currentTodoIndex = index;
-
-    const isNew = index === null || plan.todos[index] === undefined;
-    const currentTodo = !isNew ? plan.todos[index] : null;
-
-    document.getElementById('todoEditTitle').value = isNew ? '' : (currentTodo.title || '');
-    document.getElementById('todoEditStart').value = isNew ? '' : (currentTodo.start || '');
-    document.getElementById('todoEditEnd').value = isNew ? '' : (currentTodo.end || '');
-    document.getElementById('todoEditDone').checked = isNew ? false : !!currentTodo.done;
-    const progress = isNew ? 0 : (parseInt(currentTodo.progress, 10) || 0);
-    document.getElementById('todoEditProgress').value = progress;
-    document.getElementById('todoEditProgressVal').textContent = progress + '%';
-
-    const dependsOnList = document.getElementById('todoEditDependsOn');
-    if(dependsOnList){
-      const currentDeps = currentTodo && Array.isArray(currentTodo.dependsOn) ? currentTodo.dependsOn : [];
-      let listHtml = '';
-
-      // Meilensteine als Vorgänger anbieten
-      if(Array.isArray(plan.milestones) && plan.milestones.length > 0){
-        listHtml += '<div class="todo-depends-group"><b>Meilensteine</b></div>';
-        plan.milestones.forEach(m => {
-          const mId = 'm_' + m.id;
-          const checked = currentDeps.includes(mId) ? 'checked' : '';
-          listHtml += `<label class="todo-depends-item"><input type="checkbox" value="${esc(mId)}" ${checked}> 🚩 ${esc(m.name || 'Meilenstein')} (${formatDateDE(parseDateISO(m.date))})</label>`;
-        });
-      }
-
-      // Andere TODOs als Vorgänger anbieten
-      if(plan.todos && plan.todos.length > 1){
-        listHtml += '<div class="todo-depends-group"><b>Aufgaben</b></div>';
-        (plan.todos || []).forEach(t => {
-          if(currentTodo && t.id === currentTodo.id) return;
-          const checked = currentDeps.includes(t.id) ? 'checked' : '';
-          const datesStr = (t.start || t.end) ? ` (${formatDateDE(parseDateISO(t.start))}–${formatDateDE(parseDateISO(t.end))})` : '';
-          listHtml += `<label class="todo-depends-item"><input type="checkbox" value="${esc(t.id)}" ${checked}> ${esc(t.title || 'TODO')}${datesStr}</label>`;
-        });
-      }
-      if(listHtml === '') listHtml = '<span class="hint">Keine anderen Aufgaben oder Meilensteine vorhanden.</span>';
-      dependsOnList.innerHTML = listHtml;
-    }
-
-    const assigneesDiv = document.getElementById('todoEditAssignees');
-    if(assigneesDiv){
-      const assignees = projectAssignees(planProject, planWeek);
-      const currentAssignees = currentTodo && Array.isArray(currentTodo.assignees) ? currentTodo.assignees : [];
-      const seenPeople = new Set();
-      const uniquePeople = [];
-      assignees.forEach(a => {
-        if(!seenPeople.has(a.person.id)){
-          seenPeople.add(a.person.id);
-          uniquePeople.push(a.person);
-        }
-      });
-      assigneesDiv.innerHTML = uniquePeople.map(person => {
-        const checked = currentAssignees.includes(person.id) ? 'checked' : '';
-        return `<label><input type="checkbox" value="${esc(person.id)}" ${checked}> ${esc(person.name)}</label>`;
-      }).join('') || '<span class="hint">Keine Projektzuordnungen im Board.</span>';
-    }
-
-    document.getElementById('todoModal').style.display = 'flex';
-    document.getElementById('todoEditTitle').focus();
-  };
-
-  window.closeTodoModal = function(){
-    document.getElementById('todoModal').style.display = 'none';
-    currentTodoIndex = null;
-  };
-
-  window.saveTodoEdit = function(){
-    if(isLocked()) return;
-    const title = document.getElementById('todoEditTitle').value.trim();
-    let start = document.getElementById('todoEditStart').value;
-    let end = document.getElementById('todoEditEnd').value;
-    // Nur ein Datum angegeben: als eintägige Aufgabe behandeln,
-    // sonst würde kein Balken im GANTT erscheinen.
-    if(start && !end) end = start;
-    if(end && !start) start = end;
-    const done = document.getElementById('todoEditDone').checked;
-    let progress = parseInt(document.getElementById('todoEditProgress').value, 10) || 0;
-    // "Erledigt" impliziert 100 % Fortschritt
-    if(done && progress < 100) progress = 100;
-
-    const dependsOnList = document.getElementById('todoEditDependsOn');
-    const dependsOn = dependsOnList ? Array.from(dependsOnList.querySelectorAll('input[type="checkbox"]:checked')).map(cb => cb.value).filter(Boolean) : [];
-
-    const assigneesDiv = document.getElementById('todoEditAssignees');
-    const assignees = assigneesDiv ? Array.from(assigneesDiv.querySelectorAll('input:checked')).map(cb => cb.value) : [];
-
-    if(!title){ alert('Bitte einen Titel eingeben.'); return; }
-    if(start && end && parseDateISO(end) < parseDateISO(start)){ alert('Enddatum liegt vor Startdatum.'); return; }
-
-    const plan = ensurePlanLocal();
-    if(!Array.isArray(plan.todos)) plan.todos = [];
-
-    if(currentTodoIndex === null){
-      plan.todos.push({ id: uid(), title, start, end, done, progress, dependsOn, assignees });
-    } else if(plan.todos[currentTodoIndex]){
-      const t = plan.todos[currentTodoIndex];
-      t.title = title;
-      t.start = start;
-      t.end = end;
-      t.done = done;
-      t.progress = progress;
-      t.dependsOn = dependsOn;
-      t.assignees = assignees;
-    }
-    savePlan();
-    closeTodoModal();
-    renderPlanGantt();
-  };
-
-  window.deleteTodoEdit = function(){
-    if(isLocked()) return;
-    if(currentTodoIndex === null){ closeTodoModal(); return; }
-    if(!confirm('TODO löschen?')) return;
-    const plan = ensurePlanLocal();
-    if(plan.todos && plan.todos[currentTodoIndex]){
-      const deletedId = plan.todos[currentTodoIndex].id;
-      plan.todos.splice(currentTodoIndex, 1);
-      removeDependencyRefs(plan, deletedId);
-      // Meilensteine, die relativ zu dieser TODO positioniert waren, zurücksetzen
-      (plan.milestones || []).forEach(m => {
-        if(m.position === 'before:' + deletedId || m.position === 'after:' + deletedId) m.position = '';
-      });
-      savePlan();
-    }
-    closeTodoModal();
-    renderPlanGantt();
-  };
-
-  window.addTodoFromList = function(){
-    if(isLocked()) return;
-    const title = document.getElementById('newTodoTitle').value.trim();
-    let start = document.getElementById('newTodoStart').value;
-    let end = document.getElementById('newTodoEnd').value;
-    if(start && !end) end = start;
-    if(end && !start) start = end;
-    if(!title){ alert('Bitte einen Titel eingeben.'); return; }
-    if(start && end && parseDateISO(end) < parseDateISO(start)){ alert('Enddatum liegt vor Startdatum.'); return; }
-    const plan = ensurePlanLocal();
-    plan.todos.push({ id: uid(), title, start, end, done: false, progress: 0, dependsOn: [], assignees: [] });
-    document.getElementById('newTodoTitle').value = '';
-    document.getElementById('newTodoStart').value = '';
-    document.getElementById('newTodoEnd').value = '';
-    savePlan();
-    renderPlanGantt();
-  };
-
-  window.addTodo = function(){
-    openTodoModal(null);
-  };
-
-  function saveGlobalPeople(){
-    const people = db.globalPeople[department] || [];
-    if(people.length > 0){
-      const peopleCsv = globalPeopleToCsv(people);
-      sendCsvToServer('_people.csv', peopleCsv).catch(err => console.error('Speichern Personen fehlgeschlagen:', err));
-    }
-  }
-
-  window.updateTodo = function(idx, field, value){
-    if(isLocked()) return;
-    const plan = ensurePlanLocal();
-    if(!plan.todos[idx]) return;
-    plan.todos[idx][field] = value;
-    savePlan();
-    renderPlanGantt();
-  };
-
-  window.toggleTodoDone = function(idx){
-    if(isLocked()) return;
-    const plan = ensurePlanLocal();
-    if(!plan.todos[idx]) return;
-    plan.todos[idx].done = !plan.todos[idx].done;
-    savePlan();
-    renderPlanGantt();
-  };
-
-  window.deleteTodo = function(idx){
-    if(isLocked()) return;
-    if(!confirm('TODO löschen?')) return;
-    const plan = ensurePlanLocal();
-    if(!plan.todos[idx]) return;
-    const deletedId = plan.todos[idx].id;
-    plan.todos.splice(idx, 1);
-    removeDependencyRefs(plan, deletedId);
-    (plan.milestones || []).forEach(m => {
-      if(m.position === 'before:' + deletedId || m.position === 'after:' + deletedId) m.position = '';
-    });
-    savePlan();
-    renderPlanGantt();
-  };
-
-  function savePlan(){
-    if(!planWeek || !planProject) return;
-    // Speichere nur diese Sitzung; globale Personenliste nicht überschreiben
-    const filename = filenameForWeek(planWeek.label);
-    const csv = weekToCsv(planWeek);
-    sendCsvToServer(filename, csv).catch(err => console.error('Speichern fehlgeschlagen:', err));
-  }
-
-  window.renderPlanGantt = function(){
-    const container = document.getElementById('planGanttContainer');
-    if(!planProject || !container) return;
-    const prevScroll = container.scrollLeft;
-    let start = parseDateISO(document.getElementById('planGanttStart').value);
-    let end = parseDateISO(document.getElementById('planGanttEnd').value);
-    if(!start || !end){
-      const range = ganttRangeFromProjects([planProject], 7);
-      start = range.start; end = range.end;
-      document.getElementById('planGanttStart').value = formatDateISO(start);
-      document.getElementById('planGanttEnd').value = formatDateISO(end);
-    }
-    const showVacation = document.getElementById('planShowVacation').checked;
-    const vacationPeople = projectAssignees(planProject, planWeek).map(a => a.person.id);
-    const criticalPath = criticalPathActive ? computeCriticalPath(planProject) : [];
-    container.innerHTML = buildGanttHtml([planProject], start, end, { showVacation, editable: !isLocked(), highlightProjectId: planProject.id, showTodos: true, vacationPeople, pxPerDay: planGanttPxPerDay, criticalPath });
-    container.scrollLeft = prevScroll;
-    requestAnimationFrame(() => renderGanttDependencies(container));
-    renderResourceLoad();
-  };
-
-  window.renderGanttDependencies = function(container){
-    const c = container || document.getElementById('planGanttContainer');
-    if(!c) return;
-    const chart = c.querySelector('.gantt-chart');
-    if(!chart) return;
-
-    let svg = chart.querySelector('.gantt-dependencies-svg');
-    if(svg) svg.remove();
-
-    const nodeBars = Array.from(chart.querySelectorAll('.gantt-bar.todo[data-todo-id], .gantt-milestone[data-todo-id]'));
-    if(nodeBars.length === 0) return;
-
-    const chartRect = chart.getBoundingClientRect();
-    const barMap = new Map();
-    nodeBars.forEach(b => {
-      if(b.dataset.todoId) barMap.set(b.dataset.todoId, b);
-    });
-
-    const paths = [];
-    nodeBars.forEach(targetBar => {
-      const dependsOnStr = targetBar.dataset.todoDepends;
-      if(!dependsOnStr) return;
-      const depIds = dependsOnStr.split(',').map(s => s.trim()).filter(Boolean);
-      depIds.forEach(depId => {
-        const sourceBar = barMap.get(depId);
-        if(!sourceBar) return;
-
-        const sourceRect = sourceBar.getBoundingClientRect();
-        const targetRect = targetBar.getBoundingClientRect();
-
-        const x1 = sourceRect.right - chartRect.left;
-        const y1 = sourceRect.top + sourceRect.height / 2 - chartRect.top;
-        const x2 = targetRect.left - chartRect.left;
-        const y2 = targetRect.top + targetRect.height / 2 - chartRect.top;
-
-        const isConflict = x2 < x1;
-        const isDone = targetBar.classList.contains('done') && sourceBar.classList.contains('done');
-
-        let d = '';
-        if(x2 >= x1 + 10){
-          const midX = x1 + (x2 - x1) / 2;
-          d = `M ${x1} ${y1} C ${midX} ${y1}, ${midX} ${y2}, ${x2} ${y2}`;
-        } else {
-          const r = 16;
-          d = `M ${x1} ${y1} C ${x1 + r} ${y1}, ${x1 + r} ${(y1 + y2)/2}, ${(x1 + x2)/2} ${(y1 + y2)/2} C ${x2 - r} ${(y1 + y2)/2}, ${x2 - r} ${y2}, ${x2} ${y2}`;
-        }
-
-        let pathClass = 'gantt-dep-path';
-        let markerId = 'gantt-arrow-normal';
-        if(isConflict){ pathClass += ' conflict'; markerId = 'gantt-arrow-conflict'; }
-        else if(isDone){ pathClass += ' done'; markerId = 'gantt-arrow-done'; }
-
-        paths.push(`<path class="${pathClass}" d="${d}" marker-end="url(#${markerId})" data-source="${esc(sourceBar.dataset.todoId)}" data-target="${esc(targetBar.dataset.todoId)}" />`);
-      });
-    });
-
-    if(paths.length === 0) return;
-
-    svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    svg.setAttribute('class', 'gantt-dependencies-svg');
-    svg.innerHTML = `
-      <defs>
-        <marker id="gantt-arrow-normal" viewBox="0 0 10 10" refX="7" refY="5" markerWidth="6" markerHeight="6" orient="auto">
-          <path d="M 0 1.5 L 8 5 L 0 8.5 z" fill="var(--accent)" />
-        </marker>
-        <marker id="gantt-arrow-conflict" viewBox="0 0 10 10" refX="7" refY="5" markerWidth="6" markerHeight="6" orient="auto">
-          <path d="M 0 1.5 L 8 5 L 0 8.5 z" fill="var(--red)" />
-        </marker>
-        <marker id="gantt-arrow-done" viewBox="0 0 10 10" refX="7" refY="5" markerWidth="6" markerHeight="6" orient="auto">
-          <path d="M 0 1.5 L 8 5 L 0 8.5 z" fill="var(--green)" />
-        </marker>
-      </defs>
-      ${paths.join('')}
-    `;
-
-    chart.appendChild(svg);
-  };
-
-  window.fitPlanGanttRange = function(){
-    const range = ganttRangeFromProjects([planProject], 7);
-    document.getElementById('planGanttStart').value = formatDateISO(range.start);
-    document.getElementById('planGanttEnd').value = formatDateISO(range.end);
-    renderPlanGantt();
-  };
-
-  // zoomPlanGantt: ändert die Pixel-pro-Tag-Stufe des Diagramms.
-  // Nach unten hinaus wird wieder auf die Containerbreite angepasst (fit).
-  window.zoomPlanGantt = function(dir){
-    const container = document.getElementById('planGanttContainer');
-    let start = parseDateISO(document.getElementById('planGanttStart').value);
-    let end = parseDateISO(document.getElementById('planGanttEnd').value);
-    if(!start || !end) return;
-    const totalDays = Math.max(1, daysBetween(start, end) + 1);
-    const cw = container ? Math.max(200, container.clientWidth - 250) : 900;
-    const fitPx = Math.max(3, cw / totalDays);
-    const base = planGanttPxPerDay || fitPx;
-    let next;
-    if(dir > 0){
-      next = Math.min(120, Math.round(base * 1.35));
-    } else {
-      next = Math.round(base / 1.35);
-      if(next <= fitPx * 0.7) next = null;
-    }
-    planGanttPxPerDay = next;
-    renderPlanGantt();
-  };
-
-  // buildGanttHtml in main.v2.js erweitern, damit TODOs als eigene Balken dargestellt
-  // werden und neue TODOs direkt unter der Projektzeile angelegt werden können.
-  const originalBuildGanttHtml = window.buildGanttHtml;
-  window.buildGanttHtml = function(projects, start, end, options = {}){
-    if(!options.showTodos) return originalBuildGanttHtml(projects, start, end, options);
-    const baseHtml = originalBuildGanttHtml(projects, start, end, options);
-    const temp = document.createElement('div');
-    temp.innerHTML = baseHtml;
-    const chart = temp.querySelector('.gantt-chart');
-    if(!chart) return baseHtml;
-    const totalDays = Math.max(1, daysBetween(start, end) + 1);
-    const editable = options.editable;
-
-    projects.forEach(p => {
-      const plan = p.plan || {};
-      const todos = Array.isArray(plan.todos) ? plan.todos : [];
-      const milestones = Array.isArray(plan.milestones) ? plan.milestones : [];
-
-      // Projektzeile finden, unter der TODOs und Meilensteine eingehängt werden
-      const projectRow = chart.querySelector('.gantt-row.gantt-project.highlighted') ||
-                         Array.from(chart.querySelectorAll('.gantt-row.gantt-project')).find(r => {
-                           const label = r.querySelector('.gantt-label');
-                           return label && label.textContent.includes(p.name);
-                         });
-
-      function buildTodoRow(todo, tIdx){
-        if(!todo.id) todo.id = uid();
-        const s = parseDateISO(todo.start), e = parseDateISO(todo.end);
-        const row = document.createElement('div');
-        row.className = 'gantt-row gantt-todo' + (todo.done ? ' done' : '');
-        row.dataset.todoId = todo.id;
-        row.dataset.todoIndex = tIdx;
-
-        let barHtml = '';
-        if(s && e){
-          const barStart = s < start ? start : s;
-          const barEnd = e > end ? end : e;
-          if(barEnd >= start && barStart <= end){
-            const offset = daysBetween(start, barStart);
-            const span = daysBetween(barStart, barEnd) + 1;
-            const dragAttrs = editable ? ` data-gantt-type="todo" data-gantt-project="${esc(p.id)}" data-gantt-index="${tIdx}" data-gantt-start="${formatDateISO(s)}" data-gantt-end="${formatDateISO(e)}" draggable="false"` : '';
-            const handles = editable ? `<span class="gantt-resize gantt-resize-left" data-resize="left"></span><span class="gantt-resize gantt-resize-right" data-resize="right"></span>` : '';
-            const isCritical = options.criticalPath && options.criticalPath.includes(todo.id);
-            const progress = Math.max(0, Math.min(100, parseInt(todo.progress, 10) || 0));
-            barHtml = `<div class="gantt-bar todo${todo.done ? ' done' : ''}${isCritical ? ' critical' : ''}"${dragAttrs} data-todo-id="${esc(todo.id)}" data-todo-depends="${esc((todo.dependsOn || []).join(','))}" style="left:${(offset/totalDays*100).toFixed(4)}%;width:${(span/totalDays*100).toFixed(4)}%" title="${esc(todo.title || 'TODO')}: ${formatDateDE(s)}–${formatDateDE(e)}">${handles}<div class="gantt-progress" style="width:${progress}%"></div></div>`;
-          }
-        }
-
-        let depBadge = '';
-        if(Array.isArray(todo.dependsOn) && todo.dependsOn.length > 0){
-          // Vorgänger können TODOs oder Meilensteine (Prefix "m_") sein
-          const preds = todo.dependsOn.map(id => {
-            const t = todos.find(x => x.id === id);
-            if(t) return { title: t.title || 'TODO', end: t.end };
-            const m = milestones.find(x => 'm_' + x.id === id);
-            if(m) return { title: '🚩 ' + (m.name || 'Meilenstein'), end: m.date };
-            return null;
-          }).filter(Boolean);
-          if(preds.length > 0){
-            const isConflict = preds.some(pred => pred.end && todo.start && parseDateISO(todo.start) <= parseDateISO(pred.end));
-            const names = preds.map(pr => pr.title).join(', ');
-            depBadge = `<span class="gantt-dep-badge${isConflict ? ' conflict' : ''}" title="Vorgänger: ${esc(names)}">↳ ${preds.length === 1 ? esc(preds[0].title) : esc(preds.length + ' Vorgänger')}</span>`;
-          }
-        }
-
-        row.innerHTML = `<div class="gantt-label" data-todo-id="${esc(todo.id)}" style="padding-left:24px;font-weight:400;color:var(--text-muted)" title="${esc(todo.title || 'TODO')}">
-          ${editable ? '<span class="gantt-todo-drag">⋮⋮</span>' : ''}
-          <span class="gantt-todo-title"${editable ? ' onclick="openTodoModal(' + tIdx + ')" style="cursor:pointer"' : ''}>${esc(todo.title || 'TODO')}${depBadge}</span>
-        </div>
-          <div class="gantt-timeline">${barHtml}</div>`;
-        return row;
-      }
-
-      function buildMilestoneRow(m, mIdx){
-        const d = parseDateISO(m.date);
-        const row = document.createElement('div');
-        row.className = 'gantt-row gantt-milestone-row' + (m.position ? ' positioned' : '');
-        row.dataset.milestoneId = m.id;
-        row.dataset.milestoneIndex = mIdx;
-        let diamond = '', labelStyle = 'display:none';
-        if(d){
-          if(d >= start && d <= end){
-            const offset = daysBetween(start, d);
-            const left = (offset / totalDays * 100).toFixed(4) + '%';
-            const dragAttrs = editable ? ` data-gantt-type="milestone" data-gantt-project="${esc(p.id)}" data-gantt-index="${mIdx}" data-gantt-date="${formatDateISO(d)}" draggable="false"` : '';
-            const deps = esc((m.dependsOn || []).join(','));
-            diamond = `<div class="gantt-milestone"${dragAttrs} data-todo-id="m_${esc(m.id)}" data-todo-depends="${deps}" style="left:${left}" title="${esc(m.name)}: ${formatDateDE(d)}"></div>`;
-            labelStyle = 'left:' + left;
-          }
-        }
-        row.innerHTML = `<div class="gantt-label" style="padding-left:24px;font-weight:400;color:var(--text-muted)">
-          ${editable ? '<span class="gantt-todo-drag">⋮⋮</span>' : ''}
-          <span class="gantt-milestone-title"${editable ? ' onclick="openMilestoneModal(' + mIdx + ')" style="cursor:pointer"' : ''}>${esc(m.name || 'Meilenstein')}</span>
-        </div>
-          <div class="gantt-timeline">${diamond}<div class="gantt-milestone-label" style="${labelStyle}">${esc(m.name || '')}</div></div>`;
-        return row;
-      }
-
-      if(!projectRow) return;
-      let insertAfter = projectRow;
-      const insertedMilestoneIds = new Set();
-
-      todos.forEach((todo, tIdx) => {
-        // Meilensteine, die VOR dieser Aufgabe positioniert sind
-        milestones.filter(m => m.position === 'before:' + todo.id).forEach(m => {
-          const mIdx = milestones.indexOf(m);
-          const row = buildMilestoneRow(m, mIdx);
-          insertAfter.parentNode.insertBefore(row, insertAfter.nextSibling);
-          insertAfter = row;
-        });
-
-        // Aufgabenzeile
-        const todoRow = buildTodoRow(todo, tIdx);
-        insertAfter.parentNode.insertBefore(todoRow, insertAfter.nextSibling);
-        insertAfter = todoRow;
-
-        // Meilensteine, die NACH dieser Aufgabe positioniert sind
-        milestones.filter(m => m.position === 'after:' + todo.id).forEach(m => {
-          const mIdx = milestones.indexOf(m);
-          const row = buildMilestoneRow(m, mIdx);
-          insertAfter.parentNode.insertBefore(row, insertAfter.nextSibling);
-          insertAfter = row;
-          insertedMilestoneIds.add(m.id);
-        });
-      });
-
-      // Positionierte Meilensteine, deren referenzierte Aufgabe nicht mehr existiert,
-      // am Ende der Aufgabenliste anhängen, damit sie nicht verloren gehen.
-      milestones.filter(m => m.position && !insertedMilestoneIds.has(m.id)).forEach(m => {
-        const mIdx = milestones.indexOf(m);
-        const row = buildMilestoneRow(m, mIdx);
-        insertAfter.parentNode.insertBefore(row, insertAfter.nextSibling);
-        insertAfter = row;
-      });
-
-    });
-
-    return temp.innerHTML;
-  };
-
-  // ---------- GANTT Drag-Editing (Balken, Meilensteine, Urlaub) ----------
-
-  let ganttDrag = null;
-
-  function initGanttDrag(){
-    const container = document.getElementById('planGanttContainer');
-    if(!container) return;
-    container.addEventListener('mousedown', onGanttMouseDown);
-    container.addEventListener('dblclick', onGanttDoubleClick);
-    document.addEventListener('mousemove', onGanttMouseMove);
-    document.addEventListener('mouseup', onGanttMouseUp);
-    // Klick ohne Bewegung wird bereits in onGanttMouseUp behandelt (Modal öffnen).
-    // Ein zusätzlicher click-Handler würde das Modal doppelt bzw. nach einem
-    // Drag ungewollt öffnen.
-  }
-
-  function onGanttMouseDown(e){
-    if(isLocked()) return;
-    const bar = e.target.closest('[data-gantt-type]');
-    if(!bar) return;
-    const timeline = bar.closest('.gantt-timeline');
-    if(!timeline) return;
-
-    const rangeStart = parseDateISO(document.getElementById('planGanttStart').value);
-    const rangeEnd = parseDateISO(document.getElementById('planGanttEnd').value);
-    if(!rangeStart || !rangeEnd) return;
-
-    const resize = e.target.closest('.gantt-resize');
-    const rect = timeline.getBoundingClientRect();
-
-    ganttDrag = {
-      bar,
-      timeline,
-      type: bar.dataset.ganttType,
-      action: resize ? resize.dataset.resize : 'move',
-      startX: e.clientX,
-      startY: e.clientY,
-      timelineWidth: rect.width,
-      rangeStart,
-      rangeEnd,
-      moved: false,
-      originalStart: parseDateISO(bar.dataset.ganttStart || bar.dataset.ganttDate),
-      originalEnd: parseDateISO(bar.dataset.ganttEnd),
-      personId: bar.dataset.ganttPerson,
-      absenceId: bar.dataset.ganttAbsence,
-      projectId: bar.dataset.ganttProject,
-      milestoneIndex: bar.dataset.ganttType === 'milestone' && bar.dataset.ganttIndex !== undefined ? parseInt(bar.dataset.ganttIndex, 10) : null,
-      todoIndex: bar.dataset.ganttType === 'todo' && bar.dataset.ganttIndex !== undefined ? parseInt(bar.dataset.ganttIndex, 10) : null
-    };
-
-    e.preventDefault();
-    e.stopPropagation();
-  }
-
-  function onGanttMouseMove(e){
-    if(!ganttDrag) return;
-    const totalDays = daysBetween(ganttDrag.rangeStart, ganttDrag.rangeEnd) + 1;
-    const pxPerDay = ganttDrag.timelineWidth / totalDays;
-    const dx = e.clientX - ganttDrag.startX;
-    const dayDelta = Math.round(dx / pxPerDay);
-
-    if(Math.abs(dx) > 2) ganttDrag.moved = true;
-
-    if(ganttDrag.type === 'milestone'){
-      const newDate = addDays(ganttDrag.originalStart, dayDelta);
-      const offset = daysBetween(ganttDrag.rangeStart, newDate);
-      const left = (offset / totalDays * 100).toFixed(4) + '%';
-      ganttDrag.bar.style.left = left;
-      // Zugehöriges Label (nächstes Geschwister-Element) mitbewegen
-      const label = ganttDrag.bar.nextElementSibling;
-      if(label && label.classList.contains('gantt-milestone-label')) label.style.left = left;
-      return;
-    }
-
-    let newStart, newEnd;
-    if(ganttDrag.action === 'move'){
-      newStart = addDays(ganttDrag.originalStart, dayDelta);
-      newEnd = addDays(ganttDrag.originalEnd, dayDelta);
-    } else if(ganttDrag.action === 'left'){
-      newStart = addDays(ganttDrag.originalStart, dayDelta);
-      newEnd = ganttDrag.originalEnd;
-      if(newStart > newEnd) newStart = newEnd;
-    } else if(ganttDrag.action === 'right'){
-      newStart = ganttDrag.originalStart;
-      newEnd = addDays(ganttDrag.originalEnd, dayDelta);
-      if(newEnd < newStart) newEnd = newStart;
-    }
-
-    const barStart = newStart < ganttDrag.rangeStart ? ganttDrag.rangeStart : newStart;
-    const barEnd = newEnd > ganttDrag.rangeEnd ? ganttDrag.rangeEnd : newEnd;
-    const offset = daysBetween(ganttDrag.rangeStart, barStart);
-    const span = daysBetween(barStart, barEnd) + 1;
-    ganttDrag.bar.style.left = (offset / totalDays * 100).toFixed(4) + '%';
-    ganttDrag.bar.style.width = (span / totalDays * 100).toFixed(4) + '%';
-  }
-
-  function onGanttMouseUp(e){
-    if(!ganttDrag) return;
-    const drag = ganttDrag;
-    ganttDrag = null;
-
-    if(!drag.moved && drag.type === 'milestone'){
-      openMilestoneModal(drag.milestoneIndex);
-      return;
-    }
-    if(!drag.moved && drag.type === 'todo'){
-      openTodoModal(drag.todoIndex);
-      return;
-    }
-
-    const totalDays = daysBetween(drag.rangeStart, drag.rangeEnd) + 1;
-    const pxPerDay = drag.timelineWidth / totalDays;
-    const dx = e.clientX - drag.startX;
-    const dayDelta = Math.round(dx / pxPerDay);
-    if(dayDelta === 0){
-      renderPlanGantt();
-      return;
-    }
-
-    let newStartStr, newEndStr;
-    let needsRefit = false;
-
-    if(drag.type === 'milestone'){
-      const newDate = addDays(drag.originalStart, dayDelta);
-      newStartStr = formatDateISO(newDate);
-      updateMilestoneDate(drag.projectId, drag.milestoneIndex, newStartStr);
-      if(newDate < drag.rangeStart || newDate > drag.rangeEnd) needsRefit = true;
-    } else {
-      let newStart, newEnd;
-      if(drag.action === 'move'){
-        newStart = addDays(drag.originalStart, dayDelta);
-        newEnd = addDays(drag.originalEnd, dayDelta);
-      } else if(drag.action === 'left'){
-        newStart = addDays(drag.originalStart, dayDelta);
-        newEnd = drag.originalEnd;
-        if(newStart > newEnd) newStart = newEnd;
-      } else {
-        newStart = drag.originalStart;
-        newEnd = addDays(drag.originalEnd, dayDelta);
-        if(newEnd < newStart) newEnd = newStart;
-      }
-      newStartStr = formatDateISO(newStart);
-      newEndStr = formatDateISO(newEnd);
-      if(newStart < drag.rangeStart || newEnd > drag.rangeEnd) needsRefit = true;
-
-      if(drag.type === 'project'){
-        updateProjectDates(drag.projectId, newStartStr, newEndStr);
-      } else if(drag.type === 'vacation'){
-        updateVacationDates(drag.personId, drag.absenceId, newStartStr, newEndStr);
-      } else if(drag.type === 'todo'){
-        updateTodoDates(drag.todoIndex, newStartStr, newEndStr);
-      }
-    }
-
-    if(needsRefit) fitPlanGanttRange();
-    else renderPlanGantt();
-  }
-
-  function updateTodoDates(idx, start, end){
-    const plan = ensurePlanLocal();
-    if(!plan.todos[idx]) return;
-    plan.todos[idx].start = start;
-    plan.todos[idx].end = end;
-    savePlan();
-  }
-
-  function onGanttDoubleClick(e){
-    if(isLocked()) return;
-    const timeline = e.target.closest('.gantt-timeline');
-    if(!timeline) return;
-    // Nicht auslösen, wenn auf einen Balken geklickt wurde
-    if(e.target.closest('[data-gantt-type]')) return;
-    const rect = timeline.getBoundingClientRect();
-    const x = e.clientX - rect.left;
-    const rangeStart = parseDateISO(document.getElementById('planGanttStart').value);
-    const rangeEnd = parseDateISO(document.getElementById('planGanttEnd').value);
-    if(!rangeStart || !rangeEnd) return;
-    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;
-  }
-
-  function updateProjectDates(projectId, start, end){
-    const p = planWeek.projects.find(x => x.id === projectId);
-    if(!p) return;
-    ensurePlan(p);
-    p.plan.start = start;
-    p.plan.end = end;
-    savePlan();
-  }
-
-  function updateMilestoneDate(projectId, index, date){
-    const p = planWeek.projects.find(x => x.id === projectId);
-    if(!p) return;
-    ensurePlan(p);
-    if(!Array.isArray(p.plan.milestones)) p.plan.milestones = [];
-    if(p.plan.milestones[index]){
-      p.plan.milestones[index].date = date;
-      savePlan();
-      // Optional: Abhängige TODOs automatisch nachziehen
-      const msId = 'm_' + p.plan.milestones[index].id;
-      const affected = (p.plan.todos || []).filter(t => Array.isArray(t.dependsOn) && t.dependsOn.includes(msId));
-      if(affected.length > 0) autoScheduleTodos();
-    }
-  }
-
-  function updateVacationDates(personId, absenceId, start, end){
-    const localPerson = (planWeek.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[department] || [];
-    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; }
-    }
-    savePlan();
-    saveGlobalPeople();
-  }
-
-  // ---------- Kritischer Pfad & Auto-Schedule ----------
-
-  // computeCriticalPath: liefert Array der TODO-IDs, die auf einem kritischen Pfad liegen
-  // (längste Kette von Vorgänger-Abhängigkeiten, End-to-Start)
-  window.computeCriticalPath = function(project){
-    if(!project || !project.plan) return [];
-    const todos = (project.plan.todos || []).filter(t => t.start && t.end);
-    const milestones = (project.plan.milestones || []).filter(m => m.date);
-    if(todos.length === 0 && milestones.length === 0) return [];
-
-    // Einheitliche Knoten: TODOs und Meilensteine (Dauer 1)
-    const nodes = todos.map(t => ({ type: 'todo', id: t.id, obj: t, start: parseDateISO(t.start), end: parseDateISO(t.end), duration: Math.max(1, daysBetween(parseDateISO(t.start), parseDateISO(t.end)) + 1) }));
-    milestones.forEach(m => {
-      const d = parseDateISO(m.date);
-      nodes.push({ type: 'milestone', id: 'm_' + m.id, obj: m, start: d, end: d, duration: 1 });
-    });
-    const nodeMap = new Map(nodes.map(n => [n.id, n]));
-
-    function depsOf(n){
-      return Array.isArray(n.obj.dependsOn) ? n.obj.dependsOn : [];
-    }
-
-    // Frühester Start (ES) und frühestes Ende (EF) berechnen.
-    // visiting-Set schützt vor Endlos-Rekursion bei zyklischen Abhängigkeiten.
-    const es = {}, ef = {};
-    const esVisiting = new Set();
-    function computeES(n){
-      if(es[n.id] !== undefined) return es[n.id];
-      if(esVisiting.has(n.id)){ es[n.id] = null; ef[n.id] = null; return null; } // Zyklus
-      if(!n.start || !n.end){ es[n.id] = null; ef[n.id] = null; return null; }
-      esVisiting.add(n.id);
-      const deps = depsOf(n);
-      let maxEF = null;
-      deps.forEach(depId => {
-        const dep = nodeMap.get(depId);
-        if(!dep) return;
-        const depStart = computeES(dep);
-        if(!depStart) return;
-        const depEnd = addDays(depStart, dep.duration - 1);
-        if(maxEF === null || depEnd > maxEF) maxEF = depEnd;
-      });
-      esVisiting.delete(n.id);
-      es[n.id] = maxEF === null ? n.start : addDays(maxEF, 1);
-      ef[n.id] = addDays(es[n.id], n.duration - 1);
-      return es[n.id];
-    }
-    nodes.forEach(n => computeES(n));
-
-    const validNodes = nodes.filter(n => es[n.id]);
-    if(validNodes.length === 0) return [];
-    const maxEF = validNodes.reduce((max, n) => { const d = ef[n.id]; return !max || d > max ? d : max; }, null);
-
-    // Spätestes Ende (LF) und spätester Start (LS) rückwärts berechnen.
-    // Wichtig: LF eines Knotens ist der Tag VOR dem spätesten Start (LS)
-    // seines frühesten Nachfolgers – nicht vor dessen LF.
-    const lf = {}, ls = {};
-    const lfVisiting = new Set();
-    function computeLF(n){
-      if(lf[n.id] !== undefined) return lf[n.id];
-      if(lfVisiting.has(n.id)){ lf[n.id] = null; ls[n.id] = null; return null; } // Zyklus
-      if(!n.start || !n.end){ lf[n.id] = null; ls[n.id] = null; return null; }
-      lfVisiting.add(n.id);
-      const successors = validNodes.filter(succ => depsOf(succ).includes(n.id));
-      let minLF = null;
-      successors.forEach(succ => {
-        if(!computeLF(succ)) return;
-        const succLS = ls[succ.id];
-        if(!succLS) return;
-        const candidate = addDays(succLS, -1);
-        if(minLF === null || candidate < minLF) minLF = candidate;
-      });
-      lfVisiting.delete(n.id);
-      lf[n.id] = minLF === null ? maxEF : minLF;
-      ls[n.id] = addDays(lf[n.id], -(n.duration - 1));
-      return lf[n.id];
-    }
-    validNodes.forEach(n => computeLF(n));
-
-    return validNodes.filter(n => n.type === 'todo' && es[n.id] && ls[n.id] && daysBetween(es[n.id], ls[n.id]) === 0).map(n => n.id);
-  };
-
-  window.toggleCriticalPath = function(){
-    criticalPathActive = !criticalPathActive;
-    const btn = document.getElementById('criticalPathBtn');
-    if(btn) btn.classList.toggle('active', criticalPathActive);
-    renderPlanGantt();
-    if(criticalPathActive){
-      const path = computeCriticalPath(planProject);
-      if(path.length === 0){
-        showToast('Kein kritischer Pfad ermittelt (zu wenig Aufgaben oder Abhängigkeiten).');
-      } else {
-        showToast(path.length + ' Aufgabe(n) auf dem kritischen Pfad hervorgehoben.');
-      }
-    }
-  };
-
-  window.autoScheduleTodos = function(){
-    if(isLocked()) return;
-    const plan = ensurePlanLocal();
-    if(!Array.isArray(plan.todos) || plan.todos.length === 0) return;
-    const todos = plan.todos.filter(t => t.start && t.end);
-    const todoMap = new Map(todos.map(t => [t.id, t]));
-    const milestones = Array.isArray(plan.milestones) ? plan.milestones.filter(m => m.date) : [];
-    const milestoneMap = new Map(milestones.map(m => ['m_' + m.id, m]));
-
-    function duration(t){ const s = parseDateISO(t.start), e = parseDateISO(t.end); return s && e ? Math.max(1, daysBetween(s, e) + 1) : 1; }
-
-    // processed: bereits fertig eingeplante Knoten
-    // visiting: aktuell im Rekursionspfad -> schützt vor Endlos-Rekursion bei Zyklen
-    // moved: Knoten, deren Datum sich tatsächlich geändert hat
-    const processed = new Set();
-    const visiting = new Set();
-    const moved = new Set();
-    let hasCycle = false;
-
-    function scheduleTodo(t){
-      if(processed.has(t.id)) return;
-      if(visiting.has(t.id)){ hasCycle = true; return; }
-      const tStart = parseDateISO(t.start);
-      if(!tStart){ processed.add(t.id); return; }
-      visiting.add(t.id);
-      const deps = Array.isArray(t.dependsOn) ? t.dependsOn : [];
-      let earliest = tStart;
-      deps.forEach(depId => {
-        let depEnd = null;
-        const depTodo = todoMap.get(depId);
-        if(depTodo){
-          scheduleTodo(depTodo);
-          depEnd = parseDateISO(depTodo.end);
-        } else {
-          const depMs = milestoneMap.get(depId);
-          if(depMs) depEnd = parseDateISO(depMs.date);
-        }
-        if(!depEnd) return;
-        const candidate = addDays(depEnd, 1);
-        if(candidate > earliest) earliest = candidate;
-      });
-      visiting.delete(t.id);
-      const dur = duration(t);
-      const newStart = formatDateISO(earliest);
-      const newEnd = formatDateISO(addDays(earliest, dur - 1));
-      if(newStart !== t.start || newEnd !== t.end){
-        t.start = newStart;
-        t.end = newEnd;
-        moved.add(t.id);
-      }
-      processed.add(t.id);
-    }
-
-    function scheduleMilestone(m){
-      const mId = 'm_' + m.id;
-      if(processed.has(mId)) return;
-      if(visiting.has(mId)){ hasCycle = true; return; }
-      const deps = Array.isArray(m.dependsOn) ? m.dependsOn : [];
-      let earliest = parseDateISO(m.date);
-      if(!earliest){ processed.add(mId); return; }
-      visiting.add(mId);
-      deps.forEach(depId => {
-        let depEnd = null;
-        const depTodo = todoMap.get(depId);
-        if(depTodo){
-          scheduleTodo(depTodo);
-          depEnd = parseDateISO(depTodo.end);
-        } else {
-          const depMs = milestoneMap.get(depId);
-          if(depMs && depMs.id !== m.id){
-            scheduleMilestone(depMs);
-            depEnd = parseDateISO(depMs.date);
-          }
-        }
-        if(!depEnd) return;
-        const candidate = addDays(depEnd, 1);
-        if(candidate > earliest) earliest = candidate;
-      });
-      visiting.delete(mId);
-      const newDate = formatDateISO(earliest);
-      if(newDate !== m.date){
-        m.date = newDate;
-        moved.add(mId);
-      }
-      processed.add(mId);
-    }
-
-    todos.forEach(t => scheduleTodo(t));
-    milestones.forEach(m => scheduleMilestone(m));
-    if(moved.size > 0){
-      savePlan();
-      renderPlanGantt();
-      showToast(moved.size + ' Element(e) automatisch verschoben.' + (hasCycle ? ' Achtung: zyklische Abhängigkeit gefunden!' : ''));
-    } else if(hasCycle){
-      showToast('Achtung: zyklische Abhängigkeit gefunden – bitte Vorgänger prüfen.');
-    } else {
-      showToast('Keine Änderungen nötig – alle Termine passen zu den Abhängigkeiten.');
-    }
-  };
-
-  // ---------- Ressourcen-Auslastung ----------
-
-  window.renderResourceLoad = function(){
-    const container = document.getElementById('resourceLoadContainer');
-    if(!container || !planProject) return;
-    const plan = ensurePlanLocal();
-    const todos = Array.isArray(plan.todos) ? plan.todos.filter(t => t.start && t.end) : [];
-    const assignees = projectAssignees(planProject, planWeek);
-    if(assignees.length === 0){
-      container.innerHTML = '';
-      return;
-    }
-
-    const loads = {};
-    assignees.forEach(a => {
-      if(!loads[a.person.id]){
-        loads[a.person.id] = { person: a.person, roles: [], days: 0, todos: [] };
-      }
-      if(!loads[a.person.id].roles.includes(a.role)) loads[a.person.id].roles.push(a.role);
-    });
-
-    todos.forEach(t => {
-      if(!Array.isArray(t.assignees) || t.assignees.length === 0) return;
-      const days = workdaysBetween(parseDateISO(t.start), parseDateISO(t.end));
-      t.assignees.forEach(pid => {
-        if(!loads[pid]) return;
-        loads[pid].days += days;
-        loads[pid].todos.push(t.title);
-      });
-    });
-
-    const maxDays = Math.max(1, Object.values(loads).reduce((m, l) => Math.max(m, l.days), 0));
-
-    let html = '<div class="section-title" style="margin-bottom:8px;font-size:13px">Ressourcen-Auslastung (Aufgabentage, ohne Wochenenden)</div>';
-    html += '<div class="load-grid plan-resource-grid">';
-    Object.values(loads).forEach(l => {
-      const pct = Math.round(l.days / maxDays * 100);
-      const absCount = countPersonAbsences(l.person.id);
-      const absBadge = absCount > 0 ? `<div class="hint" style="font-size:10px;margin-top:2px">🏖 ${absCount} Abwesenheit(en)</div>` : '';
-
-      let todoListHtml;
-      if(l.todos.length === 0){
-        todoListHtml = '<div class="hint">keine TODOs</div>';
-      } else {
-        todoListHtml = l.todos.slice(0,3).map(t => `<div><span>${esc(t)}</span></div>`).join('');
-        if(l.todos.length > 3){
-          todoListHtml += '<div class="hint">+' + (l.todos.length - 3) + ' weitere</div>';
-        }
-      }
-
-      html += `<div class="load-card plan-resource-card plan-resource-clickable" onclick="openAbsenceModal('${esc(l.person.id)}')" title="Klicken, um Urlaube/Abwesenheiten zu bearbeiten">
-        <h3>${esc(l.person.name)} <span style="font-size:10px;color:#888;font-weight:normal">(${esc(l.roles.join(' / '))})</span></h3>
-        <div class="load-num" style="font-size:18px">${l.days}</div>
-        <div class="bar" style="height:6px;margin-top:4px"><div style="width:${pct}%;background:${pct>75?'#c53030':pct>45?'#d69e2e':'#2f855a'}"></div></div>
-        <div class="load-detail" style="font-size:10px;margin-top:4px">${todoListHtml}</div>
-        ${absBadge}
-      </div>`;
-    });
-    html += '</div>';
-    container.innerHTML = html;
-  };
-
-  // ---------- Abwesenheits-Modal (Urlaube der Projektbeteiligten) ----------
-
-  let currentAbsencePersonId = null;
-
-  // Person in der globalen Liste finden (dort werden Abwesenheiten gepflegt)
-  function findGlobalPerson(personId){
-    return (db.globalPeople[department] || []).find(p => p.id === personId) || null;
-  }
-
-  function countPersonAbsences(personId){
-    const p = findGlobalPerson(personId);
-    return p && Array.isArray(p.absences) ? p.absences.length : 0;
-  }
-
-  window.openAbsenceModal = function(personId){
-    const person = findGlobalPerson(personId);
-    if(!person) return;
-    currentAbsencePersonId = personId;
-    document.getElementById('absenceModalTitle').textContent = 'Abwesenheiten – ' + (person.fullName || person.name);
-    // Formularfelder zurücksetzen
-    const startInput = document.getElementById('absenceEditStart');
-    const endInput = document.getElementById('absenceEditEnd');
-    const rangeDisplay = document.getElementById('absenceEditRange');
-    if(startInput) startInput.value = '';
-    if(endInput) endInput.value = '';
-    if(rangeDisplay) rangeDisplay.value = '';
-    renderAbsenceModalList();
-    document.getElementById('absenceModal').style.display = 'flex';
-  };
-
-  window.closeAbsenceModal = function(){
-    document.getElementById('absenceModal').style.display = 'none';
-    currentAbsencePersonId = null;
-  };
-
-  function renderAbsenceModalList(){
-    const listDiv = document.getElementById('absenceModalList');
-    const person = findGlobalPerson(currentAbsencePersonId);
-    if(!listDiv || !person) return;
-    const absences = Array.isArray(person.absences) ? person.absences : [];
-    const locked = isLocked();
-    if(absences.length === 0){
-      listDiv.innerHTML = '<span class="hint">Keine Abwesenheiten eingetragen.</span>';
-    } else {
-      listDiv.innerHTML = '<div class="absence-list">' + absences.map(a => `
-        <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="deletePlanAbsence('${esc(a.id)}')">×</button>`}
-        </div>`).join('') + '</div>';
-    }
-    const form = document.getElementById('absenceModalForm');
-    if(form) form.style.display = locked ? 'none' : '';
-  }
-
-  window.addPlanAbsence = function(){
-    if(isLocked()) return;
-    const person = findGlobalPerson(currentAbsencePersonId);
-    if(!person) return;
-    const start = document.getElementById('absenceEditStart').value;
-    const end = document.getElementById('absenceEditEnd').value;
-    const type = document.getElementById('absenceEditType').value;
-    const note = document.getElementById('absenceEditNote').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 = [];
-    const absence = { id: uid(), start, end, type, note };
-    person.absences.push(absence);
-    person.absences.sort((a,b) => parseDateISO(a.start) - parseDateISO(b.start));
-    // Auch die Sitzungs-lokale Kopie aktualisieren, damit die Anzeige konsistent bleibt
-    const localPerson = (planWeek.people || []).find(p => p.id === currentAbsencePersonId);
-    if(localPerson){
-      if(!Array.isArray(localPerson.absences)) localPerson.absences = [];
-      localPerson.absences.push({ ...absence });
-      localPerson.absences.sort((a,b) => parseDateISO(a.start) - parseDateISO(b.start));
-    }
-    saveGlobalPeople();
-    savePlan();
-    document.getElementById('absenceEditStart').value = '';
-    document.getElementById('absenceEditEnd').value = '';
-    const rangeDisplay = document.getElementById('absenceEditRange');
-    if(rangeDisplay) rangeDisplay.value = '';
-    document.getElementById('absenceEditNote').value = '';
-    renderAbsenceModalList();
-    renderPlanGantt();
-  };
-
-  window.deletePlanAbsence = function(absenceId){
-    if(isLocked()) return;
-    const person = findGlobalPerson(currentAbsencePersonId);
-    if(!person || !Array.isArray(person.absences)) return;
-    person.absences = person.absences.filter(a => a.id !== absenceId);
-    const localPerson = (planWeek.people || []).find(p => p.id === currentAbsencePersonId);
-    if(localPerson && Array.isArray(localPerson.absences)){
-      localPerson.absences = localPerson.absences.filter(a => a.id !== absenceId);
-    }
-    saveGlobalPeople();
-    savePlan();
-    renderAbsenceModalList();
-    renderPlanGantt();
-  };
-
-  // Toast-Benachrichtigung
-  let toastTimer = null;
-  function showToast(message){
-    let toast = document.getElementById('planToast');
-    if(!toast){
-      toast = document.createElement('div');
-      toast.id = 'planToast';
-      toast.className = 'plan-toast';
-      document.body.appendChild(toast);
-    }
-    toast.textContent = message;
-    toast.classList.add('show');
-    // Vorherigen Timer abbrechen, sonst verschwindet ein neuer Toast zu früh
-    if(toastTimer) clearTimeout(toastTimer);
-    toastTimer = setTimeout(() => { toast.classList.remove('show'); toastTimer = null; }, 2500);
-  }
-
-  // Abhängigkeitslinien hängen von Pixel-Positionen ab -> bei Fenstergröße neu zeichnen
-  let resizeTimer = null;
-  window.addEventListener('resize', () => {
-    if(resizeTimer) clearTimeout(resizeTimer);
-    resizeTimer = setTimeout(() => renderGanttDependencies(), 150);
-  });
-
-  document.addEventListener('DOMContentLoaded', init);
-  document.addEventListener('DOMContentLoaded', initGanttDrag);
-  document.addEventListener('DOMContentLoaded', initGanttTodoDrag);
-})();
diff --git a/public/styles.css b/public/styles.css
index 4323d81..832c101 100644
--- a/public/styles.css
+++ b/public/styles.css
@@ -1161,8 +1161,12 @@ th.role-bauüberwachung { color: var(--text); }
 .legend-item.locked-legend-item { opacity: .7; }
 
 #boardLegend {
+  margin-top: 16px;
+  padding: 12px;
   background: var(--surface);
   border: 1px solid var(--line-soft);
+  border-radius: 6px;
+  font-size: 12px;
 }
 
 .swatch {
diff --git a/server.js b/server.js
index 7f05dbe..08fd241 100644
--- a/server.js
+++ b/server.js
@@ -1,19 +1,38 @@
 /*
  * Express-Server der Projektübersicht: liefert die statischen Frontend-Dateien aus
- * public/ (Test.html unter "/") aus und stellt den Frontend-Modulen unter public/js/
- * eine CSV-API zum Laden und Speichern der Sitzungsdaten in sessions/ bereit.
- * Standardport ist 3003, überschreibbar über die Umgebungsvariable PORT.
- * Endpunkte: GET /, GET /health, GET /load-all, POST /save-csv, POST /delete-csv.
- * Die Daten werden als UTF-8-CSV mit BOM geschrieben; ungültige Abteilungen fallen
- * auf ELT zurück, Dateinamen werden über safeName() streng validiert.
+ * public/ (Test.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.
+ *
+ * Das Schema ist voll relational normalisiert: statt eines grossen JSON-Dokuments
+ * pro Woche gibt es eigene Tabellen für Wochen-Metadaten, Wochen-Personen, Rollen,
+ * Anwesenheit, Projekte, LPH-Werte, Projekt-Zuordnungen, Projektpläne, TODOs,
+ * Meilensteine, Abhängigkeiten sowie die globalen Personen inkl. Rollen und
+ * Abwesenheiten. Die HTTP-API bleibt davon unberührt: Das Frontend sendet und
+ * erhält weiterhin komplette Wochen- und Personen-Objekte (JSON); der Server
+ * verteilt sie beim Speichern auf die Tabellen und setzt sie beim Laden wieder
+ *  Zusammen (Serializer/Deserializer).
+ *
+ *  Eine bestehende Datenbank aus dem alten Ein-Dokument-pro-Woche-Format wird
+ *  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),
+ *  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).
+ *  Ungültige Abteilungen fallen auf ELT zurück.
  */
 const express = require('express');
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
+const zlib = require('zlib');
+const { DatabaseSync } = require('node:sqlite');
 const app = express();
 
-// Wichtige Konstanten: UTF-8-BOM für CSV-Dateien, Serverport (PORT-Env) und die gültigen Abteilungsordner
-const BOM = Buffer.from([0xEF, 0xBB, 0xBF]);
+// Wichtige Konstanten: Serverport (PORT-Env) und die gültigen Abteilungsordner
 const PORT = process.env.PORT || 3003;
 const VALID_DEPARTMENTS = new Set(['ELT','HLS','ARCH']);
 
@@ -30,87 +49,1320 @@ app.use(express.static(path.join(__dirname, 'public'), {
   }
 }));
 
-// Datenverzeichnis sessions/ bei Bedarf anlegen
+// Datenverzeichnis sessions/ bei Bedarf anlegen (bind-mounted in Docker, enthält die DB)
 const SESSIONS_DIR = path.join(__dirname, 'sessions');
 if(!fs.existsSync(SESSIONS_DIR)) fs.mkdirSync(SESSIONS_DIR, { recursive: true });
 
-// Erlaubt ausschliesslich sichere CSV-Dateinamen im Format <Name>.csv
-function safeName(name){
-  const raw = String(name || '');
-  // Pfad-Trennzeichen und Verzeichnisnavigation ablehnen
-  if(/[\\/]|\.\./.test(raw)) return null;
-  const base = path.basename(raw);
-  if(!base || base.toLowerCase() === '.csv') return null;
-  const safe = base.replace(/[^a-zA-Z0-9_\-\.]/g,'_');
-  if(!/^([a-zA-Z0-9_\-]+)\.csv$/i.test(safe)) return null;
-  return safe;
+// SQLite-Datenbank öffnen (wird angelegt, falls nicht vorhanden). Der Pfad ist
+// über die Umgebungsvariable DB_PATH übersteuerbar (für Tests/Backups), sonst
+// standardmäßig sessions/projektuebersicht.db.
+const DB_PATH = process.env.DB_PATH ? path.resolve(process.env.DB_PATH) : path.join(SESSIONS_DIR, 'projektuebersicht.db');
+const db = new DatabaseSync(DB_PATH);
+db.exec('PRAGMA journal_mode = WAL;');
+db.exec('PRAGMA foreign_keys = ON;');
+db.exec('PRAGMA busy_timeout = 5000;'); // 5 s warten statt SQLITE_BUSY-Fehlern bei parallelen Schreibern
+
+// ---------- Schema (voll relational normalisiert) ----------
+
+// Der serialisierte Datenbestand einer Woche besteht aus folgenden Entitäten:
+//  - weeks: Metadaten (id, label, date, locked)
+//  - week_people / week_people_roles: personen-Kopien pro Woche
+//  - attendance: Anwesenheit pro Woche/Person
+//  - projects: Projekt-Metadaten pro Woche
+//  - project_lph: LPH-Fortschrittswerte pro Projekt
+//  - project_assign: Zuordnungen (Haupt/Optional) pro Projekt/Person/Rolle
+//  - project_plan: Plan-Kopf (start, end, progress) pro Projekt
+//  - 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
+
+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)
+)`);
+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)
+)`);
+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)
+)`);
+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)
+)`);
+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 '',
+  "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)
+)`);
+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)
+)`);
+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)
+)`);
+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)
+)`);
+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)
+)`);
+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)
+)`);
+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)
+)`);
+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,
+  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 (department, 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)
+)`);
+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)
+)`);
+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,
+  name TEXT NOT NULL DEFAULT '',
+  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)
+)`);
+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)
+)`);
+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 '',
+  email TEXT NOT NULL DEFAULT '',
+  sort_order INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (department, person_id)
+)`);
+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)
+)`);
+
+// Erlaubt ausschliesslich die gültigen Abteilungen (ELT|HLS|ARCH, sonst ELT)
+function departmentKey(department){
+  return (typeof department === 'string' && VALID_DEPARTMENTS.has(department)) ? department : 'ELT';
 }
 
-// Liefert den Zielordner für eine Abteilung (nur ELT|HLS|ARCH, sonst ELT) und legt ihn bei Bedarf an
-function departmentDir(department){
-  const dept = (typeof department === 'string' && VALID_DEPARTMENTS.has(department)) ? department : 'ELT';
-  const dir = path.join(SESSIONS_DIR, dept);
-  if(!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  return dir;
+// ---------- Migration: altes Ein-Dokument-Format -> relationales Schema ----------
+
+// hasLegacyWeeksTable: erkennt das alte Schema an der Daten-Spalte in `weeks`.
+function hasLegacyWeeksTable(){
+  const cols = db.prepare("SELECT name FROM pragma_table_info('weeks') WHERE name = 'data'").all();
+  return cols.length > 0;
 }
 
-// Route: Speichert eine CSV-Datei (mit UTF-8-BOM) für eine Abteilung im sessions/-Ordner
-app.post('/save-csv', (req, res) => {
-  const { filename, csv, department } = req.body || {};
-  if(!filename || typeof csv !== 'string') return res.status(400).json({ ok: false, error: 'Missing filename or csv' });
-  const safe = safeName(filename);
-  if(!safe) return res.status(400).json({ ok: false, error: 'Invalid filename' });
-  const dir = departmentDir(department);
-  const out = path.join(dir, safe);
-  const data = Buffer.concat([BOM, Buffer.from(csv, 'utf8')]);
-  fs.writeFile(out, data, (err) => {
-    if(err){ console.error('Write error', err); return res.status(500).json({ ok:false, error: String(err) }); }
-    console.log('Saved CSV:', out);
-    return res.json({ ok: true, path: out });
-  });
-});
+// 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){
+  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);
 
-// Route: Löscht eine CSV-Datei einer Abteilung aus dem sessions/-Ordner (fehlende Datei wird toleriert)
-app.post('/delete-csv', (req, res) => {
-  const { filename, department } = req.body || {};
-  if(!filename) return res.status(400).json({ ok: false, error: 'Missing filename' });
-  const safe = safeName(filename);
-  if(!safe) return res.status(400).json({ ok: false, error: 'Invalid filename' });
-  const dir = departmentDir(department);
-  const out = path.join(dir, safe);
-  fs.unlink(out, (err) => {
-    if(err){
-      if(err.code === 'ENOENT') {
-        console.log('CSV-Datei nicht gefunden:', out);
-        return res.json({ ok: true, missing: true });
-      }
-      console.error('Delete error', err);
-      return res.status(500).json({ ok:false, error: String(err) });
-    }
-    console.log('Deleted CSV:', out);
-    return res.json({ ok: true });
-  });
-});
+  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)
+    VALUES (?, ?, ?, ?, ?)`);
+  const insAttendance = db.prepare(`INSERT OR REPLACE INTO attendance (department, week_label, person_id, present)
+    VALUES (?, ?, ?, ?)`);
 
-// Route: Lädt alle Sitzungs-CSV-Dateien einer Abteilung plus _people.csv (nach Dateiname sortiert)
-app.get('/load-all', (req, res) => {
-  const dir = departmentDir(req.query.department);
-  fs.readdir(dir, (err, files) => {
-    if(err){ console.error('Read error', err); return res.status(500).json({ ok:false, error: String(err) }); }
-    const csvFiles = files.filter(f => f.toLowerCase().endsWith('.csv'));
-    const result = { ok: true, sessions: [], people: null };
-    csvFiles.forEach(filename => {
-      if(filename.toLowerCase() === '_people.csv'){
-        result.people = fs.readFileSync(path.join(dir, filename), 'utf8');
-        return;
-      }
-      const content = fs.readFileSync(path.join(dir, filename), 'utf8');
-      result.sessions.push({ filename, content });
+  (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));
+  });
+  const att = week.attendance || {};
+  Object.keys(att).forEach(pid => {
+    insAttendance.run(department, 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)
+    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)
+    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)
+    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)
+    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);
+    const lph = p.lph || {};
+    Object.keys(lph).forEach(l => insLph.run(department, 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);
     });
-    // Sortiere Sitzungen nach Dateiname, damit die Reihenfolge stabil ist
-    result.sessions.sort((a,b) => a.filename.localeCompare(b.filename));
-    res.json(result);
+    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);
+      });
+    });
+    (Array.isArray(p.aktuelleLP) ? p.aktuelleLP : []).forEach(lph => {
+      insAktuelleLp.run(department, 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));
+      (Array.isArray(plan.todos) ? plan.todos : []).forEach((t, tidx) => {
+        insTodo.run(department, 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(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 || '')));
+      });
+    }
   });
+  // Rückgabe der Revision für den Aufrufer (saveWeekRelational -> Route)
+  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',
+    '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);
+  });
+  // Die Wochen-Tabelle selbst nutzt `label` statt `week_label`
+  db.prepare('DELETE FROM weeks WHERE department = ? AND label = ?').run(department, 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){
+  const weekLabel = String(week.label || '');
+  const tx = db.exec('BEGIN');
+  try {
+    deleteWeekData(department, weekLabel);
+    const updatedAt = serializeWeek(department, week);
+    db.exec('COMMIT');
+    return updatedAt;
+  } catch(err){
+    db.exec('ROLLBACK');
+    throw err;
+  }
+}
+
+// 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] || [],
+  }));
+}
+
+// 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);
+
+  // 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 weekPeopleMap = {};
+  const weekRolesMap = {};
+  const attendanceMap = {};
+  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 };
+  });
+  weekRoles.forEach(r => {
+    const k = weekKey(r.week_label);
+    const arr = (weekRolesMap[k] = weekRolesMap[k] || {});
+    (arr[r.person_id] = arr[r.person_id] || []).push(r.role);
+  });
+  attendance.forEach(r => {
+    attendanceMap[weekKey(r.week_label) + '|' + r.person_id] = !!r.present;
+  });
+
+  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,
+      _arrayOrder: r.array_order,
+    };
+  });
+  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)];
+    if(p) p.assign[r.person_id + (r.role ? '|' + r.role : '')] = r.state;
+  });
+  aufwand.forEach(r => {
+    const p = projectsMap[projKey(r.week_label, r.project_id)];
+    if(p){ p.aufwandProLP = p.aufwandProLP || {}; (p.aufwandProLP[r.lph] = p.aufwandProLP[r.lph] || {})[r.role] = r.value; }
+  });
+  aktuelleLp.forEach(r => {
+    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); }
+  });
+
+  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: [] }; });
+  planPeople.forEach(r => {
+    const plan = planMap[projKey(r.week_label, r.project_id)];
+    if(plan) plan.people.push(r.person_id);
+  });
+
+  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 };
+  });
+  todoAssignees.forEach(r => {
+    const t = todoMap[todoKey(r.week_label, r.project_id, r.todo_id)];
+    if(t) t.assignees.push(r.person_id);
+  });
+  todoDeps.forEach(r => {
+    const t = todoMap[todoKey(r.week_label, r.project_id, r.todo_id)];
+    if(t) t.dependsOn.push(r.depends_on_id);
+  });
+
+  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: [] };
+  });
+  milestoneDeps.forEach(r => {
+    const m = msMap[msKey(r.week_label, r.project_id, r.milestone_id)];
+    if(m) m.dependsOn.push(r.depends_on_id);
+  });
+
+  // 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]];
+    if(plan) plan.todos.push(todoMap[k]);
+  });
+  Object.keys(msMap).forEach(k => {
+    const parts = k.split('|');
+    const plan = planMap[department + '|' + parts[1] + '|' + parts[2]];
+    if(plan) plan.milestones.push(msMap[k]);
+  });
+
+  // Wochen-Objekte zusammensetzen
+  return weeks.map(w => {
+    const wkey = weekKey(w.label);
+    const people = (weekPeopleMap[wkey] || []).filter(Boolean).map(p => {
+      const roles = (weekRolesMap[wkey] || {})[p.id] || [];
+      const full = Object.assign({}, p);
+      if(roles.length) full.role = roles;
+      return full;
+    });
+    const att = {};
+    (weekPeopleMap[wkey] || []).filter(Boolean).forEach(p => {
+      const present = attendanceMap[wkey + '|' + p.id];
+      if(present !== undefined) att[p.id] = present;
+    });
+    const weekProjects = Object.keys(projectsMap)
+      .filter(k => k.startsWith(department + '|' + w.label + '|'))
+      .map(k => {
+        const p = projectsMap[k];
+        const plan = planMap[k];
+        if(plan) p.plan = plan;
+        return p;
+      })
+      .sort((a,b) => a._arrayOrder - b._arrayOrder)
+      .map(({ _arrayOrder, ...rest }) => rest);
+    return {
+      id: w.week_id, label: w.label, date: w.date,
+      people, projects: weekProjects, attendance: att, locked: !!w.locked,
+      updatedAt: w.updated_at || '',
+    };
+  });
+}
+
+// ---------- 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) ----------
+//
+// 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
+// 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
+// werden einbezogen).
+
+// 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;
+
+// createDbSnapshot: erzeugt einen konsistenten Snapshot der SQLite-DB in die
+// angegebene Zieldatei (VACUUM INTO; funktioniert auch bei WAL-Mode).
+function createDbSnapshot(targetPath){
+  const quoted = String(targetPath).replace(/'/g, "''");
+  db.exec(`VACUUM INTO '${quoted}'`);
+}
+
+// runAutoBackup: legt ein zeitgestempeltes Backup in BACKUP_DIR ab und
+// verwirft ältere, sobald MAX_BACKUPS überschritten ist. Fehler werden nur
+// geloggt (Backup darf den Serverstart nicht verhindern).
+function runAutoBackup(){
+  try {
+    if(!fs.existsSync(BACKUP_DIR)) fs.mkdirSync(BACKUP_DIR, { recursive: true });
+    // Zeitstempel mit Millisekunden, damit auch zwei Backups innerhalb einer
+    // Sekunde (z. B. direkt nach dem Import) eindeutige Dateinamen erhalten.
+    const base = 'projektuebersicht_' + new Date().toISOString().replace(/[:.]/g, '-').slice(0, 23);
+    let file = path.join(BACKUP_DIR, base + '.db');
+    let suffix = 1;
+    while(fs.existsSync(file)) file = path.join(BACKUP_DIR, base + '-' + (suffix++) + '.db');
+    createDbSnapshot(file);
+    console.log('Datenbank-Backup erstellt:', file);
+
+    // Nur die letzten MAX_BACKUPS 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 => {
+      fs.unlinkSync(path.join(BACKUP_DIR, b.name));
+    });
+  } catch(err){
+    console.error('Automatisches Backup fehlgeschlagen:', err.message);
+  }
+}
+
+// ---------- Datenbank-Import (Wiederherstellung aus Backup) ----------
+//
+// POST /import nimmt eine mit "DB Backup" erzeugte .db-Datei als rohen
+// Binär-Body entgegen, validiert das Schema und ersetzt den gesamten
+// Datenbestand der laufenden Datenbank durch den Inhalt der Backup-Datei.
+// Das Aufspielen erfolgt per ATTACH + DELETE/INSERT-SELECT in einer
+// Transaktion: Die Live-Verbindung bleibt stabil, bei Fehlern wird
+// 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.
+const IMPORT_TABLES = ['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'];
+
+// dbTableColumns: liefert die Spaltennamen einer Tabelle (funktioniert gegen
+// jede DatabaseSync-Instanz, auch read-only Backups) via pragma_table_info.
+function dbTableColumns(conn, table){
+  return conn.prepare('SELECT name FROM pragma_table_info(?)').all(table).map(r => r.name);
+}
+
+// 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'];
+
+// restoreDbFromBackup: validiert die Backup-Datei (muss das bekannte Schema
+// mit identischen Spalten wie die Live-DB besitzen) und ersetzt den
+// Datenbestand der Live-DB durch den Snapshot. Parameter: backupPath (Pfad).
+// Wirft bei ungültigem Schema oder Transferfehler (Transaktion wird gerollt).
+function restoreDbFromBackup(backupPath){
+  const backupConn = new DatabaseSync(backupPath, { readOnly: true });
+  try {
+    // 1) Schema-Validierung: Tabelle muss existieren und jede Spalte der
+    // Live-DB (außer den als optional markierten) enthalten. Zusätzliche
+    // Spalten im Backup (z. B. aus einer neueren Version) werden ignoriert.
+    for(const t of IMPORT_TABLES){
+      const liveCols = dbTableColumns(db, t);
+      const backCols = dbTableColumns(backupConn, t);
+      if(liveCols.length === 0) throw new Error('Live-Schema defekt (Tabelle fehlt): ' + t);
+      if(backCols.length === 0) throw new Error('Ungültiges Backup (Tabelle fehlt): ' + t);
+      const missing = liveCols.filter(c => !backCols.includes(c) && !IMPORT_OPTIONAL_COLS.includes(c));
+      if(missing.length > 0) throw new Error('Backup-Schema passt nicht zur Live-DB (Tabelle ' + t + ', fehlt: ' + missing.join(', ') + ')');
+    }
+
+    // 2) Datentransfer: Backup anbinden, Bestand löschen, Snapshot übernehmen.
+    db.exec(`ATTACH DATABASE '${String(backupPath).replace(/'/g, "''")}' AS import_backup`);
+    db.exec('BEGIN');
+    try {
+      IMPORT_TABLES.forEach(t => db.exec('DELETE FROM ' + t));
+      for(const t of IMPORT_TABLES){
+        const liveCols = dbTableColumns(db, t);
+        const backCols = dbTableColumns(backupConn, t);
+        // Nur Spalten übertragen, die BEIDE Schemas enthalten (alte Backups
+        // ohne updated_at bleiben so importierbar).
+        const common = liveCols.filter(c => backCols.includes(c));
+        // Anführungszeichen um jede Spalte: `projects` enthält die
+        // SQL-Schlüsselwort-Spalte "group", die sonst einen Syntaxfehler wirft.
+        const quoted = common.map(c => '"' + c + '"').join(', ');
+        const marks = common.map(() => '?').join(', ');
+        const rows = backupConn.prepare('SELECT ' + quoted + ' FROM ' + t).all();
+        const ins = db.prepare('INSERT INTO ' + t + ' (' + quoted + ') VALUES (' + marks + ')');
+        rows.forEach(r => ins.run(...common.map(c => r[c])));
+      }
+      db.exec('COMMIT');
+    } catch(err){
+      db.exec('ROLLBACK');
+      throw err;
+    } finally {
+      db.exec('DETACH DATABASE import_backup');
+    }
+  } finally {
+    backupConn.close();
+  }
+}
+
+// ---------- Migration: altes Ein-Dokument-Format -> relationales Schema ----------
+
+// migrateLegacySchema: überführt eine bestehende Datenbank aus dem alten Format
+// (eine `weeks`-Tabelle mit JSON-`data`-Spalte sowie `people` mit JSON-`data`)
+// in das relationale Schema. Wird einmalig beim Start ausgeführt.
+function migrateLegacySchema(){
+  if(!hasLegacyWeeksTable()) return;
+  console.log('Migriere altes Wochen-Dokument-Format in relationales Schema …');
+
+  // Alte Wochen-Dokumente lesen
+  const legacyWeeks = db.prepare('SELECT department, label, data FROM weeks').all();
+  // Alte globale Personen-Dokumente lesen (eine JSON-Array-Zeile pro Abteilung)
+  const legacyPeopleRows = [];
+  const hasLegacyPeople = db.prepare("SELECT COUNT(*) AS c FROM sqlite_master WHERE type='table' AND name='people' AND sql LIKE '%data%'").get().c > 0;
+  if(hasLegacyPeople){
+    legacyPeopleRows.push(...db.prepare('SELECT department, data FROM people').all());
+  }
+  const tx = db.exec('BEGIN');
+  try {
+    // Alte Tabellen entfernen (Reihenfolge: erst Kind-Tabellen, dann Stamm)
+    db.exec(`DROP TABLE IF EXISTS week_people_roles; DROP TABLE IF EXISTS week_people;
+      DROP TABLE IF EXISTS attendance; DROP TABLE IF EXISTS project_lph;
+      DROP TABLE IF EXISTS project_assign; DROP TABLE IF EXISTS project_aufwand;
+      DROP TABLE IF EXISTS project_aktuelle_lp; DROP TABLE IF EXISTS project_plan;
+      DROP TABLE IF EXISTS plan_people; DROP TABLE IF EXISTS plan_todos;
+      DROP TABLE IF EXISTS plan_todo_assignees; DROP TABLE IF EXISTS plan_todo_deps;
+      DROP TABLE IF EXISTS plan_milestones; DROP TABLE IF EXISTS plan_milestone_deps;
+      DROP TABLE IF EXISTS projects; DROP TABLE IF EXISTS weeks;
+      DROP TABLE IF EXISTS people; DROP TABLE IF EXISTS person_roles; DROP TABLE IF EXISTS person_absences;`);
+
+    // Neue Tabellen anlegen (Schema-DDL oben ausführen)
+    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)
+    )`);
+    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)
+    )`);
+    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)
+    )`);
+    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)
+    )`);
+    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 '',
+      "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)
+    )`);
+    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)
+    )`);
+    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)
+    )`);
+    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)
+    )`);
+    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)
+    )`);
+    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)
+    )`);
+    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)
+    )`);
+    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, 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 (department, 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)
+    )`);
+    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)
+    )`);
+    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, name TEXT NOT NULL DEFAULT '', 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)
+    )`);
+    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)
+    )`);
+    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 '', email TEXT NOT NULL DEFAULT '',
+      sort_order INTEGER NOT NULL DEFAULT 0, PRIMARY KEY (department, person_id)
+    )`);
+    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)
+    )`);
+
+    // Alte Dokumente einlesen und relational speichern. Die Tabellen wurden
+    // gerade neu angelegt und sind leer; `serializeWeek` genügt (kein eigener
+    // Transaktions-Wrapper, da die äußere BEGIN/COMMIT der Migration aktiv ist).
+    legacyWeeks.forEach(row => {
+      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);
+    });
+    // Globale Personen aus dem alten Dokument-Format migrieren. serializeGlobalPeople
+    // startet selbst eine Transaktion, daher werden die Zeilen hier direkt in die
+    // neuen Tabellen eingefügt (serializeGlobalPeople ist in Transaktionen nicht
+    // aufrufbar, weil BEGIN innerhalb BEGIN nicht erlaubt ist).
+    legacyPeopleRows.forEach(row => {
+      let people;
+      try { people = JSON.parse(row.data); } catch(e){ console.error('Kaputte Personen-Liste bei Migration:', row.department, e.message); return; }
+      if(!Array.isArray(people)) return;
+      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(row.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(row.department, String(p.id || ''), String(r || ''), ridx));
+        (Array.isArray(p.absences) ? p.absences : []).forEach(a => insAbsence.run(row.department, String(p.id || ''), String(a || '')));
+      });
+    });
+    db.exec('COMMIT');
+    console.log('Migration abgeschlossen (' + legacyWeeks.length + ' Wochen).');
+  } catch(err){
+    db.exec('ROLLBACK');
+    console.error('Migration fehlgeschlagen:', err.message);
+    throw err;
+  }
+}
+
+// migrateWeeksUpdatedAt: ergänzt die `updated_at`-Spalte in bestehenden
+// relationalen Datenbanken (idempotent; neue DBs haben die Spalte bereits).
+function migrateWeeksUpdatedAt(){
+  const cols = db.prepare("SELECT name FROM pragma_table_info('weeks')").all().map(r => r.name);
+  if(!cols.includes('updated_at')){
+    db.exec("ALTER TABLE weeks ADD COLUMN updated_at TEXT NOT NULL DEFAULT ''");
+    console.log('Wochen-Tabelle um updated_at ergänzt.');
+  }
+}
+
+// Migration beim Serverstart ausführen
+migrateLegacySchema();
+migrateWeeksUpdatedAt();
+
+// Route: Speichert eine komplette Woche (als JSON-Objekt) für eine Abteilung
+app.post('/save-week', (req, res) => {
+  const { department, 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);
+  try {
+    // Revisions-/Konflikt-Check: Mit `baseUpdatedAt` meldet der Client die
+    // Version, auf der seine lokalen Daten beruhen. Ist die Woche auf dem
+    // Server zwischenzeitlich von jemand anderem gespeichert worden, wird
+    // NICHT überschrieben, sondern ein Konflikt gemeldet (HTTP 409).
+    // Wichtig: Auch eine leere Basis (updated_at='' direkt nach der Migration)
+    // wird geprüft – nur Clients OHNE baseUpdatedAt-Feld (alte Versionen)
+    // ü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.
+    if(typeof baseUpdatedAt === 'string'){
+      const row = db.prepare('SELECT updated_at FROM weeks WHERE department = ? AND label = ?').get(dept, String(week.label));
+      if(row){
+        if(baseUpdatedAt !== row.updated_at){
+          return res.status(409).json({
+            ok: false,
+            conflict: true,
+            error: 'Die Sitzung "' + week.label + '" wurde zwischenzeitlich von einer anderen Person geändert.',
+            updatedAt: row.updated_at
+          });
+        }
+      } else if(baseUpdatedAt !== ''){
+        // Die Woche existiert am Server nicht mehr (vermutlich gelöscht). Ein
+        // Save mit nicht-leerer, also älterer Revision darf eine gelöschte
+        // Sitzung nicht wiederbeleben; nur neue Wochen (leere/fehlende Basis)
+        // dürfen angelegt werden.
+        return res.status(409).json({
+          ok: false,
+          conflict: true,
+          error: 'Die Sitzung "' + week.label + '" wurde zwischenzeitlich gelöscht.',
+          updatedAt: ''
+        });
+      }
+    }
+    // `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);
+    return res.json({ ok: true, updatedAt: updatedAt || new Date().toISOString() });
+  } catch(err){
+    console.error('Save week error', err);
+    return res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// 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 || {};
+  if(!label) return res.status(400).json({ ok: false, error: 'Missing label' });
+  const dept = departmentKey(department);
+  try {
+    const row = db.prepare('SELECT 1 FROM weeks WHERE department = ? AND label = ?').get(dept, String(label));
+    const existed = !!row;
+    deleteWeekData(dept, String(label));
+    console.log('Deleted week:', dept + ' / ' + label, existed ? '' : '(nicht vorhanden)');
+    return res.json({ ok: true, deleted: existed });
+  } catch(err){
+    console.error('Delete week error', err);
+    return res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// 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) => {
+  try {
+    const dept = departmentKey(req.query.department);
+    const weeks = loadWeeks(dept);
+    const people = loadGlobalPeople(dept);
+    res.json({ ok: true, weeks, people });
+  } 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) => {
+  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)');
+  } catch(err){
+    console.error('CSV-Export fehlgeschlagen:', err);
+    if(!res.headersSent) 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) => {
+  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';
+    res.download(tmp, filename, () => fs.unlink(tmp, () => {}));
+    console.log('DB-Backup-Download:', filename);
+  } catch(err){
+    console.error('DB-Backup fehlgeschlagen:', err);
+    fs.unlink(tmp, () => {});
+    if(!res.headersSent) res.status(500).json({ ok: false, error: String(err) });
+  }
+});
+
+// Route: DB-Import (Backup-Wiederherstellung). Erwartet eine .db-Datei aus
+// GET /backup bzw. "DB Backup" als rohen Binär-Body (application/octet-stream);
+// 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) => {
+  const buf = req.body;
+  if(!Buffer.isBuffer(buf) || buf.length === 0){
+    return res.status(400).json({ ok: false, error: 'Keine Datei empfangen' });
+  }
+  const tmp = path.join(os.tmpdir(), 'projektuebersicht_import_' + Date.now() + '.db');
+  try {
+    fs.writeFileSync(tmp, buf);
+    // Zustand VOR dem Restore sichern (danach wäre der Snapshot bereits der
+    // importierte Stand und die Wiederherstellung unmöglich).
+    runAutoBackup();
+    restoreDbFromBackup(tmp);
+    console.log('Datenbank aus Backup wiederhergestellt (' + buf.length + ' Bytes)');
+    return res.json({ ok: true });
+  } catch(err){
+    console.error('Datenbank-Import fehlgeschlagen:', err);
+    if(!res.headersSent) res.status(500).json({ ok: false, error: String(err && err.message ? err.message : err) });
+  } finally {
+    fs.unlink(tmp, () => {});
+  }
 });
 
 // Route: Healthcheck-Endpunkt für Docker/Überwachung
@@ -150,7 +1402,11 @@ app.get('/:department/Projektplan/:projName', (req, res) => {
 });
 
 // Serverstart mit Fehlerbehandlung (z.B. Port bereits belegt)
-const server = app.listen(PORT, ()=> console.log(`CSV-Session server running on http://localhost:${PORT}`));
+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)
+  runAutoBackup();
+});
 server.on('error', (err) => {
   console.error('Server konnte nicht starten:', err.message);
   if(err.code === 'EADDRINUSE'){
diff --git a/sessions/.DS_Store b/sessions/.DS_Store
deleted file mode 100644
index 0588eda..0000000
Binary files a/sessions/.DS_Store and /dev/null differ
diff --git a/sessions/ARCH/KW_32___2026.csv b/sessions/ARCH/KW_32___2026.csv
deleted file mode 100644
index 75b068d..0000000
--- a/sessions/ARCH/KW_32___2026.csv
+++ /dev/null
@@ -1,8 +0,0 @@
-WOCHE;KW 32 / 2026;2026-08-05;
-PERSONEN;;;RS|Planung|Rieke Stilleke;AC|Planung|Atilla Ceylan;CJ|Planung|Carina Jost;SM|Planung|Shahab Mushref;TC|Planung|Tetiana Chevhuz;MK|Projektleitung|Maximilian Kriener;SS|Projektleitung|Sekandar Seradj;MK|Bauüberwachung|Maximilian Kriener;SS|Bauüberwachung|Sekandar Seradj;;;;;;;;;;;
-Pr.-Nr.;Bezeichnung;Status;RS;AC;CJ;SM;TC;MK;SS;MK;SS;LPH 1;LPH 2;LPH 3;LPH 4;LPH 5;LPH 6;LPH 7;LPH 8;W+M;Gruppe;Index;Plan
-ANWESENHEIT;;;;;;;;;;;;;;;;;;;;;;
-21-4001;Feuerwehrgeräteh. Rodenkirchen;- Wettbewerbsbeitrag erstellt;;;;;;;;;;100%;100%;;;;;;;;Aktive Projekte;5;
-;Umbau Praxisräume;- Bestandsaufnahme geplant Test schreiben ;;;;;;;;;;100%;;;;;;;;;In Anbahnung;0;
-;Denkmalschutzgutachten;- Kurzcheck erstellt;;;;;;;;;;100%;;;;;;;;;In Anbahnung;1;
-;Architektur Zeichnungsvorlagen;- Vorlagen aktualisiert;;;;;;;;;;100%;;;;;;;;;Allgemein;0;
\ No newline at end of file
diff --git a/sessions/ARCH/_people.csv b/sessions/ARCH/_people.csv
deleted file mode 100644
index b526578..0000000
--- a/sessions/ARCH/_people.csv
+++ /dev/null
@@ -1,8 +0,0 @@
-NAME;Rollen;Voller Name;E-Mail;Abwesenheiten
-AC;Planung;Atilla Ceylan;a.ceylan@rauschenberg-ing.de;[]
-CJ;Planung;Carina Jost;c.jost@rauschenberg-ing.de;[]
-MK;Projektleitung,Bauüberwachung;Maximilian Kriener;m.kriener@rauschenberg-ing.de;[]
-RS;Planung;Rieke Stilleke;r.stilleke@rauschenberg-ing.de;[]
-SM;Planung;Shahab Mushref;s.mushref@rauschenberg-ing.de;[]
-SS;Projektleitung,Bauüberwachung;Sekandar Seradj;s.seradj@rauschenberg-ing.de;[]
-TC;Planung;Tetiana Chevhuz;t.chevhuz@rauschenberg-ing.de;
\ No newline at end of file
diff --git a/sessions/ELT/KW_30___2026.csv b/sessions/ELT/KW_30___2026.csv
deleted file mode 100644
index 867354a..0000000
--- a/sessions/ELT/KW_30___2026.csv
+++ /dev/null
@@ -1,9 +0,0 @@
-WOCHE;KW 30 / 2026;2026-07-24;1
-PERSONEN;;;AP|Planung|AP;SK|Planung|SK;AK|Planung|AK;ED|Planung|ED;SE|Planung|SE;THK|Planung|THK;SP|Planung|SP;SG|Planung|SG;TW|Planung|TW;RR|Planung|RR;MK|Planung|MK;HR|Planung|HR;;;;;;;;;;;;;;
-Pr.-Nr.;Bezeichnung;Status;AP;SK;AK;ED;SE;THK;SP;SG;TW;RR;MK;HR;LPH 1;LPH 2;LPH 3;LPH 4;LPH 5;LPH 6;LPH 7;LPH 8;W+M;Gruppe;Index;Plan;Aufwand;Aktive Phasen
-ANWESENHEIT;;;;;;;;;;;;;;;;;;;;;;;;;;;
-18-4007;Janusz-Korczak-Gesamtsch. Bottrop;LPH5 als Vorabzug raus. NW-Räume vorauss. August.;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;95%;;Aktive Projekte;0;;;
-21-4030;NSHV Köln Immobilienprüfung in Hof;Thorsten W. klärt und übernimmt Schriftverkehr. LV liegt zur Sichtung bei T.W.;;;;;;;;;;;;;100%;100%;100%;;100%;100%;;;;Aktive Projekte;1;;;
-22-4056;Gymnasium Hemer;;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;90%;;Aktive Projekte;2;;;
-22-4066;DSW 21 – Umbau E-Mobilität;Elt-Montagen ab KW 33.;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;20%;;Aktive Projekte;3;;;
-24-4043;S-K ODL-Heim Sanierung Krefeld;Voraussichtlich LV-Abgabe.;;;;;;;;;;;;;100%;100%;100%;;100%;;;;;Aktive Projekte;4;;;
\ No newline at end of file
diff --git a/sessions/ELT/KW_31___2026.csv b/sessions/ELT/KW_31___2026.csv
deleted file mode 100644
index d1bf351..0000000
--- a/sessions/ELT/KW_31___2026.csv
+++ /dev/null
@@ -1,33 +0,0 @@
-WOCHE;KW 31 / 2026;2026-07-29;1
-PERSONEN;;;AP|Planung|Alexander Plum;AK|Planung|Alexander Kenne;ED|Planung|Erik Dunin;SK|Planung|Simon Kunigk;SE|Planung|Steven Esche;WS|Planung|Winfried Sältzer;ED|Projektleitung|Erik Dunin;SP|Projektleitung|Sebastian Pöttinger;THK|Projektleitung|Thorsten Kramp;RR|Projektleitung|Robert Röllecke;MK|Projektleitung|Maximilian Kriener;TW|Projektleitung|Thorsten Werner;SG|Projektleitung|Steffen Gaida;ED|Bauüberwachung|Erik Dunin;SK|Bauüberwachung|Simon Kunigk;SP|Bauüberwachung|Sebastian Pöttinger;THK|Bauüberwachung|Thorsten Kramp;HR|Bauüberwachung|Hermann Rollecke;;;;;;;;;;;;;;
-Pr.-Nr.;Bezeichnung;Status;AP;AK;ED;SK;SE;WS;ED;SP;THK;RR;MK;TW;SG;ED;SK;SP;THK;HR;LPH 1;LPH 2;LPH 3;LPH 4;LPH 5;LPH 6;LPH 7;LPH 8;W+M;Gruppe;Index;Plan;Aufwand;Aktive Phasen
-ANWESENHEIT;;X;X;;X;X;X;;X;X;;;;X;;X;X;X;;;;;;;;;;;;;;;
-18-4007;Janusz-Korczak-Gesamtsch. Bottrop;- KW 35 NW Raum Planung <div>- KW 44 Möbel </div>;;;;;;;;;;;;;;;;;;;100%;100%;100%;;90%;;;;;Aktive Projekte;0;"{""start"":"""",""end"":"""",""milestones"":[],""people"":[],""progress"":0}";;
-21-4030;NSHV Köln Immobilienprüfung in Hof;- Thorsten W.  klärt und übernimmt Schriftverkehr                                                                                                                                                                                - LV liegt zur Sichtung bei T.W.;;;;;;;;;;;;;;;;;;;100%;100%;100%;;100%;100%;;;;Aktive Projekte;2;;;
-22-4066;DSW 21, Umbau E-Mobilität;"- Elt-Montagen ab <font color=""#c53030""><b>KW 33</b></font>.";;;;;;;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;20%;;Aktive Projekte;6;;;
-24-4043;S-K ODL-Heim Sanierung Krefeld;- Vorraussichtlich LV-Abgabe XX.XX<div>- LPH5 mündlich freigegeben <div>- Neuer EG Grundriss mit diversen Änderungen kommt noch von Architekten</div></div>;;;;;;;;;;;;;;;;;;;100%;100%;100%;;100%;;;;;Aktive Projekte;10;;;
-21-4001;Feuerwehrgeräteh. Rodenkirchen;"- KNX muß noch programmiert werden. <font color=""#c53030"">Abnahme  27.07</font> <div><font color=""#c53030""><b>- Fertigstellung Ende Juli</b></font><div><font color=""#c53030""><b>- Abnahmen laufen bis Ende KW31</b></font></div><div><font color=""#c53030""><b>- Blackbuilding Test 26.07</b></font></div></div>";;X;;;;;;;;;;;X;;;;;;;;;;100%;100%;100%;;;Aktive Projekte;1;"{""start"":"""",""end"":"""",""milestones"":[{""id"":""mslrv3i1edl08"",""name"":""SV Abnahme"",""date"":""2026-08-18""},{""id"":""mslrvh7hjau1e"",""name"":""Test"",""date"":""2026-09-05""}],""people"":[""p_ap"",""p_ak"",""p_sk"",""p_sg""],""progress"":""0"",""todos"":[{""id"":""msluufbp114g1"",""title"":""Test"",""start"":""2026-08-09"",""end"":""2026-08-13"",""done"":false},{""id"":""mslv6h76cmx8k"",""title"":""iuguzgv"",""start"":""2026-08-23"",""end"":""2026-09-06"",""done"":false},{""id"":""mslw4l3qp1v18"",""title"":""Hallo"",""start"":""2026-11-29"",""end"":""2027-04-30"",""done"":false}]}";;
-22-4027;Sporthalle Soest;- SV und VOB Abnahme erfolgt.<div>- Nachprüfung VOB 24.07</div><div>- Keine Infos über Nachprüfung</div>;;;;;;;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;90%;;Aktive Projekte;3;;;
-22-4056;Gymnasium Hemer;;;;;;;;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;90%;;Aktive Projekte;4;;;
-22-4056-1;Gymnasium Hemer (Deckensanierung);- Beginn der Arbeiten vorraussichtlich KW 30 (KW 32 Kickoff);;;;;;;;;;;;;;;;;;;;;100%;;100%;100%;;;;Aktive Projekte;5;;;
-23-4042;GWK Neufelder Straße;"- Nachweis für E-30 Leitungen notwendig. Rechnungen wurden nicht anerkannt. <div><font color=""#c53030"">- 22.07 Aufschaltung BMA und Amok</font></div><div><font color=""#c53030"">- KW 31 VOB Abnahme</font></div>";;;;;;;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;95%;;Aktive Projekte;7;;;
-23-4070;Umbau Bürogebäude NEW, MV10;"- neue NSHV anbieten(Warten auf Infos),  <div>- 28.07 Sachverständiger Abnahme ELT&amp;SiBe </div><div>- 30.07 Sachverständigen Abnahme BMA</div>";;;;;;;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;90%;;Aktive Projekte;8;;;
-23-4072;S-K OGS-Kaldenkirchen Schulanbau;"- Feininstallation beginnt, Fertigstellung voraussichtlich <font color=""#c53030"">01.08</font>";;;;;;;;;;;;;;;;;;;;;;;;;;70%;;Aktive Projekte;9;;;
-24-4049;BMA Remscheid;"- Feuerwehrabnahme organisiert die Errichterfirma. <div>- SV-Abnahmen 15 &amp; 16.07: nicht abgenommen</div>";;;;;;;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;90%;;Aktive Projekte;11;;;
-24-4069;S-K Erw. GS Blankenheim Neubau;- nur backup;;;;;;;;;;;;;;;;;;;;;;;100%;100%;;;;Kleine Projekte;0;;;
-24-4096;Umbau Wohngebäude Kirchhoff;"- Position HA wird von uns bestimmt.                                                                                                                                                                    - Notwendiges Leerrohr für Leuchten im Vordach ist zu klären.<div><font color=""#c53030"">- Abgabe Kostenberechnung bis Ende KW29</font></div><div><font color=""#c53030"">- LV Fertig bis Ende KW 32  </font> </div>";;;;(X);;;;;;;;;;;;;;;100%;100%;100%;;95%;85%;0%;;;Aktive Projekte;12;;;
-25-4003;Märkische Bank Boele;- Feininstallation<div>- Ab KW30 Einbringung Tresore</div>;;;;;;;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;80%;;Aktive Projekte;13;;;
-25-4028;TenBrinke, Amprion, Wietmarschen;;;;;;;;;;;;;;;;;;;;100%;100%;100%;;95%;;;;;Aktive Projekte;14;;;
-25-4028-1;TenBrinke, Amprion, Meerbusch;;;;;;;;;;;;;;;;;;;;100%;100%;100%;;95%;;;;;Aktive Projekte;15;;;
-25-4028-2;TenBrinke, Amprion, Gelsenkirchen;;;;;;;;;;;;;;;;;;;;100%;100%;100%;;95%;;;;;Aktive Projekte;16;;;
-26-4018;TUI Immobilien GmbH Salzgitter;;;;;;;;;;;;;;;;;;;;50%;;;;;;;;;Aktive Projekte;17;;;
-26-4023;HA Rettungsw. Nahmer Gasst. - Los 1;;;;X;;;;;;;;;;;;;;;;;;;;;;;;;In Anbahnung;0;;;
-26-4024;HA Rettungsw. Dahl Am Obergr. - Los 2;;;;X;;;;;;;;;;;;;;;;;;;;;;;;;In Anbahnung;1;;;
-26-4025;HA, SeePark Hengstey;- LPH2 erfolgt, weitere Arbeiten folgen.;;;;;;;;;;;;;;;;;;;100%;100%;;;;;;;;Aktive Projekte;18;;;
-26-4026;Stadt Hemer, Anbau OGS Oesetalschule;"<font color=""#1a1a1a"">- Bearbeitung LPH3 in Absprache mit Achitektur S+D</font>";;;;;;;;;;;;;;;;;;;100%;100%;;;;;;;;Aktive Projekte;19;;;
-26-4046;AXA Außenbeleuchtung;- Warten auf Unterlagen (Grundlagen & Vorplanung);;;;;;;;;;;;;;;;;;;10%;;;;;;;;;Aktive Projekte;20;;;
-;KFW Köln/Bonn Sicherheitskonzept;- Auftrag erhalten;;;;;;;;;;;;;;;;;;;;;;;;;;;;In Anbahnung;2;;;
-;Swisstal;;;;;;;;;;;;;;;;;;;;;;;;;;;;;In Anbahnung;3;"{""start"":"""",""end"":"""",""milestones"":[],""people"":[],""progress"":0}";;
-;Plancodierung/Benennung;- Von Rieke erstellt. Info folgt ? KW31?;;;;;;;;;;;;;;;;;;;;;;;;;;;;Allgemein;0;;;
-;Ordnerstruktur;- in Projekthilfen _Ordnerstruktur abgelegt, ist in Anlehnung an Leitfaden aufgebaut;;;;;;;;;;;;;;;;;;;;;;;;;;;;Allgemein;1;;;
-26-4042;Zanderstraße 7, PV-Anlage;- 82 kWp Anlage angefragt. Preisschätzung wird angefertigt;;;;;;;;;;;;;;;;;;;100%;80%;;;;80%;;;;Kleine Projekte;1;;;
\ No newline at end of file
diff --git a/sessions/ELT/KW_33___2026.csv b/sessions/ELT/KW_33___2026.csv
deleted file mode 100644
index ca05d29..0000000
--- a/sessions/ELT/KW_33___2026.csv
+++ /dev/null
@@ -1,33 +0,0 @@
-WOCHE;KW 33 / 2026;2026-08-09;
-PERSONEN;;;AP|Planung|Alexander Plum;AK|Planung|Alex Kenne;ED|Planung|Erik Dunin;SK|Planung|Simon Kunigk;SE|Planung|Steven Esche;WS|Planung|Winfried Sältzer;ED|Projektleitung|Erik Dunin;SP|Projektleitung|Sebastian Pöttinger;THK|Projektleitung|Thorsten Kramp;RR|Projektleitung|Robert Röllecke;MK|Projektleitung|Maximilian Kriener;TW|Projektleitung|Thorsten Werner;SG|Projektleitung|Steffen Gaida;ED|Bauüberwachung|Erik Dunin;SK|Bauüberwachung|Simon Kunigk;SP|Bauüberwachung|Sebastian Pöttinger;THK|Bauüberwachung|Thorsten Kramp;HR|Bauüberwachung|Hermann Rollecke;;;;;;;;;;;;;;
-Pr.-Nr.;Bezeichnung;Status;AP;AK;ED;SK;SE;WS;ED;SP;THK;RR;MK;TW;SG;ED;SK;SP;THK;HR;LPH 1;LPH 2;LPH 3;LPH 4;LPH 5;LPH 6;LPH 7;LPH 8;W+M;Gruppe;Index;Plan;Aufwand;Aktive Phasen
-ANWESENHEIT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-18-4007;Janusz-Korczak-Gesamtsch. Bottrop;- KW 35 NW Raum Planung <div>- KW 44 Möbel </div>;X;;;;;;;;;;;;;;;;;;100%;100%;100%;;90%;;;;;Aktive Projekte;0;"{""start"":"""",""end"":"""",""milestones"":[],""people"":[],""progress"":0}";"{""LPH 5"":{""Planung"":0.6},""LPH 8"":{""Planung"":0,""Projektleitung"":0.2}}";
-21-4030;NSHV Köln Immobilienprüfung in Hof;- Thorsten W.  klärt und übernimmt Schriftverkehr <div>- LV liegt zur Sichtung bei T.W.</div>;X;;;;;;;;;;;;;;;;;;100%;100%;100%;;100%;100%;;;;Aktive Projekte;2;;;
-22-4066;DSW 21, Umbau E-Mobilität;- Elt-Montagen ab <font><b>KW 33</b></font>.;;;;;;;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;20%;;Aktive Projekte;7;;;
-24-4043;S-K ODL-Heim Sanierung Krefeld;- Vorraussichtlich LV-Abgabe XX.XX<div>- LPH5 mündlich freigegeben <div>- Neuer EG Grundriss mit diversen Änderungen kommt noch von Architekten</div></div>;;;;;;;;;;;;;;;;;;;100%;100%;100%;;100%;;;;;Aktive Projekte;11;;;
-21-4001;Feuerwehrgeräteh. Rodenkirchen;- KNX muß noch programmiert werden. <font>Abnahme  27.07</font> <div><font><b>- Fertigstellung Ende Juli</b></font><div><font><b>- Abnahmen laufen bis Ende KW31</b></font></div><div><font><b>- Blackbuilding Test 26.07</b></font></div></div>;X;;X;;;;X;X;;;;;;X;;;;;100%;100%;100%;;100%;100%;100%;;;Aktive Projekte;1;"{""start"":"""",""end"":"""",""milestones"":[{""id"":""mslrvh7hjau1e"",""name"":""Übergabe"",""date"":""2026-09-12"",""dependsOn"":[""mslv6h76cmx8k""],""position"":""after:mslv6h76cmx8k""}],""people"":[""p_ap"",""p_ak"",""p_sk"",""p_sg""],""progress"":""0"",""todos"":[{""id"":""msluufbp114g1"",""title"":""Test"",""start"":""2026-08-10"",""end"":""2026-08-14"",""done"":false,""dependsOn"":[],""assignees"":[""p_ap"",""p_ed""],""progress"":0},{""id"":""mslv6h76cmx8k"",""title"":""Test 2"",""start"":""2026-08-24"",""end"":""2026-09-04"",""done"":false,""dependsOn"":[""msluufbp114g1""],""assignees"":[""p_ap""],""progress"":41},{""id"":""mslw4l3qp1v18"",""title"":""Test 3"",""start"":""2026-09-14"",""end"":""2026-09-22"",""done"":false,""dependsOn"":[""m_mslrvh7hjau1e""],""assignees"":[],""progress"":0},{""id"":""msoltaa1itx48"",""title"":""Gehen"",""start"":""2026-09-23"",""end"":""2026-09-25"",""done"":false,""progress"":0,""dependsOn"":[""mslw4l3qp1v18""],""assignees"":[""p_ws""]}]}";"{""LPH 1"":{""Planung"":0.8},""LPH 2"":{""Planung"":0.8},""LPH 3"":{""Planung"":0.8},""LPH 4"":{""Planung"":0.8},""LPH 5"":{""Planung"":0.8}}";"[""LPH 5""]"
-22-4027;Sporthalle Soest;- SV und VOB Abnahme erfolgt.<div>- Nachprüfung VOB 24.07</div><div>- Keine Infos über Nachprüfung</div>;X;;;;;;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;90%;;Aktive Projekte;3;;;"[""LPH 5""]"
-22-4056;Gymnasium Hemer;;;;;;;;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;90%;;Aktive Projekte;4;;;
-22-4056-1;Gymnasium Hemer (Deckensanierung);- Beginn der Arbeiten vorraussichtlich KW 30 (KW 32 Kickoff);;;;;;;;;;;;;;;;;;;;;100%;;100%;100%;;;;Aktive Projekte;5;;;
-23-4042;GWK Neufelder Straße;- Nachweis für E-30 Leitungen notwendig. Rechnungen wurden nicht anerkannt. <div><font>- 22.07 Aufschaltung BMA und Amok</font></div><div><font>- KW 31 VOB Abnahme</font></div>;;;;;;;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;95%;;Aktive Projekte;8;;;
-23-4070;Umbau Bürogebäude NEW, MV10;"- neue NSHV anbieten(Warten auf Infos),  <div>- 28.07 Sachverständiger Abnahme ELT&amp;SiBe </div><div>- 30.07 Sachverständigen Abnahme BMA</div>";;;;;;;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;90%;;Aktive Projekte;9;;;
-23-4072;S-K OGS-Kaldenkirchen Schulanbau;- Feininstallation beginnt, Fertigstellung voraussichtlich <font>01.08</font>;;;;;;;;;;;;;;;;;;;;;;;;;;70%;;Aktive Projekte;10;;;
-24-4049;BMA Remscheid;"- Feuerwehrabnahme organisiert die Errichterfirma. <div>- SV-Abnahmen 15 &amp; 16.07: nicht abgenommen</div>";;;;;;;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;90%;;Aktive Projekte;12;;;
-24-4069;S-K Erw. GS Blankenheim Neubau;- nur backup;;;;;;;;;;;;;;;;;;;;;;;100%;100%;;;;Kleine Projekte;0;;;
-24-4096;Umbau Wohngebäude Kirchhoff;- Position HA wird von uns bestimmt. <div>- Notwendiges Leerrohr für Leuchten im Vordach ist zu klären.<div><font>- Abgabe Kostenberechnung bis Ende KW29</font></div><div><font>- LV Fertig bis Ende KW 32  </font> </div></div>;;;;;;;;;;;;;;;;;;;100%;100%;100%;;95%;85%;0%;;;Aktive Projekte;13;;;
-25-4003;Märkische Bank Boele;- Feininstallation<div>- Ab KW30 Einbringung Tresore</div>;;;;;;;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;80%;;Aktive Projekte;14;;;
-25-4028;TenBrinke, Amprion, Wietmarschen;;;;;;;;;;;;;;;;;;;;100%;100%;100%;;95%;;;;;Aktive Projekte;15;;;
-25-4028-1;TenBrinke, Amprion, Meerbusch;;;;;;;;;;;;;;;;;;;;100%;100%;100%;;95%;;;;;Aktive Projekte;16;;;
-25-4028-2;TenBrinke, Amprion, Gelsenkirchen;;;;;;;;;;;;;;;;;;;;100%;100%;100%;;95%;;;;;Aktive Projekte;17;;;
-26-4018;TUI Immobilien GmbH Salzgitter;;;;;;;;;;;;;;;;;;;;50%;;;;;;;;;Aktive Projekte;18;;;
-26-4023;HA Rettungsw. Nahmer Gasst. - Los 1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;In Anbahnung;0;;;
-26-4024;HA Rettungsw. Dahl Am Obergr. - Los 2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;In Anbahnung;1;;;
-26-4025;HA, SeePark Hengstey;- LPH2 erfolgt, weitere Arbeiten folgen.;;;;;;;;;;;;;;;;;;;100%;100%;;;;;;;;Aktive Projekte;19;;;
-26-4026;Stadt Hemer, Anbau OGS Oesetalschule;"<font color=""#1a1a1a"">- Bearbeitung LPH3 in Absprache mit Achitektur S+D</font>";;;;;;;;;;;;;;;;;;;100%;100%;;;;;;;;Aktive Projekte;20;;;
-26-4046;AXA Außenbeleuchtung;- Warten auf Unterlagen (Grundlagen & Vorplanung);;;;;;;;;;;;;;;;;;;10%;;;;;;;;;Aktive Projekte;21;;;
-;KFW Köln/Bonn Sicherheitskonzept;- Auftrag erhalten;;;;;;;;;;;;;;;;;;;;;;;;;;;;In Anbahnung;2;;;
-;Swisstal;;;;;;;;;;;;;;;;;;;;;;;;;;;;;In Anbahnung;3;"{""start"":"""",""end"":"""",""milestones"":[],""people"":[],""progress"":0}";;
-;Plancodierung/Benennung;- Von Rieke erstellt. Info folgt ? KW31?;;;;;;;;;;;;;;;;;;;;;;;;;;;;Allgemein;0;;;
-;Ordnerstruktur;- in Projekthilfen _Ordnerstruktur abgelegt, ist in Anlehnung an Leitfaden aufgebaut;;;;;;;;;;;;;;;;;;;;;;;;;;;;Allgemein;1;;;
-26-4042;Zanderstraße 7, PV-Anlage;- 82 kWp Anlage angefragt. Preisschätzung wird angefertigt;;;;;;;;;;;;;;;;;;;100%;80%;;;;80%;;;;Kleine Projekte;1;;;
\ No newline at end of file
diff --git a/sessions/ELT/_people.csv b/sessions/ELT/_people.csv
deleted file mode 100644
index 14d8eec..0000000
--- a/sessions/ELT/_people.csv
+++ /dev/null
@@ -1,14 +0,0 @@
-NAME;Rollen;Voller Name;E-Mail;Abwesenheiten
-AK;Planung;Alex Kenne;a.kenne@rauschenberg-ing.de;[]
-AP;Planung;Alexander Plum;a.plum@rauschenberg-ing.de;[]
-ED;Planung,Projektleitung,Bauüberwachung;Erik Dunin;e.dunin@rauschenberg-ing.de;[]
-HR;Planung,Bauüberwachung;Hermann Rollecke;h.roellecke@rauschenberg-ing.de;[]
-MK;Planung,Projektleitung;Maximilian Kriener;m.kriener@rauschenberg-ing.de;[]
-RR;Planung,Projektleitung;Robert Röllecke;r.roellecke@rauschenberg-ing.de;[]
-SE;Planung;Steven Esche;s.esche@rauschenberg-ing.de;[]
-SG;Planung,Projektleitung;Steffen Gaida;s.gaida@rauschenberg-ing.de;[]
-SK;Planung,Bauüberwachung;Simon Kunigk;s.kunigk@rauschenberg-ing.de;[]
-SP;Planung,Projektleitung,Bauüberwachung;Sebastian Pöttinger;s.poettinger@rauschenberg-ing.de;[]
-THK;Planung,Projektleitung,Bauüberwachung;Thorsten Kramp;t.kramp@rauschenberg-ing.de;[]
-TW;Planung,Projektleitung;Thorsten Werner;t.werner@rauschenberg-ing.de;[]
-WS;Planung;Winfried Sältzer;w.sältzer@rauschenberg-ing.de;[]
\ No newline at end of file
diff --git a/sessions/HLS/KW_30___2026.csv b/sessions/HLS/KW_30___2026.csv
deleted file mode 100644
index 867354a..0000000
--- a/sessions/HLS/KW_30___2026.csv
+++ /dev/null
@@ -1,9 +0,0 @@
-WOCHE;KW 30 / 2026;2026-07-24;1
-PERSONEN;;;AP|Planung|AP;SK|Planung|SK;AK|Planung|AK;ED|Planung|ED;SE|Planung|SE;THK|Planung|THK;SP|Planung|SP;SG|Planung|SG;TW|Planung|TW;RR|Planung|RR;MK|Planung|MK;HR|Planung|HR;;;;;;;;;;;;;;
-Pr.-Nr.;Bezeichnung;Status;AP;SK;AK;ED;SE;THK;SP;SG;TW;RR;MK;HR;LPH 1;LPH 2;LPH 3;LPH 4;LPH 5;LPH 6;LPH 7;LPH 8;W+M;Gruppe;Index;Plan;Aufwand;Aktive Phasen
-ANWESENHEIT;;;;;;;;;;;;;;;;;;;;;;;;;;;
-18-4007;Janusz-Korczak-Gesamtsch. Bottrop;LPH5 als Vorabzug raus. NW-Räume vorauss. August.;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;95%;;Aktive Projekte;0;;;
-21-4030;NSHV Köln Immobilienprüfung in Hof;Thorsten W. klärt und übernimmt Schriftverkehr. LV liegt zur Sichtung bei T.W.;;;;;;;;;;;;;100%;100%;100%;;100%;100%;;;;Aktive Projekte;1;;;
-22-4056;Gymnasium Hemer;;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;90%;;Aktive Projekte;2;;;
-22-4066;DSW 21 – Umbau E-Mobilität;Elt-Montagen ab KW 33.;;;;;;;;;;;;;100%;100%;100%;;100%;100%;100%;20%;;Aktive Projekte;3;;;
-24-4043;S-K ODL-Heim Sanierung Krefeld;Voraussichtlich LV-Abgabe.;;;;;;;;;;;;;100%;100%;100%;;100%;;;;;Aktive Projekte;4;;;
\ No newline at end of file
diff --git a/sessions/HLS/KW_32___2026.csv b/sessions/HLS/KW_32___2026.csv
deleted file mode 100644
index 4ca26a3..0000000
--- a/sessions/HLS/KW_32___2026.csv
+++ /dev/null
@@ -1,11 +0,0 @@
-WOCHE;KW 32 / 2026;2026-08-05;
-PERSONEN;;;MZ|Planung|Markus Zimmermann;FP|Planung|Frank Pietruschka;TK|Planung|Tim Küppers;RR|Projektleitung|Robert Röllecke;AS|Bauüberwachung|Andreas Simon;SL|Bauüberwachung|Steffan Licata;;;;;;;;;;;;;;
-Pr.-Nr.;Bezeichnung;Status;MZ;FP;TK;RR;AS;SL;LPH 1;LPH 2;LPH 3;LPH 4;LPH 5;LPH 6;LPH 7;LPH 8;W+M;Gruppe;Index;Plan;Aufwand;Aktive Phasen
-ANWESENHEIT;;;;;;;;;;;;;;;;;;;;;
-24-4101;Krankenhaus Köln, Heizungsmodernisierung;- Austausch Kesselhaus geplant;;;;;;;100%;100%;100%;;100%;100%;;90%;;Aktive Projekte;0;"{""start"":"""",""end"":"""",""todos"":[{""id"":""msmzj493z5gie"",""title"":""Abgabe"",""start"":""2026-08-10"",""end"":""2026-08-28"",""done"":false,""progress"":23,""dependsOn"":[],""assignees"":[""p_fp""]}],""milestones"":[{""id"":""msmzi2pbbsv1s"",""name"":""sxcdv"",""date"":""2026-08-15"",""dependsOn"":[],""position"":""""}],""people"":[],""progress"":0}";"{""LPH 1"":{""Planung"":1}}";"[""LPH 1""]"
-24-4102;Bürokomplex Dortmund, Lüftung;- Filterkonzept in Abstimmung;;;;;;;100%;100%;100%;;95%;;;;;Aktive Projekte;1;"{""start"":"""",""end"":"""",""todos"":[],""milestones"":[{""id"":""msmzhc7wo8alc"",""name"":""Test 123"",""date"":""2026-08-10"",""dependsOn"":[],""position"":""""}],""people"":[],""progress"":0}";;
-26-4105;Wohnanlage Essen, Regenwasser;- Planung Drainage;;;;;;;100%;100%;;;;;;;;Aktive Projekte;4;;;
-;Badmodernisierung Privatkunde;- Angebot erstellt;;;;;;;;;;;100%;;;;;In Anbahnung;0;;;
-;Wärmepumpen-Studie;- Erstgespräch durchgeführt;;;;;;;100%;;;;;;;;;In Anbahnung;1;;;
-;HLS Planungscheckliste;- Vorlage aktualisiert;;;;;;;100%;;;;;;;;;Allgemein;0;;;
-21-4001;Feuerwehrgeräteh. Rodenkirchen;;;;;;;;;;;;;;;;;Aktive Projekte;5;;;
\ No newline at end of file
diff --git a/sessions/HLS/_people.csv b/sessions/HLS/_people.csv
deleted file mode 100644
index 8fe1e2d..0000000
--- a/sessions/HLS/_people.csv
+++ /dev/null
@@ -1,7 +0,0 @@
-NAME;Rollen;Voller Name;E-Mail;Abwesenheiten
-AS;Bauüberwachung;Andreas Simon;[];[]
-FP;Planung;Frank Pietruschka;[];[]
-MZ;Planung;Markus Zimmermann;[];[]
-RR;Planung,Projektleitung;Robert Röllecke;[];[]
-SL;Bauüberwachung;Steffan Licata;[];[]
-TK;Planung;Tim Küppers;[];[]
\ No newline at end of file
diff --git a/sessions/backups/projektuebersicht_2026-08-18T06-36-48-511.db b/sessions/backups/projektuebersicht_2026-08-18T06-36-48-511.db
new file mode 100644
index 0000000..f7fff1e
Binary files /dev/null and b/sessions/backups/projektuebersicht_2026-08-18T06-36-48-511.db differ
diff --git a/sessions/backups/projektuebersicht_2026-08-18T06-41-14-950.db b/sessions/backups/projektuebersicht_2026-08-18T06-41-14-950.db
new file mode 100644
index 0000000..7095fdc
Binary files /dev/null and b/sessions/backups/projektuebersicht_2026-08-18T06-41-14-950.db differ
diff --git a/sessions/backups/projektuebersicht_2026-08-18T06-41-14-963.db b/sessions/backups/projektuebersicht_2026-08-18T06-41-14-963.db
new file mode 100644
index 0000000..8df9060
Binary files /dev/null and b/sessions/backups/projektuebersicht_2026-08-18T06-41-14-963.db differ
diff --git a/sessions/backups/projektuebersicht_2026-08-18T06-43-13-525.db b/sessions/backups/projektuebersicht_2026-08-18T06-43-13-525.db
new file mode 100644
index 0000000..7095fdc
Binary files /dev/null and b/sessions/backups/projektuebersicht_2026-08-18T06-43-13-525.db differ
diff --git a/sessions/backups/projektuebersicht_2026-08-18T06-47-01-551.db b/sessions/backups/projektuebersicht_2026-08-18T06-47-01-551.db
new file mode 100644
index 0000000..7095fdc
Binary files /dev/null and b/sessions/backups/projektuebersicht_2026-08-18T06-47-01-551.db differ
diff --git a/sessions/backups/projektuebersicht_2026-08-18T07-09-35-889.db b/sessions/backups/projektuebersicht_2026-08-18T07-09-35-889.db
new file mode 100644
index 0000000..7095fdc
Binary files /dev/null and b/sessions/backups/projektuebersicht_2026-08-18T07-09-35-889.db differ
diff --git a/sessions/backups/projektuebersicht_2026-08-18T07-10-17-549.db b/sessions/backups/projektuebersicht_2026-08-18T07-10-17-549.db
new file mode 100644
index 0000000..e1aa595
Binary files /dev/null and b/sessions/backups/projektuebersicht_2026-08-18T07-10-17-549.db differ
diff --git a/sessions/backups/projektuebersicht_2026-08-18T07-10-17-555.db b/sessions/backups/projektuebersicht_2026-08-18T07-10-17-555.db
new file mode 100644
index 0000000..7095fdc
Binary files /dev/null and b/sessions/backups/projektuebersicht_2026-08-18T07-10-17-555.db differ
diff --git a/sessions/backups/projektuebersicht_2026-08-18T07-12-27-276.db b/sessions/backups/projektuebersicht_2026-08-18T07-12-27-276.db
new file mode 100644
index 0000000..7095fdc
Binary files /dev/null and b/sessions/backups/projektuebersicht_2026-08-18T07-12-27-276.db differ
diff --git a/sessions/backups/projektuebersicht_2026-08-18T07-14-16-193.db b/sessions/backups/projektuebersicht_2026-08-18T07-14-16-193.db
new file mode 100644
index 0000000..1358774
Binary files /dev/null and b/sessions/backups/projektuebersicht_2026-08-18T07-14-16-193.db differ