/*
 * Express-Server der Projektübersicht: liefert die statischen Frontend-Dateien aus
 * public/ (App.html unter "/") und stellt den Frontend-Modulen unter public/js/
 * eine JSON-API zum Laden und Speichern der Sitzungsdaten bereit. Die Daten liegen
 * in einer SQLite-Datenbank (node:sqlite, Node >= 22.13) unter sessions/projektuebersicht.db.
 *
 * 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 /delete-week,
 *  GET /backup (SQLite-Snapshot als .db-Download; zusätzlich automatische Backups
 *  nach sessions/backups/ beim Serverstart), POST /import (Backup-Wiederherstellung,
 *  roher Binär-Body, schema-validiert).
 *  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 crypto = require('crypto');
const { DatabaseSync } = require('node:sqlite');
// pdfjs-dist/mammoth: reine Textauszug-Bibliotheken für den Protokoll-Import
// (POST /project-protokolle/import) — erste Abhängigkeiten außer
// express/cors, siehe CLAUDE.md "### Protokolle". pdfjs-dist statt des
// zunächst gewählten pdf-parse: dessen mitgelieferte, seit 2017
// eingefrorene pdf.js-Kopie liefert in diesem Prozess reproduzierbar
// "bad XRef entry", sobald Node's eigenes http-Modul geladen ist (bereits
// durch das bloße `require('http')` allein auslösbar, unabhängig vom
// tatsächlichen PDF-Inhalt) — in einem Express-Server also immer, da
// express selbst transitiv http lädt. Ein eigenständiges pdfjs-dist ist
// nicht betroffen.
//
// @napi-rs/canvas: zunächst bewusst draußen gehalten (siehe Git-Historie
// der .npmrc) — das Seiten-Rendering zu Bildern war hier nie gebraucht,
// solange nur TEXT aus einem PDF gezogen wurde. Für den Plan Checker
// (siehe "Plan Checker" weiter unten) ändert sich das: Maßketten und
// Plankopf sind optische Merkmale einer Zeichnung, kein Fließtext, also
// muss die Planseite als BILD an die KI gehen. Jetzt eine echte, direkte
// Abhängigkeit (nicht mehr nur pdfjs-dists optionale) — die .npmrc mit
// `omit=optional` ist deshalb entfallen, sie hätte sonst auch das für
// @napi-rs/canvas selbst nötige, plattformspezifische Binärpaket (z. B.
// @napi-rs/canvas-darwin-arm64) ausgeschlossen.
const mammoth = require('mammoth');
// undici: NICHT für fetch() selbst (das liefert Node schon global) — nur für
// die Agent-Klasse, um der KI-Erkennung gegen einen eigenen Server (siehe
// fetchMitTimeout() weiter unten) ein höheres Verbindungslimit als Node/
// undicis eigenen Vorgabewert mitzugeben, siehe dort.
const { Agent: UndiciAgent } = require('undici');
// PDF-Arbeit im Kindprozess (pdf-arbeit.js): ein Auftrag je Prozess, höchstens
// einer gleichzeitig (Warteschlange), mit Zeitlimit. Stirbt das Kind am
// Speicher, scheitert nur dieser eine Import mit verständlicher Meldung.
const { fork } = require('child_process');
const { PLAN_CHECK_KACHEL_SPALTEN, PLAN_CHECK_KACHEL_ZEILEN } = require('./pdf-arbeit.js');
const PDF_KIND_TIMEOUT_MS = 3 * 60 * 1000;
let pdfWarteschlange = Promise.resolve();
function pdfImKindprozess(art, buf){
  const lauf = pdfWarteschlange.then(() => new Promise((resolve, reject) => {
    const kind = fork(path.join(__dirname, 'pdf-arbeit.js'), [], {
      execArgv: ['--max-old-space-size=' + (Number(process.env.PDF_KIND_HEAP_MB) || 192)],
      serialization: 'advanced', stdio: ['ignore', 'inherit', 'inherit', 'ipc']
    });
    let fertig = false;
    const ende = (fn, wert) => { if(fertig) return; fertig = true; clearTimeout(uhr); fn(wert); };
    const uhr = setTimeout(() => { kind.kill('SIGKILL'); ende(reject, new Error('Das PDF konnte nicht in angemessener Zeit gelesen werden.')); }, PDF_KIND_TIMEOUT_MS);
    kind.on('message', m => m && m.ok ? ende(resolve, m.ergebnis) : ende(reject, new Error((m && m.fehler) || 'PDF konnte nicht gelesen werden.')));
    kind.on('exit', code => ende(reject, new Error(code === 99 || code === null
      ? 'Das PDF ist zu groß für den Server (Arbeitsspeicher).'
      : 'PDF konnte nicht gelesen werden (Code ' + code + ').')));
    kind.on('error', err => ende(reject, err));
    kind.send({ art, daten: buf });
  }));
  pdfWarteschlange = lauf.catch(() => {});
  return lauf;
}
function extrahierePdfText(buf){ return pdfImKindprozess('text', buf); }
async function renderPdfAlsBildsatz(buf){
  const r = await pdfImKindprozess('bild', buf);
  // IPC ("advanced") liefert Uint8Array statt Buffer zurück.
  return { uebersicht: Buffer.from(r.uebersicht), kacheln: r.kacheln.map(k => Buffer.from(k)) };
}

const app = express();

// Wichtige Konstanten: Serverport (PORT-Env) und die gültigen Abteilungsordner
const PORT = process.env.PORT || 3003;
const VALID_DEPARTMENTS = new Set(['ELT','HLS','ARCH']);

// SANDBOX_WEEK_LABEL: die eine, dauerhaft reservierte "Sitzung", in der alle
// Planung-Terminpläne liegen (CLAUDE.md, "Planung — projektunabhängige
// Terminplan-Sandbox"). Kein echtes Datum, keine echte Kalenderwoche — der
// Name selbst ist der Marker, der dieses `weeks`-Label von jeder echten
// Sitzung unterscheidet. MUSS mit der gleichnamigen Konstante in
// public/js/globals.js übereinstimmen (kein gemeinsames Modulsystem zwischen
// Server und Client in diesem Projekt, siehe "Frontend architecture").
const SANDBOX_WEEK_LABEL = '__sandbox__';
// Projekt-Zuordnungs-Rollen aus ROLES in public/js/globals.js (bewusst dupliziert,
// kein Bundler vorhanden — NICHT zu verwechseln mit users.role, s. VALID_ROLES).
const VALID_DISCIPLINE_ROLES = new Set(['Planung','Projektleitung','Bauüberwachung']);
// Systemrollen eines Kontos (users.role) stehen seit „Rollen & Rechte“ in der
// Tabelle roles (siehe RECHTE weiter unten) — geprüft über rolleExistiert().
// Nicht zu verwechseln mit den Fachrollen (user_roles), die nur die
// Projektzuordnung betreffen und keine Berechtigung verleihen.
// GELOESCHTE_PROJEKTE_TAGE: so lange bleibt ein aus der Projektliste
// gelöschtes Projekt im Papierkorb (deleted_projects) und ist für
// Administratoren wiederherstellbar; danach entfernt es
// purgeGeloeschteProjekte() endgültig.
const GELOESCHTE_PROJEKTE_TAGE = 30;
// VALID_AUFTRAGSSTATUS: der Weg von der Anfrage zum abgeschlossenen Auftrag
// (projects.auftragsstatus). Die Reihenfolge ist die fachliche Abfolge und
// steht genauso in AUFTRAGSSTATUS in public/js/auftrag.js — bewusst
// dupliziert, es gibt keinen Bundler. Serverseitig geprüft wird das nicht
// wegen der Oberfläche, sondern weil /save-week der einzige Schreibweg ist:
// ein Tippfehler im Wert wäre sonst dauerhaft in der Datenbank und jede
// Auswertung ("welche Projekte sind noch Angebot?") liefe daran vorbei.
const VALID_AUFTRAGSSTATUS = new Set(['anfrage','angebot','beauftragt','abgeschlossen']);
// DEFAULT_AUFTRAGSSTATUS: Vorgabe für Bestandsdaten und für unbelegte Felder.
// 'beauftragt' und nicht 'anfrage', weil der gesamte Altbestand beauftragte
// Arbeit ist — jeder andere Anfangswert hätte alle laufenden Projekte
// rückwirkend zu Akquise erklärt.
const DEFAULT_AUFTRAGSSTATUS = 'beauftragt';
// AUFTRAGSSTATUS_LABELS: lesbare Bezeichnungen für den CSV-Export. Der
// Schlüssel selbst ('anfrage') steht in der Datenbank, in einer Tabelle für
// Menschen hat er nichts zu suchen.
const AUFTRAGSSTATUS_LABELS = {
  anfrage: 'Anfrage', angebot: 'Angebot',
  beauftragt: 'Beauftragt', abgeschlossen: 'Abgeschlossen'
};

// normalizeAuftragsstatus: bringt einen eingehenden Wert auf einen gültigen
// Schlüssel. Wird beim SCHREIBEN gebraucht (serializeWeek) — dort ist der Wert
// bereits von der Route geprüft, leer oder fehlend darf er aber sein (alte
// Clients, Demo-Daten) und wird dann zur Vorgabe.
function normalizeAuftragsstatus(value){
  const v = String(value || '').trim();
  return VALID_AUFTRAGSSTATUS.has(v) ? v : DEFAULT_AUFTRAGSSTATUS;
}

// findInvalidAuftragsstatus: sucht in einer eingehenden Woche das erste Projekt
// mit unbekanntem Auftragsstatus. Getrennt von normalizeAuftragsstatus(), weil
// der Schreibweg BEIM SPEICHERN nicht stillschweigend zurechtbiegen darf: Ein
// unbekannter Wert ist ein Fehler im Aufruf und wird mit 400 abgewiesen,
// sonst käme aus der Oberfläche "Angebot" heraus und in der Datenbank stünde
// "beauftragt". Ein fehlendes/leeres Feld ist dagegen erlaubt (alte Clients).
// Rückgabe: { nr, name, wert } oder null, wenn alles gültig ist.
function findInvalidAuftragsstatus(week){
  const projects = Array.isArray(week && week.projects) ? week.projects : [];
  for(const p of projects){
    const raw = p && p.auftragsstatus;
    if(raw === undefined || raw === null || raw === '') continue;
    const v = String(raw).trim();
    if(!VALID_AUFTRAGSSTATUS.has(v)){
      return { nr: String((p && p.nr) || ''), name: String((p && p.name) || ''), wert: v };
    }
  }
  return null;
}

// Globale Middleware: CORS, JSON-Body-Limit (2 MB) und statisches Serving von public/ ohne Cache für Skripte/Styles
app.use(require('cors')());
// Der JSON-Parser darf NICHT über die Routen mit rohem Binär-Body laufen:
// Der Browser schickt beim Datei-Upload den Content-Type der Datei mit, und
// bei einer .json-Datei würde express.json() den Datenstrom verbrauchen, bevor
// express.raw() ihn bekommt ("Keine Datei empfangen"). 8 MB statt 2 MB, weil
// eine Sitzung mit vielen Projekten und langen Kommentaren sonst irgendwann
// still am 413 scheitert.
const RAW_BODY_ROUTES = new Set(['/import', '/project-files', '/project-protokolle/import', '/plan-checker-pruefen', '/plan-todos-aus-protokoll/einlesen']);
const jsonBodyParser = express.json({ limit: '8mb' });
app.use((req, res, next) => {
  if(req.method === 'POST' && RAW_BODY_ROUTES.has(req.path)) return next();
  jsonBodyParser(req, res, next);
});
// attachUser liest bei jedem Request das Session-Cookie und setzt req.user
// (siehe Definition weiter unten im Abschnitt "Auth: Sessions, Middleware,
// Endpunkte" — als function-Deklaration ist sie im gesamten Modul gehoistet).
// Muss vor express.static laufen, damit sie garantiert für jeden Request greift.
app.use(attachUser);
// Kompression: Texte (JSON, JS, CSS, HTML, SVG) werden gzip-komprimiert
// ausgeliefert, wenn der Browser es anbietet — /load-all schrumpft so von
// rund 150 KB auf einen Bruchteil. Statische Dateien werden je Datei und
// Änderungszeit einmal komprimiert und im Speicher gehalten.
app.use(gzipJson);
const gzipPublic = gzipStatisch(path.join(__dirname, 'public'));
app.use(gzipPublic);
// Zwischenspeichern: Jede JS-/CSS-Datei wird in App.html mit ?v=N
// eingebunden und die Nummer bei jeder Änderung erhöht — eine solche
// Adresse ändert ihren Inhalt nie und darf deshalb ein Jahr im Browser
// liegen. Alles andere (App.html selbst, Dateien ohne ?v) wird bei jedem
// Aufruf nachgefragt (no-cache + ETag, im Normalfall nur ein kurzes 304).
// Vorher: no-store, also bei JEDEM Laden rund 1,4 MB neu.
app.use(express.static(path.join(__dirname, 'public'), {
  setHeaders: (res, path) => {
    if(path.endsWith('.js') || path.endsWith('.css') || path.endsWith('.html') || path.endsWith('.svg')){
      const versioniert = res.req && /[?&]v=/.test(res.req.originalUrl || '');
      res.set('Cache-Control', versioniert ? 'public, max-age=31536000, immutable' : 'no-cache');
    }
  }
}));

// gzipJson: komprimiert res.json()-Antworten ab 1 KB, sofern der Browser
// gzip annimmt. Middleware; ersetzt res.json nur für diese Anfrage.
function gzipJson(req, res, next){
  if(!/\bgzip\b/.test(req.headers['accept-encoding'] || '')) return next();
  const original = res.json.bind(res);
  res.json = function(body){
    const text = JSON.stringify(body);
    if(text === undefined || text.length < 1024) return original(body);
    const gz = zlib.gzipSync(text, { level: 6 });
    if(!res.get('Content-Type')) res.set('Content-Type', 'application/json; charset=utf-8');
    res.set('Content-Encoding', 'gzip');
    res.set('Vary', 'Accept-Encoding');
    return res.send(gz);
  };
  next();
}

// gzipStatisch: liefert JS/CSS/HTML/SVG aus wurzel komprimiert aus (GET/HEAD,
// nur wenn der Browser gzip annimmt). Sonst — und für alles andere — weiter
// an express.static. Cache: Pfad -> { mtime, gz, etag }.
function gzipStatisch(wurzel){
  const TYPEN = { '.js': 'application/javascript; charset=utf-8', '.css': 'text/css; charset=utf-8',
    '.html': 'text/html; charset=utf-8', '.svg': 'image/svg+xml' };
  const cache = new Map();
  const mw = (req, res, next) => {
    if(req.method !== 'GET' && req.method !== 'HEAD') return next();
    let rel;
    try { rel = decodeURIComponent(req.path); } catch(e){ return next(); }
    if(rel.endsWith('/')) rel += 'index.html';
    const datei = path.join(wurzel, rel);
    if(!datei.startsWith(wurzel + path.sep)) return next();
    sende(req, res, next, datei);
  };
  // sende: eine Datei komprimiert ausliefern, sonst next() (auch nutzbar für
  // die Seitenrouten, die App.html unter anderen Pfaden liefern).
  const sende = (req, res, next, datei) => {
    if(!/\bgzip\b/.test(req.headers['accept-encoding'] || '')) return next();
    const typ = TYPEN[path.extname(datei).toLowerCase()];
    if(!typ) return next();
    let st;
    try { st = fs.statSync(datei); } catch(e){ return next(); }
    if(!st.isFile()) return next();
    let e = cache.get(datei);
    if(!e || e.mtime !== st.mtimeMs){
      const gz = zlib.gzipSync(fs.readFileSync(datei), { level: 6 });
      e = { mtime: st.mtimeMs, gz, etag: 'W/"gz-' + st.size.toString(16) + '-' + Math.floor(st.mtimeMs).toString(16) + '"' };
      cache.set(datei, e);
    }
    const versioniert = /[?&]v=/.test(req.originalUrl || '');
    res.set('Cache-Control', versioniert ? 'public, max-age=31536000, immutable' : 'no-cache');
    res.set('Vary', 'Accept-Encoding');
    res.set('ETag', e.etag);
    if(req.headers['if-none-match'] === e.etag) return res.status(304).end();
    res.set('Content-Type', typ);
    res.set('Content-Encoding', 'gzip');
    res.set('Content-Length', String(e.gz.length));
    if(req.method === 'HEAD') return res.end();
    res.end(e.gz);
  };
  mw.sende = sende;
  return mw;
}

// appSenden: App.html für die Seitenrouten — komprimiert, sonst wie bisher.
function appSenden(req, res){
  const datei = path.join(__dirname, 'public', 'App.html');
  gzipPublic.sende(req, res, () => res.sendFile(datei), datei);
}

// 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 });

// 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
// synchronous=NORMAL ist im WAL-Modus die übliche, sichere Einstellung: Die
// Datenbank bleibt bei einem Absturz konsistent, nur ein Stromausfall kann die
// allerletzten Schreibvorgänge kosten. Mit der Vorgabe FULL wartete JEDES
// Schreiben auf die SD-Karte des Pi — spürbar bei jedem Seitenaufruf.
db.exec('PRAGMA synchronous = NORMAL;');

// ---------- 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
//  - globale Personen pro Abteilung kommen seit der Ablösung von
//    people/person_roles/person_absences aus users/user_roles/user_absences
//    (siehe loadGlobalPeople, migrateRetirePeopleTablesIntoUsers)

db.exec(`CREATE TABLE IF NOT EXISTS weeks (
  label TEXT NOT NULL,
  week_id TEXT NOT NULL DEFAULT '',
  date TEXT NOT NULL DEFAULT '',
  locked INTEGER NOT NULL DEFAULT 0,
  updated_at TEXT NOT NULL DEFAULT '',
  PRIMARY KEY (label)
)`);
db.exec(`CREATE TABLE IF NOT EXISTS week_people (
  week_label TEXT NOT NULL,
  person_id TEXT NOT NULL,
  name TEXT NOT NULL DEFAULT '',
  full_name TEXT NOT NULL DEFAULT '',
  array_order INTEGER NOT NULL DEFAULT 0,
  PRIMARY KEY (week_label, person_id)
)`);
db.exec(`CREATE TABLE IF NOT EXISTS week_people_roles (
  week_label TEXT NOT NULL,
  person_id TEXT NOT NULL,
  role TEXT NOT NULL,
  role_order INTEGER NOT NULL DEFAULT 0,
  PRIMARY KEY (week_label, person_id, role)
)`);
db.exec(`CREATE TABLE IF NOT EXISTS attendance (
  week_label TEXT NOT NULL,
  person_id TEXT NOT NULL,
  present INTEGER NOT NULL DEFAULT 0,
  PRIMARY KEY (week_label, person_id)
)`);
db.exec(`CREATE TABLE IF NOT EXISTS projects (
  week_label TEXT NOT NULL,
  project_id TEXT NOT NULL,
  nr TEXT NOT NULL DEFAULT '',
  name TEXT NOT NULL DEFAULT '',
  status TEXT NOT NULL DEFAULT '',
  status_author TEXT NOT NULL DEFAULT '',
  status_at TEXT NOT NULL DEFAULT '',
  "group" TEXT NOT NULL DEFAULT '',
  array_order INTEGER NOT NULL DEFAULT 0,
  order_value INTEGER NOT NULL DEFAULT 0,
  -- besprochen: im Teammeeting abgehakt. Gehört zur SITZUNG, nicht zum
  -- Projekt: Jede Woche wird jedes Projekt neu durchgegangen, und der
  -- Haken beantwortet die Frage "hatten wir das schon?" nur für diese eine
  -- Sitzung. Deshalb steht er hier und nicht an einer wochenunabhängigen
  -- Stelle; beim Duplizieren einer Sitzung wird er zurückgesetzt.
  besprochen INTEGER NOT NULL DEFAULT 0,
  -- auftragsstatus: Wo das Projekt zwischen Anfrage und Abschluss steht
  -- ('anfrage'|'angebot'|'beauftragt'|'abgeschlossen', siehe
  -- VALID_AUFTRAGSSTATUS). Im Unterschied zu besprochen gehört der Wert zum
  -- PROJEKT und nicht zur Sitzung: Ein Angebot bleibt ein Angebot, bis es
  -- beauftragt wird, und wandert beim Duplizieren der Sitzung deshalb mit.
  -- Die Gruppe "In Anbahnung" deutete das bisher nur an; sie bleibt die
  -- Sortierung auf dem Board, sagt aber nichts darüber, ob schon ein Angebot
  -- draußen ist.
  auftragsstatus TEXT NOT NULL DEFAULT 'beauftragt',
  -- updated_at: Zeitstempel der letzten Speicherung DIESES Projekts. Bis zur
  -- Planung-Sandbox (CLAUDE.md, "Planung — projektunabhängige Terminplan-
  -- Sandbox") gab es nur eine Revision je WOCHE (weeks.updated_at) — genug,
  -- solange jede Sitzung nur wenige Projekte auf einmal hat. Die Sandbox legt
  -- aber mehrere, voneinander unabhängige Terminpläne in EINER reservierten
  -- Woche ab; ohne eine Zeitangabe je Projekt ließe sich "zuletzt bearbeitet"
  -- in der Planungsliste nicht je Plan unterscheiden. Für echte Projekte
  -- harmlos mitgeführt, aber ungenutzt.
  updated_at TEXT NOT NULL DEFAULT '',
  PRIMARY KEY (week_label, project_id)
)`);
db.exec(`CREATE TABLE IF NOT EXISTS project_tags (
  week_label TEXT NOT NULL,
  project_id TEXT NOT NULL,
  tag TEXT NOT NULL,
  tag_order INTEGER NOT NULL DEFAULT 0,
  PRIMARY KEY (week_label, project_id, tag)
)`);
db.exec(`CREATE TABLE IF NOT EXISTS project_lph (
  week_label TEXT NOT NULL,
  project_id TEXT NOT NULL,
  lph TEXT NOT NULL,
  value TEXT NOT NULL DEFAULT '',
  PRIMARY KEY (week_label, project_id, lph)
)`);
db.exec(`CREATE TABLE IF NOT EXISTS project_assign (
  week_label TEXT NOT NULL,
  project_id TEXT NOT NULL,
  person_id TEXT NOT NULL,
  role TEXT NOT NULL DEFAULT '',
  state INTEGER NOT NULL DEFAULT 0,
  PRIMARY KEY (week_label, project_id, person_id, role)
)`);
db.exec(`CREATE TABLE IF NOT EXISTS project_aufwand (
  week_label TEXT NOT NULL,
  project_id TEXT NOT NULL,
  lph TEXT NOT NULL,
  role TEXT NOT NULL DEFAULT '',
  value REAL NOT NULL DEFAULT 0,
  PRIMARY KEY (week_label, project_id, lph, role)
)`);
db.exec(`CREATE TABLE IF NOT EXISTS project_aktuelle_lp (
  week_label TEXT NOT NULL,
  project_id TEXT NOT NULL,
  lph TEXT NOT NULL,
  PRIMARY KEY (week_label, project_id, lph)
)`);
// project_beauftragte_lph: welche Leistungsphasen für dieses Projekt
// BEAUFTRAGT sind — nicht zu verwechseln mit project_aktuelle_lp (die eine
// gerade amtierende Phase) oder project_lph (Fortschritt in Prozent).
// Grundlage für die Honorar-Terminplanung (siehe js/plan/plan-honorar.js):
// das vereinbarte Honorar wird auf genau diese Phasen verteilt.
db.exec(`CREATE TABLE IF NOT EXISTS project_beauftragte_lph (
  week_label TEXT NOT NULL,
  project_id TEXT NOT NULL,
  lph TEXT NOT NULL,
  PRIMARY KEY (week_label, project_id, lph)
)`);
// project_gewerke: welche Fachbereiche des Büros das Projekt bearbeiten
// ('ELT'|'HLS'|'ARCH', dieselben Werte wie users.department). Ein Projekt
// kann zu mehreren gehören — ein Schulanbau etwa zu ELT und HLS.
//
// Wozu: Die Auswahl der Projektbeteiligten wird darauf eingeschränkt. Ein
// reines Elektro-Projekt soll nicht die ganze Belegschaft zur Auswahl
// stellen; wer trotzdem jemanden aus einem anderen Gewerk braucht, holt ihn
// ausdrücklich dazu (siehe den Wizard in js/projekt-wizard.js).
//
// Eigene Tabelle statt einer Spalte mit Trennzeichen — gleiche Bauart wie
// project_beauftragte_lph, und damit dieselben Wege beim Serialisieren.
db.exec(`CREATE TABLE IF NOT EXISTS project_gewerke (
  week_label TEXT NOT NULL,
  project_id TEXT NOT NULL,
  gewerk TEXT NOT NULL,
  PRIMARY KEY (week_label, project_id, gewerk)
)`);
// project_kommentare: Sitzungskommentar und Besprochen-Haken JE GEWERK.
// ELT, HLS und ARCH besprechen ihre Projekte in getrennten Sitzungen (Eriks
// Wunsch: "Die Kommentare und Anwesenheiten von ELT brauchen nicht in HLS
// oder Arch zu sein" / "auch wenn das Projekt in ELT besprochen ist, heißt
// das nicht, dass HLS das Projekt auch besprochen hat"). Löst die Spalten
// projects.status/status_author/status_at/besprochen ab, die nur noch für
// den Übergang (migrateKommentareJeGewerk()) gelesen und sonst leer
// geschrieben werden. Client-Form: p.kommentare = { ELT: {status,
// statusAuthor, statusAt, besprochen}, … }.
db.exec(`CREATE TABLE IF NOT EXISTS project_kommentare (
  week_label TEXT NOT NULL,
  project_id TEXT NOT NULL,
  gewerk TEXT NOT NULL,
  status TEXT NOT NULL DEFAULT '',
  status_author TEXT NOT NULL DEFAULT '',
  status_at TEXT NOT NULL DEFAULT '',
  besprochen INTEGER NOT NULL DEFAULT 0,
  PRIMARY KEY (week_label, project_id, gewerk)
)`);
db.exec(`CREATE TABLE IF NOT EXISTS project_plan (
  week_label TEXT NOT NULL,
  project_id TEXT NOT NULL,
  start TEXT NOT NULL DEFAULT '',
  end TEXT NOT NULL DEFAULT '',
  progress INTEGER NOT NULL DEFAULT 0,
  PRIMARY KEY (week_label, project_id)
)`);
db.exec(`CREATE TABLE IF NOT EXISTS plan_people (
  week_label TEXT NOT NULL,
  project_id TEXT NOT NULL,
  person_id TEXT NOT NULL,
  array_order INTEGER NOT NULL DEFAULT 0,
  PRIMARY KEY (week_label, project_id, person_id)
)`);
db.exec(`CREATE TABLE IF NOT EXISTS plan_todos (
  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,
  show_in_gantt INTEGER NOT NULL DEFAULT 1,
  leistungsphase TEXT NOT NULL DEFAULT '',
  aufwand_stunden REAL NOT NULL DEFAULT 0,
  notiz TEXT NOT NULL DEFAULT '',
  PRIMARY KEY (week_label, project_id, todo_id)
)`);
db.exec(`CREATE TABLE IF NOT EXISTS plan_todo_assignees (
  week_label TEXT NOT NULL,
  project_id TEXT NOT NULL,
  todo_id TEXT NOT NULL,
  person_id TEXT NOT NULL,
  PRIMARY KEY (week_label, project_id, todo_id, person_id)
)`);
db.exec(`CREATE TABLE IF NOT EXISTS plan_todo_deps (
  week_label TEXT NOT NULL,
  project_id TEXT NOT NULL,
  todo_id TEXT NOT NULL,
  depends_on_id TEXT NOT NULL,
  PRIMARY KEY (week_label, project_id, todo_id, depends_on_id)
)`);
db.exec(`CREATE TABLE IF NOT EXISTS plan_milestones (
  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,
  notiz TEXT NOT NULL DEFAULT '',
  PRIMARY KEY (week_label, project_id, milestone_id)
)`);
db.exec(`CREATE TABLE IF NOT EXISTS plan_milestone_deps (
  week_label TEXT NOT NULL,
  project_id TEXT NOT NULL,
  milestone_id TEXT NOT NULL,
  depends_on_id TEXT NOT NULL,
  PRIMARY KEY (week_label, project_id, milestone_id, depends_on_id)
)`);
// people / person_roles / person_absences (globale Personen pro Abteilung) sind
// abgelöst worden (siehe migrateRetirePeopleTablesIntoUsers weiter unten) —
// werden deshalb hier bewusst NICHT mehr unconditionally angelegt. Für Alt-DBs
// im früheren Ein-Dokument-Format legt migrateLegacySchema() sie transient an,
// migrateRetirePeopleTablesIntoUsers() überführt/droppt sie danach beim selben
// Start.

// ---------- User-Management, Sessions, Datei-Freigabe (Schema, additiv) ----------
db.exec(`CREATE TABLE IF NOT EXISTS users (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  username TEXT NOT NULL UNIQUE,
  display_name TEXT NOT NULL DEFAULT '',
  email TEXT NOT NULL DEFAULT '',
  password_hash TEXT NOT NULL,
  password_salt TEXT NOT NULL,
  role TEXT NOT NULL DEFAULT 'member',
  person_id TEXT NOT NULL DEFAULT '',
  active INTEGER NOT NULL DEFAULT 1,
  must_change_password INTEGER NOT NULL DEFAULT 0,
  created_at TEXT NOT NULL DEFAULT '',
  updated_at TEXT NOT NULL DEFAULT ''
)`);
db.exec(`CREATE INDEX IF NOT EXISTS idx_users_person_id ON users(person_id)`);

db.exec(`CREATE TABLE IF NOT EXISTS user_sessions (
  token TEXT PRIMARY KEY,
  user_id INTEGER NOT NULL,
  created_at TEXT NOT NULL DEFAULT '',
  last_seen_at TEXT NOT NULL DEFAULT '',
  expires_at TEXT NOT NULL DEFAULT '',
  FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE
)`);

// user_roles/user_absences: Rollen (Planung/Projektleitung/Bauüberwachung) und
// Abwesenheiten je Benutzer — lösen die alten people/person_roles/
// person_absences-Tabellen vollständig ab (loadGlobalPeople liest nur noch
// hieraus, migrateRetirePeopleTablesIntoUsers überführt/droppt die Altdaten).
db.exec(`CREATE TABLE IF NOT EXISTS user_roles (
  user_id INTEGER NOT NULL, role TEXT NOT NULL, role_order INTEGER NOT NULL DEFAULT 0,
  PRIMARY KEY (user_id, role),
  FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE
)`);
// created_by: wer den Eintrag angelegt hat. Grundlage der Löschberechtigung —
// eintragen darf jeder für jeden (die Projektleitung pflegt Urlaube ihres
// Teams mit), aber entfernen nur die betroffene Person selbst, wer ihn
// eingetragen hat, oder ein Administrator. 0 = Altbestand ohne Angabe.
db.exec(`CREATE TABLE IF NOT EXISTS user_absences (
  user_id INTEGER NOT NULL, id TEXT NOT NULL,
  start TEXT NOT NULL DEFAULT '', end TEXT NOT NULL DEFAULT '',
  type TEXT NOT NULL DEFAULT '', note TEXT NOT NULL DEFAULT '',
  created_by INTEGER NOT NULL DEFAULT 0,
  PRIMARY KEY (user_id, id),
  FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE
)`);
// Persönliche KI-Zugangsdaten für den Protokoll-Import (POST
// /project-protokolle/import), siehe readUserAiKey()/writeUserAiKey() und
// CLAUDE.md "### Protokolle": jedes Konto pflegt seinen eigenen Schlüssel +
// optionale abweichende API-URL (z. B. ein Firmen-Proxy statt der
// offiziellen Cloud-API) unter Einstellungen → Mein Konto — bewusst eine
// eigene, kleine User-Kind-Tabelle statt Zeilen in app_settings, das
// strukturell ein firmenweiter Singleton-Speicher ist.
db.exec(`CREATE TABLE IF NOT EXISTS user_ai_keys (
  user_id INTEGER NOT NULL, provider TEXT NOT NULL,
  api_key TEXT NOT NULL DEFAULT '', api_url TEXT NOT NULL DEFAULT '',
  PRIMARY KEY (user_id, provider),
  FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE
)`);

// benachrichtigungen: Hinweise an ein Konto, bisher nur "neue Aufgabe
// zugewiesen" (art 'aufgabe'). Entstehen in POST /save-week, wenn eine
// Aufgabe einen Zuständigen bekommt, den sie vorher nicht hatte
// (neueZuweisungenMelden()). Gelesen = in der Glocke angeklickt oder "alle
// gelesen". Keine Kopie in IMPORT_TABLES: wie die Konten selbst kontobezogen,
// ein DB-Import lässt sie unberührt. Alte Einträge räumt
// purgeBenachrichtigungen() auf.
db.exec(`CREATE TABLE IF NOT EXISTS benachrichtigungen (
  id TEXT PRIMARY KEY,
  user_id INTEGER NOT NULL,
  art TEXT NOT NULL DEFAULT 'aufgabe',
  titel TEXT NOT NULL DEFAULT '',
  project_id TEXT NOT NULL DEFAULT '',
  project_nr TEXT NOT NULL DEFAULT '',
  project_name TEXT NOT NULL DEFAULT '',
  week_label TEXT NOT NULL DEFAULT '',
  todo_id TEXT NOT NULL DEFAULT '',
  faellig TEXT NOT NULL DEFAULT '',
  von_name TEXT NOT NULL DEFAULT '',
  created_at TEXT NOT NULL,
  gelesen INTEGER NOT NULL DEFAULT 0,
  FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE
)`);
db.exec('CREATE INDEX IF NOT EXISTS idx_benachrichtigungen_user ON benachrichtigungen(user_id, gelesen, created_at)');

db.exec(`CREATE TABLE IF NOT EXISTS project_files (
  id TEXT PRIMARY KEY,
  project_nr TEXT NOT NULL,
  project_name TEXT NOT NULL DEFAULT '',
  original_filename TEXT NOT NULL,
  stored_name TEXT NOT NULL,
  content_type TEXT NOT NULL DEFAULT 'application/octet-stream',
  size_bytes INTEGER NOT NULL DEFAULT 0,
  uploaded_by_user_id INTEGER NOT NULL,
  status TEXT NOT NULL DEFAULT 'pending',
  created_at TEXT NOT NULL DEFAULT '',
  updated_at TEXT NOT NULL DEFAULT ''
)`);
db.exec(`CREATE INDEX IF NOT EXISTS idx_project_files_scope ON project_files(project_nr)`);

db.exec(`CREATE TABLE IF NOT EXISTS project_file_reviewers (
  file_id TEXT NOT NULL,
  user_id INTEGER NOT NULL,
  decision TEXT NOT NULL DEFAULT 'pending',
  decided_at TEXT NOT NULL DEFAULT '',
  note TEXT NOT NULL DEFAULT '',
  PRIMARY KEY (file_id, user_id)
)`);
db.exec(`CREATE INDEX IF NOT EXISTS idx_pfr_user_pending ON project_file_reviewers(user_id, decision)`);

db.exec(`CREATE TABLE IF NOT EXISTS project_file_comments (
  id TEXT PRIMARY KEY,
  file_id TEXT NOT NULL,
  user_id INTEGER NOT NULL,
  body TEXT NOT NULL,
  created_at TEXT NOT NULL DEFAULT ''
)`);

// Protokolle (Besprechungsprotokolle je Projekt) — wie project_files über
// project_nr mit dem Projekt verknüpft, NICHT über week_label/project_id:
// project_id wird bei jedem automatischen Sitzungswechsel
// (ensureCurrentWeekRollover()) neu vergeben, ein Protokoll muss aber über
// Sitzungen hinweg bestehen bleiben. week_label ist hier reine Information
// (welche Sitzung lief beim Anlegen), keine Scoping-Spalte.
db.exec(`CREATE TABLE IF NOT EXISTS project_protokolle (
  id TEXT PRIMARY KEY,
  project_nr TEXT NOT NULL,
  project_name TEXT NOT NULL DEFAULT '',
  nummer INTEGER NOT NULL,
  datum TEXT NOT NULL DEFAULT '',
  betreff TEXT NOT NULL DEFAULT '',
  ort TEXT NOT NULL DEFAULT '',
  verfasser_user_id INTEGER NOT NULL,
  week_label TEXT NOT NULL DEFAULT '',
  quelle_dateiname TEXT NOT NULL DEFAULT '',
  quelle_stored_name TEXT NOT NULL DEFAULT '',
  created_at TEXT NOT NULL DEFAULT '',
  updated_at TEXT NOT NULL DEFAULT ''
)`);
db.exec(`CREATE INDEX IF NOT EXISTS idx_protokolle_project ON project_protokolle(project_nr)`);

// protokoll_teilnehmer: Freitext-Teilnehmerliste je Protokoll (Name + Firma),
// unabhängig von Benutzerkonten — Baubesprechungen haben typischerweise
// externe Teilnehmer (Bauherr, ausführende Firmen) ohne Login hier.
db.exec(`CREATE TABLE IF NOT EXISTS protokoll_teilnehmer (
  id TEXT PRIMARY KEY,
  protokoll_id TEXT NOT NULL,
  name TEXT NOT NULL DEFAULT '',
  firma TEXT NOT NULL DEFAULT '',
  anwesend INTEGER NOT NULL DEFAULT 1,
  array_order INTEGER NOT NULL DEFAULT 0
)`);
db.exec(`CREATE INDEX IF NOT EXISTS idx_protokoll_teilnehmer_protokoll ON protokoll_teilnehmer(protokoll_id)`);

// protokoll_punkte: die eigentlichen Besprechungspunkte. stamm_id verbindet
// alle fortgeschriebenen Kopien "desselben" Punkts über mehrere Protokolle
// hinweg (siehe createProtokoll()) — nur daran hängt, ob ein Punkt als neu
// gilt (neu=1), NICHT an nummer/gruppe: beides ist freier, jederzeit vom
// Nutzer änderbarer Anzeige-Text (nummer z.B. "1", "1.1", "2.3"; gruppe z.B.
// "ELT"/"HLS" — keine feste Liste, entsteht einfach durchs Eintragen).
db.exec(`CREATE TABLE IF NOT EXISTS protokoll_punkte (
  id TEXT PRIMARY KEY,
  protokoll_id TEXT NOT NULL,
  stamm_id TEXT NOT NULL,
  nummer TEXT NOT NULL DEFAULT '',
  gruppe TEXT NOT NULL DEFAULT '',
  neu INTEGER NOT NULL DEFAULT 0,
  thema TEXT NOT NULL DEFAULT '',
  text TEXT NOT NULL DEFAULT '',
  zustaendig TEXT NOT NULL DEFAULT '',
  termin TEXT NOT NULL DEFAULT '',
  erledigt INTEGER NOT NULL DEFAULT 0,
  erstellt_am TEXT NOT NULL DEFAULT '',
  status TEXT NOT NULL DEFAULT 'offen',
  array_order INTEGER NOT NULL DEFAULT 0
)`);
db.exec(`CREATE INDEX IF NOT EXISTS idx_protokoll_punkte_protokoll ON protokoll_punkte(protokoll_id)`);

// lph_templates: firmenweite Aufgaben-Vorlagen je Leistungsphase und Gewerk
// (Spalte gewerk, nachgerüstet von migrateAddLphTemplateGewerk(); '' = gilt
// für alle Gewerke, nur Altbestand). Anders als
// alle Tabellen darüber hängt diese an KEINER Sitzung und an keinem Projekt —
// sie ist globale Konfiguration ("in LPH 5 machen wir immer diese Schritte"),
// aus der auf der Projektplan-Seite per Klick TODOs erzeugt werden (siehe
// js/plan/plan-templates.js). offset_days = Start relativ zum beim Einfügen
// gewählten Datum (0 = am Starttag), duration_days = Dauer in Kalendertagen;
// 0 = ohne Termin (die Aufgabe wird ohne Start/Ende eingefügt). Die erzeugten TODOs sind danach ganz normale plan_todos und
// haben keinerlei Verbindung mehr zur Vorlage — spätere Änderungen an der
// Vorlage wirken sich also NICHT auf bereits eingefügte Aufgaben aus (bewusst:
// ein laufender Projektplan soll sich nicht rückwirkend ändern).
db.exec(`CREATE TABLE IF NOT EXISTS lph_templates (
  id TEXT PRIMARY KEY,
  lph TEXT NOT NULL,
  title TEXT NOT NULL DEFAULT '',
  offset_days INTEGER NOT NULL DEFAULT 0,
  duration_days INTEGER NOT NULL DEFAULT 1,
  sort_order INTEGER NOT NULL DEFAULT 0
)`);
db.exec('CREATE INDEX IF NOT EXISTS idx_lph_templates_lph ON lph_templates(lph)');

// ---------- Rollen und Rechte ----------
// Eriks Wunsch: Rollen und ihre Rechte werden in der Oberfläche gepflegt
// (Admin → Rollen & Rechte, js/admin/rollen.js), neue Rollen lassen sich
// anlegen. RECHTE ist der feste Katalog — die Schlüssel stehen im Code, nur
// ihre Zuordnung zu Rollen ist frei. Fachrollen (user_roles: Planung,
// Projektleitung, Bauüberwachung) haben damit NICHTS zu tun.
//
// roles: key (= users.role), name, sort_order, fest (1 = Administrator: hat
// immer alle Rechte, ist weder änderbar noch löschbar — sonst könnte man sich
// aussperren). role_rechte: eine Zeile je Haken. Beide NICHT in
// IMPORT_TABLES: ein Backup-Import lässt Rechte wie Konten unberührt.
//
// Eine Rolle OHNE das Recht „app“ ist eine reine Wandtafel-Rolle: sie
// erreicht nur die lesenden Routen der Wandtafel (requireAuthOderKiosk) und
// zählt nirgends als Teammitglied — das frühere fest verdrahtete 'kiosk'.
const RECHTE = [
  { gruppe: 'Grundzugang', rechte: [
    ['app', 'Anwendung nutzen', 'Projekte, Wochenbericht, Auslastung und Meine Aufgaben sehen'],
    ['wand', 'Wandtafel anzeigen', ''] ]},
  { gruppe: 'Projekte', rechte: [
    ['proj.anlegen', 'Projekte anlegen und löschen', ''],
    ['proj.stamm', 'Stammdaten und Beteiligte bearbeiten', 'Projekteinstellungen'],
    ['proj.plan', 'Terminplan bearbeiten', 'Aufgaben, Meilensteine, Phasen, Vorlagen'],
    ['proj.dateien', 'Dateien hochladen, prüfen und kommentieren', ''],
    ['proj.dateienFremd', 'Fremde Dateien löschen', ''],
    ['proj.protokolle', 'Protokolle bearbeiten', 'anlegen, importieren, löschen'] ]},
  { gruppe: 'Wochenbericht', rechte: [
    ['wb.kommentar', 'Kommentar und Fortschritt bearbeiten', ''],
    ['wb.besprochen', '„Besprochen“ abhaken', ''],
    ['wb.anwesenheit', 'Anwesenheit erfassen', ''] ]},
  { gruppe: 'Team', rechte: [
    ['team.abw', 'Abwesenheiten für mich', 'eigene eintragen, ändern, löschen'],
    ['team.abwProjekte', 'Abwesenheiten für Personen meiner Projekte', 'Beteiligte der eigenen Projekte (aktuelle Sitzung)'],
    ['team.abwGewerk', 'Abwesenheiten für mein Gewerk', 'alle Konten mit demselben Gewerk'],
    ['team.abwAlle', 'Abwesenheiten für alle', ''] ]},
  { gruppe: 'Werkzeuge', rechte: [
    ['wz.planung', 'Terminplan', 'Terminpläne ohne Projekt (Seitenleiste „Terminplan“)'],
    ['wz.checker', 'Plan Checker', ''] ]},
  { gruppe: 'Sitzungen', rechte: [
    ['s.entsperren', 'Sitzung entsperren', ''],
    ['s.loeschen', 'Sitzung löschen', ''],
    ['s.gesperrt', 'Gesperrte Sitzung bearbeiten', ''] ]},
  { gruppe: 'Admin-Bereich', rechte: [
    ['a.benutzer', 'Benutzerverwaltung', ''], ['a.honorar', 'Honorar', ''],
    ['a.auslastung', 'Auslastung', ''], ['a.termine', 'Termine & Sitzungen', ''],
    ['a.feiertage', 'Feiertage', ''], ['a.vorlagen', 'Aufgaben-Vorlagen', ''],
    ['a.checker', 'Plan-Checker-Merkmale', ''], ['a.betrieb', 'Betrieb & Sicherheit', ''],
    ['a.papierkorb', 'Papierkorb', ''], ['a.backup', 'Datenbank-Backup', ''],
    ['a.import', 'Datenbank-Import', ''], ['a.rollen', 'Rollen & Rechte', ''],
    ['a.teams', 'Teams-Anbindung', ''] ]},
];
const RECHT_LABEL = new Map(RECHTE.flatMap(g => g.rechte.map(r => [r[0], r[1]])));
const RECHT_KEYS = new Set(RECHT_LABEL.keys());

db.exec(`CREATE TABLE IF NOT EXISTS roles (
  key TEXT PRIMARY KEY,
  name TEXT NOT NULL,
  sort_order INTEGER NOT NULL DEFAULT 0,
  fest INTEGER NOT NULL DEFAULT 0
)`);
db.exec(`CREATE TABLE IF NOT EXISTS role_rechte (
  role_key TEXT NOT NULL,
  recht TEXT NOT NULL,
  PRIMARY KEY (role_key, recht)
)`);

// Startbelegung = Stand vor dem Umbau: Projektleiter und Mitglied alles aus
// Grundzugang bis Werkzeuge (Mitglied ohne „Projekte anlegen und löschen“),
// Wandtafel nur die Wandtafel. Läuft nur, solange roles leer ist.
(function rollenStartbelegung(){
  if(db.prepare('SELECT COUNT(*) AS n FROM roles').get().n > 0) return;
  const basis = RECHTE.slice(0, 5).flatMap(g => g.rechte.map(r => r[0]));
  const start = [
    ['admin', 'Administrator', 1, []],
    ['projektleiter', 'Projektleiter', 0, basis],
    ['member', 'Mitglied', 0, basis.filter(k => k !== 'proj.anlegen')],
    ['kiosk', 'Wandtafel', 0, ['wand']],
  ];
  const insR = db.prepare('INSERT INTO roles (key, name, sort_order, fest) VALUES (?, ?, ?, ?)');
  const insH = db.prepare('INSERT OR IGNORE INTO role_rechte (role_key, recht) VALUES (?, ?)');
  db.exec('BEGIN');
  try {
    start.forEach(([k, n, fest, rechte], i) => { insR.run(k, n, i, fest); rechte.forEach(r => insH.run(k, r)); });
    db.exec('COMMIT');
    console.log('Rollen & Rechte: Startbelegung angelegt.');
  } catch(e){ db.exec('ROLLBACK'); throw e; }
})();

// rollenCache: key → { key, name, sortOrder, fest, rechte:Set } — jede
// Anfrage prüft gegen diesen Speicher, neu geladen nach jeder Änderung.
let rollenCache = new Map();
function ladeRollen(){
  const m = new Map();
  db.prepare('SELECT * FROM roles ORDER BY sort_order, name').all().forEach(r => {
    m.set(r.key, { key: r.key, name: r.name, sortOrder: r.sort_order, fest: !!r.fest, rechte: new Set() });
  });
  db.prepare('SELECT * FROM role_rechte').all().forEach(r => {
    const x = m.get(r.role_key);
    if(x && RECHT_KEYS.has(r.recht)) x.rechte.add(r.recht);
  });
  rollenCache = m;
}
ladeRollen();
// Umstellung der Abwesenheits-Rechte (Eriks Wunsch): „Fremde Abwesenheiten
// löschen“ (team.abwFremd) entfällt. Startbelegung wie im Entwurf: Mitglied
// nur „für mich“, Projektleiter „für mein Gewerk“ und „für Personen meiner
// Projekte“. Selbst angelegte Rollen mit team.abwFremd bekommen „für alle“
// (Mitglied und Projektleiter hatten es aus der Startbelegung, nicht bewusst).
(function abwesenheitsRechteUmstellen(){
  db.exec('CREATE TABLE IF NOT EXISTS umstellungen (name TEXT PRIMARY KEY, am TEXT NOT NULL)');
  if(db.prepare("SELECT 1 FROM umstellungen WHERE name = 'abwesenheit-rechte'").get()) return;
  const ins = db.prepare('INSERT OR IGNORE INTO role_rechte (role_key, recht) VALUES (?, ?)');
  db.exec('BEGIN');
  try {
    db.prepare("SELECT role_key FROM role_rechte WHERE recht = 'team.abwFremd' AND role_key NOT IN ('member', 'projektleiter')").all()
      .forEach(r => { ins.run(r.role_key, 'team.abwAlle'); ins.run(r.role_key, 'team.abw'); });
    if(db.prepare("SELECT 1 FROM roles WHERE key = 'projektleiter'").get()){
      ['team.abw', 'team.abwGewerk', 'team.abwProjekte'].forEach(r => ins.run('projektleiter', r));
    }
    db.exec("DELETE FROM role_rechte WHERE recht = 'team.abwFremd'");
    db.prepare("INSERT INTO umstellungen (name, am) VALUES ('abwesenheit-rechte', ?)").run(new Date().toISOString());
    db.exec('COMMIT');
  } catch(e){ db.exec('ROLLBACK'); throw e; }
  ladeRollen();
})();

// abwesenheitZiele: für wen ein Konto Abwesenheiten eintragen, ändern und
// löschen darf (und bei wem es die Art sieht). Rückgabe: { alle:Boolean,
// ids:Set<user_id> }. Das eigene Konto gehört dazu, sobald irgendein
// Abwesenheits-Recht gesetzt ist. „Meine Projekte“ = Projekte der jüngsten
// echten Sitzung, in denen beide als Beteiligte (state > 0) stehen.
function abwesenheitZiele(user){
  const ids = new Set();
  if(!user) return { alle: false, ids };
  if(hatRecht(user, 'team.abwAlle')) return { alle: true, ids };
  const gewerk = hatRecht(user, 'team.abwGewerk');
  const projekte = hatRecht(user, 'team.abwProjekte');
  if(hatRecht(user, 'team.abw') || gewerk || projekte) ids.add(user.id);
  if(gewerk && user.department){
    db.prepare('SELECT id FROM users WHERE department = ? AND active = 1').all(user.department).forEach(r => ids.add(r.id));
  }
  if(projekte && user.personId){
    const label = db.prepare('SELECT label FROM weeks WHERE label != ?').all(SANDBOX_WEEK_LABEL)
      .map(r => r.label).sort((a, b) => weekSortKeyServer(a).localeCompare(weekSortKeyServer(b))).pop();
    if(label){
      db.prepare(`SELECT DISTINCT u.id FROM project_assign a
          JOIN project_assign b ON b.week_label = a.week_label AND b.project_id = a.project_id AND b.state > 0
          JOIN users u ON u.person_id = b.person_id
        WHERE a.week_label = ? AND a.person_id = ? AND a.state > 0`).all(label, user.personId).forEach(r => ids.add(r.id));
    }
  }
  return { alle: false, ids };
}
function darfAbwesenheit(user, zielId){
  const z = abwesenheitZiele(user);
  return z.alle || z.ids.has(Number(zielId));
}

function rolleExistiert(key){ return rollenCache.has(String(key)); }
// rechteDerRolle: Liste der Rechte einer Rolle (fest = alle).
function rechteDerRolle(key){
  const r = rollenCache.get(String(key));
  if(!r) return [];
  return r.fest ? [...RECHT_KEYS] : [...r.rechte];
}
// hatRecht: darf dieses Konto das? Parameter: user (req.user), recht.
function hatRecht(user, recht){
  if(!user) return false;
  const r = rollenCache.get(user.role);
  return !!r && (r.fest || r.rechte.has(recht));
}
// istNurWandtafel: Rolle ohne Grundzugang „Anwendung nutzen“.
function istNurWandtafel(roleKey){
  const r = rollenCache.get(String(roleKey));
  return !r || (!r.fest && !r.rechte.has('app'));
}
// sqlOhneWandtafel: SQL-Bedingung, die Konten reiner Wandtafel-Rollen
// ausschließt (ersetzt das frühere role != 'kiosk'). Rollenschlüssel sind
// beim Anlegen auf [a-z0-9_-] beschränkt, daher sicher einzusetzen.
function sqlOhneWandtafel(spalte){
  const keys = [...rollenCache.keys()].filter(k => istNurWandtafel(k)).filter(k => /^[a-z0-9_-]+$/.test(k));
  const s = spalte || 'role';
  return keys.length ? `${s} NOT IN (${keys.map(k => `'${k}'`).join(',')})` : '1=1';
}
// rechtFehlt: einheitliche 403-Antwort, nennt das fehlende Recht.
function rechtFehlt(res, recht){
  return res.status(403).json({ ok: false, recht, error: 'Keine Berechtigung: „' + (RECHT_LABEL.get(recht) || recht) + '“ fehlt.' });
}
// requireRecht: Middleware — angemeldet UND Recht vorhanden.
function requireRecht(recht){
  return function(req, res, next){
    if(!req.user) return res.status(401).json({ ok: false, error: 'Nicht angemeldet.' });
    if(!hatRecht(req.user, recht)) return rechtFehlt(res, recht);
    next();
  };
}

// plan_checker_merkmale: firmenweite Grundliste der Merkmale, gegen die der
// Plan Checker (Seitenleisten-Bereich "Studenten") einen hochgeladenen Plan
// prüft (z. B. "Maßketten vorhanden"). "prompt" ist die Prüfanweisung, die
// an die KI geht — "titel" ist zugleich die Anzeige-Bezeichnung UND der
// Schlüssel, unter dem die KI ihr Ergebnis zurückgibt. Anders als
// lph_templates gibt es hier kein Gruppierungsfeld: die Liste gilt
// unterschiedslos für jede Prüfung (plus ein optionales, NICHT
// gespeichertes Zusatz-Merkmal nur für die jeweils eine Prüfung, siehe
// POST /plan-checker-pruefen).
db.exec(`CREATE TABLE IF NOT EXISTS plan_checker_merkmale (
  id TEXT PRIMARY KEY,
  titel TEXT NOT NULL,
  prompt TEXT NOT NULL,
  sort_order INTEGER NOT NULL DEFAULT 0
)`);

// lph_honorar_anteile: firmenweite Honorar-Anteile je Leistungsphase in
// Prozent (HOAI-Sätze). Bewusst NICHT als Konstante im Code, sondern
// pflegbar — die Sätze hängen vom Leistungsbild ab (Technische Ausrüstung
// nach Anlage 15 unterscheidet sich von der Objektplanung nach Anlage 10)
// und ändern sich mit HOAI-Novellen. Startet leer und wird in der
// Honorar-Maske auf der Projektplan-Seite von Administratoren befüllt.
db.exec(`CREATE TABLE IF NOT EXISTS lph_honorar_anteile (
  lph TEXT PRIMARY KEY,
  percent REAL NOT NULL DEFAULT 0
)`);

// app_settings: firmenweite Einzelwerte als Schlüssel/Wert-Paare. Werte
// stehen als TEXT und werden beim Lesen gewandelt; welche Schlüssel es gibt,
// welchen Typ und welche Vorgabe sie haben, steht in APP_SETTING_DEFS weiter
// unten — dort liegt auch die Prüfung. Eine Zeile existiert erst, wenn der
// Wert einmal gesetzt wurde; sonst gilt die Vorgabe. Damit brauchen neue
// Einstellungen weder eine eigene Tabelle noch eine Migration.
db.exec(`CREATE TABLE IF NOT EXISTS app_settings (
  key TEXT PRIMARY KEY,
  value TEXT NOT NULL DEFAULT ''
)`);

// holidays: firmenweite Feiertage und sonstige arbeitsfreie Tage. Bewusst
// eine eigene Tabelle statt eines JSON-Werts in app_settings — es ist eine
// Liste, die wächst, und sie soll sich einzeln pflegen lassen. Sie wirkt
// überall dort, wo in WERKTAGEN gerechnet wird: workdaysBetween()/
// addWorkdays() in public/js/utils.js, also in der Terminplan-Berechnung aus
// dem Honorar und in der Ressourcen-Auslastung des Projektbereichs. Die
// Terminplanung über Abhängigkeiten (Auto-Schedule) rechnet weiterhin in
// Kalendertagen — das war schon vorher so.
db.exec(`CREATE TABLE IF NOT EXISTS holidays (
  date TEXT PRIMARY KEY,
  name TEXT NOT NULL DEFAULT ''
)`);

// ---------- Migration: altes Ein-Dokument-Format -> relationales Schema ----------

// 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;
}

// ---------- Serverseitige Bereinigung von Formatierungs-HTML ----------
//
// Gegenstück zu sanitizeStatusHtml() (public/js/utils.js) für den Server.
// Dieselbe Positivliste, dieselben Regeln — aber ohne DOM, deshalb ein
// eigener, kleiner Tokenizer statt eines Parsers.
//
// Warum überhaupt serverseitig, wo der Client doch schon bereinigt: Weil die
// Bereinigung im Client eine ANZEIGE-Maßnahme ist, keine Eingangskontrolle.
// Wer eine gültige Anmeldung hat, kann die Routen direkt ansprechen und
// beliebiges HTML in einen Kommentar oder Protokollpunkt schreiben. Bis
// hierher wurde das unverändert gespeichert und erst beim Anzeigen entschärft
// — jede Stelle, die das Feld künftig einmal ohne Bereinigung anfasst, wäre
// damit sofort ein Einfallstor. Die Prüfung gehört an die Schreibstelle.
//
// Bewusst keine Abhängigkeit: Das Projekt kommt mit express/cors plus den
// drei Protokoll-Import-Bibliotheken aus; ein Sanitizer-Paket dafür
// aufzunehmen stünde in keinem Verhältnis zu diesen gut hundert Zeilen.

const SICHERE_TAGS = new Set(['b','strong','i','em','u','p','br','div','span','font']);
// Tags, deren INHALT mitverschwindet, statt ausgepackt zu werden: Bei
// <script> wäre der ausgepackte Rest sonst der sichtbare Quelltext.
const TAGS_MIT_INHALT_VERWERFEN = new Set(['script','style','noscript','template','iframe','object','embed']);
// Leere Elemente haben kein schließendes Gegenstück.
const LEERE_TAGS = new Set(['br']);

// htmlEscape: maskiert Text für die Ausgabe in HTML (wie esc() im Client).
function htmlEscape(s){
  return String(s)
    .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;').replace(/'/g, '&#39;');
}

// sicheresStyleAttribut: lässt aus einem style-Attribut nur color und
// font-weight durch — identisch zur Client-Regel. Rückgabe: bereinigter
// Wert oder '' (dann wird das Attribut ganz weggelassen).
function sicheresStyleAttribut(wert){
  return String(wert || '').split(';').map(s => s.trim()).filter(s => {
    const prop = s.split(':')[0].trim().toLowerCase();
    if(prop !== 'color' && prop !== 'font-weight') return false;
    // url(), expression() und Konsorten haben in einer Farbangabe nichts zu
    // suchen; ein Wert mit Klammern oder Semikolon fliegt vorsichtshalber raus.
    const val = s.slice(s.indexOf(':') + 1);
    return !/[()\\]/.test(val);
  }).join('; ');
}

// tagLesen: liest ab Position i (wo '<' steht) ein vollständiges Tag.
// Beachtet Anführungszeichen in Attributwerten, damit ein '>' DARIN das Tag
// nicht vorzeitig beendet. Rückgabe: { name, schliessend, attribute, ende }
// oder null, wenn an dieser Stelle kein gültiges Tag steht (dann ist das '<'
// schlicht Text).
function tagLesen(html, i){
  if(html[i] !== '<') return null;
  // Kommentare und Deklarationen überspringen und verwerfen
  if(html.startsWith('<!--', i)){
    const ende = html.indexOf('-->', i + 4);
    return { kommentar: true, ende: ende === -1 ? html.length : ende + 3 };
  }
  if(html[i + 1] === '!' || html[i + 1] === '?'){
    const ende = html.indexOf('>', i);
    return { kommentar: true, ende: ende === -1 ? html.length : ende + 1 };
  }
  let p = i + 1;
  const schliessend = html[p] === '/';
  if(schliessend) p++;
  const nameStart = p;
  while(p < html.length && /[a-zA-Z0-9]/.test(html[p])) p++;
  if(p === nameStart) return null;              // '<' ohne Tagnamen -> Text
  const name = html.slice(nameStart, p).toLowerCase();
  // Attributbereich bis zum '>' lesen, Anführungszeichen beachten
  let attr = '';
  let inQuote = null;
  while(p < html.length){
    const c = html[p];
    if(inQuote){
      if(c === inQuote) inQuote = null;
      attr += c;
    } else if(c === '"' || c === "'"){
      inQuote = c; attr += c;
    } else if(c === '>'){
      p++; break;
    } else {
      attr += c;
    }
    p++;
  }
  return { name, schliessend, attribute: attr, ende: p };
}

// attributeLesen: zieht die Attribute eines Tags als Map heraus.
function attributeLesen(roh){
  const map = {};
  const re = /([a-zA-Z_:][-\w:.]*)\s*=\s*("([^"]*)"|'([^']*)'|([^\s"'>]+))/g;
  let m;
  while((m = re.exec(roh))){
    map[m[1].toLowerCase()] = m[3] !== undefined ? m[3] : (m[4] !== undefined ? m[4] : m[5]);
  }
  return map;
}

// sanitizeFormatHtml: die eigentliche Bereinigung. Erlaubte Tags bleiben
// (mit höchstens einem gefilterten style-Attribut), verworfene Tags nehmen
// ihren Inhalt mit, alle übrigen werden ausgepackt (Inhalt bleibt, Tag fällt
// weg). Offen gebliebene Tags werden am Ende geschlossen, sodass das
// Ergebnis immer wohlgeformt ist. Parameter: html (String).
// Rückgabe: bereinigter HTML-String.
function sanitizeFormatHtml(html){
  if(html === null || html === undefined) return '';
  const quelle = String(html);
  let aus = '';
  const offen = [];            // Stapel offener, erlaubter Tags
  let verwerfenBis = null;     // Name des Tags, dessen Inhalt verworfen wird
  let verwerfenTiefe = 0;
  let i = 0;

  while(i < quelle.length){
    const c = quelle[i];
    if(c !== '<'){
      const naechstes = quelle.indexOf('<', i);
      const text = quelle.slice(i, naechstes === -1 ? quelle.length : naechstes);
      if(!verwerfenBis) aus += htmlEscape(text);
      i += text.length;
      continue;
    }
    const tag = tagLesen(quelle, i);
    if(!tag){                                   // '<' ist hier blosser Text
      if(!verwerfenBis) aus += '&lt;';
      i++;
      continue;
    }
    i = tag.ende;
    if(tag.kommentar) continue;

    if(verwerfenBis){
      // Innerhalb eines verworfenen Blocks zählt nur, wann er wieder endet.
      if(tag.name === verwerfenBis){
        if(tag.schliessend){ verwerfenTiefe--; if(verwerfenTiefe <= 0) verwerfenBis = null; }
        else verwerfenTiefe++;
      }
      continue;
    }
    if(TAGS_MIT_INHALT_VERWERFEN.has(tag.name)){
      if(!tag.schliessend){ verwerfenBis = tag.name; verwerfenTiefe = 1; }
      continue;
    }
    if(!SICHERE_TAGS.has(tag.name)) continue;   // auspacken: Tag weg, Inhalt bleibt

    if(tag.schliessend){
      // Nur schliessen, wenn das Tag auch offen ist — sonst ignorieren.
      const pos = offen.lastIndexOf(tag.name);
      if(pos !== -1){
        // Zwischendrin offen gebliebene Tags mitschliessen (korrekte Schachtelung).
        for(let k = offen.length - 1; k >= pos; k--) aus += '</' + offen[k] + '>';
        offen.length = pos;
      }
      continue;
    }
    const attrs = attributeLesen(tag.attribute);
    const style = sicheresStyleAttribut(attrs.style);
    aus += '<' + tag.name + (style ? ' style="' + htmlEscape(style) + '"' : '') + '>';
    if(!LEERE_TAGS.has(tag.name)) offen.push(tag.name);
  }
  for(let k = offen.length - 1; k >= 0; k--) aus += '</' + offen[k] + '>';
  return aus;
}

// serializeWeek: zerlegt ein Wochen-Objekt (JSON vom Frontend) in die relationalen
// Tabellen. Wird in einer Transaktion vom Aufrufer verwendet (deleteWeekData +
// serializeWeek). Ersetzt alle Zeilen der Woche.
function serializeWeek(week){
  const weekLabel = String(week.label || '');
  const nowIso = new Date().toISOString(); // Revision: wird bei jedem Speichern aktualisiert
  const upsertWeek = db.prepare(`INSERT INTO weeks (label, week_id, date, locked, updated_at) VALUES (?, ?, ?, ?, ?)
    ON CONFLICT(label) DO UPDATE SET week_id = excluded.week_id, date = excluded.date, locked = excluded.locked, updated_at = excluded.updated_at`);
  upsertWeek.run(weekLabel, String(week.id || ''), String(week.date || ''), week.locked ? 1 : 0, nowIso);

  const insWeekPerson = db.prepare(`INSERT INTO week_people (week_label, person_id, name, full_name, array_order)
    VALUES (?, ?, ?, ?, ?)`);
  const insWeekPersonRole = db.prepare(`INSERT OR IGNORE INTO week_people_roles (week_label, person_id, role, role_order)
    VALUES (?, ?, ?, ?)`);
  const insAttendance = db.prepare(`INSERT OR REPLACE INTO attendance (week_label, person_id, present)
    VALUES (?, ?, ?)`);

  // Sicherheitsnetz gegen doppelte Personen-Kennungen im Teilnehmerkreis:
  // ein zweiter Eintrag mit derselben id würde den Primärschlüssel verletzen
  // und die gesamte Transaktion (= das Speichern der Sitzung) abbrechen.
  const seenPersonIds = new Set();
  (Array.isArray(week.people) ? week.people : []).filter(p => {
    const pid = String((p && p.id) || '');
    if(!pid || seenPersonIds.has(pid)) return false;
    seenPersonIds.add(pid);
    return true;
  }).forEach((p, idx) => {
    insWeekPerson.run(weekLabel, String(p.id || ''), String(p.name || ''), String(p.fullName || ''), idx);
    (Array.isArray(p.role) ? p.role : []).forEach((r, ridx) => insWeekPersonRole.run(weekLabel, String(p.id || ''), String(r || ''), ridx));
  });
  const att = week.attendance || {};
  Object.keys(att).forEach(pid => {
    insAttendance.run(weekLabel, pid, att[pid] ? 1 : 0);
  });

  (Array.isArray(week.projects) ? week.projects : []).forEach((p, idx) => serializeProject(weekLabel, p, idx, nowIso));
  // Rückgabe der Revision für den Aufrufer (saveWeekRelational -> Route)
  return nowIso;
}

// projektStatements: die vorbereiteten INSERTs für ein Projekt, einmal angelegt.
let projektStatementsCache = null;
function projektStatements(){
  if(projektStatementsCache) return projektStatementsCache;
  const insProject = db.prepare(`INSERT INTO projects (week_label, project_id, nr, name, status, status_author, status_at, "group", array_order, order_value, project_uid, honorar, besprochen, auftragsstatus, updated_at)
    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
  const insBeauftragteLp = db.prepare(`INSERT OR IGNORE INTO project_beauftragte_lph (week_label, project_id, lph)
    VALUES (?, ?, ?)`);
  const insGewerk = db.prepare(`INSERT OR IGNORE INTO project_gewerke (week_label, project_id, gewerk)
    VALUES (?, ?, ?)`);
  const insKommentar = db.prepare(`INSERT OR REPLACE INTO project_kommentare (week_label, project_id, gewerk, status, status_author, status_at, besprochen)
    VALUES (?, ?, ?, ?, ?, ?, ?)`);
  const insTag = db.prepare(`INSERT OR IGNORE INTO project_tags (week_label, project_id, tag, tag_order)
    VALUES (?, ?, ?, ?)`);
  const insLph = db.prepare(`INSERT OR REPLACE INTO project_lph (week_label, project_id, lph, value)
    VALUES (?, ?, ?, ?)`);
  const insAssign = db.prepare(`INSERT OR REPLACE INTO project_assign (week_label, project_id, person_id, role, state)
    VALUES (?, ?, ?, ?, ?)`);
  const insAufwand = db.prepare(`INSERT OR REPLACE INTO project_aufwand (week_label, project_id, lph, role, value)
    VALUES (?, ?, ?, ?, ?)`);
  const insAktuelleLp = db.prepare(`INSERT OR IGNORE INTO project_aktuelle_lp (week_label, project_id, lph)
    VALUES (?, ?, ?)`);
  const insPlan = db.prepare(`INSERT OR REPLACE INTO project_plan (week_label, project_id, start, end, progress)
    VALUES (?, ?, ?, ?, ?)`);
  const insPlanPerson = db.prepare(`INSERT OR IGNORE INTO plan_people (week_label, project_id, person_id, array_order)
    VALUES (?, ?, ?, ?)`);
  const insTodo = db.prepare(`INSERT INTO plan_todos (week_label, project_id, todo_id, title, start, end, done, progress, sort_order, show_in_gantt, leistungsphase, aufwand_stunden, notiz)
    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
  const insTodoAssignee = db.prepare(`INSERT OR IGNORE INTO plan_todo_assignees (week_label, project_id, todo_id, person_id)
    VALUES (?, ?, ?, ?)`);
  const insTodoDep = db.prepare(`INSERT OR IGNORE INTO plan_todo_deps (week_label, project_id, todo_id, depends_on_id)
    VALUES (?, ?, ?, ?)`);
  const insMilestone = db.prepare(`INSERT INTO plan_milestones (week_label, project_id, milestone_id, name, date, position, sort_order, notiz)
    VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
  const insMilestoneDep = db.prepare(`INSERT OR IGNORE INTO plan_milestone_deps (week_label, project_id, milestone_id, depends_on_id)
    VALUES (?, ?, ?, ?)`);

  projektStatementsCache = { insProject, insBeauftragteLp, insGewerk, insKommentar, insTag, insLph, insAssign, insAufwand, insAktuelleLp, insPlan, insPlanPerson, insTodo, insTodoAssignee, insTodoDep, insMilestone, insMilestoneDep };
  return projektStatementsCache;
}

// serializeProject: schreibt EIN Projekt einer Sitzung in alle Projekttabellen
// (die Zeilen müssen vorher fehlen — deleteWeekData() bzw. deleteProjectData()).
// Gemeinsam genutzt von serializeWeek() und POST /save-projects.
// Parameter: weekLabel, p (Projekt), idx (Position, array_order), nowIso
// (Revision des Projekts, projects.updated_at).
function serializeProject(weekLabel, p, idx, nowIso){
  const { insProject, insBeauftragteLp, insGewerk, insKommentar, insTag, insLph, insAssign, insAufwand, insAktuelleLp, insPlan, insPlanPerson, insTodo, insTodoAssignee, insTodoDep, insMilestone, insMilestoneDep } = projektStatements();
  const projId = String(p.id || '');
  // status trägt Formatierungs-HTML (Fett/Kursiv/Farbe aus dem
  // Kommentar-Editor) und wird hier — an der Schreibstelle — auf die
  // erlaubte Positivliste reduziert, nicht erst beim Anzeigen. Siehe
  // sanitizeFormatHtml() oben.
  // status/status_author/status_at/besprochen bleiben leer: Kommentar und
  // Haken stehen je Gewerk in project_kommentare (siehe dort).
  insProject.run(weekLabel, projId, String(p.nr || ''), String(p.name || ''),
    '', '', '',
    String(p.group || ''), idx, typeof p.order === 'number' ? p.order : idx,
    String(p.projectUid || ''), Number(p.honorar) || 0, 0,
    normalizeAuftragsstatus(p.auftragsstatus), nowIso);
  (Array.isArray(p.beauftragteLP) ? p.beauftragteLP : []).forEach(lph => {
    insBeauftragteLp.run(weekLabel, projId, String(lph || ''));
  });
  // Nur gültige Gewerke schreiben: Ein unbekannter Wert wäre stiller
  // Datenmüll, der die Beteiligten-Auswahl später leer laufen ließe.
  (Array.isArray(p.gewerke) ? p.gewerke : []).forEach(g => {
    const wert = String(g || '').trim().toUpperCase();
    if(VALID_DEPARTMENTS.has(wert)) insGewerk.run(weekLabel, projId, wert);
  });
  (Array.isArray(p.tags) ? p.tags : []).forEach((tag, tidx) => {
    const clean = String(tag || '').trim();
    if(clean) insTag.run(weekLabel, projId, clean, tidx);
  });
  const kommentare = (p.kommentare && typeof p.kommentare === 'object') ? p.kommentare : {};
  Object.keys(kommentare).forEach(g => {
    const wert = String(g || '').trim().toUpperCase();
    const k = kommentare[g] || {};
    const text = sanitizeFormatHtml(k.status);
    // Leere Einträge nicht speichern — kein Kommentar und kein Haken ist
    // derselbe Zustand wie keine Zeile.
    if(!VALID_DEPARTMENTS.has(wert) || (!text && !k.besprochen)) return;
    insKommentar.run(weekLabel, projId, wert, text,
      text ? String(k.statusAuthor || '') : '', text ? String(k.statusAt || '') : '', k.besprochen ? 1 : 0);
  });
  const lph = p.lph || {};
  Object.keys(lph).forEach(l => insLph.run(weekLabel, projId, String(l || ''), String(lph[l] === undefined ? '' : lph[l])));
  const assign = p.assign || {};
  Object.keys(assign).forEach(key => {
    // Key-Format: "personId|Rolle"
    const sep = key.indexOf('|');
    const pid = sep >= 0 ? key.slice(0, sep) : key;
    const role = sep >= 0 ? key.slice(sep + 1) : '';
    insAssign.run(weekLabel, projId, pid, role, Number(assign[key]) || 0);
  });
  const aufwand = p.aufwandProLP || {};
  Object.keys(aufwand).forEach(lph => {
    const roles = aufwand[lph] || {};
    Object.keys(roles).forEach(role => {
      const v = Number(roles[role]);
      if(!isNaN(v)) insAufwand.run(weekLabel, projId, String(lph || ''), String(role || ''), v);
    });
  });
  (Array.isArray(p.aktuelleLP) ? p.aktuelleLP : []).forEach(lph => {
    insAktuelleLp.run(weekLabel, projId, String(lph || ''));
  });
  const plan = p.plan || null;
  if(plan){
    insPlan.run(weekLabel, projId, String(plan.start || ''), String(plan.end || ''), Number(plan.progress) || 0);
    (Array.isArray(plan.people) ? plan.people : []).forEach((pid, pidx) => insPlanPerson.run(weekLabel, projId, String(pid || ''), pidx));
    (Array.isArray(plan.todos) ? plan.todos : []).forEach((t, tidx) => {
      insTodo.run(weekLabel, projId, String(t.id || ''), String(t.title || ''),
        String(t.start || ''), String(t.end || ''), t.done ? 1 : 0, Number(t.progress) || 0, tidx,
        t.showInGantt === false ? 0 : 1, String(t.lph || ''),
        Math.max(0, Number(t.aufwand) || 0), String(t.notiz || '').slice(0, 20000));
      (Array.isArray(t.assignees) ? t.assignees : []).forEach(pid => insTodoAssignee.run(weekLabel, projId, String(t.id || ''), String(pid || '')));
      (Array.isArray(t.dependsOn) ? t.dependsOn : []).forEach(did => insTodoDep.run(weekLabel, projId, String(t.id || ''), String(did || '')));
    });
    (Array.isArray(plan.milestones) ? plan.milestones : []).forEach((m, midx) => {
      insMilestone.run(weekLabel, projId, String(m.id || ''), String(m.name || ''), String(m.date || ''), String(m.position || ''), midx, String(m.notiz || '').slice(0, 20000));
      (Array.isArray(m.dependsOn) ? m.dependsOn : []).forEach(did => insMilestoneDep.run(weekLabel, projId, String(m.id || ''), String(did || '')));
    });
  }
}

// deleteProjectData: entfernt alle Zeilen EINES Projekts einer Sitzung.
function deleteProjectData(weekLabel, projectId){
  ['project_tags','project_lph','project_assign','project_aufwand','project_aktuelle_lp',
   'project_beauftragte_lph','project_gewerke','project_kommentare','project_plan','plan_people',
   'plan_todos','plan_todo_assignees','plan_todo_deps','plan_milestones','plan_milestone_deps','projects']
    .forEach(t => db.prepare(`DELETE FROM ${t} WHERE week_label = ? AND project_id = ?`).run(weekLabel, projectId));
}

// deleteWeekData: entfernt alle relationalen Zeilen einer Woche (Label)
function deleteWeekData(weekLabel){
  const tables = ['week_people_roles','week_people','attendance','project_tags','project_lph','project_assign',
    'project_aufwand','project_aktuelle_lp','project_beauftragte_lph','project_gewerke','project_kommentare',
    '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 week_label = ?`).run(weekLabel);
  });
  // Die Wochen-Tabelle selbst nutzt `label` statt `week_label`
  db.prepare('DELETE FROM weeks WHERE label = ?').run(weekLabel);
}

// saveWeekRelational: speichert eine Woche vollständig relational (Transaktion).
// Rückgabe: die neu gesetzte Revision `updated_at` (ISO-Zeitstempel), damit der
// Client seine lokale Basis aktualisieren kann (sonst würde er beim nächsten
// Speichern einen falschen Konflikt mit sich selbst melden).
function saveWeekRelational(week){
  const weekLabel = String(week.label || '');
  const tx = db.exec('BEGIN');
  try {
    deleteWeekData(weekLabel);
    const updatedAt = serializeWeek(week);
    db.exec('COMMIT');
    return updatedAt;
  } catch(err){
    db.exec('ROLLBACK');
    throw err;
  }
}

// loadGlobalPeople: setzt die (jetzt firmenweite, nicht mehr abteilungs-
// gescopte) Personenliste aus den Tabellen users/user_roles/user_absences
// zusammen. Rückgabeform unverändert: Array von
// {id,name,fullName,email,role:[],absences:[]}.
// fuerUser (optional): Art und Notiz einer Abwesenheit sieht nur die Person
// selbst und der Administrator (feste Rolle 'admin'); für alle anderen kommen
// fremde Abwesenheiten als „abwesend“ ohne Notiz an — unabhängig von weiteren
// Rechten (Eriks Vorgabe: „jeder User sieht nur bei sich die genauen Gründe“,
// „der Admin sieht alles“). darfAbw sagt
// dem Browser, für wen er eintragen darf. Ohne fuerUser (Sitzungswechsel
// u. ä., nie an einen Browser) ungefiltert.
function loadGlobalPeople(fuerUser){
  // person_id != '' : Ein Konto ohne Personen-Kennung (z. B. das Bootstrap-
  // Konto "admin") ist keine planbare Person. Ohne diesen Filter landen
  // mehrere solcher Konten mit derselben leeren Kennung im Teilnehmerkreis
  // einer Sitzung und verletzen dort den Primärschlüssel
  // (week_label, person_id) — das Speichern schlüge dauerhaft mit 500 fehl.
  const users = db.prepare(`SELECT * FROM users WHERE active = 1 AND person_id != '' AND ${sqlOhneWandtafel()} ORDER BY display_name, username`).all();
  const roles = db.prepare(`SELECT * FROM user_roles ORDER BY role_order`).all();
  const absences = db.prepare(`SELECT * FROM user_absences`).all();
  const rolesByUser = {}; roles.forEach(r => (rolesByUser[r.user_id] = rolesByUser[r.user_id] || []).push(r.role));
  const ziele = fuerUser ? abwesenheitZiele(fuerUser) : null;
  const sichtbar = id => !fuerUser || fuerUser.role === 'admin' || id === fuerUser.id;
  const absByUser = {}; absences.forEach(a => (absByUser[a.user_id] = absByUser[a.user_id] || []).push(sichtbar(a.user_id)
    ? { id:a.id, start:a.start, end:a.end, type:a.type, note:a.note }
    : { id:a.id, start:a.start, end:a.end, type:'abwesend', note:'', verdeckt:true }));
  return users.map(u => ({
    id: u.person_id,
    userId: u.id,
    darfAbw: !!ziele && (ziele.alle || ziele.ids.has(u.id)),
    name: u.initials || u.username,
    fullName: u.display_name,
    email: u.email,
    role: rolesByUser[u.id] || [],
    absences: absByUser[u.id] || [],
    // Vertragliche Wochenstunden; 0 heißt "nicht gepflegt" und wird im
    // Frontend wie eine volle Stelle behandelt (js/load/load.js).
    capacityHours: Number(u.capacity_hours) || 0,
    // Gewerk der Person (users.department, ein VALID_DEPARTMENTS-Wert).
    // Nötig für die Auswahl der Projektbeteiligten: Ein Projekt trägt seine
    // Gewerke (project_gewerke), und angeboten werden zunächst nur die
    // Mitarbeiter daraus. Leer = keinem Gewerk zugeordnet; solche Personen
    // erscheinen nur über die ausdrückliche Auswahl "aus anderen Gewerken".
    gewerk: u.department || '',
  }));
}

// loadWeeks: setzt alle Wochen (jetzt eine einzige globale Reihe, nicht mehr
// pro Abteilung) aus den relationalen Tabellen wieder zu kompletten
// Wochen-Objekten zusammen. Rückgabe: Array von Wochen-Objekten, sortiert
// nach Label.
function loadWeeks(nurLabel){
  // nurLabel (optional): nur diese eine Sitzung laden — für GET /week und die
  // Live-Ereignisse, die sonst jedes Mal alle Sitzungen zusammensetzen müssten.
  // Auch eine Liste von Labels (für /load-all und /weeks-aelter, die nur
  // einige Sitzungen liefern).
  const labels = nurLabel === undefined ? null : (Array.isArray(nurLabel) ? nurLabel : [nurLabel]).map(String);
  if(labels && labels.length === 0) return [];
  const alle = (tabelle, reihenfolge) => {
    const spalte = tabelle === 'weeks' ? 'label' : 'week_label';
    const wo = labels ? ` WHERE ${spalte} IN (${labels.map(() => '?').join(',')})` : '';
    const st = db.prepare(`SELECT * FROM ${tabelle}${wo}${reihenfolge ? ' ' + reihenfolge : ''}`);
    return labels ? st.all(...labels) : st.all();
  };
  const weeks = alle('weeks', 'ORDER BY label');
  const weekPeople = alle('week_people', 'ORDER BY array_order');
  const weekRoles = alle('week_people_roles', 'ORDER BY role_order');
  const attendance = alle('attendance');
  const projects = alle('projects', 'ORDER BY array_order');
  const tags = alle('project_tags', 'ORDER BY tag_order');
  const lph = alle('project_lph');
  const assign = alle('project_assign');
  const aufwand = alle('project_aufwand');
  const aktuelleLp = alle('project_aktuelle_lp');
  const beauftragteLp = alle('project_beauftragte_lph');
  const gewerke = alle('project_gewerke');
  const kommentare = alle('project_kommentare');
  const plans = alle('project_plan');
  const planPeople = alle('plan_people', 'ORDER BY array_order');
  const todos = alle('plan_todos', 'ORDER BY sort_order');
  const todoAssignees = alle('plan_todo_assignees');
  const todoDeps = alle('plan_todo_deps');
  const milestones = alle('plan_milestones', 'ORDER BY sort_order');
  const milestoneDeps = alle('plan_milestone_deps');

  // Index-Karten für schnellen Zugriff
  const weekKey = (label) => label;
  const projKey = (label, pid) => label + '|' + pid;
  const todoKey = (label, pid, tid) => label + '|' + pid + '|' + tid;
  const msKey = (label, pid, mid) => label + '|' + pid + '|' + mid;

  const weekPeopleMap = {};
  const weekRolesMap = {};
  const attendanceMap = {};
  // Anhängen statt per Index setzen: Die Abfrage ist bereits nach array_order
  // sortiert. Eine Index-Zuweisung würde bei zwei gleichen Ordnungszahlen in
  // derselben Woche (möglich nach der Abteilungs-Zusammenführung) die erste
  // Person still überschreiben und Lücken im Array hinterlassen.
  weekPeople.forEach(r => {
    const k = weekKey(r.week_label);
    (weekPeopleMap[k] = weekPeopleMap[k] || []).push({ 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,
      // Kommentar und Besprochen-Haken je Gewerk (project_kommentare).
      kommentare: {},
      group: r.group,
      tags: [], lph: {}, assign: {}, order: r.order_value, plan: null,
      projectUid: r.project_uid,
      honorar: r.honorar,
      // Rückfall auf die Vorgabe, weil Zeilen aus der Zeit vor der Spalte
      // (und aus einem älteren Backup, siehe IMPORT_OPTIONAL_COLS) einen
      // leeren Wert tragen können — die Oberfläche soll keinen Leerzustand
      // anzeigen müssen.
      auftragsstatus: normalizeAuftragsstatus(r.auftragsstatus),
      beauftragteLP: [],
      gewerke: [],
      updatedAt: r.updated_at || '',
      _arrayOrder: r.array_order,
    };
  });
  tags.forEach(r => { const p = projectsMap[projKey(r.week_label, r.project_id)]; if(p) p.tags.push(r.tag); });
  lph.forEach(r => { const p = projectsMap[projKey(r.week_label, r.project_id)]; if(p) p.lph[r.lph] = r.value; });
  assign.forEach(r => {
    const p = projectsMap[projKey(r.week_label, r.project_id)];
    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); }
  });
  beauftragteLp.forEach(r => {
    const p = projectsMap[projKey(r.week_label, r.project_id)];
    if(p && !p.beauftragteLP.includes(r.lph)) p.beauftragteLP.push(r.lph);
  });
  gewerke.forEach(r => {
    const p = projectsMap[projKey(r.week_label, r.project_id)];
    if(p && !p.gewerke.includes(r.gewerk)) p.gewerke.push(r.gewerk);
  });
  kommentare.forEach(r => {
    const p = projectsMap[projKey(r.week_label, r.project_id)];
    if(p) p.kommentare[r.gewerk] = { status: r.status || '', statusAuthor: r.status_author || '', statusAt: r.status_at || '', besprochen: !!r.besprochen };
  });

  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 = {};
  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, showInGantt: !!r.show_in_gantt, lph: r.leistungsphase || '', aufwand: Number(r.aufwand_stunden) || 0, notiz: r.notiz || '' };
  });
  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 = {};
  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: [], notiz: r.notiz || '' };
  });
  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[parts[0] + '|' + parts[1]];
    if(plan) plan.todos.push(todoMap[k]);
  });
  Object.keys(msMap).forEach(k => {
    const parts = k.split('|');
    const plan = planMap[parts[0] + '|' + parts[1]];
    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(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 || '',
    };
  });
}

// ---------- Datenbank-Backup ----------
//
// Zwei Wege: (1) Beim Serverstart wird automatisch eine Kopie der SQLite-DB
// als zeitgestempelte Datei in sessions/backups/ abgelegt (nur die letzten
// aufbewahrten Backups werden behalten). (2) GET /backup liefert einen konsistenten
// Snapshot der DB als herunterladbare .db-Datei (z. B. über den Button
// "DB Backup" im Menü der Hauptseite). Beide nutzen `VACUUM INTO`, das auch
// bei aktivem WAL-Mode eine konsistente Einzeldatei erzeugt (WAL-Inhalte
// werden einbezogen).

// BACKUP_DIR: Zielordner der automatischen Backups (sessions/backups, Docker-
// bind-mounted → bleibt persistent).
const BACKUP_DIR = path.join(SESSIONS_DIR, 'backups');
// Anzahl der automatisch behaltenen Backups (die ältesten werden verworfen)
// Wie viele automatische Backups aufbewahrt werden, ist seit dem Ausbau der
// Einstellungen firmenweit pflegbar (Schlüssel 'maxBackups'); dieser Wert ist
// nur noch die Vorgabe, falls nichts gesetzt ist.
const DEFAULT_MAX_BACKUPS = 10;

// createDbSnapshot: erzeugt einen konsistenten Snapshot der SQLite-DB in die
// angegebene Zieldatei (VACUUM INTO; funktioniert auch bei WAL-Mode).
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 die eingestellte Anzahl ü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 (einstellbar, Schlüssel 'maxBackups') behalten
    const backups = fs.readdirSync(BACKUP_DIR)
      .filter(f => /^projektuebersicht_.+\.db$/.test(f))
      .map(f => ({ name: f, mtime: fs.statSync(path.join(BACKUP_DIR, f)).mtimeMs }))
      .sort((a, b) => b.mtime - a.mtime);
    backups.slice(readAppSetting('maxBackups')).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: die Sitzungs-/Projektdaten-Tabellen des relationalen Schemas;
// Grundlage für Validierung, Löschvorgang und Datentransfer. Die Reihenfolge
// ist ohne Bedeutung, da das Schema keine Foreign-Key-Constraints deklariert.
// BEWUSST NICHT enthalten sind die firmenweiten Konfigurations- und
// Kontotabellen (users, user_sessions, user_roles, user_absences,
// project_files, project_file_reviewers, project_file_comments sowie
// lph_templates): eine Wiederherstellung soll Sitzungsdaten zurückrollen,
// aber niemals Konten, Freigabestände oder Aufgaben-Vorlagen überschreiben.
const IMPORT_TABLES = ['weeks','week_people','week_people_roles','attendance','projects',
  'project_tags','project_lph','project_assign','project_aufwand','project_aktuelle_lp',
  'project_beauftragte_lph',
  'project_gewerke',
  'project_plan','plan_people','plan_todos','plan_todo_assignees','plan_todo_deps',
  'plan_milestones','plan_milestone_deps',
  'project_protokolle','protokoll_teilnehmer','protokoll_punkte',
  'project_kommentare', 'projekt_notizen'];
// IMPORT_OPTIONAL_TABLES: Tabellen, die ältere Backups noch nicht kennen.
// Fehlen sie, bleiben sie nach dem Import leer; migrateKommentareJeGewerk()
// verteilt die alten Kommentare danach aus projects.status.
const IMPORT_OPTIONAL_TABLES = ['project_kommentare', 'projekt_notizen'];

// 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).
// Die Liste muss mitwachsen, wenn Spalten ergänzt werden — sonst ist
// ausgerechnet das automatische Backup, das unmittelbar VOR einer
// Wiederherstellung geschrieben wird, nach einem Versionssprung nicht mehr
// einspielbar.
const IMPORT_OPTIONAL_COLS = ['updated_at', 'project_uid', 'honorar', 'status_author', 'status_at',
  'auftragsstatus', 'besprochen', 'leistungsphase', 'aufwand_stunden', 'notiz'];

// 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).
// pruefeBackupDatei: öffnet die Datei und prüft das Schema (Schritt 1 von
// restoreDbFromBackup()) — eigenständig, damit /import eine ungültige Datei
// mit 400 abweisen kann, BEVOR runAutoBackup() läuft. Vorher erzeugte jeder
// Fehlversuch ein Auto-Backup und verdrängte so echte ältere.
// Wirft mit verständlicher Meldung. Parameter: backupPath.
function pruefeBackupDatei(backupPath){
  let conn;
  try { conn = new DatabaseSync(backupPath, { readOnly: true }); conn.prepare('SELECT 1 FROM sqlite_master LIMIT 1').get(); }
  catch(err){ if(conn) conn.close(); throw new Error('Die Datei ist keine gültige Datenbank-Sicherung.'); }
  try {
    for(const t of IMPORT_TABLES){
      const liveCols = dbTableColumns(db, t);
      const backCols = dbTableColumns(conn, t);
      if(backCols.length === 0){
        if(IMPORT_OPTIONAL_TABLES.includes(t)) continue;
        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(', ') + ')');
    }
  } finally {
    conn.close();
  }
}

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){
        if(IMPORT_OPTIONAL_TABLES.includes(t)) continue;
        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.
    // ATTACH und BEGIN stehen INNERHALB des try: Bricht BEGIN ab (z. B. weil
    // noch eine Transaktion offen ist), muss das finally trotzdem abhängen —
    // sonst bliebe import_backup dauerhaft gebunden und jeder weitere Import
    // scheiterte bis zum Serverneustart.
    try {
      db.exec(`ATTACH DATABASE '${String(backupPath).replace(/'/g, "''")}' AS import_backup`);
      db.exec('BEGIN');
      IMPORT_TABLES.forEach(t => db.exec('DELETE FROM ' + t));
      for(const t of IMPORT_TABLES){
        const liveCols = dbTableColumns(db, t);
        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));
        if(common.length === 0) continue; // optionale Tabelle fehlt im Backup
        // 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){
      // Beide Aufräumschritte dürfen den ursprünglichen Fehler nicht
      // verdecken: Scheiterte schon ATTACH, gibt es weder Transaktion noch
      // angehängte Datenbank, und ROLLBACK/DETACH würden ihrerseits werfen.
      try { db.exec('ROLLBACK'); } catch(e){ /* keine offene Transaktion */ }
      throw err;
    } finally {
      try { db.exec('DETACH DATABASE import_backup'); } catch(e){ /* nie angehängt */ }
    }
  } 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(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.');
  }
}

// migrateRemoveDepartmentPartition: löst die bisherige Abteilungs-
// Partitionierung (ELT/HLS/ARCH als getrennte Wochen-/Projekt-Reihen) auf.
// Idempotent (Guard: `weeks` hat noch eine `department`-Spalte). Zweistufig:
// (1) Wochen mit gleichem Label aus verschiedenen Ex-Abteilungen werden zu
//     einer globalen Woche zusammengeführt (week_people/-roles/attendance
//     ebenfalls vereinigt).
// (2) Innerhalb jeder Woche werden Projekte mit gleicher, nicht-leerer `nr`
//     aus verschiedenen Ex-Abteilungen zu EINEM Projekt verschmolzen
//     (bestätigt vom Nutzer: es handelt sich um dieselben realen Bauprojekte,
//     die bisher getrennt je Gewerk geführt wurden) — inkl. Team, Leistungs-
//     phasen, Gantt/TODOs. Jede beteiligte Ex-Abteilung wird zum Tag
//     (project_tags). Konflikte (abweichende Namen/Werte) werden mit
//     deterministischer Präzedenz ELT→HLS→ARCH aufgelöst und vollständig
//     protokolliert, niemals still verworfen.
function migrateRemoveDepartmentPartition(){
  const weeksCols = db.prepare("SELECT name FROM pragma_table_info('weeks')").all().map(r => r.name);
  if(!weeksCols.includes('department')) return; // bereits migriert oder frische DB

  console.log('Migriere: Abteilungs-Partitionierung wird entfernt (Wochen und gleichnummerige Projekte werden zusammengeführt) …');

  // Zusätzlicher, eigens benannter Sicherheits-Schnappschuss VOR jeder
  // Änderung (zusätzlich zum regulären Auto-Backup, das erst NACH dem
  // Serverstart läuft) — falls je eine manuelle Wiederherstellung nötig wird.
  try {
    if(!fs.existsSync(BACKUP_DIR)) fs.mkdirSync(BACKUP_DIR, { recursive: true });
    const snapshotPath = path.join(BACKUP_DIR, 'pre-department-migration-' + new Date().toISOString().replace(/[:.]/g, '-') + '.db');
    createDbSnapshot(snapshotPath);
    console.log('Vor-Migrations-Snapshot gespeichert:', snapshotPath);
  } catch(err){
    console.error('Vor-Migrations-Snapshot fehlgeschlagen (Migration wird trotzdem fortgesetzt):', err.message);
  }

  const DEPT_ORDER = ['ELT', 'HLS', 'ARCH'];
  const deptRank = (d) => { const i = DEPT_ORDER.indexOf(d); return i === -1 ? DEPT_ORDER.length : i; };
  const conflicts = [];

  db.exec('BEGIN');
  try {
    // ---------- Stufe 1: Wochen zusammenführen (nach label) ----------
    db.exec(`CREATE TABLE weeks_new (
      label TEXT NOT NULL, week_id TEXT NOT NULL DEFAULT '', date TEXT NOT NULL DEFAULT '',
      locked INTEGER NOT NULL DEFAULT 0, updated_at TEXT NOT NULL DEFAULT '', PRIMARY KEY (label)
    )`);
    const labels = db.prepare('SELECT DISTINCT label FROM weeks').all().map(r => r.label);
    const insWeekNew = db.prepare('INSERT INTO weeks_new (label, week_id, date, locked, updated_at) VALUES (?,?,?,?,?)');
    labels.forEach(label => {
      const rows = db.prepare('SELECT * FROM weeks WHERE label = ?').all(label)
        .sort((a, b) => deptRank(a.department) - deptRank(b.department));
      if(rows.length > 1){
        conflicts.push(`Woche "${label}": ${rows.length} Abteilungs-Kopien zusammengeführt (${rows.map(r => r.department + '=' + r.date).join(', ')}).`);
      }
      const canonical = rows[0];
      const maxUpdatedAt = rows.map(r => r.updated_at || '').sort().slice(-1)[0] || '';
      insWeekNew.run(label, canonical.week_id, canonical.date, canonical.locked, maxUpdatedAt);
    });
    db.exec('DROP TABLE weeks');
    db.exec('ALTER TABLE weeks_new RENAME TO weeks');

    // week_people: bei gleicher (week_label,person_id) aus mehreren
    // Ex-Abteilungen gewinnt die Präzedenz-Reihenfolge.
    db.exec(`CREATE TABLE week_people_new (
      week_label TEXT NOT NULL, person_id TEXT NOT NULL, name TEXT NOT NULL DEFAULT '',
      full_name TEXT NOT NULL DEFAULT '', array_order INTEGER NOT NULL DEFAULT 0,
      PRIMARY KEY (week_label, person_id)
    )`);
    {
      const wpInsert = db.prepare('INSERT INTO week_people_new (week_label,person_id,name,full_name,array_order) VALUES (?,?,?,?,?)');
      const seen = new Set();
      db.prepare('SELECT * FROM week_people').all()
        .sort((a, b) => deptRank(a.department) - deptRank(b.department) || a.array_order - b.array_order)
        .forEach(r => {
          const key = r.week_label + '|' + r.person_id;
          if(seen.has(key)){
            conflicts.push(`week_people ${r.week_label}/${r.person_id}: Duplikat aus ${r.department} verworfen (Erst-Eintrag gewinnt).`);
            return;
          }
          seen.add(key);
          wpInsert.run(r.week_label, r.person_id, r.name, r.full_name, r.array_order);
        });
    }
    db.exec('DROP TABLE week_people');
    db.exec('ALTER TABLE week_people_new RENAME TO week_people');

    // week_people_roles: reine Mengenvereinigung, keine Konflikte möglich
    // (gleiche Rolle mehrfach ist harmlos, INSERT OR IGNORE übernimmt das).
    db.exec(`CREATE TABLE week_people_roles_new (
      week_label TEXT NOT NULL, person_id TEXT NOT NULL, role TEXT NOT NULL,
      role_order INTEGER NOT NULL DEFAULT 0, PRIMARY KEY (week_label, person_id, role)
    )`);
    db.exec(`INSERT OR IGNORE INTO week_people_roles_new (week_label,person_id,role,role_order)
      SELECT week_label,person_id,role,role_order FROM week_people_roles`);
    db.exec('DROP TABLE week_people_roles');
    db.exec('ALTER TABLE week_people_roles_new RENAME TO week_people_roles');

    // attendance: bei widersprüchlicher Anwesenheit gewinnt die Präzedenz.
    db.exec(`CREATE TABLE attendance_new (
      week_label TEXT NOT NULL, person_id TEXT NOT NULL, present INTEGER NOT NULL DEFAULT 0,
      PRIMARY KEY (week_label, person_id)
    )`);
    {
      const attInsert = db.prepare('INSERT INTO attendance_new (week_label,person_id,present) VALUES (?,?,?)');
      const seen = new Map();
      db.prepare('SELECT * FROM attendance').all()
        .sort((a, b) => deptRank(a.department) - deptRank(b.department))
        .forEach(r => {
          const key = r.week_label + '|' + r.person_id;
          if(seen.has(key)){
            if(seen.get(key) !== r.present){
              conflicts.push(`attendance ${r.week_label}/${r.person_id}: widersprüchliche Anwesenheit (${r.department}=${r.present}) verworfen, Erst-Eintrag gewinnt.`);
            }
            return;
          }
          seen.set(key, r.present);
          attInsert.run(r.week_label, r.person_id, r.present);
        });
    }
    db.exec('DROP TABLE attendance');
    db.exec('ALTER TABLE attendance_new RENAME TO attendance');

    // ---------- Stufe 2: Projekte je Woche nach `nr` zusammenführen ----------
    db.exec(`CREATE TABLE projects_new (
      week_label TEXT NOT NULL, project_id TEXT NOT NULL, nr TEXT NOT NULL DEFAULT '',
      name TEXT NOT NULL DEFAULT '', status TEXT NOT NULL DEFAULT '', "group" TEXT NOT NULL DEFAULT '',
      array_order INTEGER NOT NULL DEFAULT 0, order_value INTEGER NOT NULL DEFAULT 0,
      PRIMARY KEY (week_label, project_id)
    )`);
    db.exec(`CREATE TABLE IF NOT EXISTS project_tags (
      week_label TEXT NOT NULL, project_id TEXT NOT NULL, tag TEXT NOT NULL,
      tag_order INTEGER NOT NULL DEFAULT 0, PRIMARY KEY (week_label, project_id, tag)
    )`);

    // Gruppierung: gleiche (week_label,nr) mit nicht-leerer nr gehören
    // zusammen; jede Zeile mit leerer nr bildet ihre eigene Einzel-Gruppe
    // (nichts zum Abgleichen vorhanden, bleibt eigenständig).
    const groups = new Map();
    let soloCounter = 0;
    db.prepare('SELECT * FROM projects').all().forEach(r => {
      const groupKey = (r.nr && r.nr.trim() !== '')
        ? r.week_label + '|nr:' + r.nr
        : r.week_label + '|solo:' + (soloCounter++);
      if(!groups.has(groupKey)) groups.set(groupKey, []);
      groups.get(groupKey).push(r);
    });

    const insProjectNew = db.prepare(`INSERT INTO projects_new (week_label,project_id,nr,name,status,"group",array_order,order_value)
      VALUES (?,?,?,?,?,?,?,?)`);
    const insTagNew = db.prepare('INSERT OR IGNORE INTO project_tags (week_label,project_id,tag,tag_order) VALUES (?,?,?,?)');
    // projectIdMap: alter Schlüssel "department|week_label|project_id" -> neue
    // (überlebende) project_id innerhalb derselben week_label.
    const projectIdMap = new Map();

    groups.forEach(rawRows => {
      const rows = rawRows.slice().sort((a, b) => deptRank(a.department) - deptRank(b.department));
      const survivor = rows[0];
      const weekLabel = survivor.week_label;
      const newProjectId = survivor.project_id;

      rows.forEach(r => projectIdMap.set(r.department + '|' + r.week_label + '|' + r.project_id, newProjectId));

      if(rows.length > 1){
        if(new Set(rows.map(r => r.name)).size > 1){
          conflicts.push(`Projekt ${survivor.nr} (${weekLabel}): unterschiedliche Namen zusammengeführt (${rows.map(r => r.department + '="' + r.name + '"').join(', ')}), "${survivor.name}" übernommen.`);
        }
        if(new Set(rows.map(r => r.group)).size > 1){
          conflicts.push(`Projekt ${survivor.nr} (${weekLabel}): unterschiedliche Gruppen (${rows.map(r => r.department + '="' + r.group + '"').join(', ')}), "${survivor.group}" übernommen.`);
        }
      }
      // Status (freier Text): alle nicht-leeren Texte mit Abteilungs-Präfix
      // zusammenführen statt einen zu verwerfen — kein Informationsverlust.
      // Identischer Text aus mehreren Abteilungen (z. B. eine gemeinsame
      // Besprechungsnotiz) wird dedupliziert statt wortgleich doppelt gezeigt.
      const statusByText = new Map();
      rows.forEach(r => {
        const t = (r.status || '').trim();
        if(!t) return;
        if(!statusByText.has(t)) statusByText.set(t, []);
        statusByText.get(t).push(r.department);
      });
      const mergedStatus = Array.from(statusByText.entries())
        .map(([text, depts]) => `[${depts.join('+')}] ${text}`)
        .join(' | ');

      insProjectNew.run(weekLabel, newProjectId, survivor.nr, survivor.name, mergedStatus, survivor.group, survivor.array_order, survivor.order_value);

      Array.from(new Set(rows.map(r => r.department))).forEach((d, idx) => insTagNew.run(weekLabel, newProjectId, d, idx));
    });
    db.exec('DROP TABLE projects');
    db.exec('ALTER TABLE projects_new RENAME TO projects');

    // mapProjectId: löst für eine alte (department,week_label,project_id) die
    // neue (verschmolzene) project_id auf. Fällt auf die alte ID zurück, falls
    // aus irgendeinem Grund kein Mapping existiert (sollte nie vorkommen, da
    // JEDE alte projects-Zeile oben ein Mapping bekommen hat).
    function mapProjectId(department, weekLabel, projectId){
      return projectIdMap.get(department + '|' + weekLabel + '|' + projectId) || projectId;
    }

    // project_lph: Vereinigung je (week_label,neue_project_id,lph); bei
    // widersprüchlichen Werten gewinnt das Maximum (weiter fortgeschrittene
    // Abteilung bestimmt den gemeinsamen Fortschritt dieser Leistungsphase).
    db.exec(`CREATE TABLE project_lph_new (
      week_label TEXT NOT NULL, project_id TEXT NOT NULL, lph TEXT NOT NULL,
      value TEXT NOT NULL DEFAULT '', PRIMARY KEY (week_label, project_id, lph)
    )`);
    {
      const merged = new Map();
      db.prepare('SELECT * FROM project_lph').all()
        .sort((a, b) => deptRank(a.department) - deptRank(b.department))
        .forEach(r => {
          const newPid = mapProjectId(r.department, r.week_label, r.project_id);
          const key = r.week_label + '|' + newPid + '|' + r.lph;
          const existing = merged.get(key);
          if(existing){
            if(existing.value !== r.value){
              const a = Number(existing.value), b = Number(r.value);
              const winner = (!isNaN(a) && !isNaN(b)) ? (b > a ? r.value : existing.value) : existing.value;
              conflicts.push(`project_lph ${r.week_label}/${newPid}/LP${r.lph}: unterschiedliche Werte (${existing.value} vs ${r.value}) — Maximum "${winner}" übernommen.`);
              existing.value = winner;
            }
            return;
          }
          merged.set(key, { weekLabel: r.week_label, projectId: newPid, lph: r.lph, value: r.value });
        });
      const ins = db.prepare('INSERT INTO project_lph_new (week_label,project_id,lph,value) VALUES (?,?,?,?)');
      merged.forEach(v => ins.run(v.weekLabel, v.projectId, v.lph, v.value));
    }
    db.exec('DROP TABLE project_lph');
    db.exec('ALTER TABLE project_lph_new RENAME TO project_lph');

    // project_assign: Vereinigung je (week_label,neue_project_id,person_id,role);
    // bei widersprüchlichem Status (0/1/2) gewinnt das Maximum.
    db.exec(`CREATE TABLE project_assign_new (
      week_label TEXT NOT NULL, project_id TEXT NOT NULL, person_id TEXT NOT NULL,
      role TEXT NOT NULL DEFAULT '', state INTEGER NOT NULL DEFAULT 0,
      PRIMARY KEY (week_label, project_id, person_id, role)
    )`);
    {
      const merged = new Map();
      db.prepare('SELECT * FROM project_assign').all()
        .sort((a, b) => deptRank(a.department) - deptRank(b.department))
        .forEach(r => {
          const newPid = mapProjectId(r.department, r.week_label, r.project_id);
          const key = r.week_label + '|' + newPid + '|' + r.person_id + '|' + r.role;
          const existing = merged.get(key);
          if(existing){
            if(existing.state !== r.state){
              const winner = Math.max(existing.state, r.state);
              conflicts.push(`project_assign ${r.week_label}/${newPid}/${r.person_id}|${r.role}: unterschiedlicher Status (${existing.state} vs ${r.state}) — Maximum ${winner} übernommen.`);
              existing.state = winner;
            }
            return;
          }
          merged.set(key, { weekLabel: r.week_label, projectId: newPid, personId: r.person_id, role: r.role, state: r.state });
        });
      const ins = db.prepare('INSERT INTO project_assign_new (week_label,project_id,person_id,role,state) VALUES (?,?,?,?,?)');
      merged.forEach(v => ins.run(v.weekLabel, v.projectId, v.personId, v.role, v.state));
    }
    db.exec('DROP TABLE project_assign');
    db.exec('ALTER TABLE project_assign_new RENAME TO project_assign');

    // project_aufwand: Vereinigung je (week_label,neue_project_id,lph,role);
    // bei Widerspruch gewinnt die Präzedenz (Gewichtungsfaktoren sind eher
    // Konfiguration als Fortschritt, kein "Maximum" sinnvoll).
    db.exec(`CREATE TABLE project_aufwand_new (
      week_label TEXT NOT NULL, project_id TEXT NOT NULL, lph TEXT NOT NULL,
      role TEXT NOT NULL DEFAULT '', value REAL NOT NULL DEFAULT 0,
      PRIMARY KEY (week_label, project_id, lph, role)
    )`);
    {
      const merged = new Map();
      db.prepare('SELECT * FROM project_aufwand').all()
        .sort((a, b) => deptRank(a.department) - deptRank(b.department))
        .forEach(r => {
          const newPid = mapProjectId(r.department, r.week_label, r.project_id);
          const key = r.week_label + '|' + newPid + '|' + r.lph + '|' + r.role;
          const existing = merged.get(key);
          if(existing){
            if(existing.value !== r.value){
              conflicts.push(`project_aufwand ${r.week_label}/${newPid}/LP${r.lph}/${r.role}: unterschiedliche Werte (${existing.value} vs ${r.value}) — erster Wert (${existing.value}) übernommen.`);
            }
            return;
          }
          merged.set(key, { weekLabel: r.week_label, projectId: newPid, lph: r.lph, role: r.role, value: r.value });
        });
      const ins = db.prepare('INSERT INTO project_aufwand_new (week_label,project_id,lph,role,value) VALUES (?,?,?,?,?)');
      merged.forEach(v => ins.run(v.weekLabel, v.projectId, v.lph, v.role, v.value));
    }
    db.exec('DROP TABLE project_aufwand');
    db.exec('ALTER TABLE project_aufwand_new RENAME TO project_aufwand');

    // project_aktuelle_lp: reine Mengenvereinigung (ein Projekt kann jetzt
    // mehrere gleichzeitig aktive Leistungsphasen zeigen — gewollt).
    db.exec(`CREATE TABLE project_aktuelle_lp_new (
      week_label TEXT NOT NULL, project_id TEXT NOT NULL, lph TEXT NOT NULL,
      PRIMARY KEY (week_label, project_id, lph)
    )`);
    {
      const ins = db.prepare('INSERT OR IGNORE INTO project_aktuelle_lp_new (week_label,project_id,lph) VALUES (?,?,?)');
      db.prepare('SELECT * FROM project_aktuelle_lp').all().forEach(r => {
        ins.run(r.week_label, mapProjectId(r.department, r.week_label, r.project_id), r.lph);
      });
    }
    db.exec('DROP TABLE project_aktuelle_lp');
    db.exec('ALTER TABLE project_aktuelle_lp_new RENAME TO project_aktuelle_lp');

    // project_plan (Gantt-Rahmen je Projekt): start = frühester, end =
    // spätester Termin (gemeinsame Zeitspanne beider Arbeitsanteile);
    // progress-Widerspruch -> Maximum.
    db.exec(`CREATE TABLE project_plan_new (
      week_label TEXT NOT NULL, project_id TEXT NOT NULL, start TEXT NOT NULL DEFAULT '',
      end TEXT NOT NULL DEFAULT '', progress INTEGER NOT NULL DEFAULT 0,
      PRIMARY KEY (week_label, project_id)
    )`);
    {
      const merged = new Map();
      db.prepare('SELECT * FROM project_plan').all()
        .sort((a, b) => deptRank(a.department) - deptRank(b.department))
        .forEach(r => {
          const newPid = mapProjectId(r.department, r.week_label, r.project_id);
          const key = r.week_label + '|' + newPid;
          const existing = merged.get(key);
          if(existing){
            if(r.start && (!existing.start || r.start < existing.start)) existing.start = r.start;
            if(r.end && (!existing.end || r.end > existing.end)) existing.end = r.end;
            if(existing.progress !== r.progress){
              const winner = Math.max(existing.progress, r.progress);
              conflicts.push(`project_plan ${r.week_label}/${newPid}: unterschiedlicher Fortschritt (${existing.progress}% vs ${r.progress}%) — Maximum ${winner}% übernommen.`);
              existing.progress = winner;
            }
            return;
          }
          merged.set(key, { weekLabel: r.week_label, projectId: newPid, start: r.start, end: r.end, progress: r.progress });
        });
      const ins = db.prepare('INSERT INTO project_plan_new (week_label,project_id,start,end,progress) VALUES (?,?,?,?,?)');
      merged.forEach(v => ins.run(v.weekLabel, v.projectId, v.start, v.end, v.progress));
    }
    db.exec('DROP TABLE project_plan');
    db.exec('ALTER TABLE project_plan_new RENAME TO project_plan');

    // plan_people: reine Mengenvereinigung.
    db.exec(`CREATE TABLE plan_people_new (
      week_label TEXT NOT NULL, project_id TEXT NOT NULL, person_id TEXT NOT NULL,
      array_order INTEGER NOT NULL DEFAULT 0, PRIMARY KEY (week_label, project_id, person_id)
    )`);
    {
      const ins = db.prepare('INSERT OR IGNORE INTO plan_people_new (week_label,project_id,person_id,array_order) VALUES (?,?,?,?)');
      db.prepare('SELECT * FROM plan_people ORDER BY array_order').all().forEach(r => {
        ins.run(r.week_label, mapProjectId(r.department, r.week_label, r.project_id), r.person_id, r.array_order);
      });
    }
    db.exec('DROP TABLE plan_people');
    db.exec('ALTER TABLE plan_people_new RENAME TO plan_people');

    // plan_todos / plan_todo_assignees / plan_todo_deps / plan_milestones /
    // plan_milestone_deps: todo_id/milestone_id sind zufällige uid()-Strings,
    // daher praktisch kein Kollisionsrisiko — reines Umhängen auf die neue
    // project_id (das Gantt/TODO des vereinten Projekts zeigt danach schlicht
    // die Aufgaben aller beteiligten Abteilungen zusammen).
    db.exec(`CREATE TABLE plan_todos_new (
      week_label TEXT NOT NULL, project_id TEXT NOT NULL, todo_id TEXT NOT NULL,
      title TEXT NOT NULL DEFAULT '', start TEXT NOT NULL DEFAULT '', end TEXT NOT NULL DEFAULT '',
      done INTEGER NOT NULL DEFAULT 0, progress INTEGER NOT NULL DEFAULT 0, sort_order INTEGER NOT NULL DEFAULT 0,
      PRIMARY KEY (week_label, project_id, todo_id)
    )`);
    {
      const ins = db.prepare(`INSERT OR IGNORE INTO plan_todos_new (week_label,project_id,todo_id,title,start,end,done,progress,sort_order) VALUES (?,?,?,?,?,?,?,?,?)`);
      db.prepare('SELECT * FROM plan_todos ORDER BY sort_order').all().forEach(r => {
        ins.run(r.week_label, mapProjectId(r.department, r.week_label, r.project_id), r.todo_id, r.title, r.start, r.end, r.done, r.progress, r.sort_order);
      });
    }
    db.exec('DROP TABLE plan_todos');
    db.exec('ALTER TABLE plan_todos_new RENAME TO plan_todos');

    db.exec(`CREATE TABLE plan_todo_assignees_new (
      week_label TEXT NOT NULL, project_id TEXT NOT NULL, todo_id TEXT NOT NULL, person_id TEXT NOT NULL,
      PRIMARY KEY (week_label, project_id, todo_id, person_id)
    )`);
    {
      const ins = db.prepare('INSERT OR IGNORE INTO plan_todo_assignees_new (week_label,project_id,todo_id,person_id) VALUES (?,?,?,?)');
      db.prepare('SELECT * FROM plan_todo_assignees').all().forEach(r => {
        ins.run(r.week_label, mapProjectId(r.department, r.week_label, r.project_id), r.todo_id, r.person_id);
      });
    }
    db.exec('DROP TABLE plan_todo_assignees');
    db.exec('ALTER TABLE plan_todo_assignees_new RENAME TO plan_todo_assignees');

    db.exec(`CREATE TABLE plan_todo_deps_new (
      week_label TEXT NOT NULL, project_id TEXT NOT NULL, todo_id TEXT NOT NULL, depends_on_id TEXT NOT NULL,
      PRIMARY KEY (week_label, project_id, todo_id, depends_on_id)
    )`);
    {
      const ins = db.prepare('INSERT OR IGNORE INTO plan_todo_deps_new (week_label,project_id,todo_id,depends_on_id) VALUES (?,?,?,?)');
      db.prepare('SELECT * FROM plan_todo_deps').all().forEach(r => {
        ins.run(r.week_label, mapProjectId(r.department, r.week_label, r.project_id), r.todo_id, r.depends_on_id);
      });
    }
    db.exec('DROP TABLE plan_todo_deps');
    db.exec('ALTER TABLE plan_todo_deps_new RENAME TO plan_todo_deps');

    db.exec(`CREATE TABLE plan_milestones_new (
      week_label TEXT NOT NULL, project_id TEXT NOT NULL, milestone_id TEXT NOT NULL,
      name TEXT NOT NULL DEFAULT '', date TEXT NOT NULL DEFAULT '', position TEXT NOT NULL DEFAULT '',
      sort_order INTEGER NOT NULL DEFAULT 0, PRIMARY KEY (week_label, project_id, milestone_id)
    )`);
    {
      const ins = db.prepare(`INSERT OR IGNORE INTO plan_milestones_new (week_label,project_id,milestone_id,name,date,position,sort_order) VALUES (?,?,?,?,?,?,?)`);
      db.prepare('SELECT * FROM plan_milestones ORDER BY sort_order').all().forEach(r => {
        ins.run(r.week_label, mapProjectId(r.department, r.week_label, r.project_id), r.milestone_id, r.name, r.date, r.position, r.sort_order);
      });
    }
    db.exec('DROP TABLE plan_milestones');
    db.exec('ALTER TABLE plan_milestones_new RENAME TO plan_milestones');

    db.exec(`CREATE TABLE plan_milestone_deps_new (
      week_label TEXT NOT NULL, project_id TEXT NOT NULL, milestone_id TEXT NOT NULL, depends_on_id TEXT NOT NULL,
      PRIMARY KEY (week_label, project_id, milestone_id, depends_on_id)
    )`);
    {
      const ins = db.prepare('INSERT OR IGNORE INTO plan_milestone_deps_new (week_label,project_id,milestone_id,depends_on_id) VALUES (?,?,?,?)');
      db.prepare('SELECT * FROM plan_milestone_deps').all().forEach(r => {
        ins.run(r.week_label, mapProjectId(r.department, r.week_label, r.project_id), r.milestone_id, r.depends_on_id);
      });
    }
    db.exec('DROP TABLE plan_milestone_deps');
    db.exec('ALTER TABLE plan_milestone_deps_new RENAME TO plan_milestone_deps');

    // project_files: department-Spalte entfernen (jetzt korrekt über
    // project_nr allein identifiziert, da gleichnummerige Projekte ab jetzt
    // als EIN Projekt gelten). Physische Dateien lagen bisher unter
    // sessions/uploads/<department>/<datei>, künftig flach unter
    // sessions/uploads/<datei> — best-effort verschoben (Tabelle ist aktuell
    // in der Praxis leer, dieser Pfad daher selten).
    const pfCols = db.prepare("SELECT name FROM pragma_table_info('project_files')").all().map(r => r.name);
    if(pfCols.includes('department')){
      db.exec(`CREATE TABLE project_files_new (
        id TEXT PRIMARY KEY, project_nr TEXT NOT NULL, project_name TEXT NOT NULL DEFAULT '',
        original_filename TEXT NOT NULL, stored_name TEXT NOT NULL,
        content_type TEXT NOT NULL DEFAULT 'application/octet-stream', size_bytes INTEGER NOT NULL DEFAULT 0,
        uploaded_by_user_id INTEGER NOT NULL, status TEXT NOT NULL DEFAULT 'pending',
        created_at TEXT NOT NULL DEFAULT '', updated_at TEXT NOT NULL DEFAULT ''
      )`);
      db.exec(`INSERT INTO project_files_new (id,project_nr,project_name,original_filename,stored_name,content_type,size_bytes,uploaded_by_user_id,status,created_at,updated_at)
        SELECT id,project_nr,project_name,original_filename,stored_name,content_type,size_bytes,uploaded_by_user_id,status,created_at,updated_at FROM project_files`);
      const oldFileRows = db.prepare('SELECT id, department, stored_name FROM project_files').all();
      db.exec('DROP TABLE project_files');
      db.exec('ALTER TABLE project_files_new RENAME TO project_files');
      db.exec('DROP INDEX IF EXISTS idx_project_files_scope');
      db.exec('CREATE INDEX idx_project_files_scope ON project_files(project_nr)');
      oldFileRows.forEach(r => {
        try {
          const oldPath = path.join(SESSIONS_DIR, 'uploads', r.department, r.stored_name);
          const newPath = path.join(SESSIONS_DIR, 'uploads', r.stored_name);
          if(fs.existsSync(oldPath) && !fs.existsSync(newPath)) fs.renameSync(oldPath, newPath);
        } catch(err){
          conflicts.push(`project_files ${r.id}: physische Datei konnte nicht verschoben werden (${err.message}).`);
        }
      });
    }

    db.exec('COMMIT');
    console.log(`Migration abgeschlossen. ${conflicts.length} Konflikt(e)/Hinweis(e) protokolliert:`);
    conflicts.forEach(c => console.log('  - ' + c));
  } catch(err){
    db.exec('ROLLBACK');
    console.error('Department-Migration fehlgeschlagen, Datenbank unverändert:', err);
    throw err;
  }
}

// migrateAddProjectUid: vergibt jeder projects-Zeile eine dauerhafte,
// wochenunabhängige project_uid (Basis für echte Projekt-Historie über
// mehrere Sitzungen hinweg, siehe "Projekt-Historie"-Architekturnotiz).
// Anders als project_id (wird bei jedem cloneWeek() neu vergeben, siehe
// js/weeks.js) und nr (informell stabil, aber änderbar/leer möglich) wird
// project_uid einmal bei echter Projekt-Entstehung erzeugt
// (saveNewProj()/demoProj()) und danach nie wieder verändert — cloneWeek()
// kopiert sie unverändert mit. Läuft NACH migrateRemoveDepartmentPartition()
// (setzt eine bereits globale, nicht mehr abteilungsgetrennte projects-
// Tabelle voraus). Idempotent (Guard: Spalte existiert bereits).
// migrateAddProjectBesprochen: rüstet die Spalte `besprochen` nach
// (idempotentes ALTER TABLE, gleiches Muster wie migrateUsersDepartment()).
// Bestandszeilen starten mit 0 — für vergangene Sitzungen ist der Haken
// ohnehin bedeutungslos.
function migrateAddProjectBesprochen(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('projects')").all().map(r => r.name);
  if(!cols.includes('besprochen')){
    db.exec('ALTER TABLE projects ADD COLUMN besprochen INTEGER NOT NULL DEFAULT 0');
    console.log('Projekt-Tabelle um besprochen ergänzt.');
  }
}


// migrateBackfillProjectGewerkeAusTags: setzt für Projekte OHNE jede
// project_gewerke-Zeile das Gewerk aus dem Schlagwort, das
// migrateRemoveDepartmentPartition() beim Zusammenführen der früheren
// Abteilungs-Sitzungen automatisch als project_tags-Eintrag vergeben hat
// (ELT/HLS/ARCH). Ohne diese Übernahme verschwände jedes Bestandsprojekt aus
// jeder Gewerke-gefilterten Ansicht des Wochenberichts (berichtProjekte()),
// weil project_gewerke — der Assistent "Neues Projekt" schreibt hierhin —
// für alle vor dem Assistenten angelegten Projekte leer ist. Idempotent:
// sobald ein Projekt mindestens eine project_gewerke-Zeile hat (egal woher,
// auch aus dieser Migration selbst), wird es bei künftigen Läufen
// übersprungen — eine spätere manuelle Korrektur in den Projekteinstellungen
// wird also nicht rückgängig gemacht.
function migrateBackfillProjectGewerkeAusTags(){
  const kandidaten = db.prepare(`
    SELECT DISTINCT pt.week_label, pt.project_id, pt.tag
    FROM project_tags pt
    WHERE pt.tag IN ('ELT','HLS','ARCH')
      AND NOT EXISTS (
        SELECT 1 FROM project_gewerke pg
        WHERE pg.week_label = pt.week_label AND pg.project_id = pt.project_id
      )
  `).all();
  if(!kandidaten.length) return;
  const ins = db.prepare('INSERT OR IGNORE INTO project_gewerke (week_label, project_id, gewerk) VALUES (?,?,?)');
  db.exec('BEGIN');
  try {
    kandidaten.forEach(r => ins.run(r.week_label, r.project_id, r.tag));
    db.exec('COMMIT');
    console.log('Gewerke aus Schlagwörtern übernommen:', kandidaten.length, 'Zuordnung(en).');
  } catch(err){
    db.exec('ROLLBACK');
    console.error('Gewerke-Backfill aus Schlagwörtern fehlgeschlagen:', err.message);
  }
}

// migrateKommentareJeGewerk: verteilt die alten, gewerkübergreifenden
// Kommentare und Haken (projects.status/status_author/status_at/besprochen)
// auf project_kommentare. Läuft bei jedem Start und nach jedem DB-Import;
// idempotent, weil die Altspalten danach geleert werden.
// Zuordnung je Kommentar: das Gewerk des Verfassers (users.department über
// den Anzeigenamen), wenn das Projekt dieses Gewerk hat; sonst das einzige
// Gewerk des Projekts; bei mehreren und unbekanntem Verfasser alle Gewerke
// des Projekts — welches gemeint war, lässt sich dann nicht mehr sagen.
// Projekte ohne Gewerk bleiben unverändert (sie erscheinen ohnehin in keinem
// Gewerke-Wochenbericht).
function migrateKommentareJeGewerk(){
  const zeilen = db.prepare(`SELECT week_label, project_id, status, status_author, status_at, besprochen
    FROM projects WHERE status != '' OR besprochen = 1`).all();
  if(!zeilen.length) return;
  const gewerkeVon = db.prepare('SELECT gewerk FROM project_gewerke WHERE week_label = ? AND project_id = ?');
  const abteilungVon = db.prepare("SELECT department FROM users WHERE display_name = ? AND department != '' LIMIT 1");
  const vorhanden = db.prepare('SELECT 1 FROM project_kommentare WHERE week_label = ? AND project_id = ? AND gewerk = ?');
  const ins = db.prepare(`INSERT INTO project_kommentare (week_label, project_id, gewerk, status, status_author, status_at, besprochen)
    VALUES (?, ?, ?, ?, ?, ?, ?)`);
  const leeren = db.prepare(`UPDATE projects SET status = '', status_author = '', status_at = '', besprochen = 0
    WHERE week_label = ? AND project_id = ?`);
  let anzahl = 0;
  db.exec('BEGIN');
  try {
    zeilen.forEach(r => {
      const gewerke = gewerkeVon.all(r.week_label, r.project_id).map(x => x.gewerk);
      if(!gewerke.length) return;
      let ziele = gewerke;
      if(r.status && gewerke.length > 1){
        const a = r.status_author ? abteilungVon.get(r.status_author) : null;
        if(a && gewerke.includes(a.department)) ziele = [a.department];
      }
      ziele.forEach(g => {
        if(vorhanden.get(r.week_label, r.project_id, g)) return;
        ins.run(r.week_label, r.project_id, g, r.status || '', r.status_author || '', r.status_at || '', r.besprochen ? 1 : 0);
      });
      leeren.run(r.week_label, r.project_id);
      anzahl++;
    });
    db.exec('COMMIT');
    if(anzahl) console.log('Kommentare je Gewerk übernommen:', anzahl, 'Projekt-Fassung(en).');
  } catch(err){
    db.exec('ROLLBACK');
    console.error('Übernahme der Kommentare je Gewerk fehlgeschlagen:', err.message);
  }
}

// migrateDropProjectGroesse: entfernt die frühere Spalte `groesse`
// (Projektgröße 0–1, Ersatz für ein fehlendes Honorar in der alten
// Auslastungsrechnung). Seit die Auslastung allein aus Aufgaben-Stunden
// entsteht, hat sie keine Verwendung mehr — Eriks Wunsch, sie auch aus der
// Datenbank zu nehmen. Idempotent; ein Backup mit der Spalte bleibt
// importierbar (überzählige Spalten werden beim Import ignoriert).
function migrateDropProjectGroesse(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('projects')").all().map(r => r.name);
  if(cols.includes('groesse')){
    db.exec('ALTER TABLE projects DROP COLUMN groesse');
    console.log('Spalte projects.groesse entfernt.');
  }
}

// einmaligeUmstellung: führt eine Datenumstellung genau einmal je
// Datenbank aus (Merker in der Tabelle umstellungen). Für Umstellungen, die
// nicht an ein neu angelegtes Feld gekoppelt werden können.
function einmaligeUmstellung(name, fn){
  db.exec('CREATE TABLE IF NOT EXISTS umstellungen (name TEXT PRIMARY KEY, am TEXT NOT NULL)');
  if(db.prepare('SELECT 1 FROM umstellungen WHERE name = ?').get(name)) return;
  fn();
  db.prepare('INSERT INTO umstellungen (name, am) VALUES (?, ?)').run(name, new Date().toISOString());
}

// kommentarSpiegelstricheUmbrechen: Eriks Wunsch für die Bestandskommentare
// — jeder Spiegelstrich "- " beginnt eine eigene Zeile. Ältere Kommentare
// (aus der Zeit des Markup-Editors bzw. aus eingefügtem Text) tragen ihre
// Stichpunkte oft als eine Zeile "- A - B - C". Rein textuell, ohne DOM:
// Das HTML wird in Tags und Text zerlegt; Block-Tags (br/div/p) gelten als
// Zeilenanfang, Inline-Tags (b/i/span/font …) nicht. Ein "-" mit
// Leerzeichen (oder Anfang) davor und Leerzeichen/&nbsp; danach bekommt ein
// <br> vorangestellt — außer es steht schon am Zeilenanfang oder nur hinter
// einem Gewerke-Vorsatz wie "[ELT]" ("[ELT] - Text" bleibt eine Zeile).
// Bindestriche in Wörtern ("SV-Abnahme") bleiben unberührt. Repariert
// nebenbei als Text gespeicherte "&nbsp;" (siehe unten).
// Parameter: html (String). Rückgabe: String (unverändert, wenn nichts zu tun).
function kommentarSpiegelstricheUmbrechen(html){
  // Eine ältere Fassung des Kommentarfelds hat das geschützte Leerzeichen nach
  // dem Strich als Text "&nbsp;" gespeichert (sichtbar als "-&nbsp;").
  if(html) html = String(html).replace(/&amp;nbsp;/g, '&nbsp;');
  if(!html || html.indexOf('-') === -1) return html;
  const teile = String(html).split(/(<[^>]*>)/);
  let zeile = '';       // sichtbarer Text der laufenden Zeile bis hierher
  const aus = teile.map(t => {
    if(t.startsWith('<')){
      if(/^<\/?(br|div|p)\b/i.test(t)) zeile = '';
      return t;
    }
    const neu = t.replace(/(^|\s)-(?=\s|&nbsp;|\u00a0)/g, (m, vor, pos, ganz) => {
      const sichtbar = (zeile + ganz.slice(0, pos)).replace(/&nbsp;/g, ' ').trim();
      if(sichtbar === '' || /^\[[^\]]{1,20}\]$/.test(sichtbar)) return m;
      return '<br>-';
    }).replace(/\s+<br>-/g, '<br>-');
    zeile += t;
    return neu;
  });
  return aus.join('');
}

// kommentarVorsatzEntfernen: nimmt den Gewerke-Vorsatz "[ELT] ", "[ELT+HLS] "
// am Textanfang weg. Ihn hat migrateRemoveDepartmentPartition() beim
// Zusammenführen der Abteilungen vor jeden Kommentar gesetzt; seit es
// Kommentare je Gewerk gibt, steht das Gewerk ohnehin am Eintrag und wird
// in der Anzeige als eigene Beschriftung gezeigt (Eriks Wunsch: "nur als
// Systemtext, komplett weg vom normalen Text"). Ein direkt folgendes <br>
// fällt mit weg, damit keine Leerzeile am Anfang bleibt.
// Parameter: html (String). Rückgabe: String.
function kommentarVorsatzEntfernen(html){
  if(!html) return html;
  return String(html).replace(/^\s*\[(?:ELT|HLS|ARCH)(?:\s*\+\s*(?:ELT|HLS|ARCH))*\]\s*(?:<br\s*\/?>\s*)?/i, '');
}

function kommentareVorsatzUmstellen(){
  const zeilen = db.prepare("SELECT week_label, project_id, gewerk, status FROM project_kommentare WHERE status LIKE '%[%'").all();
  const upd = db.prepare('UPDATE project_kommentare SET status = ? WHERE week_label = ? AND project_id = ? AND gewerk = ?');
  let n = 0;
  db.exec('BEGIN');
  try {
    zeilen.forEach(r => {
      const neu = kommentarVorsatzEntfernen(r.status);
      if(neu !== r.status){ upd.run(neu, r.week_label, r.project_id, r.gewerk); n++; }
    });
    db.exec('COMMIT');
  } catch(e){ db.exec('ROLLBACK'); throw e; }
  if(n) console.log('Gewerke-Vorsatz aus ' + n + ' Kommentaren entfernt.');
}

function kommentareSpiegelstricheUmstellen(){
  const zeilen = db.prepare("SELECT week_label, project_id, gewerk, status FROM project_kommentare WHERE status != ''").all();
  const upd = db.prepare('UPDATE project_kommentare SET status = ? WHERE week_label = ? AND project_id = ? AND gewerk = ?');
  let n = 0;
  db.exec('BEGIN');
  try {
    zeilen.forEach(r => {
      const neu = kommentarSpiegelstricheUmbrechen(r.status);
      if(neu !== r.status){ upd.run(neu, r.week_label, r.project_id, r.gewerk); n++; }
    });
    db.exec('COMMIT');
  } catch(e){ db.exec('ROLLBACK'); throw e; }
  console.log('Spiegelstriche in ' + n + ' Bestandskommentaren auf eigene Zeilen gesetzt.');
}

// migrateAddPlanTodoLeistungsphase: rüstet die Spalte `leistungsphase` nach
// (idempotent). Kennzeichnet eine Aufgabe als Balken einer Leistungsphase
// ("LPH 5") — die Auslastung verteilt die Reststunden einer Phase auf die
// Wochen ihres Balkens. Gesetzt von "Terminplan aus Honorar" und vom
// Projekt-Assistenten
// und "+ Neu" → "Leistungsphase"; ältere Balken kennzeichnet
// phasenbalkenAusTitel() einmalig.
function migrateAddPlanTodoLeistungsphase(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('plan_todos')").all().map(r => r.name);
  if(!cols.includes('leistungsphase')){
    db.exec("ALTER TABLE plan_todos ADD COLUMN leistungsphase TEXT NOT NULL DEFAULT ''");
    console.log('plan_todos um leistungsphase ergänzt.');
  }
  // Phasenbalken sind seit Eriks Wunsch NUR noch über leistungsphase eine
  // Phase, nicht mehr über ihren Titel. Bestehende Balken, die bisher allein
  // am Titel erkannt wurden ("LPH 5 (307 h)", "LPH 5 …", "W+M"), werden
  // einmalig gekennzeichnet — danach zählt nur das Feld.
  einmaligeUmstellung('phasenbalken-aus-titel', phasenbalkenAusTitel);
}

// phasenbalkenAusTitel: kennzeichnet Balken, die bisher allein am Titel als
// Phase erkannt wurden. Läuft einmal je Datenbank und nach einem
// Backup-Import (ältere Backups kennen das Feld noch nicht).
function phasenbalkenAusTitel(){
  const n = db.prepare(`UPDATE plan_todos SET leistungsphase = CASE
        WHEN title GLOB 'W+M' OR title GLOB 'W+M *' OR title GLOB 'W+M(*' THEN 'W+M'
        ELSE substr(title, 1, 5) END
      WHERE leistungsphase = '' AND (title GLOB 'LPH [1-9]' OR title GLOB 'LPH [1-9] *' OR title GLOB 'LPH [1-9](*'
        OR title GLOB 'W+M' OR title GLOB 'W+M *' OR title GLOB 'W+M(*')`).run().changes;
  if(n) console.log(n + ' Phasenbalken anhand ihres Titels als Leistungsphase gekennzeichnet.');
}

// migrateAddPlanTodoAufwand: aufwand_stunden — geschätzter Aufwand einer
// Aufgabe; zählt zur Auslastung der Zuständigen (verteilt auf den Zeitraum
// der Aufgabe). Idempotent.
function migrateAddPlanTodoAufwand(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('plan_todos')").all().map(r => r.name);
  if(!cols.includes('aufwand_stunden')){
    db.exec('ALTER TABLE plan_todos ADD COLUMN aufwand_stunden REAL NOT NULL DEFAULT 0');
    console.log('plan_todos um aufwand_stunden ergänzt.');
  }
}

// migrateAddPlanTodoNotiz: notiz — freier Text zur Aufgabe, z. B. die Mail,
// aus der „Termin aus Mail“ sie erzeugt hat (Absender, Datum, Text). Idempotent.
function migrateAddPlanTodoNotiz(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('plan_todos')").all().map(r => r.name);
  if(!cols.includes('notiz')){
    db.exec("ALTER TABLE plan_todos ADD COLUMN notiz TEXT NOT NULL DEFAULT ''");
    console.log('plan_todos um notiz ergänzt.');
  }
  const msCols = db.prepare("SELECT name FROM pragma_table_info('plan_milestones')").all().map(r => r.name);
  if(!msCols.includes('notiz')){
    db.exec("ALTER TABLE plan_milestones ADD COLUMN notiz TEXT NOT NULL DEFAULT ''");
    console.log('plan_milestones um notiz ergänzt.');
  }
}

// migrateAddPlanTodoShowInGantt: rüstet die Spalte `show_in_gantt` nach
// (idempotent, gleiches ALTER-TABLE-Muster wie migrateAddProjectBesprochen()).
// DEFAULT 1, damit jede bestehende Aufgabe ihr bisheriges Verhalten behält
// (sichtbar im GANTT, sobald Start UND Ende gesetzt sind) — die neue
// Checkbox im Aufgaben-Dialog ("Im Terminplan anzeigen", plan-modals.js)
// blendet gezielt EINZELNE Aufgaben aus, ändert an diesem Normalfall nichts.
// Erik auf eigenen Wunsch, nachdem "TODOs aus Protokoll" (plan-protokoll-
// todos.js) gezeigt hatte, dass ein einzelner Import leicht 15-25 Aufgaben
// auf einmal anlegt — alle MIT Datum (siehe dortiger Kopfkommentar), also
// bisher alle zwingend auch als GANTT-Balken.
// migrateAddLphTemplateGewerk: Aufgaben-Vorlagen je Gewerk (Eriks Wunsch).
// Bestandsvorlagen behalten gewerk = '' und gelten dann für alle Gewerke.
function migrateAddLphTemplateGewerk(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('lph_templates')").all().map(r => r.name);
  if(!cols.includes('gewerk')){
    db.exec("ALTER TABLE lph_templates ADD COLUMN gewerk TEXT NOT NULL DEFAULT ''");
    console.log('lph_templates um gewerk ergänzt.');
  }
  // anteil: Anteil des Schritts in Prozent (z. B. nach Siemon-Tabelle).
  // Beim Einfügen bekommt jeder Schritt diesen Anteil an der Dauer der Phase
  // (js/plan/plan-templates.js) — Eriks Wunsch. 0 = kein Anteil hinterlegt.
  if(!cols.includes('anteil')){
    db.exec('ALTER TABLE lph_templates ADD COLUMN anteil REAL NOT NULL DEFAULT 0');
    console.log('lph_templates um anteil ergänzt.');
  }
  // enthalten_in: Buchstaben der Schritte, in denen dieser enthalten ist
  // (Siemon-Tabelle „in a) enth.“, z. B. 'a' oder 'a,b') — er läuft beim
  // Einfügen zeitgleich mit ihnen statt mit eigenem Anteil.
  if(!cols.includes('enthalten_in')){
    db.exec("ALTER TABLE lph_templates ADD COLUMN enthalten_in TEXT NOT NULL DEFAULT ''");
    console.log('lph_templates um enthalten_in ergänzt.');
  }
}

function migrateAddPlanTodoShowInGantt(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('plan_todos')").all().map(r => r.name);
  if(!cols.includes('show_in_gantt')){
    db.exec('ALTER TABLE plan_todos ADD COLUMN show_in_gantt INTEGER NOT NULL DEFAULT 1');
    console.log('plan_todos um show_in_gantt ergänzt.');
  }
}

// migrateAddProjectUpdatedAt: rüstet die Spalte `updated_at` nach (idempotent,
// gleiches ALTER-TABLE-Muster wie migrateAddProjectBesprochen()). Gebraucht von
// der Planung-Sandbox, siehe Spaltenkommentar am CREATE TABLE oben.
function migrateAddProjectUpdatedAt(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('projects')").all().map(r => r.name);
  if(!cols.includes('updated_at')){
    db.exec("ALTER TABLE projects ADD COLUMN updated_at TEXT NOT NULL DEFAULT ''");
    console.log('Projekt-Tabelle um updated_at ergänzt.');
  }
}

// migrateAddUserAiKeyModel: rüstet die Spalte `model` nach (idempotent,
// gleiches Muster wie migrateAddProjectBesprochen()). Leer = die in
// erkennePunkteMitChatGPT()/erkennePunkteMitClaude()/pruefePlanMitChatGPT()/
// pruefePlanMitClaude() hartcodierte Vorgabe gilt weiterhin — nötig, seit
// Erik mit Mammouth.ai einen eigenständigen Anbieter mit eigenem
// Modell-Katalog anbinden wollte: "gpt-4o-mini"/"gpt-4o" sind feste
// OpenAI-Modellnamen, die bei einem fremden Anbieter schlicht nicht
// existieren (HTTP 400 "Invalid model name ... Call /v1/models to view
// available models for your key"). Bisher ließ sich bei "Eigener Server"
// nur die URL überschreiben, nie der Modellname — dieselbe Lücke, die schon
// bei der API-URL bestand, bevor sie ergänzt wurde (siehe
// istGueltigeAiUrl()/normalisiereAiUrl() oben).
function migrateAddUserAiKeyModel(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('user_ai_keys')").all().map(r => r.name);
  if(!cols.includes('model')){
    db.exec("ALTER TABLE user_ai_keys ADD COLUMN model TEXT NOT NULL DEFAULT ''");
    console.log('user_ai_keys-Tabelle um model ergänzt.');
  }
}

// migrateAddProtokollQuelle: rüstet die beiden Spalten nach, die ein
// importiertes Protokoll von einem manuell angelegten unterscheiden
// (idempotent, gleiches Muster wie migrateAddProjectBesprochen()). Beide
// bleiben für ein manuell angelegtes Protokoll leer — siehe
// legeProtokollAn() und CLAUDE.md "### Protokolle".
function migrateAddProtokollQuelle(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('project_protokolle')").all().map(r => r.name);
  if(!cols.includes('quelle_dateiname')){
    db.exec("ALTER TABLE project_protokolle ADD COLUMN quelle_dateiname TEXT NOT NULL DEFAULT ''");
    db.exec("ALTER TABLE project_protokolle ADD COLUMN quelle_stored_name TEXT NOT NULL DEFAULT ''");
    console.log('Protokoll-Tabelle um Quelle-Spalten ergänzt.');
  }
}

// migrateAddProtokollPunktErstelltAm: rüstet das Datum nach, an dem ein
// Punkt zum ERSTEN Mal erfasst wurde (Erik's Wunsch) — bestehende Zeilen
// bleiben leer, da ihr echtes Entstehungsdatum nicht mehr rekonstruierbar
// ist (idempotent, gleiches Muster wie migrateAddProtokollQuelle()).
function migrateAddProtokollPunktErstelltAm(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('protokoll_punkte')").all().map(r => r.name);
  if(!cols.includes('erstellt_am')){
    db.exec("ALTER TABLE protokoll_punkte ADD COLUMN erstellt_am TEXT NOT NULL DEFAULT ''");
    console.log('Protokoll-Punkte-Tabelle um erstellt_am ergänzt.');
  }
}

// migrateAddProtokollPunktStatus: löst das bisherige boolesche `erledigt`
// in einen Status mit drei Werten auf (offen/erledigt/info, Eriks Wunsch
// nach einem dritten Zustand für rein informative Punkte ohne eigene
// Handlung). `erledigt` bleibt als Spalte bestehen und wird weiterhin
// synchron mitgeschrieben (reine Rückwärtskompatibilität, z. B. für
// IMPORT_TABLES-Restores älterer Backups) — maßgeblich für die Anwendung
// ist ab hier ausschließlich `status`. Bestehende Zeilen werden anhand
// ihres bisherigen `erledigt`-Werts befüllt, der ADD-COLUMN-Standardwert
// 'offen' allein würde erledigte Altpunkte fälschlich wieder öffnen.
function migrateAddProtokollPunktStatus(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('protokoll_punkte')").all().map(r => r.name);
  if(!cols.includes('status')){
    db.exec("ALTER TABLE protokoll_punkte ADD COLUMN status TEXT NOT NULL DEFAULT 'offen'");
    db.exec("UPDATE protokoll_punkte SET status = 'erledigt' WHERE erledigt = 1");
    console.log('Protokoll-Punkte-Tabelle um status ergänzt.');
  }
}

// migrateAddProtokollPunktEntfaelltNaechstes: rüstet das Merkmal nach, das
// einem erledigten Punkt EINE Gnadenrunde gibt (Eriks Wunsch): 'offen' und
// 'info' laufen wie bisher unbegrenzt weiter, aber 'erledigt' soll nicht
// sofort verschwinden, sondern genau einmal noch — als erledigt markiert,
// zusätzlich mit einem Hinweis "entfällt im nächsten Protokoll" — im
// nächsten Protokoll auftauchen und erst im übernächsten entfallen. Dieses
// Flag steht NICHT auf dem Punkt, der gerade erledigt markiert wurde,
// sondern wird erst von legeProtokollAn() auf die fortgeschriebene KOPIE
// gesetzt, wenn ihre Quelle status='erledigt' hatte — siehe dort. Idempotent,
// gleiches Muster wie migrateAddProtokollPunktStatus().
function migrateAddProtokollPunktEntfaelltNaechstes(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('protokoll_punkte')").all().map(r => r.name);
  if(!cols.includes('entfaellt_naechstes')){
    db.exec("ALTER TABLE protokoll_punkte ADD COLUMN entfaellt_naechstes INTEGER NOT NULL DEFAULT 0");
    console.log('Protokoll-Punkte-Tabelle um entfaellt_naechstes ergänzt.');
  }
}

// ensureSandboxWeek: legt die reservierte `weeks`-Zeile für die Planung-
// Sandbox einmalig an (INSERT OR IGNORE — beim zweiten und jedem weiteren
// Start ist sie schon da). Kein echtes Datum, nie gesperrt. Alle Terminpläne
// der Planung hängen an diesem einen `week_label`, siehe SANDBOX_WEEK_LABEL.
function ensureSandboxWeek(){
  db.prepare(`INSERT OR IGNORE INTO weeks (label, week_id, date, locked, updated_at)
    VALUES (?, 'sandbox', '', 0, '')`).run(SANDBOX_WEEK_LABEL);
}

// getIsoWeekInfo: ISO-Kalenderwoche UND -Wochenjahr eines Datums (das
// Wochenjahr kann an Jahresgrenzen vom Kalenderjahr abweichen — Silvester
// kann in KW 1 des Folgejahres liegen). Portiert von getWeekNumber()
// (public/js/utils.js) — reines, browserunabhängiges JS, hier um das
// Wochenjahr erweitert, das für den Sitzungswechsel unten gebraucht wird.
// Parameter: date (Date). Rückgabe: {week, year}.
function getIsoWeekInfo(date){
  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
  const dayNum = d.getUTCDay() || 7;
  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
  const year = d.getUTCFullYear();
  const yearStart = new Date(Date.UTC(year, 0, 1));
  const week = Math.ceil((((d - yearStart) / 86400000) + 1) / 7);
  return { week, year };
}

// formatWeekLabel: "KW <n zweistellig> / <JJJJ>" — das Format, das sowohl
// validateWeekLabel()s Regex (früher public/js/weeks.js) als auch
// weekSortKey()/weekSortKeyServer() erwarten.
function formatWeekLabel(week, year){
  return 'KW ' + String(week).padStart(2, '0') + ' / ' + year;
}

// ensureCurrentWeekRollover: legt automatisch eine neue Sitzung an, sobald
// der Kalender in eine neue ISO-Woche gewechselt hat — unabhängig davon, ob
// irgendjemand die Anwendung gerade nutzt (siehe CLAUDE.md, Abschnitt zum
// automatischen Sitzungswechsel). Ersetzt die früheren, manuellen Knöpfe
// "Neue Sitzung"/"Sitzung duplizieren" (public/js/weeks.js, entfernt).
// Repliziert exakt das Rücksetzverhalten des früheren cloneWeek(): neue
// week-/Projekt-ids, Kommentar/Verfasser/Zeitstempel/besprochen geleert,
// alles andere (Beteiligte, Zuordnungen, Terminpläne, Honorar, beauftragte
// Leistungsphasen, Gewerke, project_uid) bleibt unverändert erhalten. Sperrt
// anschließend — sofern app_settings.autoLockAktiv aktiv ist — alle anderen
// echten Sitzungen, dieselbe Invariante, die applyAutoLock() bisher nur
// clientseitig durchsetzte. Ohne jede bestehende echte Sitzung (frische
// Installation) wird stattdessen eine leere Sitzung angelegt (wie es früher
// newWeek() tat), damit ein frisches System nicht für immer ohne jede
// Sitzung dasteht. Fehler werden geloggt, nie geworfen — darf den
// Serverbetrieb nie stören. Keine Parameter, keine Rückgabe.
function ensureCurrentWeekRollover(){
  try {
    // Nur die jüngste Sitzung laden — alle Sitzungen stündlich komplett
    // zusammenzusetzen kostete auf dem Pi Zero unnötig Speicher.
    const juengstesLabel = db.prepare('SELECT label FROM weeks WHERE label != ?').all(SANDBOX_WEEK_LABEL)
      .map(r => r.label)
      .sort((a, b) => weekSortKeyServer(a).localeCompare(weekSortKeyServer(b)))
      .pop();
    const echteWochen = juengstesLabel === undefined ? [] : loadWeeks(juengstesLabel);
    const { week, year } = getIsoWeekInfo(new Date());
    const heuteKey = String(year) + '-' + String(week).padStart(2, '0');
    const neuesLabel = formatWeekLabel(week, year);

    let neueWoche;
    if(echteWochen.length === 0){
      // Frische Installation: keine Quelle zum Kopieren vorhanden.
      neueWoche = {
        id: crypto.randomUUID(), label: neuesLabel, date: heuteIsoLokal(),
        people: loadGlobalPeople(), projects: [], attendance: {}, locked: false
      };
    } else {
      const sortiert = echteWochen.slice()
        .sort((a, b) => weekSortKeyServer(a.label).localeCompare(weekSortKeyServer(b.label)));
      const letzte = sortiert[sortiert.length - 1];
      const letzteKey = weekSortKeyServer(letzte.label);
      if(heuteKey <= letzteKey) return; // schon auf dem Stand der aktuellen Kalenderwoche

      neueWoche = JSON.parse(JSON.stringify(letzte));
      neueWoche.id = crypto.randomUUID();
      neueWoche.label = neuesLabel;
      neueWoche.date = heuteIsoLokal();
      neueWoche.attendance = {};
      neueWoche.locked = false;
      delete neueWoche.updatedAt;
      (neueWoche.projects || []).forEach(p => {
        p.id = crypto.randomUUID();
        // Eriks Wunsch: Der Kommentar der Vorwoche wird je Gewerk übernommen
        // und in der Besprechung angepasst; nur der Besprochen-Haken gehört
        // zur Sitzung und beginnt leer.
        const vorher = p.kommentare || {};
        p.kommentare = {};
        Object.keys(vorher).forEach(g => {
          const k = vorher[g] || {};
          if(!String(k.status || '').trim()) return;
          p.kommentare[g] = { status: k.status, statusAuthor: k.statusAuthor || '',
            statusAt: k.statusAt || '', besprochen: false };
        });
        delete p.statusState;
      });
    }

    saveWeekRelational(neueWoche);
    console.log('Automatischer Sitzungswechsel: neue Sitzung "' + neuesLabel + '" angelegt.');
    if(typeof ereignisSenden === 'function') ereignisSenden({ typ: 'neu' }, null);

    if(Number(readAppSettings().autoLockAktiv)){
      const nowIso = new Date().toISOString();
      db.prepare(`UPDATE weeks SET locked = 1, updated_at = ?
        WHERE label != ? AND label != ?`).run(nowIso, neuesLabel, SANDBOX_WEEK_LABEL);
    }
  } catch(err){
    console.error('Automatischer Sitzungswechsel fehlgeschlagen:', err);
  }
}

function migrateAddProjectUid(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('projects')").all().map(r => r.name);
  if(!cols.includes('project_uid')){
    db.exec("ALTER TABLE projects ADD COLUMN project_uid TEXT NOT NULL DEFAULT ''");
  } else {
    // Die Spalte allein genügt als Abschluss-Kennzeichen NICHT: Das ALTER
    // TABLE läuft außerhalb der Transaktion, das Nachfüllen darin. Brach das
    // Nachfüllen einmal ab (z. B. SQLITE_BUSY), existierte die Spalte, war
    // aber überall leer — und jeder weitere Start übersprang die Migration.
    // Die Projekt-Historie über Sitzungen hinweg wäre dauerhaft tot gewesen.
    const offen = db.prepare("SELECT COUNT(*) AS c FROM projects WHERE project_uid = ''").get();
    if(!offen || offen.c === 0) return; // wirklich fertig
    console.log('Migriere: project_uid wird nachgefüllt (' + offen.c + ' Zeile(n) ohne Kennung) …');
  }

  // Backfill für Bestandsdaten: Zeilen mit gleicher, nicht-leerer nr über
  // alle Wochen hinweg gelten als dasselbe reale Projekt und bekommen
  // dieselbe uid. Zeilen ohne nr können nicht zusammengeführt werden (kein
  // anderer stabiler Schlüssel vorhanden) und bekommen je eine eigene uid.
  // Bekannte Grenze dieses einmaligen Rückblicks: eine in der Vergangenheit
  // wiederverwendete nr (zwei echte Projekte) wird fälschlich zusammengeführt,
  // eine mitten in der Historie geänderte nr wird fälschlich getrennt — ab
  // dem Zeitpunkt dieser Migration tritt das Problem nicht mehr auf, da
  // project_uid danach nie wieder aus nr neu berechnet wird.
  const rows = db.prepare('SELECT week_label, project_id, nr, project_uid FROM projects').all();
  const uidByNr = new Map();
  // Bereits vergebene Kennungen als Vorgabe übernehmen: Beim Nachfüllen eines
  // Teilbestands (siehe Guard oben) dürfen vorhandene Kennungen NICHT neu
  // gewürfelt werden — sonst risse die Verbindung desselben Projekts über
  // mehrere Sitzungen hinweg ab.
  rows.forEach(r => {
    const key = (r.nr || '').trim();
    if(key && r.project_uid && !uidByNr.has(key)) uidByNr.set(key, r.project_uid);
  });
  const update = db.prepare('UPDATE projects SET project_uid = ? WHERE week_label = ? AND project_id = ?');

  db.exec('BEGIN');
  try {
    rows.forEach(r => {
      if(r.project_uid) return; // schon gesetzt, nicht anfassen
      const key = (r.nr || '').trim();
      let projectUid;
      if(key){
        if(!uidByNr.has(key)) uidByNr.set(key, crypto.randomUUID());
        projectUid = uidByNr.get(key);
      } else {
        projectUid = crypto.randomUUID();
      }
      update.run(projectUid, r.week_label, r.project_id);
    });
    db.exec('COMMIT');
  } catch(err){
    db.exec('ROLLBACK');
    console.error('project_uid-Migration fehlgeschlagen, Datenbank unverändert:', err);
    throw err;
  }
  console.log(`project_uid vergeben: ${rows.length} Zeile(n), ${uidByNr.size} eindeutige Projekt-Historie(n) über nr gruppiert.`);
}

// migrateAddProjectHonorar: ergänzt die Spalte `honorar` in der Tabelle
// `projects` (vereinbartes Netto-Honorar in Euro, Grundlage der
// Honorar-Terminplanung). Idempotent, gleiches Muster wie
// migrateWeeksUpdatedAt(). Bestandsprojekte bekommen 0 und gelten damit als
// "kein Honorar hinterlegt" — die Honorar-Maske verlangt dann eine Eingabe,
// bevor sie rechnet.
function migrateAddProjectHonorar(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('projects')").all().map(r => r.name);
  if(cols.includes('honorar')) return;
  db.exec('ALTER TABLE projects ADD COLUMN honorar REAL NOT NULL DEFAULT 0');
  console.log('Projekte-Tabelle um honorar ergänzt.');
}

// migrateAddProjectStatusAuthor: ergänzt die Spalten `status_author` und
// `status_at` in der Tabelle `projects` — Verfasser (Anzeigename zum
// Zeitpunkt des Schreibens) und Zeitstempel des Wochenkommentars. Bewusst
// der Anzeigename und nicht die user_id: der Kommentar ist ein historischer
// Eintrag, er soll auch nach dem Löschen oder Umbenennen eines Kontos noch
// aussagen, wer ihn damals verfasst hat. Idempotent, gleiches Muster wie
// migrateAddProjectHonorar(). Bestandskommentare bekommen leere Werte und
// werden in der Oberfläche als "unbekannt" ausgewiesen — der Verfasser ist
// rückwirkend nicht ermittelbar.
function migrateAddProjectStatusAuthor(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('projects')").all().map(r => r.name);
  if(cols.includes('status_author')) return;
  db.exec("ALTER TABLE projects ADD COLUMN status_author TEXT NOT NULL DEFAULT ''");
  db.exec("ALTER TABLE projects ADD COLUMN status_at TEXT NOT NULL DEFAULT ''");
  console.log('Projekt-Tabelle um status_author/status_at ergänzt.');
}

// migrateAddProjectAuftragsstatus: rüstet die Spalte `auftragsstatus` nach
// (idempotentes ALTER TABLE, gleiches Muster wie
// migrateAddProjectBesprochen()). Bestandszeilen bekommen über den
// Spalten-Default 'beauftragt' — der Altbestand ist beauftragte Arbeit, und
// jeder andere Anfangswert hätte laufende Projekte rückwirkend zu Akquise
// erklärt (siehe DEFAULT_AUFTRAGSSTATUS).
function migrateAddProjectAuftragsstatus(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('projects')").all().map(r => r.name);
  if(!cols.includes('auftragsstatus')){
    db.exec("ALTER TABLE projects ADD COLUMN auftragsstatus TEXT NOT NULL DEFAULT 'beauftragt'");
    console.log('Projekt-Tabelle um auftragsstatus ergänzt.');
  }
}

// migrateUsersDepartment: ergänzt die Spalten `department`/`initials` in
// bestehenden users-Tabellen (idempotent; neue DBs haben sie bereits).
function migrateUsersDepartment(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('users')").all().map(r => r.name);
  // einfuehrung_am: wann das Konto den Rundgang (public/js/einfuehrung.js)
  // abgeschlossen hat; leer = steht noch aus. Bewusst auch für bestehende
  // Konten leer (Eriks Wunsch: jeder macht den Rundgang einmal).
  if(!cols.includes('einfuehrung_am')){
    db.exec("ALTER TABLE users ADD COLUMN einfuehrung_am TEXT NOT NULL DEFAULT ''");
    console.log('Benutzer-Tabelle um einfuehrung_am ergänzt.');
  }
  // dashboard_reihenfolge: eigene Reihenfolge der Projekte auf "Meine
  // Aufgaben" (JSON-Liste von Projekt-Schlüsseln, meist project_uid); leer =
  // wie in der Projektliste. Je Konto, damit sie auf jedem Gerät gilt.
  // kalender_token: geheime Adresse des Kalender-Abos (/kalender/<token>.ics),
  // leer = abgeschaltet. Siehe "Kalender-Abo für Outlook".
  if(!cols.includes('kalender_token')){
    db.exec("ALTER TABLE users ADD COLUMN kalender_token TEXT NOT NULL DEFAULT ''");
    console.log('Benutzer-Tabelle um kalender_token ergänzt.');
  }
  if(!cols.includes('dashboard_reihenfolge')){
    db.exec("ALTER TABLE users ADD COLUMN dashboard_reihenfolge TEXT NOT NULL DEFAULT ''");
    console.log('Benutzer-Tabelle um dashboard_reihenfolge ergänzt.');
  }
  if(!cols.includes('department')){
    db.exec("ALTER TABLE users ADD COLUMN department TEXT NOT NULL DEFAULT ''");
    console.log('Benutzer-Tabelle um department ergänzt.');
  }
  if(!cols.includes('initials')){
    db.exec("ALTER TABLE users ADD COLUMN initials TEXT NOT NULL DEFAULT ''");
    console.log('Benutzer-Tabelle um initials ergänzt.');
  }
  // capacity_hours: vertragliche Wochenstunden. Bis dahin kannte die
  // Auslastungsrechnung keine Teilzeit — sie maß jede Person an einer vollen
  // Stelle, eine halbe Stelle erschien deshalb dauerhaft unterbeschäftigt
  // (in js/load/load.js ausdrücklich als offener Punkt vermerkt). 0 bedeutet
  // "nicht gepflegt" und wird wie eine volle Stelle behandelt, damit
  // Bestandskonten ihr bisheriges Bild behalten.
  if(!cols.includes('capacity_hours')){
    db.exec('ALTER TABLE users ADD COLUMN capacity_hours REAL NOT NULL DEFAULT 0');
    console.log('Benutzer-Tabelle um capacity_hours ergänzt.');
  }
}

// migrateUsersVorNachname: Vor- und Nachname als eigene Spalten
// (first_name/last_name). Bis dahin gab es nur den Anzeigenamen; daraus
// ließen sich Benutzername und E-Mail-Adresse nicht verlässlich ableiten (ein
// einzelnes Wort im Feld ergab z. B. nur den Nachnamen). display_name bleibt
// bestehen und wird beim Anlegen/Bearbeiten als "Vorname Nachname" gesetzt —
// alle übrigen Stellen lesen weiter display_name. Bestandskonten bekommen
// Vor-/Nachname einmalig aus display_name (erstes Wort / Rest). Benutzernamen
// bleiben unverändert: Angemeldet wird mit dem Anfang der E-Mail-Adresse
// (z. B. e.dunin), und genau so heißen die Bestandskonten bereits.
function migrateUsersVorNachname(){
  const cols = db.prepare("SELECT name FROM pragma_table_info('users')").all().map(r => r.name);
  if(cols.includes('first_name') && cols.includes('last_name')) return;
  if(!cols.includes('first_name')) db.exec("ALTER TABLE users ADD COLUMN first_name TEXT NOT NULL DEFAULT ''");
  if(!cols.includes('last_name'))  db.exec("ALTER TABLE users ADD COLUMN last_name TEXT NOT NULL DEFAULT ''");
  const rows = db.prepare('SELECT id, display_name FROM users').all();
  const setNamen = db.prepare('UPDATE users SET first_name = ?, last_name = ? WHERE id = ?');
  rows.forEach(r => {
    const woerter = String(r.display_name || '').trim().split(/\s+/).filter(Boolean);
    setNamen.run(woerter[0] || '', woerter.slice(1).join(' '), r.id);
  });
  console.log('Benutzer-Tabelle um Vor-/Nachname ergänzt (' + rows.length + ' Konten aus dem Anzeigenamen befüllt).');
}

// dedupeUserPersonIds: person_id musste bisher nur je Abteilung eindeutig
// sein (alte people-Tabelle); jetzt identifiziert person_id global einen
// Benutzer, daher müssen Bestandskollisionen vor dem UNIQUE INDEX aufgelöst
// werden. Alle bis auf die erste Zeile je Kollision bekommen "_<id>" angehängt.
function dedupeUserPersonIds(){
  const dupes = db.prepare(`SELECT person_id, COUNT(*) c FROM users WHERE person_id != '' GROUP BY person_id HAVING c > 1`).all();
  dupes.forEach(d => {
    const rows = db.prepare('SELECT id FROM users WHERE person_id = ? ORDER BY id').all(d.person_id);
    rows.slice(1).forEach(r => {
      const newId = d.person_id + '_' + r.id;
      db.prepare('UPDATE users SET person_id = ? WHERE id = ?').run(newId, r.id);
      console.warn(`Person-ID-Kollision behoben: Benutzer #${r.id} bekommt "${newId}" statt "${d.person_id}" (bitte in der Benutzerverwaltung prüfen).`);
    });
  });
}

// ensureUserPersonIdUniqueIndex: löst zuerst Bestandskollisionen auf (siehe
// dedupeUserPersonIds) und legt danach den UNIQUE-Index an (idempotent,
// überspringt leere person_id-Werte per partiellem Index).
function ensureUserPersonIdUniqueIndex(){
  dedupeUserPersonIds();
  db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_users_person_id_unique ON users(person_id) WHERE person_id != ''`);
}

// migrateRetirePeopleTablesIntoUsers: löst das alte, abteilungsbezogene
// Projektbeteiligte-Schema (people/person_roles/person_absences) endgültig ab,
// nachdem es durch die globalen User-Accounts (users/user_roles/user_absences)
// ersetzt wurde. Idempotent: läuft nur, solange die Tabelle `people` noch
// existiert. person_absences wird bewusst NICHT übernommen (enthielt bereits
// vorher keine sinnvollen Daten, siehe serializeGlobalPeople-Altcode), und für
// historische people-Zeilen ohne passenden User wird KEIN Platzhalter-User
// angelegt (würde die Benutzerliste mit nicht-loginfähigen Karteileichen
// verschmutzen) — stattdessen wird einmalig auf der Konsole protokolliert.
function migrateRetirePeopleTablesIntoUsers(){
  const stillExists = db.prepare("SELECT COUNT(*) c FROM sqlite_master WHERE type='table' AND name='people'").get().c > 0;
  if(!stillExists) return;
  console.log('Migriere altes Projektbeteiligte-Schema (people/person_roles/person_absences) …');
  const legacyPeople = db.prepare('SELECT * FROM people').all();
  const legacyRoles = db.prepare('SELECT * FROM person_roles').all();
  let merged = 0; const unmatched = [];
  db.exec('BEGIN');
  try {
    legacyPeople.forEach(p => {
      const user = db.prepare('SELECT id FROM users WHERE department = ? AND person_id = ?').get(p.department, p.person_id);
      if(!user){ unmatched.push(p.department + '/' + p.person_id + ' (' + p.full_name + ')'); return; }
      legacyRoles.filter(r => r.department === p.department && r.person_id === p.person_id)
        .forEach(r => db.prepare('INSERT OR IGNORE INTO user_roles (user_id, role, role_order) VALUES (?,?,?)').run(user.id, r.role, r.role_order));
      merged++;
    });
    db.exec('DROP TABLE people; DROP TABLE person_roles; DROP TABLE person_absences;');
    db.exec('COMMIT');
    console.log(`Migration abgeschlossen: ${merged} Personen-Rollen übernommen. ${unmatched.length} alte Einträge ohne passenden Benutzer (nicht automatisch migrierbar):`);
    unmatched.forEach(u => console.log('  - ' + u));
  } catch(err){ db.exec('ROLLBACK'); console.error('Migration fehlgeschlagen:', err.message); throw err; }
}

// ---------- Auth: Passwort-Hashing ----------

// hashPassword: erzeugt Salt + scrypt-Hash für ein neues/geändertes Passwort.
function hashPassword(password){
  const salt = crypto.randomBytes(16).toString('hex');
  const hash = crypto.scryptSync(password, salt, 64).toString('hex');
  return { hash, salt };
}

// verifyPassword: prüft ein eingegebenes Passwort gegen gespeicherten Salt+Hash
// (zeitkonstanter Vergleich gegen Timing-Angriffe).
function verifyPassword(password, salt, expectedHash){
  const hash = crypto.scryptSync(password, salt, 64);
  const expected = Buffer.from(expectedHash, 'hex');
  return hash.length === expected.length && crypto.timingSafeEqual(hash, expected);
}

// bootstrapInitialAdmin: legt beim allerersten Start (users-Tabelle leer) ein
// Admin-Konto mit zufällig generiertem Passwort an (kein Hardcoded-Passwort im
// Code). Läuft danach nie wieder (Guard: COUNT(*) > 0). Das Klartext-Passwort
// wird einmalig auf die Konsole ausgegeben und zusätzlich nach
// sessions/INITIAL_ADMIN_PASSWORD.txt geschrieben (liegt außerhalb von
// public/, wird also nie von express.static ausgeliefert).
function bootstrapInitialAdmin(){
  const row = db.prepare('SELECT COUNT(*) AS c FROM users').get();
  if(row.c > 0) return;
  const password = crypto.randomBytes(15).toString('base64url');
  const { hash, salt } = hashPassword(password);
  const now = new Date().toISOString();
  db.prepare('INSERT INTO users (username, display_name, role, password_hash, password_salt, must_change_password, created_at, updated_at) VALUES (?,?,?,?,?,1,?,?)')
    .run('admin', 'Administrator', 'admin', hash, salt, now, now);
  const msg = 'Erstmaliges Admin-Konto angelegt.\n  Benutzername: admin\n  Passwort:     ' + password + '\n  (Bitte nach dem ersten Login sofort ändern.)';
  console.log(msg);
  try {
    fs.writeFileSync(path.join(SESSIONS_DIR, 'INITIAL_ADMIN_PASSWORD.txt'), msg + '\n', 'utf8');
  } catch(err){
    console.error('Konnte INITIAL_ADMIN_PASSWORD.txt nicht schreiben:', err);
  }
}

// Migration beim Serverstart ausführen
migrateLegacySchema();
migrateWeeksUpdatedAt();
migrateRemoveDepartmentPartition();
migrateBackfillProjectGewerkeAusTags();
migrateAddProjectUid();
migrateAddProjectBesprochen();
migrateAddProjectHonorar();
migrateAddProjectStatusAuthor();
migrateAddProjectAuftragsstatus();
migrateDropProjectGroesse();
migrateAddProjectUpdatedAt();
migrateAddPlanTodoShowInGantt();
migrateAddLphTemplateGewerk();
migrateAddPlanTodoLeistungsphase();
migrateAddPlanTodoAufwand();
migrateAddPlanTodoNotiz();
migrateAddUserAiKeyModel();
migrateAddProtokollQuelle();
migrateAddProtokollPunktErstelltAm();
migrateAddProtokollPunktStatus();
migrateAddProtokollPunktEntfaelltNaechstes();
migrateUsersDepartment();
migrateUsersVorNachname();
migrateKommentareJeGewerk();
// ---------- Aufgaben-Vorlagen: Grundleistungen nach HOAI ----------
// Eriks Wunsch: die Aufgaben-Vorlagen je Gewerk mit den Grundleistungen der
// HOAI füllen — ARCH nach Anlage 10.1 (Gebäude und Innenräume), ELT und HLS
// nach Anlage 15.1 (Technische Ausrüstung; die HOAI unterscheidet die
// Anlagengruppen bei den Grundleistungen nicht). Titel sind gekürzt, der
// Buchstabe der HOAI steht am Ende. Ohne Termin (duration_days = 0, siehe
// lph_templates): Die Dauer legt man im Projekt fest. Die Prozentanteile der
// Siemon-Tabelle sind bewusst NICHT hinterlegt — sie lagen nicht vor.
// Läuft einmal (einmaligeUmstellung) und nur für Gewerke ohne eigene Vorlagen.
const HOAI_GRUNDLEISTUNGEN = {
  gebaeude: {
    'LPH 1': [
      'Aufgabenstellung klären (Vorgaben, Bedarfsplanung) (a)',
      'Ortsbesichtigung (b)',
      'Zum Leistungs- und Untersuchungsbedarf beraten (c)',
      'Entscheidungshilfen zur Auswahl weiterer Fachplaner formulieren (d)',
      'Ergebnisse zusammenfassen, erläutern und dokumentieren (e)'],
    'LPH 2': [
      'Grundlagen analysieren, Leistungen mit Fachplanern abstimmen (a)',
      'Zielvorstellungen abstimmen, auf Zielkonflikte hinweisen (b)',
      'Vorplanung erarbeiten, Varianten untersuchen und bewerten (c)',
      'Wesentliche Zusammenhänge, Vorgaben und Bedingungen klären (d)',
      'Ergebnisse für Fachplaner bereitstellen, Koordination und Integration (e)',
      'Vorverhandlungen über die Genehmigungsfähigkeit (f)',
      'Kostenschätzung nach DIN 276, Vergleich mit Budget (g)',
      'Terminplan mit den wesentlichen Vorgängen erstellen (h)',
      'Ergebnisse zusammenfassen, erläutern und dokumentieren (i)'],
    'LPH 3': [
      'Entwurfsplanung bis zum vollständigen Entwurf erarbeiten (a)',
      'Ergebnisse für Fachplaner bereitstellen, Koordination und Integration (b)',
      'Objektbeschreibung (c)',
      'Verhandlungen über die Genehmigungsfähigkeit (d)',
      'Kostenberechnung nach DIN 276, Vergleich mit Kostenschätzung (e)',
      'Terminplan fortschreiben (f)',
      'Ergebnisse zusammenfassen, erläutern und dokumentieren (g)'],
    'LPH 4': [
      'Vorlagen und Nachweise für Genehmigungen erarbeiten und zusammenstellen (a)',
      'Vorlagen einreichen (b)',
      'Planungsunterlagen, Beschreibungen und Berechnungen ergänzen und anpassen (c)'],
    'LPH 5': [
      'Ausführungsplanung mit allen Einzelangaben erarbeiten (a)',
      'Ausführungs-, Detail- und Konstruktionszeichnungen (b)',
      'Ergebnisse für Fachplaner bereitstellen, Koordination und Integration (c)',
      'Terminplan fortschreiben (d)',
      'Ausführungsplanung während der Objektausführung fortschreiben (e)',
      'Montagepläne auf Übereinstimmung mit der Ausführungsplanung prüfen (f)'],
    'LPH 6': [
      'Vergabeterminplan aufstellen (a)',
      'Leistungsbeschreibungen mit Leistungsverzeichnissen aufstellen, Mengen ermitteln (b)',
      'Schnittstellen zu den Leistungsbeschreibungen der Fachplaner abstimmen (c)',
      'Kosten anhand bepreister Leistungsverzeichnisse ermitteln (d)',
      'Kostenkontrolle: bepreiste LV mit Kostenberechnung vergleichen (e)',
      'Vergabeunterlagen für alle Leistungsbereiche zusammenstellen (f)'],
    'LPH 7': [
      'Vergaben der Fachplaner koordinieren (a)',
      'Angebote einholen (b)',
      'Angebote prüfen und werten, Preisspiegel aufstellen (c)',
      'Bietergespräche führen (d)',
      'Vergabevorschläge erstellen, Vergabeverfahren dokumentieren (e)',
      'Vertragsunterlagen für alle Leistungsbereiche zusammenstellen (f)',
      'Kostenkontrolle: Ausschreibungsergebnisse mit bepreisten LV vergleichen (g)',
      'Bei der Auftragserteilung mitwirken (h)'],
    'LPH 8': [
      'Ausführung überwachen (Genehmigung, Verträge, Pläne, Regeln der Technik) (a)',
      'Ausführung einfacher Tragwerke auf Standsicherheitsnachweis überwachen (b)',
      'An der Objektüberwachung Beteiligte koordinieren (c)',
      'Terminplan (Balkendiagramm) aufstellen, fortschreiben, überwachen (d)',
      'Bauablauf dokumentieren (Bautagebuch) (e)',
      'Gemeinsames Aufmaß mit den ausführenden Unternehmen (f)',
      'Rechnungsprüfung einschließlich Prüfen der Aufmaße (g)',
      'Rechnungsprüfungen mit Auftragssummen inkl. Nachträgen vergleichen (h)',
      'Kostenkontrolle: Abrechnung mit Vertragspreisen vergleichen (i)',
      'Kostenfeststellung nach DIN 276 (j)',
      'Abnahme organisieren, Mängel feststellen, Abnahmeempfehlung (k)',
      'Öffentlich-rechtliche Abnahmen beantragen und teilnehmen (l)',
      'Dokumentation, Zeichnungen und Berechnungen systematisch zusammenstellen (m)',
      'Objekt übergeben (n)',
      'Verjährungsfristen für Mängelansprüche auflisten (o)',
      'Beseitigung der Abnahmemängel überwachen (p)'],
    'LPH 9': [
      'Innerhalb der Verjährungsfristen festgestellte Mängel fachlich bewerten (a)',
      'Objektbegehung vor Ablauf der Verjährungsfristen (b)',
      'Bei der Freigabe von Sicherheitsleistungen mitwirken (c)'],
  },
  technik: {
    'LPH 1': [
      'Aufgabenstellung im Benehmen mit dem Objektplaner klären (a)',
      'Planungsrandbedingungen ermitteln, zum Leistungsbedarf und zur Erschließung beraten (b)',
      'Ergebnisse zusammenfassen, erläutern und dokumentieren (c)'],
    'LPH 2': [
      'Grundlagen analysieren, beim Abstimmen der Leistungen mitwirken (a)',
      'Planungskonzept erarbeiten: Vordimensionierung, Varianten, Raumbedarf (b)',
      'Funktionsschema bzw. Prinzipschaltbild je Anlage aufstellen (c)',
      'Fachübergreifende Prozesse, Randbedingungen und Schnittstellen klären (d)',
      'Vorverhandlungen mit Behörden und Versorgern (e)',
      'Kostenschätzung nach DIN 276 (2. Ebene) und Terminplanung (f)',
      'Ergebnisse zusammenfassen, erläutern und dokumentieren (g)'],
    'LPH 3': [
      'Planungskonzept bis zum vollständigen Entwurf durcharbeiten (a)',
      'Alle Systeme und Anlagenteile festlegen (b)',
      'Anlagen berechnen und bemessen, Entwurf zeichnen, Schemata fortschreiben (c)',
      'Berechnungsergebnisse übergeben, Durchführungen und Lasten für die Tragwerksplanung (d)',
      'Verhandlungen mit Behörden über die Genehmigungsfähigkeit (e)',
      'Kostenberechnung nach DIN 276 (3. Ebene) und Terminplanung (f)',
      'Kostenkontrolle: Kostenberechnung mit Kostenschätzung vergleichen (g)',
      'Ergebnisse zusammenfassen, erläutern und dokumentieren (h)'],
    'LPH 4': [
      'Vorlagen und Nachweise für Genehmigungen erarbeiten, bei Behördenverhandlungen mitwirken (a)',
      'Planungsunterlagen, Beschreibungen und Berechnungen vervollständigen und anpassen (b)'],
    'LPH 5': [
      'Ausführungsplanung bis zur ausführungsreifen Lösung erarbeiten (a)',
      'Berechnungen fortschreiben, Anlagen zeichnen, Schemata detaillieren, abstimmen (b)',
      'Schlitz- und Durchbruchspläne anfertigen (c)',
      'Terminplan fortschreiben (d)',
      'Ausführungsplanung auf Stand der Ausschreibung fortschreiben und übergeben (e)',
      'Montage- und Werkstattpläne prüfen und anerkennen (f)'],
    'LPH 6': [
      'Mengen als Grundlage für die Leistungsverzeichnisse ermitteln (a)',
      'Vergabeunterlagen mit Leistungsverzeichnissen inkl. Wartung aufstellen (b)',
      'Beim Abstimmen der Schnittstellen zu anderen Leistungsbeschreibungen mitwirken (c)',
      'Kosten anhand bepreister Leistungsverzeichnisse ermitteln (d)',
      'Kostenkontrolle: bepreiste LV mit Kostenberechnung vergleichen (e)',
      'Vergabeunterlagen zusammenstellen (f)'],
    'LPH 7': [
      'Angebote einholen (a)',
      'Angebote prüfen und werten, Preisspiegel aufstellen (b)',
      'Bietergespräche führen (c)',
      'Ausschreibungsergebnisse mit bepreisten LV und Kostenberechnung vergleichen (d)',
      'Vergabevorschläge erstellen, bei der Dokumentation mitwirken (e)',
      'Vertragsunterlagen zusammenstellen, bei der Auftragserteilung mitwirken (f)'],
    'LPH 8': [
      'Ausführung überwachen (Genehmigung, Verträge, Montagepläne, Regeln der Technik) (a)',
      'Bei der Koordination der Projektbeteiligten mitwirken (b)',
      'Terminplan (Balkendiagramm) aufstellen, fortschreiben, überwachen (c)',
      'Bauablauf dokumentieren (Bautagebuch) (d)',
      'Nachträge prüfen und bewerten (e)',
      'Gemeinsames Aufmaß mit den ausführenden Unternehmen (f)',
      'Rechnungsprüfung, Leistungsstand bescheinigen (g)',
      'Kostenkontrolle: Abrechnung mit Vertragspreisen und Kostenanschlag vergleichen (h)',
      'Kostenfeststellung (i)',
      'Bei Leistungs- und Funktionsprüfungen mitwirken (j)',
      'Fachtechnische Abnahme, Abnahmeprotokoll, Mängel feststellen (k)',
      'Behördliche Abnahmen beantragen und teilnehmen (l)',
      'Revisionsunterlagen auf Vollständigkeit prüfen (m)',
      'Verjährungsfristen der Mängelansprüche auflisten (n)',
      'Beseitigung der Abnahmemängel überwachen (o)',
      'Dokumentation, Zeichnungen und Berechnungen systematisch zusammenstellen (p)'],
    'LPH 9': [
      'Innerhalb der Verjährungsfristen festgestellte Mängel fachlich bewerten (a)',
      'Objektbegehung vor Ablauf der Verjährungsfristen (b)',
      'Bei der Freigabe von Sicherheitsleistungen mitwirken (c)'],
  },
};
function hoaiVorlagenEinfuegen(){
  const vorhanden = new Set(db.prepare('SELECT DISTINCT gewerk FROM lph_templates').all().map(r => r.gewerk));
  const ins = db.prepare(`INSERT INTO lph_templates (id, lph, gewerk, title, offset_days, duration_days, sort_order)
    VALUES (?, ?, ?, ?, 0, 0, ?)`);
  const ziele = [['ARCH', 'gebaeude'], ['ELT', 'technik'], ['HLS', 'technik']];
  db.exec('BEGIN');
  try {
    let n = 0;
    ziele.forEach(([gewerk, art]) => {
      if(vorhanden.has(gewerk)) return; // eigene Vorlagen nie überschreiben
      Object.entries(HOAI_GRUNDLEISTUNGEN[art]).forEach(([lph, titel]) => {
        titel.forEach((t, i) => { ins.run(crypto.randomUUID(), lph, gewerk, t, i); n++; });
      });
    });
    db.exec('COMMIT');
    if(n) console.log('Aufgaben-Vorlagen: ' + n + ' HOAI-Grundleistungen angelegt.');
  } catch(e){ db.exec('ROLLBACK'); throw e; }
}
einmaligeUmstellung('kommentar-spiegelstriche', kommentareSpiegelstricheUmstellen);
// kommentareInAktuelleSitzungUebernehmen: einmalig zur Einführung der
// Kommentar-Übernahme im Sitzungswechsel. Füllt in der jüngsten echten
// Sitzung jeden LEEREN Kommentar je Gewerk mit dem zuletzt geschriebenen aus
// einer früheren Sitzung (gleiche project_uid). Der Besprochen-Haken bleibt.
function kommentareInAktuelleSitzungUebernehmen(){
  const labels = db.prepare('SELECT label FROM weeks WHERE label != ?').all(SANDBOX_WEEK_LABEL)
    .map(r => r.label)
    .sort((a, b) => weekSortKeyServer(a).localeCompare(weekSortKeyServer(b)));
  if(labels.length < 2) return;
  const aktuell = labels[labels.length - 1];
  const rang = new Map(labels.map((l, i) => [l, i]));
  const projekte = db.prepare("SELECT project_id, project_uid FROM projects WHERE week_label = ? AND project_uid != ''").all(aktuell);
  const frueher = db.prepare(`SELECT k.week_label, k.gewerk, k.status, k.status_author, k.status_at
    FROM project_kommentare k JOIN projects p ON p.week_label = k.week_label AND p.project_id = k.project_id
    WHERE p.project_uid = ? AND k.week_label != ? AND k.week_label != ? AND trim(k.status) != ''`);
  const schreiben = db.prepare(`INSERT INTO project_kommentare (week_label, project_id, gewerk, status, status_author, status_at, besprochen)
    VALUES (?, ?, ?, ?, ?, ?, 0)
    ON CONFLICT(week_label, project_id, gewerk) DO UPDATE SET status = excluded.status,
      status_author = excluded.status_author, status_at = excluded.status_at
    WHERE trim(project_kommentare.status) = ''`);
  const jetzt = new Date().toISOString();
  let n = 0;
  db.exec('BEGIN');
  try {
    projekte.forEach(pr => {
      const juengste = new Map();
      frueher.all(pr.project_uid, aktuell, SANDBOX_WEEK_LABEL).forEach(r => {
        if(!rang.has(r.week_label)) return;
        const bisher = juengste.get(r.gewerk);
        if(!bisher || rang.get(r.week_label) > rang.get(bisher.week_label)) juengste.set(r.gewerk, r);
      });
      juengste.forEach((r, g) => {
        const erg = schreiben.run(aktuell, pr.project_id, g, r.status, r.status_author || '', r.status_at || '');
        if(erg.changes){
          n++;
          db.prepare('UPDATE projects SET updated_at = ? WHERE week_label = ? AND project_id = ?').run(jetzt, aktuell, pr.project_id);
        }
      });
    });
    if(n) db.prepare('UPDATE weeks SET updated_at = ? WHERE label = ?').run(jetzt, aktuell);
    db.exec('COMMIT');
    if(n) console.log('Kommentar-Übernahme: ' + n + ' Kommentar(e) in "' + aktuell + '" übernommen.');
  } catch(e){ db.exec('ROLLBACK'); throw e; }
}
einmaligeUmstellung('kommentare-uebernehmen', kommentareInAktuelleSitzungUebernehmen);
// SIEMON_ANTEILE: Teilleistungsbewertung nach dem Siemon-Gutachten zur
// HOAI 2021 (Anlagenband zum Gutachten 2021-1, Anlage 1.1 Gebäude und 1.7
// Technische Ausrüstung, veröffentlicht u. a. auf architektenhonorar.de):
// ein Wert je Grundleistung in Prozent des Gesamthonorars, Summe je Phase =
// HOAI-Prozentsatz. Löst die zuerst hinterlegten Mittelwerte der Spannen aus
// den Siemon-Tabellen 2013 ab (SIEMON_2013 unten, nur noch zum Erkennen
// unveränderter Werte bei der Umstellung) — Eriks Meldung „die Werte sind
// nicht richtig“.
const SIEMON_ANTEILE = {
  gebaeude: {
    'LPH 1': { a: 0.75, b: 0.10, c: 0.75, d: 0.25, e: 0.15 },
    'LPH 2': { a: 0.50, b: 0.10, c: 3.00, d: 0.85, e: 0.50, f: 0.30, g: 1.00, h: 0.50, i: 0.25 },
    'LPH 3': { a: 11.00, b: 1.15, c: 0.40, d: 0.20, e: 1.25, f: 0.35, g: 0.65 },
    'LPH 4': { a: 2.50, b: 0.25, c: 0.25 },
    'LPH 5': { a: 10.00, b: 9.50, c: 3.00, d: 0.85, e: 0.40, f: 1.25 },
    'LPH 6': { a: 0.20, b: 7.60, c: 0.35, d: 1.50, e: 0.25, f: 0.10 },
    'LPH 7': { a: 0.25, b: 0.10, c: 2.00, d: 0.25, e: 0.80, f: 0.10, g: 0.25, h: 0.25 },
    'LPH 8': { a: 18.00, b: 0.10, c: 1.50, d: 1.60, e: 0.75, f: 1.00, g: 3.75, h: 0.25, i: 0.85, j: 1.00,
               k: 1.50, l: 0.10, m: 0.25, n: 0.25, o: 0.10, p: 1.00 },
    'LPH 9': { a: 1.00, b: 0.80, c: 0.20 },
  },
  technik: {
    'LPH 1': { a: 1.50, b: 0.30, c: 0.20 },
    'LPH 2': { a: 0.80, b: 5.25, c: 1.00, d: 0.80, e: 0.20, f: 0.70, g: 0.25 },
    'LPH 3': { a: 5.50, b: 0.25, c: 9.95, d: 0.25, e: 0.15, f: 0.65, g: 0.10, h: 0.15 },
    'LPH 4': { a: 1.75, b: 0.25 },
    'LPH 5': { a: 4.50, b: 8.50, c: 4.00, d: 0.50, e: 0.50, f: 4.00 },
    'LPH 6': { a: 2.90, b: 3.05, c: 0.10, d: 0.75, e: 0.10, f: 0.10 },
    'LPH 7': { a: 0.10, b: 3.50, c: 0.50, d: 0.25, e: 0.50, f: 0.15 },
    'LPH 8': { a: 17.50, b: 0.30, c: 0.65, d: 0.50, e: 0.10, f: 2.25, g: 6.50, h: 0.85, i: 0.80, j: 0.50,
               k: 2.50, l: 0.10, m: 0.75, n: 0.10, o: 1.50, p: 0.10 },
    'LPH 9': { a: 0.50, b: 0.40, c: 0.10 },
  },
};
// SIEMON_2013: die zuerst eingetragenen Werte (Mittelwerte der Spannen der
// Siemon-Tabellen 2013, Buchstabe = „in x) enthalten“). Nur noch dafür da,
// bei der Umstellung auf 2021 zu erkennen, was niemand verändert hat.
const SIEMON_2013 = {
  gebaeude: {
    'LPH 1': { a: 0.875, b: 'a', c: 0.875, d: 'c', e: 0.3 },
    'LPH 2': { a: 0.375, b: 'a', c: 3.25, d: 1.5, e: 'd', f: 0.3, g: 1.125, h: 0.3, i: 0.3 },
    'LPH 3': { a: 11, b: 1, c: 0.5, d: 0.75, e: 1.5, f: 0.375, g: 0.375 },
    'LPH 4': { a: 3, b: 'a', c: 'a' },
    'LPH 5': { a: 11.5, b: 11.5, c: 'a,b', d: 0.5, e: 0.75, f: 'a,b' },
    'LPH 6': { a: 0.125, b: 8.5, c: 'b', d: 1.5, e: 'd', f: 'b' },
    'LPH 7': { a: 0.3, b: 0.125, c: 3.125, d: 'c', e: 'c', f: 0.175, g: 0.375, h: 0.125 },
    'LPH 8': { a: 21.5, b: 'a', c: 'a', d: 0.75, e: 0.375, f: 'g', g: 5.5, h: 1.25, i: 'h', j: 0.75,
               k: 2, l: 'k', m: 0.175, n: 'k', o: 'k', p: 0.875 },
    'LPH 9': { a: 0.625, b: 1.375, c: 'b' },
  },
  technik: {
    'LPH 1': { a: 0.875, b: 0.875, c: 0.175 },
    'LPH 2': { a: 0.375, b: 6, c: 'b', d: 1.5, e: 'd', f: 0.75, g: 0.175 },
    'LPH 3': { a: 5.5, b: 'a', c: 10.5, d: 0.175, e: 'a', f: 1.125, g: 'f', h: 0.175 },
    'LPH 4': { a: 2, b: 'a' },
    'LPH 5': { a: 5, b: 9.5, c: 3, d: 0.3, e: 0.75, f: 3 },
    'LPH 6': { a: 2.625, b: 3, c: 'a,b', d: 1.5, e: 'd', f: 'b' },
    'LPH 7': { a: 0.05, b: 3.875, c: 'b', d: 0.75, e: 'b', f: 0.175 },
    'LPH 8': { a: 19, b: 0.75, c: 0.375, d: 0.375, e: 0.5, f: 'g', g: 9, h: 1, i: 'h', j: 0.175,
               k: 3.25, l: 'k', m: 0.625, n: 'k', o: 0.875, p: 0.175 },
    'LPH 9': { a: 0.5, b: 0.625, c: 'b' },
  },
};
// siemon2021Umstellen: ersetzt die Werte von 2013 durch die von 2021 — nur
// dort, wo noch genau der 2013 eingetragene Wert steht (selbst Gepflegtes
// bleibt). Einmalig (einmaligeUmstellung('siemon-anteile-2021')).
function siemon2021Umstellen(){
  const art = { ARCH: 'gebaeude', ELT: 'technik', HLS: 'technik' };
  const upd = db.prepare("UPDATE lph_templates SET anteil = ?, enthalten_in = '' WHERE id = ?");
  let n = 0;
  db.exec('BEGIN');
  try {
    db.prepare('SELECT * FROM lph_templates').all().forEach(t => {
      const a = art[t.gewerk];
      const m = String(t.title).match(/\(([a-p])\)\s*$/);
      if(!a || !m) return;
      const alt = (SIEMON_2013[a][t.lph] || {})[m[1]];
      const neuW = (SIEMON_ANTEILE[a][t.lph] || {})[m[1]];
      if(alt === undefined || neuW === undefined) return;
      const unveraendert = typeof alt === 'number'
        ? (Math.abs((Number(t.anteil) || 0) - alt) < 1e-9 && !t.enthalten_in)
        : (t.enthalten_in === alt && !(Number(t.anteil) > 0));
      if(!unveraendert) return;
      upd.run(neuW, t.id); n++;
    });
    db.exec('COMMIT');
    if(n) console.log('Aufgaben-Vorlagen: ' + n + ' Anteile auf Siemon-Gutachten 2021 umgestellt.');
  } catch(e){ db.exec('ROLLBACK'); throw e; }
}
// siemonAnteileEintragen: trägt die Werte in die HOAI-Vorlagen ein — je
// Gewerk und Phase über den Buchstaben am Ende des Titels („… (c)“). Nur
// Schritte ohne Anteil und ohne „enthalten in“, also nie etwas, das jemand
// schon selbst gepflegt hat. Einmalig (einmaligeUmstellung).
function siemonAnteileEintragen(){
  const art = { ARCH: 'gebaeude', ELT: 'technik', HLS: 'technik' };
  const upd = db.prepare('UPDATE lph_templates SET anteil = ?, enthalten_in = ? WHERE id = ?');
  let n = 0;
  db.exec('BEGIN');
  try {
    db.prepare("SELECT * FROM lph_templates WHERE anteil = 0 AND enthalten_in = ''").all().forEach(t => {
      const tab = SIEMON_ANTEILE[art[t.gewerk]];
      const m = String(t.title).match(/\(([a-p])\)\s*$/);
      if(!tab || !tab[t.lph] || !m) return;
      const wert = tab[t.lph][m[1]];
      if(wert === undefined) return;
      if(typeof wert === 'number') upd.run(wert, '', t.id); else upd.run(0, wert, t.id);
      n++;
    });
    db.exec('COMMIT');
    if(n) console.log('Aufgaben-Vorlagen: Siemon-Anteile für ' + n + ' Schritte eingetragen.');
  } catch(e){ db.exec('ROLLBACK'); throw e; }
}
einmaligeUmstellung('hoai-aufgabenvorlagen', hoaiVorlagenEinfuegen);
einmaligeUmstellung('siemon-anteile', siemonAnteileEintragen);
einmaligeUmstellung('siemon-anteile-2021', siemon2021Umstellen);
// Idempotent (ein bereits entfernter Vorsatz ist weg) — läuft deshalb bei
// jedem Start und nach /import, damit ältere Backups ihn nicht zurückbringen.
kommentareVorsatzUmstellen();
ensureSandboxWeek();
ensureUserPersonIdUniqueIndex();
migrateRetirePeopleTablesIntoUsers();
// migrateAbsencesCreatedBy: ergänzt die Spalte created_by in bestehenden
// Datenbanken (idempotent). Altbestand behält 0 und ist damit nur von der
// betroffenen Person selbst oder von Administratoren löschbar.
(function migrateAbsencesCreatedBy(){
  try {
    const cols = db.prepare("SELECT name FROM pragma_table_info('user_absences')").all().map(r => r.name);
    if(!cols.includes('created_by')){
      db.exec("ALTER TABLE user_absences ADD COLUMN created_by INTEGER NOT NULL DEFAULT 0");
      console.log('Migriert: user_absences.created_by ergänzt.');
    }
  } catch(err){
    console.error('Migration user_absences.created_by fehlgeschlagen:', err.message);
  }
})();

bootstrapInitialAdmin();

// Abgelaufene Sitzungen beim Start entfernen. Sie wurden bisher nur ignoriert,
// blieben aber für immer in der Tabelle stehen — und damit auch in jedem
// Backup-Snapshot.
try {
  const removed = db.prepare('DELETE FROM user_sessions WHERE expires_at <= ?').run(new Date().toISOString());
  if(removed && removed.changes) console.log('Abgelaufene Sitzungen entfernt:', removed.changes);
} catch(err){
  console.error('Aufräumen der Sitzungen fehlgeschlagen:', err.message);
}

// ---------- Papierkorb gelöschter Projekte ----------
// deleted_projects: ein Schnappschuss (das vollständige Projekt-Objekt als
// JSON, wie es /load-all liefert — inkl. Terminplan, Beteiligten, LPH) je
// gelöschtem Projekt. Bewusst JSON statt relational: Der Eintrag wird nie
// abgefragt oder ausgewertet, nur 1:1 wieder in eine Sitzung eingesetzt.
// Dateien und Protokolle hängen an project_nr (nicht an der Projekt-ID) und
// werden beim Löschen gar nicht angefasst — nach dem Wiederherstellen sind
// sie deshalb ohne weiteres Zutun wieder da.
db.exec(`CREATE TABLE IF NOT EXISTS deleted_projects (
  id TEXT PRIMARY KEY,
  week_label TEXT NOT NULL DEFAULT '',
  project_id TEXT NOT NULL DEFAULT '',
  project_uid TEXT NOT NULL DEFAULT '',
  nr TEXT NOT NULL DEFAULT '',
  name TEXT NOT NULL DEFAULT '',
  data TEXT NOT NULL,
  deleted_by_user_id INTEGER NOT NULL DEFAULT 0,
  deleted_by_name TEXT NOT NULL DEFAULT '',
  deleted_at TEXT NOT NULL
)`);

// purgeGeloeschteProjekte: entfernt Papierkorb-Einträge, die älter als
// GELOESCHTE_PROJEKTE_TAGE sind. Läuft beim Start und stündlich mit dem
// Sitzungswechsel (siehe app.listen()).
function purgeGeloeschteProjekte(){
  try {
    const grenze = new Date(Date.now() - GELOESCHTE_PROJEKTE_TAGE * 24 * 60 * 60 * 1000).toISOString();
    const r = db.prepare('DELETE FROM deleted_projects WHERE deleted_at < ?').run(grenze);
    if(r && r.changes) console.log('Papierkorb: ' + r.changes + ' Projekt(e) nach ' + GELOESCHTE_PROJEKTE_TAGE + ' Tagen endgültig entfernt.');
  } catch(err){
    console.error('Aufräumen des Projekt-Papierkorbs fehlgeschlagen:', err.message);
  }
}
purgeGeloeschteProjekte();

// ---------- Auth: Sessions, Middleware, Endpunkte ----------

const SESSION_COOKIE = 'puebersicht_session';
// Gültigkeitsdauer einer Anmeldung. Vorgabe 30 Tage, firmenweit über den
// Schlüssel 'sessionTage' pflegbar (siehe sessionMaxAgeMs()).
const DEFAULT_SESSION_TAGE = 30;

// sessionMaxAgeMs: aktuelle Gültigkeitsdauer in Millisekunden. Wirkt auf neu
// erzeugte Sitzungen; bestehende behalten ihr gespeichertes expires_at.
function sessionMaxAgeMs(){
  return readAppSetting('sessionTage') * 24 * 60 * 60 * 1000;
}

// parseCookies: minimaler handgeschriebener Cookie-Parser (kein cookie-parser-
// Paket — Projekt-Konvention: nur express+cors als npm-Abhängigkeiten).
function parseCookies(req){
  const header = req.headers.cookie || '';
  const out = {};
  header.split(';').forEach(part => {
    const idx = part.indexOf('=');
    if(idx === -1) return;
    const k = part.slice(0, idx).trim();
    const v = part.slice(idx + 1).trim();
    if(k) out[k] = decodeURIComponent(v);
  });
  return out;
}

// setSessionCookie / clearSessionCookie: setzen bzw. löschen das Session-Cookie
// (HttpOnly, SameSite=Lax, 30 Tage Laufzeit, Secure nur bei HTTPS-Requests).
function setSessionCookie(res, token, req){
  const secure = req && req.secure ? '; Secure' : '';
  res.setHeader('Set-Cookie', `${SESSION_COOKIE}=${encodeURIComponent(token)}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${Math.floor(sessionMaxAgeMs()/1000)}${secure}`);
}

function clearSessionCookie(res){
  res.setHeader('Set-Cookie', `${SESSION_COOKIE}=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0`);
}

// attachUser: liest das Session-Cookie, lädt (falls gültig) Session+User und
// setzt req.user entsprechend (oder null). Läuft für JEDEN Request (auch vor
// dem statischen Datei-Ausliefern), damit spätere Routen sich stets auf
// req.user verlassen können. Aktualisiert nebenbei last_seen_at der Session.
function attachUser(req, res, next){
  req.user = null;
  const cookies = parseCookies(req);
  const token = cookies[SESSION_COOKIE];
  if(!token) return next();
  const row = db.prepare(`
    SELECT s.expires_at AS expires_at, u.id AS id, u.username AS username,
           u.display_name AS display_name, u.email AS email, u.role AS role,
           u.person_id AS person_id, u.active AS active,
           u.must_change_password AS must_change_password, u.department AS department,
           u.einfuehrung_am AS einfuehrung_am, u.dashboard_reihenfolge AS dashboard_reihenfolge
    FROM user_sessions s JOIN users u ON u.id = s.user_id
    WHERE s.token = ?
  `).get(token);
  if(!row || !row.active || row.expires_at <= new Date().toISOString()) return next();
  req.user = {
    id: row.id,
    username: row.username,
    displayName: row.display_name,
    email: row.email,
    role: row.role,
    personId: row.person_id,
    mustChangePassword: !!row.must_change_password,
    // department: das eigene Gewerk des Kontos — der Wochenbericht schlägt es
    // als Vorauswahl vor (js/wochenbericht/wochenbericht.js), damit man nicht
    // jedes Mal manuell das eigene Gewerk wählen muss.
    department: row.department || '',
    // einfuehrungFaellig: Rundgang noch nicht abgeschlossen (js/einfuehrung.js)
    einfuehrungFaellig: !row.einfuehrung_am,
    // dashboardReihenfolge: eigene Projektreihenfolge auf "Meine Aufgaben"
    dashboardReihenfolge: (() => { try { const a = JSON.parse(row.dashboard_reihenfolge || '[]'); return Array.isArray(a) ? a : []; } catch(e){ return []; } })()
  };
  // last_seen_at höchstens einmal je Minute und Sitzung schreiben. Vorher
  // schrieb JEDE Anfrage — auch jede der rund 60 JS/CSS-Dateien eines
  // Seitenaufrufs — in die Datenbank; auf der SD-Karte des Pi der größte
  // Teil der Ladezeit.
  const jetzt = Date.now();
  if(jetzt - (sitzungZuletztGeschrieben.get(token) || 0) > 60 * 1000){
    sitzungZuletztGeschrieben.set(token, jetzt);
    try {
      db.prepare('UPDATE user_sessions SET last_seen_at = ? WHERE token = ?').run(new Date(jetzt).toISOString(), token);
    } catch(err){
      console.error('Konnte last_seen_at nicht aktualisieren:', err);
    }
  }
  next();
}
const sitzungZuletztGeschrieben = new Map();
// (Registrierung via app.use(attachUser) erfolgt bewusst weiter oben, direkt
// nach express.json() und vor express.static — siehe dort.)

// requireAuth / requireRole: Middleware-Fabriken für spätere Phasen, die damit
// bestehende Routen absichern. In dieser Phase werden sie auf KEINE bestehende
// Route angewendet.
function requireAuth(req, res, next){
  if(!req.user) return res.status(401).json({ ok:false, error:'Nicht angemeldet.' });
  // Rollen ohne „Anwendung nutzen“ (früher fest: 'kiosk') sind überall, wo
  // requireAuth genügte, bewusst AUSGESCHLOSSEN — sie dürfen nichts schreiben
  // und nichts lesen, was die Wandtafel nicht selbst braucht. Die wenigen
  // Routen, die sie braucht, nutzen requireAuthOderKiosk statt requireAuth.
  if(istNurWandtafel(req.user.role)) return res.status(403).json({ ok:false, error:'Dieses Konto hat nur Lesezugriff für die Wandtafel.' });
  next();
}
// requireAuthOderKiosk: wie requireAuth, lässt zusätzlich die Kiosk-Rolle zu —
// ausschließlich für die wenigen Routen, die ein Kiosk-Konto selbst braucht:
// die lesenden Routen, die die Wandtafel beim Laden aufruft (GET /load-all,
// /app-settings, /holidays, /honorar-config), /logout (ein Kiosk-Konto darf
// sich abmelden können, auch wenn die Oberfläche dort aktuell keinen Knopf
// dafür zeigt) sowie /change-password und /change-email (auf das EIGENE
// Konto beschränkt — jedes neu angelegte Konto, auch ein Kiosk-Konto, trägt
// must_change_password und MUSS sein Passwort beim ersten Login ändern
// können, sonst bliebe der erzwungene Dialog für immer unerfüllbar).
function requireAuthOderKiosk(req, res, next){
  if(!req.user) return res.status(401).json({ ok:false, error:'Nicht angemeldet.' });
  next();
}
function requireRole(role){
  return function(req, res, next){
    if(!req.user) return res.status(401).json({ ok:false, error:'Nicht angemeldet.' });
    if(req.user.role !== role) return res.status(403).json({ ok:false, error:'Keine Berechtigung.' });
    next();
  };
}

// Route: Login — prüft Benutzername/Passwort, legt bei Erfolg eine neue Session
// an und setzt das Session-Cookie. Liefert bei falschem Benutzernamen, falschem
// Passwort oder inaktivem Konto absichtlich dieselbe Fehlermeldung (kein
// Username-Enumeration-Unterschied).
// loginAttempts: Fehlversuche je Absender-Adresse (nur im Arbeitsspeicher,
// kein Zustand in der Datenbank). Nach den eingestellten Fehlversuchen ist
// die Anmeldung für die eingestellte Dauer gesperrt — ohne diese Bremse kann ein
// Passwort beliebig oft durchprobiert werden.
const loginAttempts = new Map();
// Vorgaben der Anmeldebremse; firmenweit über 'loginMaxVersuche' und
// 'loginSperreMinuten' pflegbar (siehe loginMaxAttempts()/loginBlockMs()).
const DEFAULT_LOGIN_MAX_ATTEMPTS = 10;
const DEFAULT_LOGIN_BLOCK_MINUTEN = 10;
function loginMaxAttempts(){ return readAppSetting('loginMaxVersuche'); }
function loginBlockMs(){ return readAppSetting('loginSperreMinuten') * 60 * 1000; }

// Schlüssel aus Benutzername UND Absender-Adresse: Nur nach der Adresse zu
// sperren würde im Büro alle hinter derselben Leitung aussperren, sobald sich
// eine Person zehnmal vertippt. So ist immer nur das betroffene Konto von
// dieser Stelle aus gebremst.
// Schlüssel aus der NORMALISIERTEN Kennung (wie sie /login auch sucht: ohne
// "@…", ohne Leerzeichen, klein) — sonst bekam jede Schreibweise
// ("x@a.de", " x") einen eigenen Zähler und die Sperre ließ sich beliebig
// umgehen. Die Adresse kommt nur noch aus der Verbindung selbst: Der
// Header X-Forwarded-For ist frei wählbar, und vor diesem Server steht kein
// Proxy, der ihn setzen würde.
function loginKennung(username){
  const eingabe = String(username || '').trim();
  return (eingabe.includes('@') ? eingabe.slice(0, eingabe.indexOf('@')) : eingabe).trim().toLowerCase();
}
function loginClientKey(req, username){
  const ip = String(req.socket.remoteAddress || 'unbekannt');
  return loginKennung(username) + '|' + ip;
}

function loginIsBlocked(key){
  const entry = loginAttempts.get(key);
  if(!entry) return false;
  if(Date.now() - entry.first > loginBlockMs()){ loginAttempts.delete(key); return false; }
  return entry.count >= loginMaxAttempts();
}

function loginNoteFailure(key){
  const entry = loginAttempts.get(key);
  if(!entry || Date.now() - entry.first > loginBlockMs()) loginAttempts.set(key, { count: 1, first: Date.now() });
  else entry.count++;
}

app.post('/login', (req, res) => {
  const { username, password } = req.body || {};
  if(!username || !password) return res.status(400).json({ ok:false, error:'Benutzername und Passwort erforderlich.' });
  // Nur Zeichenketten — eine Zahl ließ scrypt mit 500 abbrechen.
  if(typeof username !== 'string' || typeof password !== 'string'){
    return res.status(400).json({ ok:false, error:'Benutzername und Passwort erforderlich.' });
  }
  const clientKey = loginClientKey(req, username);
  if(loginIsBlocked(clientKey)){
    return res.status(429).json({ ok:false, error:'Zu viele Fehlversuche. Bitte in einigen Minuten erneut versuchen.' });
  }
  // Benutzername = Anfang der E-Mail-Adresse (z. B. e.dunin). Wer die
  // ganze Adresse eintippt, wird ebenso erkannt (alles ab "@" fällt weg),
  // und Groß-/Kleinschreibung spielt keine Rolle ("E.Dunin").
  const kennung = loginKennung(username);
  const row = db.prepare('SELECT * FROM users WHERE username = ? COLLATE NOCASE').get(kennung);
  // Auch bei unbekanntem Benutzernamen einmal hashen: Sonst verrät die
  // Antwortzeit (scrypt läuft bewusst langsam), welche Konten es gibt.
  const salt = row ? row.password_salt : 'unbekannt';
  const expected = row ? row.password_hash : crypto.scryptSync('x', 'unbekannt', 64).toString('hex');
  const passwordOk = verifyPassword(password, salt, expected);
  if(!row || !row.active || !passwordOk){
    loginNoteFailure(clientKey);
    return res.status(401).json({ ok:false, error:'Benutzername oder Passwort falsch.' });
  }
  loginAttempts.delete(clientKey);
  const token = crypto.randomBytes(32).toString('hex');
  const now = new Date().toISOString();
  const expiresAt = new Date(Date.now() + sessionMaxAgeMs()).toISOString();
  db.prepare('INSERT INTO user_sessions (token, user_id, created_at, last_seen_at, expires_at) VALUES (?,?,?,?,?)')
    .run(token, row.id, now, now, expiresAt);
  setSessionCookie(res, token, req);
  res.json({
    ok: true,
    user: {
      id: row.id,
      username: row.username,
      displayName: row.display_name,
      role: row.role,
      personId: row.person_id,
      mustChangePassword: !!row.must_change_password
    }
  });
});

// Route: Logout — löscht die Session des aktuellen Cookies und leert das Cookie.
app.post('/logout', requireAuthOderKiosk, (req, res) => {
  const cookies = parseCookies(req);
  const token = cookies[SESSION_COOKIE];
  if(token) db.prepare('DELETE FROM user_sessions WHERE token = ?').run(token);
  clearSessionCookie(res);
  res.json({ ok:true });
});

// Route: liefert den aktuell angemeldeten Benutzer (oder null) — Basis für das
// clientseitige Login-Overlay.
app.get('/whoami', (req, res) => {
  // rechte/rolleName: für die Oberfläche (Knöpfe ein-/ausblenden). Die
  // eigentliche Grenze sind requireRecht()/hatRecht() an den Routen.
  const user = req.user ? Object.assign({}, req.user, {
    rechte: rechteDerRolle(req.user.role),
    rolleName: (rollenCache.get(req.user.role) || {}).name || req.user.role
  }) : null;
  res.json({ ok:true, user });
});

// POST /einfuehrung {erledigt: true}: Rundgang abgeschlossen bzw.
// übersprungen — nur für das eigene Konto. Neu starten lässt er sich jederzeit
// unter Einstellungen, ohne diesen Stand zu ändern.
app.post('/einfuehrung', requireAuth, (req, res) => {
  try {
    const wert = (req.body || {}).erledigt === false ? '' : new Date().toISOString();
    db.prepare('UPDATE users SET einfuehrung_am = ? WHERE id = ?').run(wert, req.user.id);
    res.json({ ok: true });
  } catch(err){ console.error('Einführung speichern fehlgeschlagen:', err); res.status(500).json({ ok: false, error: String(err) }); }
});

// POST /dashboard-reihenfolge {reihenfolge:[schlüssel]} — eigene Reihenfolge
// der Projekte auf "Meine Aufgaben"; leere Liste = wie in der Projektliste.
// Nur das eigene Konto.
app.post('/dashboard-reihenfolge', requireAuth, (req, res) => {
  try {
    const liste = (req.body || {}).reihenfolge;
    if(!Array.isArray(liste)) return res.status(400).json({ ok: false, error: 'reihenfolge muss eine Liste sein.' });
    const sauber = [...new Set(liste.map(x => String(x || '').slice(0, 100)).filter(Boolean))].slice(0, 500);
    db.prepare('UPDATE users SET dashboard_reihenfolge = ? WHERE id = ?').run(sauber.length ? JSON.stringify(sauber) : '', req.user.id);
    res.json({ ok: true, reihenfolge: sauber });
  } catch(err){ console.error('Dashboard-Reihenfolge speichern fehlgeschlagen:', err); res.status(500).json({ ok: false, error: String(err) }); }
});

// ---------- Rollen & Rechte: Routen ----------
// GET liefert Katalog und Rollen (mit Anzahl Konten) — jedes angemeldete
// Konto mit Grundzugang, weil die Benutzerverwaltung die Liste für ihre
// Rollenauswahl braucht. Ändern nur mit Recht „Rollen & Rechte“.
function rollenAntwort(){
  const zaehl = new Map(db.prepare('SELECT role, COUNT(*) AS n FROM users WHERE active = 1 GROUP BY role').all().map(r => [r.role, r.n]));
  return {
    ok: true,
    katalog: RECHTE.map(g => ({ gruppe: g.gruppe, rechte: g.rechte.map(([key, name, hinweis]) => ({ key, name, hinweis })) })),
    rollen: [...rollenCache.values()].map(r => ({ key: r.key, name: r.name, fest: r.fest, konten: zaehl.get(r.key) || 0, rechte: rechteDerRolle(r.key) }))
  };
}
app.get('/rollen', requireAuth, (req, res) => {
  try { res.json(rollenAntwort()); }
  catch(err){ console.error('Rollen laden fehlgeschlagen:', err); res.status(500).json({ ok: false, error: String(err) }); }
});

// POST /rollen {name, vonRolle?}: neue Rolle, optional mit den Rechten einer
// bestehenden. Der Schlüssel wird aus dem Namen gebildet (a-z, 0-9, -).
app.post('/rollen', requireRecht('a.rollen'), (req, res) => {
  try {
    const name = String((req.body || {}).name || '').trim();
    if(!name) return res.status(400).json({ ok: false, error: 'Name fehlt.' });
    if([...rollenCache.values()].some(r => r.name.toLowerCase() === name.toLowerCase())){
      return res.status(409).json({ ok: false, error: 'Eine Rolle mit diesem Namen gibt es schon.' });
    }
    const basis = name.toLowerCase().replace(/ä/g, 'ae').replace(/ö/g, 'oe').replace(/ü/g, 'ue').replace(/ß/g, 'ss')
      .replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 30) || 'rolle';
    let key = basis, i = 2;
    while(rollenCache.has(key)) key = basis + '-' + (i++);
    const von = (req.body || {}).vonRolle ? String(req.body.vonRolle) : '';
    if(von && !rolleExistiert(von)) return res.status(400).json({ ok: false, error: 'Unbekannte Vorlage-Rolle.' });
    const sort = (db.prepare('SELECT MAX(sort_order) AS m FROM roles').get().m || 0) + 1;
    db.exec('BEGIN');
    try {
      db.prepare('INSERT INTO roles (key, name, sort_order, fest) VALUES (?, ?, ?, 0)').run(key, name, sort);
      const ins = db.prepare('INSERT OR IGNORE INTO role_rechte (role_key, recht) VALUES (?, ?)');
      (von ? rechteDerRolle(von) : []).forEach(r => ins.run(key, r));
      db.exec('COMMIT');
    } catch(e){ db.exec('ROLLBACK'); throw e; }
    ladeRollen();
    res.json(Object.assign(rollenAntwort(), { neu: key }));
  } catch(err){ console.error('Rolle anlegen fehlgeschlagen:', err); res.status(500).json({ ok: false, error: String(err) }); }
});

// PATCH /rollen/:key {name}: umbenennen. Administrator bleibt, wie er ist.
app.patch('/rollen/:key', requireRecht('a.rollen'), (req, res) => {
  try {
    const r = rollenCache.get(String(req.params.key));
    if(!r) return res.status(404).json({ ok: false, error: 'Rolle nicht gefunden.' });
    if(r.fest) return res.status(400).json({ ok: false, error: 'Die Rolle Administrator ist fest.' });
    const name = String((req.body || {}).name || '').trim();
    if(!name) return res.status(400).json({ ok: false, error: 'Name fehlt.' });
    if([...rollenCache.values()].some(x => x.key !== r.key && x.name.toLowerCase() === name.toLowerCase())){
      return res.status(409).json({ ok: false, error: 'Eine Rolle mit diesem Namen gibt es schon.' });
    }
    db.prepare('UPDATE roles SET name = ? WHERE key = ?').run(name, r.key);
    ladeRollen();
    res.json(rollenAntwort());
  } catch(err){ console.error('Rolle umbenennen fehlgeschlagen:', err); res.status(500).json({ ok: false, error: String(err) }); }
});

// PUT /rollen/:key/rechte {rechte:[…], an:true|false}: setzt oder entzieht
// ein oder mehrere Rechte (ein Schalter oder „alle/keine“ einer Gruppe).
app.put('/rollen/:key/rechte', requireRecht('a.rollen'), (req, res) => {
  try {
    const r = rollenCache.get(String(req.params.key));
    if(!r) return res.status(404).json({ ok: false, error: 'Rolle nicht gefunden.' });
    if(r.fest) return res.status(400).json({ ok: false, error: 'Die Rolle Administrator hat immer alle Rechte.' });
    const liste = Array.isArray((req.body || {}).rechte) ? req.body.rechte.map(String) : [];
    if(!liste.length || liste.some(k => !RECHT_KEYS.has(k))) return res.status(400).json({ ok: false, error: 'Unbekanntes Recht.' });
    const an = !!req.body.an;
    // Sich selbst „Rollen & Rechte“ zu entziehen, sperrte einen sofort aus.
    if(!an && r.key === req.user.role && liste.includes('a.rollen')){
      return res.status(400).json({ ok: false, error: 'Du kannst deiner eigenen Rolle „Rollen & Rechte“ nicht entziehen.' });
    }
    const stmt = an
      ? db.prepare('INSERT OR IGNORE INTO role_rechte (role_key, recht) VALUES (?, ?)')
      : db.prepare('DELETE FROM role_rechte WHERE role_key = ? AND recht = ?');
    db.exec('BEGIN');
    try { liste.forEach(k => stmt.run(r.key, k)); db.exec('COMMIT'); }
    catch(e){ db.exec('ROLLBACK'); throw e; }
    ladeRollen();
    res.json(rollenAntwort());
  } catch(err){ console.error('Rechte setzen fehlgeschlagen:', err); res.status(500).json({ ok: false, error: String(err) }); }
});

// DELETE /rollen/:key: nur ohne zugeordnete Konten (auch deaktivierte).
app.delete('/rollen/:key', requireRecht('a.rollen'), (req, res) => {
  try {
    const r = rollenCache.get(String(req.params.key));
    if(!r) return res.json(rollenAntwort());
    if(r.fest) return res.status(400).json({ ok: false, error: 'Die Rolle Administrator kann nicht gelöscht werden.' });
    const konten = db.prepare('SELECT display_name FROM users WHERE role = ? ORDER BY display_name').all(r.key).map(x => x.display_name);
    if(konten.length){
      return res.status(409).json({ ok: false, error: 'Der Rolle sind noch Konten zugeordnet: ' + konten.join(', ') + '. Erst eine andere Rolle zuweisen.' });
    }
    db.exec('BEGIN');
    try {
      db.prepare('DELETE FROM role_rechte WHERE role_key = ?').run(r.key);
      db.prepare('DELETE FROM roles WHERE key = ?').run(r.key);
      db.exec('COMMIT');
    } catch(e){ db.exec('ROLLBACK'); throw e; }
    ladeRollen();
    res.json(rollenAntwort());
  } catch(err){ console.error('Rolle löschen fehlgeschlagen:', err); res.status(500).json({ ok: false, error: String(err) }); }
});

// Route: Passwort ändern — verlangt immer das aktuelle Passwort (auch bei
// erzwungenem must_change_password), neues Passwort muss mind. 8 Zeichen haben.
app.post('/change-password', requireAuthOderKiosk, (req, res) => {
  const { currentPassword, newPassword } = req.body || {};
  if(!currentPassword || !newPassword || typeof currentPassword !== 'string' || typeof newPassword !== 'string'){
    return res.status(400).json({ ok:false, error:'Aktuelles und neues Passwort erforderlich.' });
  }
  if(newPassword.length < 8) return res.status(400).json({ ok:false, error:'Neues Passwort muss mindestens 8 Zeichen haben.' });
  const row = db.prepare('SELECT * FROM users WHERE id = ?').get(req.user.id);
  if(!row || !verifyPassword(currentPassword, row.password_salt, row.password_hash)){
    return res.status(401).json({ ok:false, error:'Aktuelles Passwort falsch.' });
  }
  const { hash, salt } = hashPassword(newPassword);
  db.prepare('UPDATE users SET password_hash = ?, password_salt = ?, must_change_password = 0, updated_at = ? WHERE id = ?')
    .run(hash, salt, new Date().toISOString(), row.id);
  res.json({ ok:true });
});

// Route: eigene E-Mail-Adresse ändern — im Unterschied zu Anzeigename, Rolle
// und Personen-Zuordnung (weiterhin nur PATCH /admin/users/:id) pflegt jedes
// Konto seine E-Mail selbst, deshalb hier statt in der Admin-Benutzerverwaltung.
// Kein Formatzwang (wie auch beim Admin-Pfad) — nur eine leere Eingabe wird
// abgelehnt, das Leeren des Feldes geschieht wie gehabt über die
// Benutzerverwaltung.
app.post('/change-email', requireAuthOderKiosk, (req, res) => {
  const { email } = req.body || {};
  const trimmed = String(email || '').trim();
  if(!trimmed) return res.status(400).json({ ok:false, error:'E-Mail-Adresse erforderlich.' });
  db.prepare('UPDATE users SET email = ?, updated_at = ? WHERE id = ?')
    .run(trimmed, new Date().toISOString(), req.user.id);
  res.json({ ok:true, email: trimmed });
});

// ---------- Admin-Benutzerverwaltung ----------
//
// Alle Routen dieses Abschnitts verlangen das Recht „Benutzerverwaltung“ und
// dienen dem Abschnitt Benutzerverwaltung des Bereichs Admin. Sie legen
// Benutzerkonten an, ändern sie, setzen Passwörter zurück und löschen Konten
// (Soft-Delete standardmäßig, Hard-Delete nur ohne Referenzen in
// project_files/project_file_reviewers/project_file_comments).

// parseCapacityHours: prüft die vertraglichen Wochenstunden eines Kontos.
// Leer/undefiniert ergibt 0 = "nicht gepflegt"; das Frontend rechnet dann mit
// einer vollen Stelle, damit Bestandskonten ihr bisheriges Auslastungsbild
// behalten. Rückgabe: Zahl 0–80 oder null bei unbrauchbarer Eingabe.
function parseCapacityHours(value){
  if(value === undefined || value === null || value === '') return 0;
  const n = Number(value);
  if(!Number.isFinite(n) || n < 0 || n > 80) return null;
  return n;
}

// generateRandomPassword: erzeugt ein zufälliges Klartext-Passwort für neu
// angelegte Accounts bzw. einen Passwort-Reset (gleiche Methode wie
// bootstrapInitialAdmin).
function generateRandomPassword(){
  return crypto.randomBytes(15).toString('base64url');
}

// serializeUserRow: wandelt eine users-Zeile in die öffentliche Repräsentation
// um (OHNE password_hash/password_salt).
function serializeUserRow(row){
  return {
    id: row.id,
    username: row.username,
    displayName: row.display_name,
    firstName: row.first_name || '',
    lastName: row.last_name || '',
    email: row.email,
    role: row.role,
    personId: row.person_id,
    department: row.department,
    initials: row.initials,
    capacityHours: Number(row.capacity_hours) || 0,
    active: !!row.active,
    mustChangePassword: !!row.must_change_password,
    createdAt: row.created_at,
    updatedAt: row.updated_at,
  };
}

// loadUserRolesByUserId: Batch-Query aller user_roles, gruppiert nach user_id
// (analog zum bestehenden Muster in loadGlobalPeople() für person_roles) —
// vermeidet eine Einzelabfrage pro Zeile in GET /admin/users bzw. GET /users.
function loadUserRolesByUserId(){
  const rows = db.prepare('SELECT * FROM user_roles ORDER BY role_order').all();
  const byUser = {};
  rows.forEach(r => { (byUser[r.user_id] = byUser[r.user_id] || []).push(r.role); });
  return byUser;
}

// Route: Liste aller Benutzer (ohne Passwortfelder), sortiert nach Benutzername.
app.get('/admin/users', requireRecht('a.benutzer'), (req, res) => {
  try {
    const rows = db.prepare('SELECT * FROM users ORDER BY username').all();
    const rolesByUser = loadUserRolesByUserId();
    res.json({ ok: true, users: rows.map(r => Object.assign(serializeUserRow(r), { roles: rolesByUser[r.id] || [] })) });
  } catch(err){
    console.error('Admin-Benutzerliste fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Abwesenheiten eines einzelnen Benutzers, sortiert nach Start-Datum.
// GET /admin/users liefert bewusst keine Abwesenheiten mit (würde die Liste
// unnötig aufblähen) — das Bearbeiten-Modal in admin-users.js lädt sie beim
// Öffnen separat über diese Route nach.
app.get('/admin/users/:id/absences', requireRecht('a.benutzer'), (req, res) => {
  const id = Number(req.params.id);
  try {
    const rows = db.prepare('SELECT id, start, end, type, note FROM user_absences WHERE user_id = ? ORDER BY start').all(id);
    res.json({ ok: true, absences: rows });
  } catch(err){
    console.error('Abwesenheiten laden fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Legt einen neuen Benutzer an. Passwort entweder explizit (mind. 8
// Zeichen) oder automatisch generiert (generatePassword: true); in jedem Fall
// muss der neue Account beim ersten Login sein Passwort ändern. `personId`
// wird 1:1 vom Client übernommen (Berechnung/Vorschau via personIdForName()
// passiert clientseitig).
app.post('/admin/users', requireRecht('a.benutzer'), (req, res) => {
  const { username, email, role, personId, department, initials, capacityHours, roles, password, generatePassword } = req.body || {};
  const firstName = String((req.body || {}).firstName || '').trim();
  const lastName = String((req.body || {}).lastName || '').trim();
  // Anzeigename = "Vorname Nachname"; ältere Clients schicken nur displayName.
  const displayName = (firstName || lastName) ? [firstName, lastName].filter(Boolean).join(' ') : String((req.body || {}).displayName || '').trim();
  if(!username || !String(username).trim()) return res.status(400).json({ ok: false, error: 'Benutzername erforderlich.' });
  if(!displayName) return res.status(400).json({ ok: false, error: 'Vor- und Nachname erforderlich.' });
  if(db.prepare('SELECT id FROM users WHERE username = ? COLLATE NOCASE').get(String(username).trim())){
    return res.status(409).json({ ok: false, error: 'Benutzername bereits vergeben.' });
  }
  const finalRole = role ? String(role) : 'member';
  if(!rolleExistiert(finalRole)) return res.status(400).json({ ok: false, error: 'Ungültige Rolle.' });
  // Administrator vergibt nur, wer selbst Administrator ist — sonst könnte
  // sich eine Rolle mit „Benutzerverwaltung“ selbst alle Rechte verschaffen.
  if(rollenCache.get(finalRole).fest && !(rollenCache.get(req.user.role) || {}).fest){
    return res.status(403).json({ ok: false, error: 'Nur ein Administrator kann die Rolle Administrator vergeben.' });
  }
  if(typeof department !== 'string' || !VALID_DEPARTMENTS.has(department)){
    return res.status(400).json({ ok: false, error: 'Ungültige oder fehlende Abteilung.' });
  }
  const roleList = Array.isArray(roles) ? roles : [];
  for(const r of roleList){
    if(!VALID_DISCIPLINE_ROLES.has(r)) return res.status(400).json({ ok: false, error: 'Ungültige Rolle: ' + r });
  }
  // Ein Kiosk-Konto hat keine Fachrolle — es erscheint in keinem
  // Projektboard und wird keiner Rolle zugeordnet, die Felder wären also
  // ohnehin wirkungslos; ihr Setzen wird deshalb zurückgewiesen statt
  // stillschweigend ignoriert.
  if(istNurWandtafel(finalRole) && roleList.length > 0){
    return res.status(400).json({ ok: false, error: 'Ein reines Wandtafel-Konto kann keine Fachrolle haben.' });
  }
  // capacityHours: vertragliche Wochenstunden (Teilzeit). 0 bzw. keine
  // Angabe heißt "nicht gepflegt" — das Frontend rechnet dann mit einer
  // vollen Stelle weiter.
  const capacity = parseCapacityHours(capacityHours);
  if(capacity === null) return res.status(400).json({ ok: false, error: 'Wochenstunden müssen zwischen 0 und 80 liegen.' });

  let plainPassword;
  if(generatePassword === true){
    plainPassword = generateRandomPassword();
  } else if(typeof password === 'string' && password){
    if(password.length < 8) return res.status(400).json({ ok: false, error: 'Passwort muss mindestens 8 Zeichen haben.' });
    plainPassword = password;
  } else {
    return res.status(400).json({ ok: false, error: 'Passwort erforderlich (manuell oder generatePassword).' });
  }

  const { hash, salt } = hashPassword(plainPassword);
  const now = new Date().toISOString();
  try {
    const info = db.prepare(`INSERT INTO users
      (username, display_name, first_name, last_name, email, role, person_id, department, initials, capacity_hours, password_hash, password_salt, active, must_change_password, created_at, updated_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, 1, ?, ?)`)
      .run(String(username).trim(), displayName, firstName, lastName, String(email || ''), finalRole, String(personId || ''), department, String(initials || ''), capacity, hash, salt, now, now);
    const insRole = db.prepare('INSERT INTO user_roles (user_id, role, role_order) VALUES (?, ?, ?)');
    roleList.forEach((r, idx) => insRole.run(info.lastInsertRowid, r, idx));
    const row = db.prepare('SELECT * FROM users WHERE id = ?').get(info.lastInsertRowid);
    const result = { ok: true, user: Object.assign(serializeUserRow(row), { roles: roleList }) };
    result.sitzungGeaendert = kontenInAktuelleSitzung([row.id]) > 0;
    if(generatePassword === true) result.generatedPassword = plainPassword;
    res.json(result);
  } catch(err){
    if(err && String(err.message || '').includes('person_id')){
      return res.status(409).json({ ok: false, error: 'Person-ID bereits vergeben.' });
    }
    if(err && String(err.message || '').includes('UNIQUE')){
      return res.status(409).json({ ok: false, error: 'Benutzername bereits vergeben.' });
    }
    console.error('Benutzer anlegen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Aktualisiert einen bestehenden Benutzer (nur die übergebenen Felder).
// Schützt einen Admin davor, sich selbst zu deaktivieren oder zu degradieren.
app.patch('/admin/users/:id', requireRecht('a.benutzer'), (req, res) => {
  const id = Number(req.params.id);
  const row = db.prepare('SELECT * FROM users WHERE id = ?').get(id);
  if(!row) return res.status(404).json({ ok: false, error: 'Benutzer nicht gefunden.' });

  const { displayName, email, role, active, personId, department, initials, capacityHours, roles } = req.body || {};
  if(role !== undefined && !rolleExistiert(role)){
    return res.status(400).json({ ok: false, error: 'Ungültige Rolle.' });
  }
  // Administrator vergeben oder entziehen darf nur ein Administrator.
  const ichAdmin = !!(rollenCache.get(req.user.role) || {}).fest;
  const zielAdminVorher = !!(rollenCache.get(row.role) || {}).fest;
  if(role !== undefined && String(role) !== row.role && !ichAdmin
     && (zielAdminVorher || (rollenCache.get(String(role)) || {}).fest)){
    return res.status(403).json({ ok: false, error: 'Nur ein Administrator kann die Rolle Administrator vergeben oder entziehen.' });
  }
  if(department !== undefined && !VALID_DEPARTMENTS.has(department)){
    return res.status(400).json({ ok: false, error: 'Ungültige Abteilung.' });
  }
  let capacity;
  if(capacityHours !== undefined){
    capacity = parseCapacityHours(capacityHours);
    if(capacity === null) return res.status(400).json({ ok: false, error: 'Wochenstunden müssen zwischen 0 und 80 liegen.' });
  }
  let roleList;
  if(roles !== undefined){
    roleList = Array.isArray(roles) ? roles : [];
    for(const r of roleList){
      if(!VALID_DISCIPLINE_ROLES.has(r)) return res.status(400).json({ ok: false, error: 'Ungültige Rolle: ' + r });
    }
  }
  // Ein Kiosk-Konto hat keine Fachrolle — geprüft gegen die Rolle UND die
  // Fachrollen-Liste, wie sie nach diesem PATCH jeweils gelten würden (eines
  // von beiden kann unverändert bleiben, wenn es im Body fehlt).
  const effectiveRole = role !== undefined ? String(role) : row.role;
  if(istNurWandtafel(effectiveRole)){
    const effectiveRoles = roles !== undefined
      ? roleList
      : db.prepare('SELECT role FROM user_roles WHERE user_id = ?').all(id).map(r => r.role);
    if(effectiveRoles.length > 0){
      return res.status(400).json({ ok: false, error: 'Ein reines Wandtafel-Konto kann keine Fachrolle haben.' });
    }
  }
  const isSelf = req.user.id === id;
  const wouldDeactivate = active !== undefined && !active;
  // Degradierung schließt jeden Wechsel WEG von admin ein, nicht nur zu
  // 'member' — sonst gäbe es für den Selbstschutz eine Kiosk-förmige Lücke.
  const wouldDemote = role !== undefined && zielAdminVorher && !(rollenCache.get(String(role)) || {}).fest;
  if(isSelf && (wouldDeactivate || wouldDemote)){
    return res.status(400).json({ ok: false, error: 'Sie können sich nicht selbst deaktivieren oder degradieren.' });
  }
  // Der letzte aktive Administrator bleibt: sonst kann niemand mehr Rollen
  // und Rechte pflegen.
  if(zielAdminVorher && row.active && (wouldDeactivate || wouldDemote)){
    const festRollen = [...rollenCache.values()].filter(r => r.fest).map(r => r.key);
    const n = db.prepare(`SELECT COUNT(*) AS n FROM users WHERE active = 1 AND role IN (${festRollen.map(() => '?').join(',')})`).get(...festRollen).n;
    if(n <= 1) return res.status(400).json({ ok: false, error: 'Der letzte aktive Administrator kann nicht deaktiviert oder herabgestuft werden.' });
  }

  const fields = [];
  const values = [];
  const { firstName, lastName } = req.body || {};
  if(firstName !== undefined || lastName !== undefined){
    // Vor-/Nachname setzen auch den Anzeigenamen — er ist ihre Verbindung.
    const alt = db.prepare('SELECT first_name, last_name FROM users WHERE id = ?').get(id) || {};
    const vn = firstName !== undefined ? String(firstName).trim() : (alt.first_name || '');
    const nn = lastName !== undefined ? String(lastName).trim() : (alt.last_name || '');
    if(!vn && !nn) return res.status(400).json({ ok: false, error: 'Vor- und Nachname erforderlich.' });
    fields.push('first_name = ?', 'last_name = ?', 'display_name = ?');
    values.push(vn, nn, [vn, nn].filter(Boolean).join(' '));
  } else if(displayName !== undefined){ fields.push('display_name = ?'); values.push(String(displayName)); }
  if(email !== undefined){ fields.push('email = ?'); values.push(String(email)); }
  if(role !== undefined){ fields.push('role = ?'); values.push(role); }
  if(active !== undefined){ fields.push('active = ?'); values.push(active ? 1 : 0); }
  if(personId !== undefined){ fields.push('person_id = ?'); values.push(String(personId)); }
  if(department !== undefined){ fields.push('department = ?'); values.push(department); }
  if(initials !== undefined){ fields.push('initials = ?'); values.push(String(initials)); }
  if(capacity !== undefined){ fields.push('capacity_hours = ?'); values.push(capacity); }
  const now = new Date().toISOString();
  fields.push('updated_at = ?'); values.push(now);
  values.push(id);
  try {
    db.prepare(`UPDATE users SET ${fields.join(', ')} WHERE id = ?`).run(...values);
    // Neue Person-ID: in der laufenden Sitzung und der Planung-Sandbox
    // mitziehen. Sonst legte kontenInAktuelleSitzung() die Person unter der
    // neuen ID ein zweites Mal an, und ihre Zuordnungen, Aufgaben und
    // Anwesenheit hingen weiter an der alten. Ältere Sitzungen bleiben
    // Historie (wie beim endgültigen Löschen).
    const alteId = String(row.person_id || ''), neueId = personId !== undefined ? String(personId) : alteId;
    if(alteId && neueId && alteId !== neueId){
      const echte = db.prepare('SELECT label FROM weeks WHERE label != ?').all(SANDBOX_WEEK_LABEL).map(r => r.label)
        .sort((a, b) => weekSortKeyServer(a).localeCompare(weekSortKeyServer(b)));
      [echte[echte.length - 1], SANDBOX_WEEK_LABEL].filter(Boolean).forEach(w => {
        ['week_people','week_people_roles','attendance','project_assign','plan_todo_assignees','plan_people'].forEach(t => {
          db.prepare(`UPDATE OR IGNORE ${t} SET person_id = ? WHERE week_label = ? AND person_id = ?`).run(neueId, w, alteId);
          db.prepare(`DELETE FROM ${t} WHERE week_label = ? AND person_id = ?`).run(w, alteId);
        });
        db.prepare('UPDATE weeks SET updated_at = ? WHERE label = ?').run(new Date().toISOString(), w);
      });
    }
    if(roleList !== undefined){
      db.prepare('DELETE FROM user_roles WHERE user_id = ?').run(id);
      const insRole = db.prepare('INSERT INTO user_roles (user_id, role, role_order) VALUES (?, ?, ?)');
      roleList.forEach((r, idx) => insRole.run(id, r, idx));
    }
    // Deaktivierung erzwingt sofortigen Logout (alle Sessions löschen).
    if(wouldDeactivate){
      db.prepare('DELETE FROM user_sessions WHERE user_id = ?').run(id);
      offenePruefungenAufraeumen(id);
    }
    const updated = db.prepare('SELECT * FROM users WHERE id = ?').get(id);
    const updatedRoles = roleList !== undefined ? roleList : (loadUserRolesByUserId()[id] || []);
    const sitzungGeaendert = kontenInAktuelleSitzung([id]) > 0;
    res.json({ ok: true, user: Object.assign(serializeUserRow(updated), { roles: updatedRoles }), sitzungGeaendert });
  } catch(err){
    if(err && String(err.message || '').includes('person_id')){
      return res.status(409).json({ ok: false, error: 'Person-ID bereits vergeben.' });
    }
    console.error('Benutzer aktualisieren fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Setzt das Passwort eines Benutzers auf ein neues Zufallspasswort
// zurück, erzwingt eine Passwortänderung beim nächsten Login und löscht alle
// bestehenden Sessions (erzwingt Neuanmeldung).
app.post('/admin/users/:id/reset-password', requireRecht('a.benutzer'), (req, res) => {
  const id = Number(req.params.id);
  const row = db.prepare('SELECT * FROM users WHERE id = ?').get(id);
  if(!row) return res.status(404).json({ ok: false, error: 'Benutzer nicht gefunden.' });
  const plainPassword = generateRandomPassword();
  const { hash, salt } = hashPassword(plainPassword);
  const now = new Date().toISOString();
  try {
    db.prepare('UPDATE users SET password_hash = ?, password_salt = ?, must_change_password = 1, updated_at = ? WHERE id = ?')
      .run(hash, salt, now, id);
    db.prepare('DELETE FROM user_sessions WHERE user_id = ?').run(id);
    res.json({ ok: true, generatedPassword: plainPassword });
  } catch(err){
    console.error('Passwort zurücksetzen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Löscht einen Benutzer. Standardmäßig Soft-Delete (active = 0 +
// Sessions löschen, erzwingt Logout); mit `?hard=1` endgültiges Löschen,
// sofern der Benutzer nirgends referenziert wird (project_files.uploaded_by_user_id,
// project_file_reviewers.user_id, project_file_comments.user_id — diese Tabellen
// sind schon angelegt, aber aktuell noch leer). Ein Admin kann sich selbst
// weder soft- noch hard-löschen.
// loescheBenutzerEndgueltig: entfernt ein Konto samt seiner Verweise, in
// einer Transaktion. Auf Eriks Wunsch verschwindet die Person dabei aus den
// Projekten und damit aus der Auslastung — aber nur in der AKTUELLEN Sitzung
// (jüngste echte Woche) und in den Planung-Terminplänen. Ältere Sitzungen
// sind Historie (Verlauf im Wochenbericht) und bleiben unverändert.
// Welche Kennungen gemeint sind, bestimmt je Woche personenKennungenInWoche():
// users.person_id UND jede Kennung im Teilnehmerkreis dieser Woche mit
// demselben vollen Namen — Altbestand trägt Kurzkennungen (p_ap statt
// p_alexander_plum), an denen die Zuordnungen hängen; dieselbe Brücke
// über den Namen nutzt kapazitaetsFaktor() in public/js/load/load.js.
// Entfernt werden dort: Teilnehmerkreis
// (week_people/_roles), Anwesenheit, Projektzuordnungen (project_assign —
// daraus rechnet die Auslastung), Beteiligte des Terminplans (plan_people)
// und Aufgaben-Zuständigkeiten (plan_todo_assignees). Die betroffenen
// Wochen bekommen eine neue Revision, damit ein Browser mit altem Stand
// beim nächsten Speichern einen Konflikt bekommt und neu lädt, statt die
// Person wieder hineinzuschreiben.
// Dateien: Hochgeladene Dateien und Kommentare bleiben und erscheinen als
// „Gelöschter Benutzer" (LEFT JOIN + COALESCE in den Datei-Abfragen).
// Prüfaufträge an die Person werden entfernt und der Gesamtstatus der
// betroffenen, noch offenen Dateien neu berechnet (dieselbe Regel wie in
// POST /project-files/:id/review). Sitzungen, Rollen, Abwesenheiten und
// KI-Schlüssel fallen per ON DELETE CASCADE mit weg.
// Rückgabe: Zähler dessen, was entfernt wurde.
function personenKennungenInWoche(row, woche){
  const ids = new Set();
  if(row.person_id) ids.add(String(row.person_id));
  const name = String(row.display_name || '').trim();
  if(name){
    db.prepare('SELECT person_id FROM week_people WHERE week_label = ? AND full_name = ?').all(woche, name)
      .forEach(r => ids.add(r.person_id));
  }
  return [...ids].filter(Boolean);
}

// kontenInAktuelleSitzung: trägt aktive Konten in den Teilnehmerkreis der
// AKTUELLEN Sitzung (jüngste echte Woche) ein bzw. gleicht dort Kürzel,
// Name und Fachrollen mit dem Konto ab. Der Teilnehmerkreis einer Sitzung
// ist eine Kopie, die beim Sitzungswechsel entsteht — ein später angelegtes
// Konto fehlte darin, und der Assistent "Neues Projekt" bot niemanden an
// (aufgefallen auf einer frisch aufgesetzten Datenbank, deren Sitzung vor den
// Konten entstand). Ältere Sitzungen bleiben als Historie unberührt.
// userIds: nur diese Konten; ohne Angabe alle aktiven (Abgleich beim Start).
// Bei einer Änderung bekommt die Woche eine neue Revision, damit ein Browser
// mit altem Stand neu lädt, statt die Person beim Speichern wieder zu tilgen.
function kontenInAktuelleSitzung(userIds){
  const echte = db.prepare('SELECT label FROM weeks WHERE label != ?').all(SANDBOX_WEEK_LABEL).map(r => r.label)
    .sort((a, b) => weekSortKeyServer(a).localeCompare(weekSortKeyServer(b)));
  const woche = echte[echte.length - 1];
  if(!woche) return 0;
  const filter = Array.isArray(userIds) ? new Set(userIds.map(Number)) : null;
  // Kiosk-Konten (Wandtafel) gehören nicht in den Teilnehmerkreis: Sie
  // haben keine Fachrolle und könnten keine Aufgabe je bearbeiten.
  const konten = db.prepare(`SELECT * FROM users WHERE active = 1 AND person_id != '' AND ${sqlOhneWandtafel()}`).all()
    .filter(u => !filter || filter.has(u.id));
  let geaendert = 0;
  db.exec('BEGIN');
  try {
    // Bereits eingetragene Kiosk-Konten wieder austragen — solange sie keinem
    // Projekt der Sitzung zugeordnet sind (dann bleibt die Zuordnung lesbar).
    db.prepare(`SELECT person_id FROM users WHERE NOT (${sqlOhneWandtafel()}) AND person_id != ''`).all().forEach(k => {
      const zugeordnet = db.prepare('SELECT 1 FROM project_assign WHERE week_label = ? AND person_id = ? AND state > 0 LIMIT 1').get(woche, k.person_id);
      if(zugeordnet) return;
      const weg = db.prepare('DELETE FROM week_people WHERE week_label = ? AND person_id = ?').run(woche, k.person_id).changes;
      if(weg){
        db.prepare('DELETE FROM week_people_roles WHERE week_label = ? AND person_id = ?').run(woche, k.person_id);
        db.prepare('DELETE FROM attendance WHERE week_label = ? AND person_id = ?').run(woche, k.person_id);
        geaendert++;
      }
    });
    konten.forEach(u => {
      const rollen = db.prepare('SELECT role FROM user_roles WHERE user_id = ? ORDER BY role_order').all(u.id).map(r => r.role);
      const kuerzel = u.initials || u.username;
      const da = db.prepare('SELECT * FROM week_people WHERE week_label = ? AND person_id = ?').get(woche, u.person_id);
      const alteRollen = db.prepare('SELECT role FROM week_people_roles WHERE week_label = ? AND person_id = ? ORDER BY role_order')
        .all(woche, u.person_id).map(r => r.role);
      if(da && da.name === kuerzel && da.full_name === u.display_name && alteRollen.join('|') === rollen.join('|')) return;
      if(da){
        db.prepare('UPDATE week_people SET name = ?, full_name = ? WHERE week_label = ? AND person_id = ?')
          .run(kuerzel, u.display_name, woche, u.person_id);
      } else {
        const ende = db.prepare('SELECT COALESCE(MAX(array_order), -1) + 1 n FROM week_people WHERE week_label = ?').get(woche).n;
        db.prepare('INSERT INTO week_people (week_label, person_id, name, full_name, array_order) VALUES (?, ?, ?, ?, ?)')
          .run(woche, u.person_id, kuerzel, u.display_name, ende);
      }
      db.prepare('DELETE FROM week_people_roles WHERE week_label = ? AND person_id = ?').run(woche, u.person_id);
      const insRolle = db.prepare('INSERT INTO week_people_roles (week_label, person_id, role, role_order) VALUES (?, ?, ?, ?)');
      rollen.forEach((r, i) => insRolle.run(woche, u.person_id, r, i));
      geaendert++;
    });
    if(geaendert) db.prepare('UPDATE weeks SET updated_at = ? WHERE label = ?').run(new Date().toISOString(), woche);
    db.exec('COMMIT');
  } catch(err){
    db.exec('ROLLBACK');
    console.error('Teilnehmerkreis der aktuellen Sitzung konnte nicht abgeglichen werden:', err);
    return 0;
  }
  if(geaendert) console.log(`Teilnehmerkreis "${woche}": ${geaendert} Konto/Konten eingetragen bzw. abgeglichen.`);
  return geaendert;
}

// offenePruefungenAufraeumen: nimmt ein deaktiviertes Konto aus den noch
// offenen Dateiprüfungen und berechnet deren Gesamtstatus neu. Ohne das blieb
// eine Datei, deren Prüfer deaktiviert wurde, für immer "ausstehend" — die
// übrigen Prüfer konnten zustimmen, so viel sie wollten. War das Konto der
// EINZIGE Prüfer, bleibt die Prüfung stehen (eine Datei ganz ohne Prüfer
// wäre ebenso festgefahren; nach einer Reaktivierung geht es dort weiter).
// Parameter: userId. Keine Rückgabe.
function offenePruefungenAufraeumen(userId){
  const jetzt = new Date().toISOString();
  const offen = db.prepare(`SELECT r.file_id FROM project_file_reviewers r JOIN project_files f ON f.id = r.file_id
    WHERE r.user_id = ? AND r.decision = 'pending' AND f.status = 'pending'`).all(userId);
  offen.forEach(({ file_id }) => {
    const andere = db.prepare('SELECT decision FROM project_file_reviewers WHERE file_id = ? AND user_id != ?').all(file_id, userId).map(r => r.decision);
    if(!andere.length) return;
    db.prepare('DELETE FROM project_file_reviewers WHERE file_id = ? AND user_id = ?').run(file_id, userId);
    let status = 'pending';
    if(andere.some(d => d === 'rejected')) status = 'rejected';
    else if(andere.every(d => d === 'approved')) status = 'approved';
    if(status !== 'pending') db.prepare('UPDATE project_files SET status = ?, updated_at = ? WHERE id = ?').run(status, jetzt, file_id);
  });
}

function loescheBenutzerEndgueltig(row){
  const echte = db.prepare('SELECT label FROM weeks WHERE label != ?').all(SANDBOX_WEEK_LABEL).map(r => r.label)
    .sort((a, b) => weekSortKeyServer(a).localeCompare(weekSortKeyServer(b)));
  const wochen = [echte[echte.length - 1], SANDBOX_WEEK_LABEL].filter(Boolean);
  const zaehler = { zuordnungen: 0, aufgaben: 0, pruefauftraege: 0 };
  const jetzt = new Date().toISOString();

  db.exec('BEGIN');
  try {
    wochen.forEach(w => {
      const ids = personenKennungenInWoche(row, w);
      if(!ids.length) return;
      ids.forEach(pid => {
        zaehler.zuordnungen += db.prepare('DELETE FROM project_assign WHERE week_label = ? AND person_id = ?').run(w, pid).changes;
        zaehler.aufgaben += db.prepare('DELETE FROM plan_todo_assignees WHERE week_label = ? AND person_id = ?').run(w, pid).changes;
        ['plan_people', 'week_people_roles', 'week_people', 'attendance'].forEach(t => {
          db.prepare(`DELETE FROM ${t} WHERE week_label = ? AND person_id = ?`).run(w, pid);
        });
      });
      db.prepare('UPDATE weeks SET updated_at = ? WHERE label = ?').run(jetzt, w);
    });

    const dateien = db.prepare('SELECT file_id FROM project_file_reviewers WHERE user_id = ?').all(row.id).map(r => r.file_id);
    zaehler.pruefauftraege = db.prepare('DELETE FROM project_file_reviewers WHERE user_id = ?').run(row.id).changes;
    dateien.forEach(fileId => {
      const datei = db.prepare('SELECT status FROM project_files WHERE id = ?').get(fileId);
      if(!datei || datei.status !== 'pending') return;
      const entscheidungen = db.prepare('SELECT decision FROM project_file_reviewers WHERE file_id = ?').all(fileId).map(r => r.decision);
      let status = 'pending';
      if(entscheidungen.some(d => d === 'rejected')) status = 'rejected';
      else if(entscheidungen.length > 0 && entscheidungen.every(d => d === 'approved')) status = 'approved';
      if(status !== 'pending') db.prepare('UPDATE project_files SET status = ?, updated_at = ? WHERE id = ?').run(status, jetzt, fileId);
    });

    db.prepare('DELETE FROM users WHERE id = ?').run(row.id);
    db.exec('COMMIT');
  } catch(err){
    db.exec('ROLLBACK');
    throw err;
  }
  return zaehler;
}

app.delete('/admin/users/:id', requireRecht('a.benutzer'), (req, res) => {
  const id = Number(req.params.id);
  const row = db.prepare('SELECT * FROM users WHERE id = ?').get(id);
  if(!row) return res.status(404).json({ ok: false, error: 'Benutzer nicht gefunden.' });
  if(req.user.id === id) return res.status(400).json({ ok: false, error: 'Sie können Ihren eigenen Account nicht löschen.' });

  const hard = req.query.hard === '1';
  try {
    if(hard){
      const ergebnis = loescheBenutzerEndgueltig(row);
      console.log('Benutzer endgültig gelöscht:', row.username, ergebnis);
      return res.json(Object.assign({ ok: true, hard: true }, ergebnis));
    }
    const now = new Date().toISOString();
    db.prepare('UPDATE users SET active = 0, updated_at = ? WHERE id = ?').run(now, id);
    db.prepare('DELETE FROM user_sessions WHERE user_id = ?').run(id);
    offenePruefungenAufraeumen(id);
    res.json({ ok: true, hard: false });
  } catch(err){
    console.error('Benutzer löschen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Speichert eine komplette Woche (als JSON-Objekt) für eine Abteilung
app.post('/save-week', requireAuth, (req, res) => {
  const { week, baseUpdatedAt } = req.body || {};
  if(!week || typeof week.label !== 'string' || !week.label) return res.status(400).json({ ok: false, error: 'Missing week or label' });
  // Auftragsstatus prüfen, BEVOR irgendetwas geschrieben wird: /save-week ist
  // der einzige Schreibweg für Projektdaten, ein unbekannter Wert bliebe also
  // dauerhaft stehen (siehe findInvalidAuftragsstatus()).
  const badStatus = findInvalidAuftragsstatus(week);
  if(badStatus){
    return res.status(400).json({
      ok: false,
      error: 'Unbekannter Auftragsstatus "' + badStatus.wert + '" am Projekt '
        + ((badStatus.nr ? badStatus.nr + ' ' : '') + badStatus.name).trim()
        + '. Erlaubt: ' + Array.from(VALID_AUFTRAGSSTATUS).join(', ') + '.'
    });
  }
  try {
    // Revisions-/Konflikt-Check: Mit `baseUpdatedAt` meldet der Client die
    // Version, auf der seine lokalen Daten beruhen. Ist die Woche auf dem
    // 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.
    // Sperr-Status serverseitig durchsetzen: Eine gesperrte Sitzung darf NUR
    // über /unlock-week (Recht „Sitzung entsperren“) wieder geöffnet werden. Das
    // Sperren selbst (false -> true) bleibt jedem erlaubt, weil es die
    // Auto-Sperre des Clients (applyAutoLock(), public/js/weeks.js) beim
    // normalen Speichern mitschreibt. Ohne diese Prüfung wäre die Sperre reine
    // Client-Logik: ein beliebiges Mitglied könnte die Woche mit locked:false
    // zurückschreiben und die Admin-Grenze umgehen.
    const lockRow = db.prepare('SELECT locked FROM weeks WHERE label = ?').get(String(week.label));
    if(lockRow && lockRow.locked && !week.locked && !hatRecht(req.user, 's.gesperrt')){
      return res.status(403).json({
        ok: false,
        error: 'Die Sitzung "' + week.label + '" ist gesperrt. Nur Administratoren können sie wieder öffnen.'
      });
    }
    // Auch der INHALT einer gesperrten Sitzung ist für Nicht-Admins tabu —
    // bisher wurde nur das Entsperren abgewiesen, Kommentare und Aufgaben
    // einer gesperrten Woche ließen sich über die API weiter ändern. Als 409
    // (Konflikt) statt 403: Ein Browser, der die Woche noch offen glaubt (etwa
    // weil der Sitzungswechsel sie inzwischen gesperrt hat), lädt sie dann neu
    // und zeigt sie gesperrt, statt in einer Fehlerschleife zu hängen.
    // Das Mitschreiben der Auto-Sperre ist nicht betroffen: Es trifft nur
    // Wochen, die am Server noch offen sind.
    if(lockRow && lockRow.locked && !hatRecht(req.user, 's.gesperrt')){
      const stand = db.prepare('SELECT updated_at FROM weeks WHERE label = ?').get(String(week.label));
      return res.status(409).json({
        ok: false, conflict: true,
        error: 'Die Sitzung "' + week.label + '" ist gesperrt und kann nicht mehr geändert werden.',
        updatedAt: stand ? stand.updated_at : ''
      });
    }

    if(typeof baseUpdatedAt === 'string'){
      const row = db.prepare('SELECT updated_at FROM weeks WHERE label = ?').get(String(week.label));
      if(row){
        if(baseUpdatedAt !== row.updated_at){
          return res.status(409).json({
            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: ''
        });
      }
    }
    // Angelegte und gelöschte Projekte erkennen: /save-week schreibt immer
    // die ganze Woche, beides ist also nur am Vergleich mit dem gespeicherten
    // Stand zu sehen (projektlisteAenderungen()). Nur Projektleiter und
    // Administratoren dürfen das (403 sonst, bevor irgendetwas geschrieben
    // wird); gelöschte Projekte wandern in den Papierkorb
    // (deleted_projects). Die Planung-Sandbox ist ausgenommen — ihre
    // Terminpläne sind keine Projekte der Projektliste und werden dort von
    // jedem angelegt und gelöscht.
    // Jede Projekt-id und jede projectUid darf in einer Woche nur einmal
    // vorkommen. Eine doppelte id ließ das Speichern mit 500 (UNIQUE) scheitern;
    // eine doppelte uid ließ eine Kopie eines bestehenden Projekts als
    // "bekannt" durchgehen — so konnte auch ein Mitglied Projekte anlegen,
    // und das spätere Löschen der Kopie landete nicht im Papierkorb.
    {
      const ids = new Set(), uids = new Set();
      for(const p of (Array.isArray(week.projects) ? week.projects : []).filter(Boolean)){
        const id = String(p.id || ''), uid = String(p.projectUid || '');
        if((id && ids.has(id)) || (uid && uids.has(uid))){
          return res.status(400).json({ ok: false, error: 'Ein Projekt kommt in der Sitzung doppelt vor (' + String(p.nr || p.name || id) + ').' });
        }
        if(id) ids.add(id);
        if(uid) uids.add(uid);
      }
    }
    const aenderung = week.label === SANDBOX_WEEK_LABEL
      ? { neu: [], entfernt: [] } : projektlisteAenderungen(week);
    const entfernt = aenderung.entfernt;
    if((aenderung.neu.length || entfernt.length) && !darfProjektlisteAendern(req.user)){
      return res.status(403).json({
        ok: false,
        error: aenderung.neu.length
          ? 'Keine Berechtigung: „Projekte anlegen und löschen“ fehlt.'
          : 'Keine Berechtigung: „Projekte anlegen und löschen“ fehlt.',
        recht: 'proj.anlegen'
      });
    }
    {
      const fehlt = fehlendesBearbeitungsrecht(req.user, week.label, week.projects, week);
      if(fehlt) return rechtFehlt(res, fehlt);
    }

    // Zuständige VOR dem Speichern festhalten — danach lassen sich neu
    // hinzugekommene erkennen (neueZuweisungenMelden()). Eine Woche, die es
    // noch nicht gab, meldet nichts: Sie entsteht als Ganzes, nicht durch
    // eine Zuweisung.
    const wocheGabEs = !!db.prepare('SELECT 1 FROM weeks WHERE label = ?').get(String(week.label));
    const alteZuweisungen = new Set(db.prepare('SELECT todo_id, person_id FROM plan_todo_assignees WHERE week_label = ?')
      .all(String(week.label)).map(r => r.todo_id + '|' + r.person_id));

    // `updatedAt` zurückgeben, damit der Client seine lokale Revisions-Basis
    // aktualisieren kann (verhindert falsche Eigen-Konflikte beim nächsten Save).
    const updatedAt = saveWeekRelational(week);
    if(entfernt.length) legeInPapierkorb(entfernt, week.label, req.user);
    if(wocheGabEs) neueZuweisungenMelden(week, alteZuweisungen, req.user, req);
    console.log('Saved week:', week.label);
    ereignisSenden({ typ: 'woche', label: week.label, updatedAt }, req);
    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) });
  }
});

// ---------- Teams: persönliche Nachricht bei neuen Aufgaben ----------
//
// Eriks Wunsch: Wird jemandem eine Aufgabe zugewiesen, bekommt GENAU DIESE
// Person in Teams eine Nachricht (Einzelchat mit dem Flow-Bot) mit Link
// direkt auf die Aufgabe im Projekt — nicht der ganze Kanal (Eriks Wahl
// „nur persönlich“). Dafür legt man in Teams einen Workflow an: Auslöser
// „Bei Empfang einer Teams-Webhookanforderung“, Aktion „Karte in einem Chat
// oder Kanal veröffentlichen“ als Flow-Bot im Chat, Empfänger
// triggerBody()?['empfaenger'], Karte string(triggerBody()?['karte']). Die
// Adresse des Auslösers trägt ein Admin unter Admin → Teams ein (Recht
// a.teams). Die App schickt je Person {empfaenger: E-Mail, karte: Adaptive
// Card}; Empfänger ist users.email (muss dem Teams-Anmeldenamen
// entsprechen). Personen ohne Konto oder E-Mail bekommen nichts. Die Adresse ist ein
// Geheimnis (wer sie kennt, kann in den Kanal schreiben) — sie steht in
// `integrationen`, nicht in app_settings (das jedes Konto lesen darf), und
// geht nie an den Browser zurück. Nicht in IMPORT_TABLES.
//
// Senden braucht Internetzugang nach außen; ein Fehler wird nur geloggt,
// das Speichern der Sitzung scheitert nie daran.

db.exec(`CREATE TABLE IF NOT EXISTS integrationen (
  schluessel TEXT PRIMARY KEY,
  wert TEXT NOT NULL DEFAULT ''
)`);

function integrationLesen(k){
  const r = db.prepare('SELECT wert FROM integrationen WHERE schluessel = ?').get(k);
  return r ? r.wert : '';
}
function integrationSchreiben(k, v){
  db.prepare('INSERT INTO integrationen (schluessel, wert) VALUES (?, ?) ON CONFLICT(schluessel) DO UPDATE SET wert = excluded.wert')
    .run(k, String(v));
}

// teamsKarte: die Adaptive Card selbst (der Workflow legt sie in den Chat).
function teamsKarte(titel, zeilen, fakten, link, linkText){
  const body = [{ type: 'TextBlock', text: titel, weight: 'Bolder', size: 'Medium', wrap: true }];
  zeilen.forEach(z => body.push({ type: 'TextBlock', text: z, wrap: true, spacing: 'Small' }));
  if(fakten.length) body.push({ type: 'FactSet', facts: fakten.map(([title, value]) => ({ title, value })) });
  return {
    $schema: 'http://adaptivecards.io/schemas/adaptive-card.json',
    type: 'AdaptiveCard', version: '1.4', body,
    actions: link ? [{ type: 'Action.OpenUrl', title: linkText || 'Öffnen', url: link }] : []
  };
}

// teamsSenden: an die eingetragene Adresse schicken. Rückgabe: Promise —
// wirft bei Fehler (für den Test-Knopf); Aufrufer im Hintergrund fangen ab.
async function teamsSenden(nachricht, url){
  const ziel = url || integrationLesen('teams_webhook');
  if(!ziel) throw new Error('Keine Teams-Adresse eingetragen.');
  const res = await fetchMitTimeout(ziel, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(nachricht)
  });
  if(!res.ok){
    const t = await res.text().catch(() => '');
    throw new Error('Teams antwortete mit HTTP ' + res.status + (t ? ': ' + t.slice(0, 200) : ''));
  }
}

// aufgabenLink: Adresse der Aufgabe im Projekt (der Browser öffnet sie direkt
// im Aufgaben-Panel, Parameter aufgabe=). Host aus der speichernden Anfrage —
// also die Adresse, unter der die App im Büro aufgerufen wird.
function aufgabenLink(req, weekLabel, p, todoId){
  if(!req) return '';
  const u = new URL('/Projektplan/' + encodeURIComponent(p.name || ''), req.protocol + '://' + req.get('host'));
  u.searchParams.set('weekLabel', weekLabel);
  u.searchParams.set('projNr', p.nr || '');
  u.searchParams.set('aufgabe', String(todoId));
  u.hash = 'aufgaben';
  return u.toString();
}

function teamsDatum(iso){
  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(String(iso || ''));
  return m ? m[3] + '.' + m[2] + '.' + m[1] : '';
}

// teamsNeueAufgaben: je Aufgabe mit neu Zuständigen EINE Nachricht. neu =
// Map todoId -> { p, t, personen:[ids] }. Läuft im Hintergrund.
// teamsNeueAufgaben: je neu zuständiger PERSON eine Nachricht an sie selbst.
// neu = Map todoId -> { p, t, personen:[person_ids] }. Läuft im Hintergrund.
function teamsNeueAufgaben(weekLabel, neu, user, req){
  if(!neu.size || integrationLesen('teams_neue_aufgaben') !== '1' || !integrationLesen('teams_webhook')) return;
  const namen = new Map(db.prepare('SELECT person_id, name, full_name FROM week_people WHERE week_label = ?').all(weekLabel)
    .map(r => [r.person_id, r.full_name || r.name || r.person_id]));
  const konto = db.prepare(`SELECT email FROM users WHERE person_id = ? AND person_id != '' AND active = 1 AND email != '' AND ${sqlOhneWandtafel()}`);
  const von = (user && (user.displayName || user.username)) || '';
  neu.forEach(({ p, t, personen }) => {
    const wer = personen.map(id => namen.get(id) || id).join(', ');
    const zeitraum = t.start && t.end && t.start !== t.end ? teamsDatum(t.start) + ' – ' + teamsDatum(t.end) : '';
    const fakten = [['Projekt', [p.nr, p.name].filter(Boolean).join(' ')]];
    if(personen.length > 1) fakten.push(['Zuständig', wer]);
    if(t.end) fakten.push(['Fällig', teamsDatum(t.end)]);
    if(zeitraum) fakten.push(['Zeitraum', zeitraum]);
    if(Number(t.aufwand) > 0) fakten.push(['Aufwand', String(t.aufwand).replace('.', ',') + ' h']);
    if(von) fakten.push(['Zugewiesen von', von]);
    const karte = teamsKarte('Neue Aufgabe für Sie: ' + (t.title || 'Aufgabe'), [], fakten,
      aufgabenLink(req, weekLabel, p, t.id), 'Aufgabe öffnen');
    personen.forEach(pid => {
      const k = konto.get(pid);
      if(!k){ console.log('Teams: keine E-Mail für', namen.get(pid) || pid, '— keine Nachricht'); return; }
      teamsSenden({ empfaenger: k.email, karte })
        .catch(err => console.warn('Teams-Nachricht an', k.email, 'nicht gesendet:', err.message));
    });
  });
}

app.get('/admin/teams', requireRecht('a.teams'), (req, res) => {
  const url = integrationLesen('teams_webhook');
  let host = '';
  try { host = url ? new URL(url).host : ''; } catch(e){ /* egal */ }
  res.json({ ok: true, konfiguriert: !!url, host, neueAufgaben: integrationLesen('teams_neue_aufgaben') === '1' });
});

// PUT {webhook?, neueAufgaben?} — webhook '' entfernt die Adresse.
app.put('/admin/teams', requireRecht('a.teams'), (req, res) => {
  try {
    const b = req.body || {};
    if(typeof b.webhook === 'string'){
      const w = b.webhook.trim();
      if(w){
        let u;
        try { u = new URL(w); } catch(e){ return res.status(400).json({ ok: false, error: 'Das ist keine gültige Adresse.' }); }
        if(u.protocol !== 'https:') return res.status(400).json({ ok: false, error: 'Die Teams-Adresse muss mit https:// beginnen.' });
      }
      integrationSchreiben('teams_webhook', w);
    }
    if(typeof b.neueAufgaben === 'boolean') integrationSchreiben('teams_neue_aufgaben', b.neueAufgaben ? '1' : '0');
    res.json({ ok: true });
  } catch(err){
    console.error('Teams-Einstellung speichern fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// POST /admin/teams/test — Testnachricht; Fehler als {ok:false, error} mit
// HTTP 200 (ein fehlgeschlagener Test ist ein erwartetes Ergebnis).
// Die Testnachricht geht an den Admin selbst (seine E-Mail aus dem Konto).
app.post('/admin/teams/test', requireRecht('a.teams'), async (req, res) => {
  try {
    const email = (db.prepare('SELECT email FROM users WHERE id = ?').get(req.user.id) || {}).email || '';
    if(!email) return res.json({ ok: false, error: 'Ihr Konto hat keine E-Mail-Adresse — die braucht Teams, um Sie zu finden (Einstellungen → Mein Konto).' });
    const link = req.protocol + '://' + req.get('host') + '/';
    await teamsSenden({ empfaenger: email, karte: teamsKarte('Projektübersicht ist mit Teams verbunden',
      ['Ab jetzt bekommt jede Person hier eine Nachricht, wenn ihr eine Aufgabe zugewiesen wird — mit Link direkt zur Aufgabe.'],
      [['Eingerichtet von', req.user.displayName || req.user.username]], link, 'Projektübersicht öffnen') });
    res.json({ ok: true, an: email });
  } catch(err){
    res.json({ ok: false, error: err.message });
  }
});

// neueZuweisungenMelden: legt für jede Person, die einer offenen Aufgabe neu
// als zuständig zugewiesen wurde, eine Benachrichtigung an — sofern zu der
// Person ein aktives Konto gehört (users.person_id; Kiosk-Konten nicht) und
// sie sich nicht selbst zugewiesen hat. Läuft NACH dem erfolgreichen
// Speichern und darf es nie scheitern lassen (Fehler werden nur geloggt).
// Parameter: week (gespeichertes Wochenobjekt), alt (Set "todoId|personId"
// vor dem Speichern), user (req.user). Keine Rückgabe.
function neueZuweisungenMelden(week, alt, user, req){
  try {
    const konto = db.prepare(`SELECT id FROM users WHERE person_id = ? AND person_id != '' AND active = 1 AND ${sqlOhneWandtafel()}`);
    const schonDa = db.prepare('SELECT 1 FROM benachrichtigungen WHERE user_id = ? AND todo_id = ? AND gelesen = 0');
    const ins = db.prepare(`INSERT INTO benachrichtigungen
      (id, user_id, art, titel, project_id, project_nr, project_name, week_label, todo_id, faellig, von_name, created_at)
      VALUES (?, ?, 'aufgabe', ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
    const jetzt = new Date().toISOString();
    const von = (user && (user.displayName || user.username)) || '';
    let anzahl = 0;
    // Für Teams: je Aufgabe die neu Zuständigen — auch Personen ohne Konto,
    // aber nicht, wer sich selbst zuweist; nie aus der Planung-Sandbox.
    const fuerTeams = new Map();
    const sandbox = week.label === SANDBOX_WEEK_LABEL;
    const ichPerson = user && user.personId ? String(user.personId) : '';
    (Array.isArray(week.projects) ? week.projects : []).forEach(p => {
      const todos = (p && p.plan && Array.isArray(p.plan.todos)) ? p.plan.todos : [];
      todos.forEach(t => {
        if(!t || t.done) return;
        (Array.isArray(t.assignees) ? t.assignees : []).forEach(pid => {
          if(alt.has(String(t.id) + '|' + String(pid))) return;
          if(!sandbox && !t.lph && String(pid) !== ichPerson){
            if(!fuerTeams.has(String(t.id))) fuerTeams.set(String(t.id), { p, t, personen: [] });
            fuerTeams.get(String(t.id)).personen.push(String(pid));
          }
          const k = konto.get(String(pid));
          if(!k || (user && k.id === user.id)) return;
          if(schonDa.get(k.id, String(t.id))) return;
          ins.run(crypto.randomUUID(), k.id, String(t.title || 'Aufgabe'), String(p.id || ''), String(p.nr || ''),
            String(p.name || ''), String(week.label || ''), String(t.id || ''), String(t.end || ''), von, jetzt);
          anzahl++;
        });
      });
    });
    if(anzahl) console.log('Benachrichtigungen angelegt:', anzahl, '(neue Aufgaben-Zuweisungen)');
    teamsNeueAufgaben(String(week.label || ''), fuerTeams, user, req);
  } catch(err){
    console.error('Benachrichtigungen konnten nicht angelegt werden:', err.message);
  }
}

// purgeBenachrichtigungen: gelesene nach 60, alle nach 180 Tagen entfernen.
function purgeBenachrichtigungen(){
  try {
    const tag = 864e5;
    const n = db.prepare('DELETE FROM benachrichtigungen WHERE (gelesen = 1 AND created_at < ?) OR created_at < ?')
      .run(new Date(Date.now() - 60 * tag).toISOString(), new Date(Date.now() - 180 * tag).toISOString()).changes;
    if(n) console.log('Alte Benachrichtigungen entfernt:', n);
  } catch(err){ console.error('Benachrichtigungen aufräumen fehlgeschlagen:', err.message); }
}

// GET /benachrichtigungen: die 30 jüngsten des angemeldeten Kontos plus die
// Zahl der ungelesenen (für die Glocke). Kiosk-Konten bekommen 403 über
// requireAuth wie überall.
app.get('/benachrichtigungen', requireAuth, (req, res) => {
  try {
    const rows = db.prepare(`SELECT * FROM benachrichtigungen WHERE user_id = ?
      ORDER BY created_at DESC LIMIT 30`).all(req.user.id);
    const ungelesen = db.prepare('SELECT COUNT(*) AS n FROM benachrichtigungen WHERE user_id = ? AND gelesen = 0').get(req.user.id).n;
    res.json({ ok: true, ungelesen, eintraege: rows.map(r => ({
      id: r.id, art: r.art, titel: r.titel, projectId: r.project_id, projectNr: r.project_nr,
      projectName: r.project_name, weekLabel: r.week_label, todoId: r.todo_id, faellig: r.faellig,
      von: r.von_name, erstellt: r.created_at, gelesen: !!r.gelesen,
    })) });
  } catch(err){
    console.error('Benachrichtigungen laden fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// POST /benachrichtigungen/gelesen {ids:[…]} oder {alle:true}: markiert als
// gelesen — immer nur Einträge des eigenen Kontos.
app.post('/benachrichtigungen/gelesen', requireAuth, (req, res) => {
  try {
    const { ids, alle } = req.body || {};
    let n = 0;
    if(alle){
      n = db.prepare('UPDATE benachrichtigungen SET gelesen = 1 WHERE user_id = ? AND gelesen = 0').run(req.user.id).changes;
    } else if(Array.isArray(ids)){
      const upd = db.prepare('UPDATE benachrichtigungen SET gelesen = 1 WHERE user_id = ? AND id = ?');
      ids.slice(0, 200).forEach(id => { n += upd.run(req.user.id, String(id)).changes; });
    } else {
      return res.status(400).json({ ok: false, error: 'ids oder alle angeben.' });
    }
    res.json({ ok: true, markiert: n });
  } catch(err){
    console.error('Benachrichtigungen markieren fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// POST /benachrichtigungen/loeschen {ids:[…]} oder {alle:true}: entfernt
// Einträge endgültig (Eriks Wunsch: für die User löschbar) — wie beim
// Markieren immer nur Einträge des eigenen Kontos.
app.post('/benachrichtigungen/loeschen', requireAuth, (req, res) => {
  try {
    const { ids, alle } = req.body || {};
    let n = 0;
    if(alle){
      n = db.prepare('DELETE FROM benachrichtigungen WHERE user_id = ?').run(req.user.id).changes;
    } else if(Array.isArray(ids)){
      const del = db.prepare('DELETE FROM benachrichtigungen WHERE user_id = ? AND id = ?');
      ids.slice(0, 200).forEach(id => { n += del.run(req.user.id, String(id)).changes; });
    } else {
      return res.status(400).json({ ok: false, error: 'ids oder alle angeben.' });
    }
    res.json({ ok: true, geloescht: n });
  } catch(err){
    console.error('Benachrichtigungen löschen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// ---------- Live-Ereignisse (Server-Sent Events) ----------
//
// Eriks Wunsch: Änderungen sollen sofort bei allen ankommen, nicht erst beim
// nächsten Abfragen (vorher alle 20 Sekunden), und nur der geänderte Teil.
// GET /ereignisse hält je offenem Browser eine Verbindung offen; nach jedem
// Speichern meldet ereignisSenden() allen anderen, was sich geändert hat:
//   { typ:'projekte', label, updatedAt, projekte:[…] } — nur die geänderten
//       Projekte, so wie sie jetzt in der Datenbank stehen (POST /save-projects)
//   { typ:'woche', label, updatedAt, geloescht? } — eine ganze Sitzung hat sich
//       geändert (POST /save-week, Entsperren, Papierkorb, Löschen); der
//       Browser holt sie über GET /week nach
//   { typ:'neu' } — neue Sitzung oder Backup eingespielt: alles neu laden
// Der Absender bekommt sein eigenes Ereignis nicht (Kopfzeile X-Client-Id,
// je Browser-Tab zufällig). Keine Abhängigkeit, kein WebSocket: SSE ist
// reines HTTP und läuft unverändert durch Docker. Ein vorgeschalteter Proxy
// (nginx) darf diese Antwort nicht puffern — X-Accel-Buffering: no.
const ereignisKunden = new Set();   // { res, token, clientId }

app.get('/ereignisse', requireAuthOderKiosk, (req, res) => {
  res.writeHead(200, {
    'Content-Type': 'text/event-stream; charset=utf-8',
    'Cache-Control': 'no-cache, no-transform',
    'Connection': 'keep-alive',
    'X-Accel-Buffering': 'no'
  });
  res.write('retry: 3000\n\n');
  const kunde = {
    res,
    token: parseCookies(req)[SESSION_COOKIE] || '',
    clientId: String(req.query.client || '')
  };
  ereignisKunden.add(kunde);
  req.on('close', () => ereignisKunden.delete(kunde));
});

// Herzschlag: hält die Verbindung durch Router/Proxys offen, die stille
// Verbindungen sonst nach einer Weile trennen.
setInterval(() => { ereignisKunden.forEach(k => { try { k.res.write(': ping\n\n'); } catch(e){} }); }, 25000);

// ereignisSenden: verteilt ein Ereignis an alle verbundenen Browser außer dem
// auslösenden. Abgelaufene oder abgemeldete Sitzungen bekommen nichts mehr
// und werden getrennt. Parameter: daten (Objekt), req (auslösende Anfrage
// oder null).
function ereignisSenden(daten, req){
  if(ereignisKunden.size === 0) return;
  const von = req ? String(req.get('x-client-id') || '') : '';
  const text = 'data: ' + JSON.stringify(daten) + '\n\n';
  const jetzt = new Date().toISOString();
  const gueltig = db.prepare('SELECT 1 FROM user_sessions WHERE token = ? AND expires_at > ?');
  ereignisKunden.forEach(k => {
    if(von && k.clientId === von) return;
    if(!gueltig.get(k.token, jetzt)){ ereignisKunden.delete(k); try { k.res.end(); } catch(e){} return; }
    try { k.res.write(text); } catch(e){ ereignisKunden.delete(k); }
  });
}

// GET /week?label=: eine einzelne Sitzung (statt /load-all mit allen) — für
// das Nachladen nach einem Ereignis und beim Zusammenführen. Die Sandbox
// kommt in derselben Form wie bei /load-all (nur ihre Projekte).
app.get('/week', requireAuthOderKiosk, (req, res) => {
  try {
    const label = String(req.query.label || '');
    const w = label ? loadWeeks(label)[0] : null;
    if(!w) return res.status(404).json({ ok: false, error: 'Sitzung nicht gefunden' });
    res.json({ ok: true, week: w });
  } catch(err){
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// POST /save-projects {label, projects:[{project, baseUpdatedAt}]}: speichert
// NUR die übergebenen Projekte einer Sitzung — der Browser schickt, was sich
// gegenüber dem zuletzt bekannten Server-Stand geändert hat, statt der ganzen
// Sitzung. Konflikte werden je PROJEKT geprüft (projects.updated_at): Zwei
// Personen an verschiedenen Projekten kommen sich nicht mehr in die Quere.
// Nur für bestehende Projekte; Anlegen, Löschen, Umsortieren und Änderungen
// an der Sitzung selbst (Teilnehmer, Anwesenheit, Sperre) laufen weiter über
// /save-week. Antwort: { ok, updatedAt (Sitzung), projekte: {id: updatedAt} };
// 409 { conflict, projekte:[ids] }, wenn ein Projekt inzwischen anders steht.
app.post('/save-projects', requireAuth, (req, res) => {
  const { label, projects } = req.body || {};
  if(typeof label !== 'string' || !label || !Array.isArray(projects) || projects.length === 0){
    return res.status(400).json({ ok: false, error: 'label und projects erforderlich' });
  }
  const liste = projects.filter(e => e && e.project && e.project.id);
  const badStatus = findInvalidAuftragsstatus({ projects: liste.map(e => e.project) });
  if(badStatus){
    return res.status(400).json({ ok: false, error: 'Unbekannter Auftragsstatus "' + badStatus.wert + '".' });
  }
  try {
    const wocheRow = db.prepare('SELECT locked, updated_at FROM weeks WHERE label = ?').get(label);
    if(!wocheRow) return res.status(409).json({ ok: false, conflict: true, error: 'Die Sitzung "' + label + '" gibt es nicht mehr.', projekte: [] });
    if(wocheRow.locked && !hatRecht(req.user, 's.gesperrt')){
      return res.status(409).json({ ok: false, conflict: true, error: 'Die Sitzung "' + label + '" ist gesperrt.', projekte: [] });
    }
    const stand = db.prepare('SELECT array_order, updated_at, project_uid FROM projects WHERE week_label = ? AND project_id = ?');
    const konflikte = [];
    const gefunden = liste.map(e => {
      const row = stand.get(label, String(e.project.id));
      if(!row || String(e.baseUpdatedAt || '') !== String(row.updated_at || '')
        || String(e.project.projectUid || '') !== String(row.project_uid || '')) konflikte.push(String(e.project.id));
      return { e, row };
    });
    if(konflikte.length){
      return res.status(409).json({ ok: false, conflict: true, projekte: konflikte,
        error: 'Ein Projekt wurde zwischenzeitlich von einer anderen Person geändert.' });
    }
    {
      const fehlt = fehlendesBearbeitungsrecht(req.user, label, liste.map(e => e.project), null);
      if(fehlt) return rechtFehlt(res, fehlt);
    }
    const alteZuweisungen = new Set(db.prepare('SELECT todo_id, person_id FROM plan_todo_assignees WHERE week_label = ?')
      .all(label).map(r => r.todo_id + '|' + r.person_id));
    const jetzt = new Date().toISOString();
    db.exec('BEGIN');
    try {
      gefunden.forEach(({ e, row }) => {
        deleteProjectData(label, String(e.project.id));
        serializeProject(label, e.project, row.array_order, jetzt);
      });
      // Die Sitzung als Ganzes ist damit auch geändert: Ein gleichzeitiges
      // /save-week auf altem Stand muss das als Konflikt bemerken.
      db.prepare('UPDATE weeks SET updated_at = ? WHERE label = ?').run(jetzt, label);
      db.exec('COMMIT');
    } catch(err){ db.exec('ROLLBACK'); throw err; }
    neueZuweisungenMelden({ label, projects: liste.map(e => e.project) }, alteZuweisungen, req.user, req);
    const ids = new Set(liste.map(e => String(e.project.id)));
    const frisch = (loadWeeks(label)[0] || { projects: [] }).projects.filter(p => ids.has(String(p.id)));
    ereignisSenden({ typ: 'projekte', label, updatedAt: jetzt, projekte: frisch }, req);
    const projekte = {};
    frisch.forEach(p => { projekte[p.id] = p.updatedAt; });
    console.log('Saved projects:', label, Array.from(ids).length);
    res.json({ ok: true, updatedAt: jetzt, projekte });
  } catch(err){
    console.error('Save projects error', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// GET /week-revisionen: der Revisionsstand (weeks.updated_at) jeder Sitzung —
// winzig, deshalb fragt der Browser ihn alle 20 Sekunden ab und holt nur bei
// einer Abweichung die geänderte Sitzung nach (Live-Abgleich beim
// gleichzeitigen Arbeiten, js/store.js). Für die Wandtafel ebenfalls lesbar.
// GET /weeks-aelter?vor=<label>&anzahl=5: die nächsten älteren Sitzungen vor
// <label> vollständig ("Weitere laden" im Verlauf), dazu wie viele danach
// noch übrig sind.
app.get('/weeks-aelter', requireAuthOderKiosk, (req, res) => {
  try {
    const liste = echteSitzungenSortiert();
    const vor = String(req.query.vor || '');
    const anzahl = Math.min(50, Math.max(1, Math.floor(Number(req.query.anzahl)) || 5));
    const idx = liste.findIndex(w => w.label === vor);
    const bis = idx < 0 ? liste.length : idx;
    const von = Math.max(0, bis - anzahl);
    const weeks = loadWeeks(liste.slice(von, bis).map(w => w.label));
    res.json({ ok: true, weeks, uebrig: von });
  } catch(err){
    console.error('Ältere Sitzungen laden fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

app.get('/week-revisionen', requireAuthOderKiosk, (req, res) => {
  try {
    const revisionen = {};
    db.prepare('SELECT label, updated_at FROM weeks').all().forEach(r => { revisionen[r.label] = r.updated_at || ''; });
    res.json({ ok: true, revisionen });
  } catch(err){
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// ---------- Bearbeitungsrechte beim Speichern ----------
// /save-week und /save-projects schreiben ganze Projekte. Welches Recht eine
// Änderung braucht, zeigt erst der Vergleich mit dem gespeicherten Stand:
// Kommentar und Leistungsphasen-Fortschritt → wb.kommentar, „besprochen“ →
// wb.besprochen, Terminplan (plan) → proj.plan, alles andere am Projekt →
// proj.stamm, Anwesenheit der Sitzung → wb.anwesenheit, die Planung-Sandbox
// → wz.planung. Wer alle diese Rechte hat (Startbelegung), überspringt den
// Vergleich ganz — nur eingeschränkte Rollen zahlen dafür.
const BEARBEITUNGS_RECHTE = ['wb.kommentar', 'wb.besprochen', 'wb.anwesenheit', 'proj.stamm', 'proj.plan'];
const PROJEKT_FELDER_OHNE_RECHT = new Set(['id', 'projectUid', 'updatedAt', 'order',
  'status', 'statusAuthor', 'statusAt', 'besprochen', 'statusState']);

// normWert: vergleichbare Form — leere Werte (undefined, null, '', false, 0,
// [], {}) gelten als gleich, Zahlen und Text ebenso („5“ = 5), Schlüssel-
// reihenfolge zählt nicht. Sonst meldete ein Feld, das der Browser nur
// anders schreibt, eine Änderung, die niemand gemacht hat.
function normWert(v){
  if(v === undefined || v === null || v === '' || v === false || v === 0) return null;
  if(Array.isArray(v)){ const a = v.map(normWert); return a.length ? a : null; }
  if(typeof v === 'object'){
    const o = {};
    Object.keys(v).sort().forEach(k => { const x = normWert(v[k]); if(x !== null) o[k] = x; });
    return Object.keys(o).length ? o : null;
  }
  return String(v);
}
const gleichNorm = (a, b) => JSON.stringify(normWert(a)) === JSON.stringify(normWert(b));

// fehlendesBearbeitungsrecht: erstes fehlende Recht für die Änderungen oder
// null. Parameter: user, label, projekte (eingehend), woche (bei /save-week,
// für die Anwesenheit; sonst null).
function fehlendesBearbeitungsrecht(user, label, projekte, woche){
  if(String(label) === SANDBOX_WEEK_LABEL) return hatRecht(user, 'wz.planung') ? null : 'wz.planung';
  if(BEARBEITUNGS_RECHTE.every(r => hatRecht(user, r))) return null;
  const alt = loadWeeks(String(label))[0];
  if(!alt) return null; // neue Sitzung: legt nur der Server an
  if(woche && !hatRecht(user, 'wb.anwesenheit') && !gleichNorm(woche.attendance, alt.attendance)) return 'wb.anwesenheit';
  const altJeId = new Map(), altJeUid = new Map();
  (alt.projects || []).forEach(p => { altJeId.set(String(p.id), p); if(p.projectUid) altJeUid.set(String(p.projectUid), p); });
  for(const p of (projekte || []).filter(Boolean)){
    const a = altJeId.get(String(p.id)) || (p.projectUid && altJeUid.get(String(p.projectUid)));
    if(!a) continue; // neu angelegt — prüft darfProjektlisteAendern()
    const keys = new Set([...Object.keys(p), ...Object.keys(a)]);
    for(const k of keys){
      if(PROJEKT_FELDER_OHNE_RECHT.has(k) || gleichNorm(p[k], a[k])) continue;
      if(k === 'kommentare'){
        const kn = p.kommentare || {}, ka = a.kommentare || {};
        for(const g of new Set([...Object.keys(kn), ...Object.keys(ka)])){
          const x = kn[g] || {}, y = ka[g] || {};
          if(!gleichNorm({ s: x.status, a: x.statusAuthor, t: x.statusAt }, { s: y.status, a: y.statusAuthor, t: y.statusAt })
             && !hatRecht(user, 'wb.kommentar')) return 'wb.kommentar';
          if(!gleichNorm(x.besprochen, y.besprochen) && !hatRecht(user, 'wb.besprochen')) return 'wb.besprochen';
        }
        continue;
      }
      const recht = k === 'lph' ? 'wb.kommentar' : k === 'plan' ? 'proj.plan' : 'proj.stamm';
      if(!hatRecht(user, recht)) return recht;
    }
  }
  return null;
}

// darfProjektlisteAendern: Recht „Projekte anlegen und löschen“ (Rollen &
// Rechte). Dieselbe Regel steht clientseitig in
// darfProjektlisteAendern() (public/js/auth.js), dort nur als UI-Gate.
function darfProjektlisteAendern(user){
  return hatRecht(user, 'proj.anlegen');
}

// projektlisteAenderungen: vergleicht die eingehende Woche mit dem
// gespeicherten Stand. Ein Projekt gilt als dasselbe, wenn seine ID ODER
// seine projectUid übereinstimmt. Rückgabe:
//   neu      — eingehende Projekte ohne Gegenstück (angelegt)
//   entfernt — vollständige gespeicherte Projekt-Objekte (aus loadWeeks())
//              ohne Gegenstück (gelöscht); der teure loadWeeks()-Aufruf läuft
//              nur, wenn die günstige Vorprüfung überhaupt eines findet.
// Neue Sitzungen legt nur der Server selbst an (ensureCurrentWeekRollover(),
// ohne /save-week) — eine über /save-week neu eingehende Woche mit Projekten
// zählt deshalb ebenfalls als Anlegen.
function projektlisteAenderungen(week){
  const label = String(week.label);
  const gespeichert = db.prepare('SELECT project_id, project_uid FROM projects WHERE week_label = ?').all(label);
  const eingehend = (Array.isArray(week.projects) ? week.projects : []).filter(Boolean);

  const altIds = new Set(gespeichert.map(r => r.project_id));
  const altUids = new Set(gespeichert.map(r => r.project_uid).filter(Boolean));
  const neu = eingehend.filter(p => !altIds.has(String(p.id || '')) && !(p.projectUid && altUids.has(String(p.projectUid))));

  const ids = new Set(eingehend.map(p => String(p.id || '')).filter(Boolean));
  const uids = new Set(eingehend.map(p => String(p.projectUid || '')).filter(Boolean));
  const fehlend = gespeichert.filter(r => !ids.has(r.project_id) && !(r.project_uid && uids.has(r.project_uid)));
  if(!fehlend.length) return { neu, entfernt: [] };
  // Nur diese eine Sitzung laden, nicht alle (loadWeeks(label)).
  const w = loadWeeks(label)[0];
  const fehlendIds = new Set(fehlend.map(r => r.project_id));
  return { neu, entfernt: w ? (w.projects || []).filter(p => fehlendIds.has(String(p.id))) : [] };
}

// legeInPapierkorb: schreibt je gelöschtem Projekt einen Schnappschuss nach
// deleted_projects. Läuft NACH dem erfolgreichen Speichern der Woche — ein
// fehlgeschlagenes Speichern darf keinen Papierkorb-Eintrag für ein Projekt
// hinterlassen, das in Wahrheit noch da ist.
function legeInPapierkorb(projekte, weekLabel, user){
  const ins = db.prepare(`INSERT INTO deleted_projects
    (id, week_label, project_id, project_uid, nr, name, data, deleted_by_user_id, deleted_by_name, deleted_at)
    VALUES (?,?,?,?,?,?,?,?,?,?)`);
  const jetzt = new Date().toISOString();
  projekte.forEach(p => {
    try {
      ins.run(crypto.randomUUID(), String(weekLabel), String(p.id || ''), String(p.projectUid || ''),
        String(p.nr || ''), String(p.name || ''), JSON.stringify(p),
        user ? Number(user.id) || 0 : 0, user ? String(user.displayName || user.username || '') : '', jetzt);
      console.log('Projekt in den Papierkorb gelegt:', ((p.nr ? p.nr + ' ' : '') + (p.name || '')).trim());
    } catch(err){
      console.error('Papierkorb-Eintrag fehlgeschlagen:', err.message);
    }
  });
}

// Route: Papierkorb — listet die gelöschten Projekte der letzten
// GELOESCHTE_PROJEKTE_TAGE Tage (ohne den Schnappschuss selbst).
app.get('/admin/deleted-projects', requireRecht('a.papierkorb'), (req, res) => {
  try {
    purgeGeloeschteProjekte();
    const rows = db.prepare(`SELECT id, week_label, nr, name, deleted_by_name, deleted_at
      FROM deleted_projects ORDER BY deleted_at DESC`).all();
    const tagMs = 24 * 60 * 60 * 1000;
    res.json({
      ok: true,
      aufbewahrungTage: GELOESCHTE_PROJEKTE_TAGE,
      projekte: rows.map(r => ({
        id: r.id, weekLabel: r.week_label, nr: r.nr, name: r.name,
        deletedBy: r.deleted_by_name, deletedAt: r.deleted_at,
        endgueltigAm: new Date(Date.parse(r.deleted_at) + GELOESCHTE_PROJEKTE_TAGE * tagMs).toISOString()
      }))
    });
  } catch(err){
    console.error('Papierkorb laden fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Papierkorb — stellt ein gelöschtes Projekt wieder her. Ziel ist
// immer die aktuelle (jüngste echte) Sitzung, nicht die, aus der es gelöscht
// wurde: Ältere Sitzungen sind gesperrte Historie. Eine Nummern-Kollision mit
// einem inzwischen neu angelegten Projekt wird mit 409 abgewiesen (Dateien
// und Protokolle hängen an der Nummer und gehörten sonst zwei Projekten).
app.post('/admin/deleted-projects/:id/restore', requireRecht('a.papierkorb'), (req, res) => {
  try {
    const row = db.prepare('SELECT * FROM deleted_projects WHERE id = ?').get(String(req.params.id));
    if(!row) return res.status(404).json({ ok: false, error: 'Eintrag nicht gefunden (evtl. schon wiederhergestellt oder abgelaufen).' });
    const echte = loadWeeks().filter(w => w.label !== SANDBOX_WEEK_LABEL)
      .sort((a, b) => weekSortKeyServer(a.label).localeCompare(weekSortKeyServer(b.label)));
    const ziel = echte[echte.length - 1];
    if(!ziel) return res.status(409).json({ ok: false, error: 'Es gibt keine Sitzung, in die das Projekt zurückkehren könnte.' });

    const projekt = JSON.parse(row.data);
    const projekte = Array.isArray(ziel.projects) ? ziel.projects : (ziel.projects = []);
    const nr = String(projekt.nr || '').trim();
    if(nr && projekte.some(p => String(p.nr || '').trim() === nr)){
      return res.status(409).json({ ok: false, error: 'In der Sitzung "' + ziel.label + '" gibt es bereits ein Projekt mit der Nummer ' + nr + '.' });
    }
    if(projekt.projectUid && projekte.some(p => p.projectUid === projekt.projectUid)){
      return res.status(409).json({ ok: false, error: 'Dieses Projekt steht bereits in der Sitzung "' + ziel.label + '".' });
    }
    // Neue ID, falls die alte in der Zielsitzung schon vergeben ist (nach
    // einem Sitzungswechsel praktisch ausgeschlossen, aber billig abzusichern).
    if(!projekt.id || projekte.some(p => p.id === projekt.id)) projekt.id = crypto.randomUUID();
    // Ans Ende seiner Gruppe — die alte Position kann inzwischen belegt sein.
    const maxOrder = projekte.filter(p => p.group === projekt.group)
      .reduce((m, p) => Math.max(m, Number(p.order) || 0), -1);
    projekt.order = maxOrder + 1;
    // Der Sitzungskommentar gehört zur Sitzung, aus der das Projekt stammt.
    if(row.week_label !== ziel.label){
      projekt.kommentare = {}; delete projekt.statusState;
    }
    projekte.push(projekt);

    const updatedAt = saveWeekRelational(ziel);
    db.prepare('DELETE FROM deleted_projects WHERE id = ?').run(row.id);
    console.log('Projekt aus dem Papierkorb wiederhergestellt:', ((projekt.nr ? projekt.nr + ' ' : '') + (projekt.name || '')).trim(), '→', ziel.label);
    ereignisSenden({ typ: 'woche', label: ziel.label, updatedAt }, req);
    res.json({ ok: true, weekLabel: ziel.label, updatedAt });
  } catch(err){
    console.error('Wiederherstellen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Papierkorb — entfernt einen Eintrag sofort endgültig.
app.delete('/admin/deleted-projects/:id', requireRecht('a.papierkorb'), (req, res) => {
  try {
    db.prepare('DELETE FROM deleted_projects WHERE id = ?').run(String(req.params.id));
    res.json({ ok: true });
  } catch(err){
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Löscht eine Woche (fehlende Woche wird toleriert)
app.post('/delete-week', requireRecht('s.loeschen'), (req, res) => {
  const { label } = req.body || {};
  if(!label) return res.status(400).json({ ok: false, error: 'Missing label' });
  if(label === SANDBOX_WEEK_LABEL) return res.status(400).json({ ok: false, error: 'Die Planung-Sandbox ist keine Sitzung und kann hier nicht gelöscht werden.' });
  try {
    const row = db.prepare('SELECT 1 FROM weeks WHERE label = ?').get(String(label));
    const existed = !!row;
    // In einer Transaktion: deleteWeekData() räumt 18 Tabellen leer. Bricht
    // eines der DELETEs ab, blieben sonst Waisen-Zeilen zurück, die eine
    // später gleichnamig angelegte Sitzung wieder einsammeln würde.
    db.exec('BEGIN');
    try {
      deleteWeekData(String(label));
      db.exec('COMMIT');
    } catch(err){
      try { db.exec('ROLLBACK'); } catch(e){ /* keine offene Transaktion */ }
      throw err;
    }
    console.log('Deleted week:', label, existed ? '' : '(nicht vorhanden)');
    if(existed) ereignisSenden({ typ: 'woche', label: String(label), geloescht: true }, req);
    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: Entsperrt eine gesperrte Woche (Admin-only — ersetzt die bisher rein
// clientseitige Entsperr-Logik). Setzt `locked = 0` und schreibt eine neue
// Revision (`updated_at`), damit der Client seine lokale Sync-Basis
// aktualisieren kann (gleiche Konvention wie bei /save-week).
app.post('/unlock-week', requireRecht('s.entsperren'), (req, res) => {
  const { label } = req.body || {};
  if(!label) return res.status(400).json({ ok: false, error: 'Missing label' });
  if(label === SANDBOX_WEEK_LABEL) return res.status(400).json({ ok: false, error: 'Die Planung-Sandbox ist keine Sitzung und wird nie gesperrt.' });
  try {
    const row = db.prepare('SELECT 1 FROM weeks WHERE label = ?').get(String(label));
    if(!row) return res.status(404).json({ ok: false, error: 'Sitzung nicht gefunden.' });
    const updatedAt = new Date().toISOString();
    db.prepare('UPDATE weeks SET locked = 0, updated_at = ? WHERE label = ?').run(updatedAt, String(label));
    console.log('Unlocked week:', label);
    ereignisSenden({ typ: 'woche', label: String(label), updatedAt }, req);
    return res.json({ ok: true, updatedAt });
  } catch(err){
    console.error('Unlock week error', err);
    return res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Lädt alle Wochen (jetzt eine einzige globale Reihe) plus die
// firmenweite Personenliste. Liefert strukturierte JSON-Objekte (aus den
// relationalen Tabellen zusammengesetzt); nach Label sortiert.
// echteSitzungenSortiert: alle echten Sitzungen (ohne Sandbox) als schlanke
// Liste, älteste zuerst — {id, label, date, locked, updatedAt}.
function echteSitzungenSortiert(){
  return db.prepare('SELECT week_id, label, date, locked, updated_at FROM weeks WHERE label != ?').all(SANDBOX_WEEK_LABEL)
    .map(r => ({ id: r.week_id, label: r.label, date: r.date || '', locked: !!r.locked, updatedAt: r.updated_at || '' }))
    .sort((a, b) => weekSortKeyServer(a.label).localeCompare(weekSortKeyServer(b.label)));
}

// GET /load-all?wochen=N: Mit wochen nur die jüngsten N Sitzungen vollständig
// (Eriks Wunsch: aktuelle + drei davor), dazu wochenListe = ALLE Sitzungen
// schlank (Name, Datum, Sperre) für Admin → Sitzungen und das Nachladen.
// Ohne wochen wie früher alle (z. B. ältere Browser-Stände).
app.get('/load-all', requireAuthOderKiosk, (req, res) => {
  try {
    const anzahl = Math.floor(Number(req.query.wochen));
    const wochenListe = echteSitzungenSortiert();
    const allWeeks = anzahl > 0
      ? loadWeeks(wochenListe.slice(-anzahl).map(w => w.label).concat([SANDBOX_WEEK_LABEL]))
      : loadWeeks();
    // Die reservierte Sandbox-"Sitzung" (Planung, siehe SANDBOX_WEEK_LABEL)
    // ist keine echte Sitzung — sie wird separat als sandboxPlans
    // ausgeliefert, statt in weeks[] zu landen. So kommt sie clientseitig
    // strukturell nie in db.weeks an und kann dort auch nicht versehentlich
    // in Board/Wochenbericht/Auslastung/Sitzungsverwaltung auftauchen.
    const weeks = allWeeks.filter(w => w.label !== SANDBOX_WEEK_LABEL);
    const sandbox = allWeeks.find(w => w.label === SANDBOX_WEEK_LABEL);
    const sandboxPlans = sandbox ? sandbox.projects : [];
    const sandboxUpdatedAt = sandbox ? sandbox.updatedAt : '';
    const people = loadGlobalPeople(req.user);
    res.json({ ok: true, weeks, people, sandboxPlans, sandboxUpdatedAt, wochenListe });
  } catch(err){
    console.error('Load error', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// ---------- Dashboard ----------

// heuteIsoLokal / isoPlusTageLokal: Datum als YYYY-MM-TT in der ZEITZONE DES
// SERVERS, nicht in UTC.
//
// new Date().toISOString().slice(0,10) rechnet nach UTC um: In deutscher
// Sommerzeit (UTC+2) liefert es zwischen 00:00 und 02:00 Ortszeit noch den
// Vortag. Termine von heute galten in diesem Fenster als überfällig, und die
// Abwesenheitsliste ließ eine heute beginnende Abwesenheit aus. Voraussetzung
// ist, dass der Server auf die Zeitzone des Büros gestellt ist — im
// Docker-Container also TZ=Europe/Berlin.
// Parameter: (isoPlusTageLokal) n = Tage in die Zukunft, auch negativ.
// Rückgabe: String.
function heuteIsoLokal(){
  return isoPlusTageLokal(0);
}
function isoPlusTageLokal(n){
  const d = new Date();
  d.setDate(d.getDate() + (Number(n) || 0));
  const m = String(d.getMonth() + 1).padStart(2, '0');
  const t = String(d.getDate()).padStart(2, '0');
  return d.getFullYear() + '-' + m + '-' + t;
}

// weekSortKeyServer: serverseitige Portierung von weekSortKey()
// (public/js/utils.js) — wird NUR im Fallback von /my-dashboard gebraucht,
// wenn die applyAutoLock()-Invariante (genau eine entsperrte Woche je
// Abteilung) ausnahmsweise verletzt ist (0 oder >1 entsperrte Wochen).
function weekSortKeyServer(label){
  const m = String(label || '').match(/KW\s*(\d+)[^\d]+(\d{4})/i);
  if(m){
    const kw = m[1].padStart(2, '0');
    return `${m[2]}-${kw}`;
  }
  return String(label || '').toLowerCase();
}

// Route: persönliches Dashboard des angemeldeten Benutzers — liefert die
// offenen TODOs des eigenen person_id in der aktuell entsperrten (firmenweit
// globalen) Sitzung, ausstehende Datei-Freigaben sowie `colleagueAbsences`
// (aktuelle/anstehende Abwesenheiten aller anderen aktiven Nutzer, siehe
// loadGlobalPeople()). Jede Aufgabe bekommt zusätzlich die Tags ihres
// Projekts (`tags: string[]`, ggf. leer) mit — separat nachgeladen aus
// project_tags, gruppiert nach project_id (siehe Kommentar unten), NICHT per
// JOIN (würde bei mehreren Tags Aufgaben-Zeilen verdoppeln).
app.get('/my-dashboard', requireAuth, (req, res) => {
  try {
    // Normalfall: applyAutoLock() garantiert genau eine entsperrte Woche
    // (jetzt firmenweit global, nicht mehr je Abteilung).
    // Die Planung-Sandbox ist immer entsperrt und keine echte Sitzung — ohne
    // diesen Ausschluss gab es stets zwei entsperrte Wochen, und die richtige
    // wurde nur zufällig über die Sortierung im Rückfallzweig gefunden.
    const unlocked = db.prepare('SELECT label FROM weeks WHERE locked = 0 AND label != ?').all(SANDBOX_WEEK_LABEL);
    let weekLabel = null;
    if(unlocked.length === 1){
      weekLabel = unlocked[0].label;
    } else {
      // Fallback (0 oder >1 entsperrte Wochen, sollte normalerweise nicht
      // vorkommen): jüngste Woche nach weekSortKeyServer() wählen.
      const all = db.prepare('SELECT label FROM weeks WHERE label != ?').all(SANDBOX_WEEK_LABEL);
      if(all.length > 0){
        weekLabel = all.map(r => r.label)
          .sort((a, b) => weekSortKeyServer(b).localeCompare(weekSortKeyServer(a)))[0];
      }
    }
    let tasks = [];
    if(weekLabel && req.user.personId){
      tasks = db.prepare(`
        SELECT t.todo_id AS todoId, t.title AS title, t.start AS start, t.end AS end,
               t.progress AS progress, t.project_id AS projectId, p.nr AS projectNr, p.name AS projectName
        FROM plan_todos t
        JOIN plan_todo_assignees a
          ON a.week_label = t.week_label
         AND a.project_id = t.project_id AND a.todo_id = t.todo_id
        JOIN projects p
          ON p.week_label = t.week_label
         AND p.project_id = t.project_id
        WHERE t.week_label = ? AND t.done = 0 AND a.person_id = ?
      `).all(weekLabel, req.user.personId);
      // Sortierung nach Fälligkeit aufsteigend, leere Werte ans Ende.
      tasks.sort((a, b) => {
        if(!a.end && !b.end) return 0;
        if(!a.end) return 1;
        if(!b.end) return -1;
        return a.end < b.end ? -1 : (a.end > b.end ? 1 : 0);
      });
      // Tags der zugehörigen Projekte nachladen: project_tags hat keine
      // todo_id, ein direkter JOIN würde also bei mehreren Tags pro Projekt
      // die TODO-Zeile vervielfachen. Separate, nach (week_label, project_id)
      // gruppierte Abfrage stattdessen (gleiches Muster wie beim Zusammenbau
      // der Projekte in loadWeeks()). project_id ist nur ein internes
      // Zuordnungsfeld für diese Nachladung und wird vor der Antwort wieder
      // entfernt (kein Teil der bisherigen /my-dashboard-Antwortform).
      const projectIds = [...new Set(tasks.map(t => t.projectId))];
      if(projectIds.length > 0){
        const placeholders = projectIds.map(() => '?').join(',');
        const tagRows = db.prepare(`
          SELECT project_id AS projectId, tag FROM project_tags
          WHERE week_label = ? AND project_id IN (${placeholders})
          ORDER BY tag_order
        `).all(weekLabel, ...projectIds);
        const tagsByProject = {};
        tagRows.forEach(r => { (tagsByProject[r.projectId] || (tagsByProject[r.projectId] = [])).push(r.tag); });
        tasks.forEach(t => { t.tags = tagsByProject[t.projectId] || []; });
      }
      tasks.forEach(t => { delete t.projectId; });
    }

    // ---------- Termine der eigenen Projekte ----------
    //
    // Nicht dasselbe wie `tasks` oben: Dort stehen die Aufgaben, die der
    // Person PERSÖNLICH zugewiesen sind — auch in Projekten, mit denen sie
    // sonst nichts zu tun hat. Hier stehen die Termine der PROJEKTE, denen
    // sie zugeordnet ist (project_assign), unabhängig davon, wer die einzelne
    // Aufgabe erledigt. Eine Projektleitung muss wissen, wann im eigenen
    // Projekt etwas fällig wird, auch wenn ein anderer es abarbeitet.
    //
    // Doppelungen werden unterdrückt: Was schon unter `tasks` steht,
    // erscheint hier nicht noch einmal (siehe eigeneTodoIds).
    //
    // Der Zeitraum endet nach 21 Tagen. Ohne Grenze stünden Termine aus einem
    // Jahr in der Liste und die dringenden gingen darin unter; überfällige
    // bleiben dagegen ohne Altersgrenze stehen, denn eine Frist verfällt
    // nicht dadurch, dass sie lange gerissen ist.
    const HORIZONT_TAGE = 21;
    let projectDates = [];
    if(weekLabel && req.user.personId){
      const grenzeIso = isoPlusTageLokal(HORIZONT_TAGE);
      const heuteIso = heuteIsoLokal();

      // Projekte, denen die Person in irgendeiner Rolle zugeordnet ist.
      // state 1 = Hauptverantwortung, 2 = Unterstützung; 0 kommt in der
      // Tabelle nicht vor (cycleAssign() löscht den Eintrag stattdessen),
      // wird aber sicherheitshalber ausgeschlossen.
      const meineProjekte = db.prepare(`
        SELECT DISTINCT a.project_id AS projectId
        FROM project_assign a
        WHERE a.week_label = ? AND a.person_id = ? AND a.state IN (1, 2)
      `).all(weekLabel, req.user.personId).map(r => r.projectId);

      if(meineProjekte.length > 0){
        const platzhalter = meineProjekte.map(() => '?').join(',');
        const eigeneTodoIds = new Set(tasks.map(t => t.todoId));

        // Aufgaben: offen, mit Fälligkeit, in den eigenen Projekten.
        const todos = db.prepare(`
          SELECT t.todo_id AS id, t.title AS titel, t.end AS datum, t.progress AS progress,
                 t.project_id AS projectId, p.nr AS projectNr, p.name AS projectName
          FROM plan_todos t
          JOIN projects p ON p.week_label = t.week_label AND p.project_id = t.project_id
          WHERE t.week_label = ? AND t.done = 0 AND t.end != ''
            AND t.project_id IN (${platzhalter})
        `).all(weekLabel, ...meineProjekte);

        // Meilensteine: sie tragen kein Erledigt-Kennzeichen, deshalb zählt
        // allein das Datum.
        const milestones = db.prepare(`
          SELECT m.milestone_id AS id, m.name AS titel, m.date AS datum,
                 m.project_id AS projectId, p.nr AS projectNr, p.name AS projectName
          FROM plan_milestones m
          JOIN projects p ON p.week_label = m.week_label AND p.project_id = m.project_id
          WHERE m.week_label = ? AND m.date != ''
            AND m.project_id IN (${platzhalter})
        `).all(weekLabel, ...meineProjekte);

        // Zuständige je Aufgabe nachladen — getrennt, weil ein JOIN über
        // plan_todo_assignees die Aufgabenzeile bei mehreren Zuständigen
        // vervielfachen würde (gleiches Muster wie bei den Tags oben).
        const namen = {};
        db.prepare(`
          SELECT a.todo_id AS todoId, a.project_id AS projectId, a.person_id AS personId
          FROM plan_todo_assignees a
          WHERE a.week_label = ? AND a.project_id IN (${platzhalter})
        `).all(weekLabel, ...meineProjekte).forEach(r => {
          const key = r.projectId + '|' + r.todoId;
          (namen[key] || (namen[key] = [])).push(r.personId);
        });
        // Namen der Zuständigen: aus week_people der Sitzung, NICHT aus
        // loadGlobalPeople(). Die globale Liste enthält nur Personen mit
        // Benutzerkonto; die Teilnehmerliste einer Sitzung führt dagegen
        // jede Person, die dort mitarbeitet. Ohne diesen Weg stand in der
        // Terminliste "p_ap" statt "Alexander Plum".
        const personenNamen = {};
        db.prepare(`
          SELECT person_id AS id, name, full_name AS fullName
          FROM week_people WHERE week_label = ?
        `).all(weekLabel).forEach(w => {
          personenNamen[w.id] = w.fullName || w.name || w.id;
        });

        projectDates = todos.map(t => ({
          art: 'aufgabe',
          id: t.id,
          titel: t.titel,
          datum: t.datum,
          progress: t.progress,
          projectNr: t.projectNr,
          projectName: t.projectName,
          zustaendig: (namen[t.projectId + '|' + t.id] || [])
            .map(pid => personenNamen[pid] || pid),
          selbst: eigeneTodoIds.has(t.id),
        })).concat(milestones.map(m => ({
          art: 'meilenstein',
          id: m.id,
          titel: m.titel,
          datum: m.datum,
          projectNr: m.projectNr,
          projectName: m.projectName,
          zustaendig: [],
          selbst: false,
        })));

        projectDates = projectDates
          // Was bereits unter "Meine Aufgaben" steht, hier nicht wiederholen.
          .filter(d => !d.selbst)
          .filter(d => d.datum <= grenzeIso)
          .sort((a, b) => (a.datum < b.datum ? -1 : (a.datum > b.datum ? 1 : 0)));

        // Der Server liefert auch gleich die Einordnung mit, damit Browser
        // und PDF/Export nicht jeweils eigene Stichtage rechnen.
        projectDates.forEach(d => {
          d.ueberfaellig = d.datum < heuteIso;
          d.heute = d.datum === heuteIso;
        });
      }
    }

    const pendingReviews = db.prepare(`
      SELECT f.id AS fileId, f.project_nr AS projectNr,
             f.project_name AS projectName, f.original_filename AS originalFilename,
             COALESCE(NULLIF(u.display_name, ''), u.username, 'Gelöschter Benutzer') AS uploadedBy,
             f.created_at AS createdAt
      FROM project_file_reviewers r
      JOIN project_files f ON f.id = r.file_id
      LEFT JOIN users u ON u.id = f.uploaded_by_user_id
      WHERE r.user_id = ? AND r.decision = 'pending' AND f.status = 'pending'
      ORDER BY f.created_at DESC
    `).all(req.user.id);

    // Abwesenheiten der Kollegen: firmenweite Personenliste (loadGlobalPeople(),
    // keine Abteilungstrennung mehr), gefiltert auf Abwesenheiten, die heute
    // laufen oder innerhalb der nächsten 14 Tage beginnen — der Aufrufer selbst
    // wird per person_id ausgeschlossen. Sortiert nach Startdatum; `current`
    // markiert eine heute laufende Abwesenheit fürs Hervorheben im Dashboard.
    const todayIso = heuteIsoLokal();
    const horizonIso = isoPlusTageLokal(14);
    const colleagueAbsences = [];
    loadGlobalPeople(req.user).forEach(person => {
      if(person.id && person.id === req.user.personId) return;
      (person.absences || []).forEach(a => {
        if(!a.start || !a.end) return;
        if(a.end < todayIso || a.start > horizonIso) return;
        colleagueAbsences.push({
          personId: person.id,
          name: person.fullName || person.name,
          type: a.type,
          note: a.note,
          start: a.start,
          end: a.end,
          current: a.start <= todayIso && todayIso <= a.end,
        });
      });
    });
    colleagueAbsences.sort((a, b) => (a.start < b.start ? -1 : (a.start > b.start ? 1 : 0)));

    res.json({ ok: true, weekLabel, tasks, projectDates, pendingReviews, colleagueAbsences });
  } catch(err){
    console.error('Dashboard-Fehler', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// ---------- Datei-Upload, Freigabe, Kommentare ----------
//
// Dateien werden über project_nr allein mit Projekten verknüpft, NICHT über
// (week_label, project_id) — project_id wird bei jedem Wochen-Klon neu
// generiert (cloneWeek(), public/js/weeks.js), project_nr bleibt über den
// gesamten Projektlebenszyklus stabil und identifiziert seit der Zusammen-
// führung gleichnummeriger Projekte über ehemalige Abteilungsgrenzen hinweg
// eindeutig das eine logische Projekt. Ein Projekt ohne project_nr kann daher
// keine Dateien erhalten.
//
// Sicherheitskritisch: original_filename/project_nr/project_name/filename
// (Client-Eingaben) werden NIEMALS in einen Dateisystempfad eingesetzt. Der
// Pfad setzt sich ausschließlich aus einer serverseitig erzeugten UUID
// (stored_name) zusammen; original_filename dient nur als Anzeige-/
// Download-Header-Wert.

// UPLOADS_DIR: Basisverzeichnis für hochgeladene Projektdateien
// ein Unterordner (lazy angelegt, siehe uploadDirFor()).
const UPLOADS_DIR = path.join(SESSIONS_DIR, 'uploads');

// uploadDirFor: liefert (und legt bei Bedarf an) das Upload-Verzeichnis einer
// Abteilung. Parameter department MUSS bereits gegen VALID_DEPARTMENTS
// geprüft sein (nur dann sind ausschließlich 'ELT'/'HLS'/'ARCH' möglich).
function uploadDirFor(){
  if(!fs.existsSync(UPLOADS_DIR)) fs.mkdirSync(UPLOADS_DIR, { recursive: true });
  return UPLOADS_DIR;
}

// extractFileExtension: extrahiert per Whitelist-Regex eine kurze
// alphanumerische Dateiendung aus einem (nicht vertrauenswürdigen)
// Dateinamen. Kein Treffer (z. B. kein Punkt, zu lange/exotische Endung) →
// leerer String, kein Fehler.
function extractFileExtension(filename){
  const m = String(filename || '').match(/\.([a-zA-Z0-9]{1,8})$/);
  return m ? m[1].toLowerCase() : '';
}

// serializeFileRow: wandelt eine project_files-Zeile (ggf. mit JOIN-Feldern)
// in die öffentliche Repräsentation für GET /project-files um.
function serializeFileRow(row){
  return {
    id: row.id,
    projectNr: row.project_nr,
    projectName: row.project_name,
    originalFilename: row.original_filename,
    contentType: row.content_type,
    sizeBytes: row.size_bytes,
    status: row.status,
    createdAt: row.created_at,
    updatedAt: row.updated_at,
    uploadedBy: row.uploadedBy,
    // Uploader-ID mitgeben: Der Client kann den "Löschen"-Knopf sonst nicht
    // an dieselbe Regel binden, die der Server durchsetzt (Uploader, solange
    // die Datei offen ist — oder Admin).
    uploadedByUserId: row.uploaded_by_user_id,
  };
}

// Route: Liste aller aktiven Benutzer (ohne Passwortfelder, ohne inaktive
// Konten) — für die Prüfer-Auswahl beim Datei-Upload. Bewusst für JEDEN
// eingeloggten Benutzer zugänglich (requireAuth, kein Admin-Recht),
// da jeder Uploader Prüfer auswählen muss; getrennt von GET /admin/users
// (admin-only, zeigt zusätzlich inaktive Konten + mehr Felder).
app.get('/users', requireAuth, (req, res) => {
  try {
    // role != 'kiosk': das Wandtafel-Konto ist kein Teammitglied — es soll
    // weder im Datei-Freigabe-Prüfer-Auswahlfeld noch in der
    // abteilungsübergreifenden Besetzung zur Wahl stehen.
    const rows = db.prepare(`SELECT id, username, display_name, email, person_id, department, initials FROM users WHERE active = 1 AND ${sqlOhneWandtafel()} ORDER BY display_name, username`).all();
    const rolesByUser = loadUserRolesByUserId();
    res.json({ ok: true, users: rows.map(r => ({
      id: r.id, username: r.username, displayName: r.display_name, email: r.email,
      personId: r.person_id, department: r.department, initials: r.initials,
      roles: rolesByUser[r.id] || [],
    })) });
  } catch(err){
    console.error('Benutzerliste fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// ---------- Abwesenheiten ----------
// Rechte (Rollen & Rechte, Gruppe „Team“): team.abw (für mich),
// team.abwProjekte, team.abwGewerk, team.abwAlle — geprüft über
// darfAbwesenheit() für Anlegen, Ändern und Löschen gleichermaßen.
const ABWESENHEIT_ARTEN = new Set(['Urlaub', 'Krank', 'Fortbildung', 'Sonstiges']);
// abwesenheitPruefen: Eingaben prüfen. Rückgabe: Fehlertext oder ''.
function abwesenheitPruefen(start, end, type){
  const iso = /^\d{4}-\d{2}-\d{2}$/;
  if(!iso.test(String(start || '')) || !iso.test(String(end || ''))) return 'Start- und Enddatum erforderlich.';
  if(String(end) < String(start)) return 'Das Ende liegt vor dem Beginn.';
  if(!ABWESENHEIT_ARTEN.has(String(type || ''))) return 'Unbekannte Art der Abwesenheit.';
  return '';
}
const ABW_KEIN_RECHT = 'Für diese Person darfst du keine Abwesenheiten eintragen.';

// GET /personen: die Personenliste wie in /load-all (mit den Abwesenheiten
// aus Sicht des Aufrufers) — zum Nachladen nach einem Live-Ereignis.
app.get('/personen', requireAuthOderKiosk, (req, res) => {
  res.json({ ok: true, people: loadGlobalPeople(req.user) });
});

app.post('/users/:id/absences', requireAuth, (req, res) => {
  const id = Number(req.params.id);
  const user = db.prepare('SELECT id FROM users WHERE id = ?').get(id);
  if(!user) return res.status(404).json({ ok: false, error: 'Benutzer nicht gefunden.' });
  if(!darfAbwesenheit(req.user, id)) return res.status(403).json({ ok: false, error: ABW_KEIN_RECHT });
  const { start, end, type, note } = req.body || {};
  const fehler = abwesenheitPruefen(start, end, type);
  if(fehler) return res.status(400).json({ ok: false, error: fehler });
  try {
    const absenceId = crypto.randomUUID();
    db.prepare('INSERT INTO user_absences (user_id, id, start, end, type, note, created_by) VALUES (?, ?, ?, ?, ?, ?, ?)')
      .run(id, absenceId, String(start), String(end), String(type), String(note || ''), req.user.id);
    ereignisSenden({ typ: 'personen' }, req);
    res.json({ ok: true, absence: { id: absenceId, start: String(start), end: String(end), type: String(type), note: String(note || '') } });
  } catch(err){
    console.error('Abwesenheit anlegen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

app.patch('/users/:id/absences/:absenceId', requireAuth, (req, res) => {
  const id = Number(req.params.id);
  if(!darfAbwesenheit(req.user, id)) return res.status(403).json({ ok: false, error: ABW_KEIN_RECHT });
  const row = db.prepare('SELECT * FROM user_absences WHERE user_id = ? AND id = ?').get(id, req.params.absenceId);
  if(!row) return res.status(404).json({ ok: false, error: 'Abwesenheit nicht gefunden.' });
  const b = req.body || {};
  const start = b.start !== undefined ? b.start : row.start;
  const end = b.end !== undefined ? b.end : row.end;
  const type = b.type !== undefined ? b.type : row.type;
  const note = b.note !== undefined ? String(b.note) : row.note;
  const fehler = abwesenheitPruefen(start, end, type);
  if(fehler) return res.status(400).json({ ok: false, error: fehler });
  db.prepare('UPDATE user_absences SET start = ?, end = ?, type = ?, note = ? WHERE user_id = ? AND id = ?')
    .run(String(start), String(end), String(type), note, id, req.params.absenceId);
  ereignisSenden({ typ: 'personen' }, req);
  res.json({ ok: true, absence: { id: row.id, start: String(start), end: String(end), type: String(type), note } });
});

// Löschen: idempotent (auch ok, wenn nichts gelöscht wurde).
app.delete('/users/:id/absences/:absenceId', requireAuth, (req, res) => {
  try {
    const targetUserId = Number(req.params.id);
    if(!darfAbwesenheit(req.user, targetUserId)) return res.status(403).json({ ok: false, error: ABW_KEIN_RECHT });
    const r = db.prepare('DELETE FROM user_absences WHERE user_id = ? AND id = ?').run(targetUserId, req.params.absenceId);
    if(r.changes) ereignisSenden({ typ: 'personen' }, req);
    res.json({ ok: true });
  } catch(err){
    console.error('Abwesenheit löschen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// empfangeInDatei: schreibt den rohen Anfrage-Body als Datenstrom in ziel,
// ohne ihn im Speicher zu sammeln. Über maxBytes: Abbruch, Datei weg, 413.
// Rückgabe: Promise<Anzahl Bytes>.
function empfangeInDatei(req, ziel, maxBytes){
  return new Promise((resolve, reject) => {
    const aus = fs.createWriteStream(ziel);
    let n = 0, abgebrochen = false;
    const fehler = (err) => {
      if(abgebrochen) return; abgebrochen = true;
      req.unpipe(aus); aus.destroy(); fs.unlink(ziel, () => {});
      reject(err);
    };
    req.on('data', chunk => {
      n += chunk.length;
      if(n > maxBytes){ const e = new Error('Datei zu groß (höchstens ' + Math.round(maxBytes / 1048576) + ' MB).'); e.status = 413; fehler(e); req.resume(); }
    });
    req.on('aborted', () => fehler(new Error('Upload abgebrochen.')));
    aus.on('error', fehler);
    aus.on('finish', () => { if(!abgebrochen) resolve(n); });
    req.pipe(aus);
  });
}

// Route: Datei-Upload für ein Projekt. Roher Binär-Body (wie /import), Metadaten
// als Query-Parameter, da der Body ausschließlich die Datei selbst enthält.
app.post('/project-files', requireAuth, requireRecht('proj.dateien'), async (req, res) => {
  try {
    const projectNr = String(req.query.projectNr || '');
    if(!projectNr) return res.status(400).json({ ok: false, error: 'Projekt hat keine Projektnummer.' });
    const projectName = String(req.query.projectName || '');

    let filename = '';
    try { filename = decodeURIComponent(String(req.query.filename || '')); }
    catch(e){ filename = String(req.query.filename || ''); }
    const ext = extractFileExtension(filename);

    // Reviewer-Parameter: Komma-getrennte IDs -> Zahlen -> nur existierende,
    // aktive Benutzer -> Uploader (kein Self-Review) entfernen.
    const rawReviewerIds = String(req.query.reviewers || '')
      .split(',')
      .map(s => Number(s.trim()))
      .filter(n => Number.isInteger(n) && n > 0);
    // Kiosk-Konten können nie entscheiden (requireAuth weist sie ab) — als
    // Prüfer würden sie die Datei für immer offen halten.
    const activeUsers = db.prepare(`SELECT id FROM users WHERE active = 1 AND ${sqlOhneWandtafel()}`).all().map(r => r.id);
    const activeSet = new Set(activeUsers);
    const reviewerIds = Array.from(new Set(rawReviewerIds))
      .filter(id => activeSet.has(id) && id !== req.user.id);
    if(reviewerIds.length === 0){
      return res.status(400).json({ ok: false, error: 'Mindestens ein Prüfer erforderlich.' });
    }

    const id = crypto.randomUUID();
    const storedName = id + (ext ? '.' + ext : '');
    const dir = uploadDirFor();
    // Direkt auf die Platte statt erst ganz in den Arbeitsspeicher (Pi Zero:
    // eine 200-MB-Datei im RAM brachte den Server zum Absturz).
    let groesse;
    try { groesse = await empfangeInDatei(req, path.join(dir, storedName), 200 * 1024 * 1024); }
    catch(err){ return res.status(err.status || 400).json({ ok: false, error: err.message }); }
    if(!groesse){
      fs.unlink(path.join(dir, storedName), () => {});
      return res.status(400).json({ ok: false, error: 'Keine Datei empfangen' });
    }

    const contentType = req.headers['content-type'] || 'application/octet-stream';
    const now = new Date().toISOString();

    db.exec('BEGIN');
    try {
      db.prepare(`INSERT INTO project_files
          (id, project_nr, project_name, original_filename, stored_name, content_type, size_bytes, uploaded_by_user_id, status, created_at, updated_at)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?)`)
        .run(id, projectNr, projectName, filename || storedName, storedName, contentType, groesse, req.user.id, now, now);
      const insReviewer = db.prepare(`INSERT INTO project_file_reviewers (file_id, user_id, decision, decided_at, note) VALUES (?, ?, 'pending', '', '')`);
      reviewerIds.forEach(uid => insReviewer.run(id, uid));
      db.exec('COMMIT');
    } catch(err){
      db.exec('ROLLBACK');
      // Bereits geschriebene Datei bei Fehler wieder entfernen (best effort).
      fs.unlink(path.join(dir, storedName), () => {});
      throw err;
    }

    console.log('Datei hochgeladen:', projectNr, '-', filename || storedName);
    res.json({
      ok: true,
      file: {
        id, projectNr, projectName,
        originalFilename: filename || storedName,
        contentType, sizeBytes: groesse, status: 'pending', createdAt: now,
        uploadedBy: req.user.displayName,
      }
    });
  } catch(err){
    console.error('Datei-Upload fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Liste aller Dateien eines Projekts (project_nr), inkl. Uploader-Name,
// Prüferstatus je Prüfer und Kommentaranzahl.
app.get('/project-files', requireAuth, (req, res) => {
  try {
    const projectNr = String(req.query.projectNr || '');
    const rows = db.prepare(`
      SELECT f.*, COALESCE(NULLIF(u.display_name, ''), u.username, 'Gelöschter Benutzer') AS uploadedBy
      FROM project_files f
      LEFT JOIN users u ON u.id = f.uploaded_by_user_id
      WHERE f.project_nr = ?
      ORDER BY f.created_at DESC
    `).all(projectNr);
    const reviewerStmt = db.prepare(`
      SELECT r.user_id AS userId, COALESCE(NULLIF(u.display_name, ''), u.username, 'Gelöschter Benutzer') AS displayName, r.decision AS decision
      FROM project_file_reviewers r
      LEFT JOIN users u ON u.id = r.user_id
      WHERE r.file_id = ?
    `);
    const commentCountStmt = db.prepare('SELECT COUNT(*) AS c FROM project_file_comments WHERE file_id = ?');
    const files = rows.map(row => {
      const out = serializeFileRow(row);
      out.reviewers = reviewerStmt.all(row.id);
      out.commentCount = commentCountStmt.get(row.id).c;
      return out;
    });
    res.json({ ok: true, files });
  } catch(err){
    console.error('Dateiliste fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Datei-Download. Der Dateisystempfad besteht ausschließlich aus der
// (server-seitig erzeugten) stored_name-UUID — original_filename fließt NUR
// in den Content-Disposition-Header ein (zweites res.download()-Argument),
// niemals in den Pfad.
app.get('/project-files/:id/download', requireAuth, (req, res) => {
  try {
    const row = db.prepare('SELECT * FROM project_files WHERE id = ?').get(req.params.id);
    if(!row) return res.status(404).json({ ok: false, error: 'Datei nicht gefunden.' });
    const filePath = path.join(UPLOADS_DIR, row.stored_name);
    res.download(filePath, row.original_filename, (err) => {
      if(err && !res.headersSent){
        console.error('Datei-Download fehlgeschlagen:', err);
        res.status(404).json({ ok: false, error: 'Datei nicht gefunden.' });
      }
    });
  } catch(err){
    console.error('Datei-Download fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Freigabe-Entscheidung eines Prüfers. Nur möglich, solange der
// Gesamtstatus der Datei noch nicht terminal (approved/rejected) ist, und nur
// für Benutzer, die tatsächlich als Prüfer für diese Datei eingetragen sind.
// Neuberechnung des Gesamtstatus: eine Ablehnung blockiert sofort; erst wenn
// ALLE Prüfer zugestimmt haben, gilt die Datei als freigegeben.
app.post('/project-files/:id/review', requireAuth, requireRecht('proj.dateien'), (req, res) => {
  try {
    const fileRow = db.prepare('SELECT * FROM project_files WHERE id = ?').get(req.params.id);
    if(!fileRow) return res.status(404).json({ ok: false, error: 'Datei nicht gefunden.' });

    const { decision, note } = req.body || {};
    if(decision !== 'approved' && decision !== 'rejected'){
      return res.status(400).json({ ok: false, error: 'Ungültige Entscheidung.' });
    }

    const reviewerRow = db.prepare('SELECT * FROM project_file_reviewers WHERE file_id = ? AND user_id = ?').get(fileRow.id, req.user.id);
    if(!reviewerRow) return res.status(403).json({ ok: false, error: 'Sie sind für diese Datei nicht als Prüfer eingetragen.' });

    if(fileRow.status === 'approved' || fileRow.status === 'rejected'){
      return res.status(409).json({ ok: false, error: 'Über diese Datei wurde bereits abschließend entschieden.' });
    }

    const now = new Date().toISOString();
    db.prepare('UPDATE project_file_reviewers SET decision = ?, decided_at = ?, note = ? WHERE file_id = ? AND user_id = ?')
      .run(decision, now, String(note || ''), fileRow.id, req.user.id);

    const allDecisions = db.prepare('SELECT decision FROM project_file_reviewers WHERE file_id = ?').all(fileRow.id).map(r => r.decision);
    let newStatus = 'pending';
    if(allDecisions.some(d => d === 'rejected')) newStatus = 'rejected';
    else if(allDecisions.length > 0 && allDecisions.every(d => d === 'approved')) newStatus = 'approved';

    db.prepare('UPDATE project_files SET status = ?, updated_at = ? WHERE id = ?').run(newStatus, now, fileRow.id);
    console.log('Datei-Freigabe:', fileRow.id, '-', req.user.username, '->', decision, '(Gesamtstatus:', newStatus + ')');
    res.json({ ok: true, status: newStatus });
  } catch(err){
    console.error('Freigabe-Entscheidung fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Kommentare einer Datei lesen (chronologisch aufsteigend).
app.get('/project-files/:id/comments', requireAuth, (req, res) => {
  try {
    const rows = db.prepare(`
      SELECT c.id AS id, c.user_id AS userId, COALESCE(NULLIF(u.display_name, ''), u.username, 'Gelöschter Benutzer') AS displayName,
             c.body AS body, c.created_at AS createdAt
      FROM project_file_comments c
      LEFT JOIN users u ON u.id = c.user_id
      WHERE c.file_id = ?
      ORDER BY c.created_at ASC
    `).all(req.params.id);
    res.json({ ok: true, comments: rows });
  } catch(err){
    console.error('Kommentare laden fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Kommentar zu einer Datei hinzufügen. Jeder eingeloggte Benutzer darf
// kommentieren, nicht nur die eingetragenen Prüfer.
app.post('/project-files/:id/comments', requireAuth, requireRecht('proj.dateien'), (req, res) => {
  try {
    const fileRow = db.prepare('SELECT id FROM project_files WHERE id = ?').get(req.params.id);
    if(!fileRow) return res.status(404).json({ ok: false, error: 'Datei nicht gefunden.' });
    const body = String((req.body || {}).body || '').trim();
    if(!body) return res.status(400).json({ ok: false, error: 'Kommentartext erforderlich.' });
    const id = crypto.randomUUID();
    const now = new Date().toISOString();
    db.prepare('INSERT INTO project_file_comments (id, file_id, user_id, body, created_at) VALUES (?, ?, ?, ?, ?)')
      .run(id, fileRow.id, req.user.id, body, now);
    res.json({ ok: true, comment: { id, userId: req.user.id, displayName: req.user.displayName, body, createdAt: now } });
  } catch(err){
    console.error('Kommentar anlegen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Datei löschen. Erlaubt für den Uploader, solange die Datei noch
// 'pending' ist, oder jederzeit für Admins. Löscht zuerst die DB-Zeile
// (inkl. abhängiger Prüfer-/Kommentar-Zeilen — explizit statt sich auf eine
// FK-CASCADE zu verlassen, da project_file_reviewers/project_file_comments
// keine deklarierten FOREIGN KEY-Constraints auf project_files haben), dann
// best-effort die physische Datei.
app.delete('/project-files/:id', requireAuth, (req, res) => {
  try {
    const row = db.prepare('SELECT * FROM project_files WHERE id = ?').get(req.params.id);
    if(!row) return res.status(404).json({ ok: false, error: 'Datei nicht gefunden.' });

    const isOwnerAndPending = (req.user.id === row.uploaded_by_user_id) && row.status === 'pending';
    const isAdmin = hatRecht(req.user, 'proj.dateienFremd');
    if(!isOwnerAndPending && !isAdmin){
      return res.status(403).json({ ok: false, error: 'Keine Berechtigung, diese Datei zu löschen.' });
    }

    db.exec('BEGIN');
    try {
      db.prepare('DELETE FROM project_file_comments WHERE file_id = ?').run(row.id);
      db.prepare('DELETE FROM project_file_reviewers WHERE file_id = ?').run(row.id);
      db.prepare('DELETE FROM project_files WHERE id = ?').run(row.id);
      db.exec('COMMIT');
    } catch(err){
      db.exec('ROLLBACK');
      throw err;
    }
    fs.unlink(path.join(UPLOADS_DIR, row.stored_name), (err) => {
      if(err) console.error('Physische Datei konnte nicht gelöscht werden:', err);
    });
    console.log('Datei gelöscht:', row.id, '-', row.original_filename);
    res.json({ ok: true });
  } catch(err){
    console.error('Datei löschen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// ---------- Protokolle (Besprechungsprotokolle je Projekt) ----------
//
// Verknüpft über project_nr (siehe Tabellendefinition oben), nicht über
// week_label/project_id. Speichermuster: eigene Routen, aber "ganzes Objekt
// ersetzen" wie saveWeekRelational()/deleteWeekData() (Zeilen löschen, neu
// einfügen, in einer Transaktion) statt vieler kleiner Einzel-Feld-Routen —
// Punkte und Teilnehmer werden ohnehin gemeinsam in einer Sitzung bearbeitet.

// loadProtokollDetail: baut ein volles Protokoll (Kopfdaten + Teilnehmer +
// Punkte) für die Antwort von GET/POST/PUT zusammen. Parameter: id.
// Rückgabe: Objekt oder null, wenn nicht gefunden.
function loadProtokollDetail(id){
  const row = db.prepare(`SELECT p.*, u.display_name AS verfasser_name
    FROM project_protokolle p LEFT JOIN users u ON u.id = p.verfasser_user_id
    WHERE p.id = ?`).get(id);
  if(!row) return null;
  const teilnehmer = db.prepare('SELECT * FROM protokoll_teilnehmer WHERE protokoll_id = ? ORDER BY array_order').all(row.id)
    .map(t => ({ id: t.id, name: t.name, firma: t.firma, anwesend: !!t.anwesend }));

  // vorherigeWerte: Thema/Text des UNMITTELBAR vorangegangenen Protokolls
  // (chronologisch davor, per nummer), je stamm_id — Grundlage für
  // themaGeaendert/textGeaendert unten (Eriks Wunsch): ein fortgeschriebener
  // Punkt (neu=0), dessen Thema oder Text sich gegenüber der letzten Fassung
  // geändert hat, soll das erkennbar machen, aber nur AN DEM GEÄNDERTEN FELD
  // (gelb), nicht an der ganzen Zeile wie bei einem echten neuen Punkt
  // (.is-neu) — ein neuer Punkt hat ohnehin keine Vorfassung zum Vergleichen.
  const prevRow = db.prepare(`SELECT id FROM project_protokolle
    WHERE project_nr = ? AND nummer < ? ORDER BY nummer DESC LIMIT 1`).get(row.project_nr, row.nummer);
  const vorherigeWerte = new Map();
  if(prevRow){
    db.prepare('SELECT stamm_id, thema, text FROM protokoll_punkte WHERE protokoll_id = ?').all(prevRow.id)
      .forEach(p => vorherigeWerte.set(p.stamm_id, { thema: p.thema, text: p.text }));
  }

  const punkte = db.prepare('SELECT * FROM protokoll_punkte WHERE protokoll_id = ? ORDER BY array_order').all(row.id)
    .map(p => {
      const vorher = !p.neu ? vorherigeWerte.get(p.stamm_id) : null;
      return { id: p.id, nummer: p.nummer, gruppe: p.gruppe, neu: !!p.neu, thema: p.thema, text: p.text,
        zustaendig: p.zustaendig, termin: p.termin, status: p.status || 'offen', erstelltAm: p.erstellt_am || '',
        entfaelltNaechstes: !!p.entfaellt_naechstes,
        themaGeaendert: !!(vorher && vorher.thema !== p.thema),
        textGeaendert: !!(vorher && vorher.text !== p.text) };
    });
  return {
    id: row.id, projectNr: row.project_nr, projectName: row.project_name, nummer: row.nummer,
    datum: row.datum, betreff: row.betreff, ort: row.ort, verfasserName: row.verfasser_name || '',
    weekLabel: row.week_label, quelleDateiname: row.quelle_dateiname || '',
    createdAt: row.created_at, updatedAt: row.updated_at,
    teilnehmer, punkte
  };
}

// Route: Liste aller Protokolle eines Projekts (Zusammenfassung je Protokoll
// für die Listenansicht — offene/erledigte Punkte, Teilnehmerzahl —, nicht
// die vollen Punkte/Teilnehmer, das liefert erst GET /:id).
app.get('/project-protokolle', requireAuth, (req, res) => {
  try {
    const projectNr = String(req.query.projectNr || '');
    if(!projectNr) return res.status(400).json({ ok: false, error: 'Projekt hat keine Projektnummer.' });
    const rows = db.prepare(`SELECT p.*, u.display_name AS verfasser_name
      FROM project_protokolle p LEFT JOIN users u ON u.id = p.verfasser_user_id
      WHERE p.project_nr = ? ORDER BY p.nummer DESC`).all(projectNr);
    const protokolle = rows.map(row => {
      const punkte = db.prepare('SELECT status FROM protokoll_punkte WHERE protokoll_id = ?').all(row.id);
      const teilnehmerCount = db.prepare('SELECT COUNT(*) AS c FROM protokoll_teilnehmer WHERE protokoll_id = ?').get(row.id).c;
      const offenCount = punkte.filter(p => p.status === 'offen').length;
      return {
        id: row.id, nummer: row.nummer, datum: row.datum, betreff: row.betreff, ort: row.ort,
        verfasserName: row.verfasser_name || '', createdAt: row.created_at,
        // Info-Punkte sind weder offen noch erledigt — eigene Zahl statt
        // sie bei "erledigt" mitzuzählen.
        offenCount, erledigtCount: punkte.filter(p => p.status === 'erledigt').length,
        infoCount: punkte.filter(p => p.status === 'info').length, teilnehmerCount
      };
    });
    res.json({ ok: true, protokolle });
  } catch(err){
    console.error('Protokolle laden fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

app.get('/project-protokolle/:id', requireAuth, (req, res) => {
  try {
    const protokoll = loadProtokollDetail(req.params.id);
    if(!protokoll) return res.status(404).json({ ok: false, error: 'Protokoll nicht gefunden.' });
    res.json({ ok: true, protokoll });
  } catch(err){
    console.error('Protokoll laden fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: neues Protokoll anlegen. nummer wird serverseitig vergeben
// (MAX(nummer)+1 je project_nr, sonst 1); Teilnehmer kommen vorbelegt vom
// Client (siehe js/plan/plan-protokoll.js); offene Punkte des zuletzt
// angelegten Protokolls desselben Projekts werden KOPIERT (neue id, gleiche
// stamm_id/nummer, neu=0) — das "Fortschreiben". Im allerersten Protokoll
// eines Projekts gibt es nichts zu kopieren, dort sind zwangsläufig alle
// später hinzugefügten Punkte neu.
// legeProtokollAn: die gemeinsame Anlege-Logik für ein neues Protokoll —
// genutzt sowohl von POST /project-protokolle (manuelles Anlegen) als auch
// von POST /project-protokolle/import (Datei-Import, siehe unten). Beide
// Wege sollen ein Protokoll auf exakt dieselbe Art in die Sitzungsfolge
// einreihen: nummer fortlaufend je project_nr, offene Punkte des zuletzt
// angelegten Protokolls desselben Projekts kopiert (das "Fortschreiben",
// siehe CLAUDE.md "### Protokolle"). Der Import hängt danach zusätzlich
// erkannte Punkte an (`zusatzPunkte`) — beim manuellen Anlegen ist dieses
// Array einfach leer.
// Parameter: { projectNr, projectName, weekLabel, datum, betreff, ort,
// verfasserUserId, teilnehmer, zusatzPunkte, quelleDateiname,
// quelleStoredName } — die letzten beiden bleiben leer für ein normal
// angelegtes Protokoll. Läuft in einer eigenen Transaktion. Rückgabe: die
// neue Protokoll-`id`. Wirft bei einem Fehler (Aufrufer fangen und in eine
// HTTP-Antwort übersetzen).
// VALID_PROTOKOLL_PUNKT_STATUS: der Status eines Punkts — 'offen' (läuft
// weiter, wird fortgeschrieben), 'erledigt' (abgeschlossen) oder 'info'
// (rein informativ, keine eigene Handlung nötig — z. B. eine bereits
// zur Kenntnis genommene Mitteilung). Nur 'offen' wird beim Anlegen des
// nächsten Protokolls fortgeschrieben (legeProtokollAn()); sowohl
// 'erledigt' als auch 'info' laufen nicht weiter mit, aus demselben Grund:
// beides ist nichts mehr, worauf jemand noch reagieren muss.
const VALID_PROTOKOLL_PUNKT_STATUS = new Set(['offen', 'erledigt', 'info']);
// PROTOKOLL_PUNKT_MARKER: erkennt einen Zeilenanfang wie "1.1", "TOP 3",
// "Punkt 2.4" oder "1." als Beginn eines neuen Punkts; der Rest der Zeile
// wird dessen Thema. Ein Regex-Satz für mehrere gängige Schreibweisen, kein
// Anspruch auf Vollständigkeit — siehe erkennePunkteAusText().
const PROTOKOLL_PUNKT_MARKER = /^\s*(?:top|punkt)?\s*(\d+(?:\.\d+)*)[.\):]?\s+(.+)$/i;
// PROTOKOLL_LABEL_MUSTER: Label-Muster, die INNERHALB eines erkannten
// Punkttexts nach Zuständig/Termin suchen — nur bei eindeutigem Treffer
// übernommen (siehe erkennePunkteAusText()).
// Nicht-gierig bis zum nächsten Satzende, Zeilenende ODER dem nächsten
// bekannten Label — sonst reißt z. B. "Zuständig: Firma Muster. Termin: …"
// (beides auf einer Zeile, ohne Komma dazwischen) den Termin-Teil mit in den
// Zuständig-Treffer hinein. Ein Punkt gilt nur als Satzende, wenn ihm keine
// Ziffer folgt — sonst würde ein Datum wie "15.10.2026" beim ersten Punkt
// abgeschnitten.
const PROTOKOLL_LABEL_STOP = '(?=[,;]|\\.(?!\\d)|$|\\s*(?:zust(?:ä|ae|a)ndig|verantwortlich|termin|frist)\\s*:)';
const PROTOKOLL_LABEL_MUSTER = [
  { feld: 'zustaendig', regex: new RegExp('(?:zust(?:ä|ae|a)ndig|verantwortlich)\\s*:\\s*([^,;]+?)' + PROTOKOLL_LABEL_STOP, 'i') },
  { feld: 'termin', regex: new RegExp('(?:termin|frist)\\s*:\\s*([^,;]+?)' + PROTOKOLL_LABEL_STOP, 'i') }
];

// erkennePunkteAusText: reines String-Processing ohne I/O (kein Netzwerk,
// keine KI) — teilt einen aus PDF/Word extrahierten Freitext heuristisch in
// Protokoll-Punkte auf. Siehe CLAUDE.md "### Protokolle" für die Begründung
// jeder Regel. Erkennt PROTOKOLL_PUNKT_MARKER-Zeilen als neue Punkte, alles
// dazwischen wird deren Text; findet sich darin ein PROTOKOLL_LABEL_MUSTER,
// wird der Wert herausgelöst statt im Fließtext zu bleiben. `gruppe` wird
// bewusst NIE geraten — jeder erkannte Punkt landet in "Ohne Gruppe", der
// Nutzer ordnet in der ohnehin vorhandenen Detailansicht selbst zu. Findet
// sich im ganzen Text kein einziger Marker (keine erkennbare Nummerierung),
// greift ein Fallback: jeder nicht-leere Absatz (durch Leerzeile getrennt)
// wird ein eigener Punkt — liefert immer ein Grundgerüst statt eines leeren
// Protokolls. `nummer` hier ist rein informationell (die im Quelldokument
// gefundene Nummer) — angezeigt wird sie ohnehin nie aus der Datenbank,
// sondern immer frisch aus Gruppe+Reihenfolge errechnet
// (berechneProtokollNummern(), public/js/plan/plan-protokoll.js).
// Parameter: text (String). Rückgabe: Array von
// { nummer, gruppe, thema, text, zustaendig, termin, erledigt }.
// normalisiereTermin: bringt ein erkanntes Datum auf ISO (JJJJ-MM-TT), das
// Format, das Protokoll-Ansicht, PDF (parseDateISO()) und <input type=date>
// erwarten. Protokolle schreiben "15.10.2026" oder "5.1.26" — das wurde
// bisher unverändert gespeichert und erschien dann überall als "kein
// Termin"; bei "TODOs aus Protokoll" ging die Fälligkeit still verloren.
// Was kein erkennbares Datum ist ("KW 45", "laufend"), bleibt wie es ist.
// Parameter: wert. Rückgabe: String.
function normalisiereTermin(wert){
  const s = String(wert || '').trim();
  const m = s.match(/^(\d{1,2})\.(\d{1,2})\.(\d{2}|\d{4})$/);
  if(!m) return s;
  const jahr = m[3].length === 2 ? '20' + m[3] : m[3];
  const monat = Number(m[2]), tag = Number(m[1]);
  if(monat < 1 || monat > 12 || tag < 1 || tag > 31) return s;
  return jahr + '-' + String(monat).padStart(2, '0') + '-' + String(tag).padStart(2, '0');
}

function erkennePunkteAusText(text){
  const zeilen = String(text || '').split(/\r?\n/).map(z => z.trim());

  const treffer = [];
  let aktuell = null;
  zeilen.forEach(zeile => {
    if(!zeile) return;
    const m = zeile.match(PROTOKOLL_PUNKT_MARKER);
    if(m){
      if(aktuell) treffer.push(aktuell);
      aktuell = { nummer: m[1], thema: m[2].trim(), textZeilen: [], zustaendig: '', termin: '', erledigt: false };
    } else if(aktuell){
      aktuell.textZeilen.push(zeile);
    }
  });
  if(aktuell) treffer.push(aktuell);

  if(treffer.length === 0){
    return String(text || '').split(/\r?\n\s*\r?\n/)
      .map(a => a.replace(/\s+/g, ' ').trim())
      .filter(Boolean)
      .map(a => ({
        nummer: '', gruppe: '', thema: a.slice(0, 60), text: a.length > 60 ? a : '',
        zustaendig: '', termin: '', erledigt: false
      }));
  }

  return treffer.map(t => {
    // Labels wie "Zuständig:"/"Termin:" stehen bei kurzen Punkten oft in
    // derselben Zeile wie das Thema (ein Word-Absatz je Punkt), nicht in
    // einer eigenen Folgezeile — deshalb wird über Thema UND die
    // nachfolgenden Zeilen gemeinsam gesucht, nicht nur über Letztere.
    let thema = t.thema;
    let restText = t.textZeilen.join(' ').replace(/\s+/g, ' ').trim();
    PROTOKOLL_LABEL_MUSTER.forEach(({ feld, regex }) => {
      let lm = thema.match(regex);
      if(lm){
        t[feld] = lm[1].trim();
        thema = thema.replace(lm[0], '').trim();
        return;
      }
      lm = restText.match(regex);
      if(lm){
        t[feld] = lm[1].trim();
        restText = restText.replace(lm[0], '').trim();
      }
    });
    // Entfernen eines Labels aus der Mitte des Themas kann einen
    // verwaisten Satzpunkt zurücklassen ("…abzuschließen. ." statt
    // "…abzuschließen.") — am Ende auf einen einzigen Punkt einkürzen.
    thema = thema.replace(/[.\s]+$/, m => (m.indexOf('.') !== -1 ? '.' : '')).trim();
    const erledigt = /\berledigt\b|\bgeschlossen\b/i.test(restText) || /\berledigt\b|\bgeschlossen\b/i.test(thema);
    // status zusätzlich zu erledigt: Der Client (TODOs aus Protokoll) wählt
    // offene Punkte über status vor — ohne das Feld war nichts vorausgewählt.
    return { nummer: t.nummer, gruppe: '', thema, text: restText,
      zustaendig: t.zustaendig, termin: normalisiereTermin(t.termin), erledigt,
      status: erledigt ? 'erledigt' : 'offen' };
  });
}

// ---------- KI-gestützte Erkennung (ChatGPT/Claude) für den Protokoll-Import ----------
//
// Alternative zu erkennePunkteAusText() oben: statt starrer Regex-Muster
// liest ein Sprachmodell den Text und liefert dieselbe Punkt-Form zurück.
// Bewusst zusätzlich zur Heuristik, nicht statt ihr — siehe CLAUDE.md
// "### Protokolle": ohne hinterlegten Schlüssel oder bei jedem Fehler
// (Netzwerk, falscher Schlüssel, Zeitüberschreitung, unerwartete Antwort)
// fällt der Aufrufer (POST /project-protokolle/import) automatisch auf
// erkennePunkteAusText() zurück — der Import funktioniert immer, auch ohne
// Internetzugang des Servers. Beide Anbieter laufen über das in Node bereits
// global verfügbare fetch() — keine neue npm-Abhängigkeit.

const KI_MAX_TEXT_LAENGE = 40000; // ~10k Tokens; deckelt Kosten/Dauer bei
  // einer versehentlich riesigen Datei, reicht für jedes normale Protokoll.
const KI_TIMEOUT_MS_CLOUD = 45000;
// Ein lokal laufender Server (LM Studio, Ollama) rechnet auf der eigenen
// Maschine, oft ohne oder mit begrenzter GPU-Beschleunigung — eine einzelne
// Antwort kann mehrere Minuten dauern, weit jenseits dessen, was bei einer
// Cloud-API schon ein Hänger wäre. Mit dem kurzen, einheitlichen Timeout
// brach die Anfrage bei Erik vorzeitig ab ("This operation was aborted"),
// obwohl LM Studio nachweislich weiterrechnete und fertig geworden wäre
// ("läuft aber durch"). Ein kurzer, einheitlicher Timeout hätte lokale
// Modelle damit praktisch unbenutzbar gemacht. Ursprünglich 300000 (5 min),
// dann 900000 (15 min) — beide brachen bei Erik immer noch ab, vor allem
// seit der Prompt jetzt für jeden erkannten Punkt echten Fließtext erzeugt
// (also deutlich mehr Tokens generiert als die frühere, kaputte Fassung,
// die oft fast leer blieb): bei ~12.000 generierten Tokens auf seiner
// Hardware lief LM Studio selbst nachweislich sauber bis zum Ende durch
// (vom eigenen "Fertig"-Zustand im LM-Studio-Fenster bestätigt), nur die
// eigene AbortController-Schranke hier griff vorher. Auf 30 Minuten
// angehoben, mit entsprechendem Headroom bei LOKAL_DISPATCHER (unten).
// Der Import zeigt währenddessen den Ladehinweis im Dialog
// (#protokollImportLoading, plan-protokoll.js), das lange Warten ist also
// sichtbar, kein scheinbares Hängenbleiben.
const KI_TIMEOUT_MS_LOKAL = 1800000;

// KI_TIMEOUT_MS_CLOUD_FREMD: ein abweichender, aber weiterhin REMOTE
// liegender Endpunkt (z. B. Mammouth.ai, OpenRouter, ein Firmen-Proxy) ist
// weder "die echte, bekanntermaßen schnelle OpenAI/Anthropic-API" (dort
// gilt zurecht der scharfe KI_TIMEOUT_MS_CLOUD) noch "lokale CPU-Inferenz,
// die Minuten dauern darf" (KI_TIMEOUT_MS_LOKAL) — ein eigener,
// mittlerer Wert. Gefunden bei einem echten Fehlschlag: "TODOs aus
// Protokoll" brach bei Erik zuverlässig mit "This operation was aborted"
// ab, obwohl der Protokoll-Import grundsätzlich funktionierte — derselbe
// Konto-Schlüssel zeigte auf https://api.mammouth.ai/v1 (Modell
// "gpt-6-luna"), kein Loopback, also griff bislang der scharfe
// KI_TIMEOUT_MS_CLOUD (45s). Direkt gegen den echten Schlüssel nachgestellt
// (derselbe Aufruf, derselbe Prompt, dasselbe Dokument wie im Fehlerfall):
// ein einzelnes triviales Prompt beantwortete der Anbieter in 1,3s, die
// tatsächliche Punkte-Erkennung eines realen Protokolls (29.594 Zeichen)
// brauchte dagegen 39,2s — schon im Erfolgsfall nur 6s unter dem alten
// Limit, jede normale Schwankung (Tageszeit, Dokumentlänge, Anbieterlast)
// reichte seither zuverlässig zum Abbruch. Ein Drittanbieter-Proxy ist
// grundsätzlich langsamer und weniger vorhersagbar als die Original-API,
// aber immer noch ein verwalteter Cloud-Dienst, keine CPU-Inferenz auf
// fremder Hardware — 2 Minuten geben das Dreifache der gemessenen Dauer
// als Spielraum, ohne in die Größenordnung von KI_TIMEOUT_MS_LOKAL zu gehen.
const KI_TIMEOUT_MS_CLOUD_FREMD = 120000;

// LOKAL_DISPATCHER: Node's globales fetch() läuft intern über undici, dessen
// eigener Standard-Agent Verbindungen nach headersTimeout/bodyTimeout = 5
// Minuten von sich aus kappt — UNABHÄNGIG vom eigenen AbortController unten.
// Solange KI_TIMEOUT_MS_LOKAL ebenfalls bei 5 Minuten lag, fiel das nicht
// auf: beide Zeitgeber liefen praktisch gleichzeitig ab, und man sah immer
// den eigenen, sauberen "This operation was aborted"-Abbruch. Nach dem
// Anheben auf 15 Minuten griff undicis eigenes 5-Minuten-Limit als Erstes —
// bei Erik reproduzierbar als "fetch failed", obwohl LM Studio selbst
// nachweislich sauber durchlief. Ein eigener Agent mit angehobenem Limit
// ist die einzige Möglichkeit, das zu umgehen: fetch() selbst bietet dafür
// keine Option, nur das (nicht standardisierte, aber von Node übernommene)
// `dispatcher`-Feld in den Request-Optionen. Nur für lokale Ziele
// verwendet — eine Cloud-API bleibt beim kurzen KI_TIMEOUT_MS_CLOUD (45s),
// weit unter undicis Vorgabewert, dort besteht das Problem gar nicht.
const LOKAL_DISPATCHER = new UndiciAgent({
  headersTimeout: KI_TIMEOUT_MS_LOKAL + 10000,
  bodyTimeout: KI_TIMEOUT_MS_LOKAL + 10000
});

// KI_SYSTEM_PROMPT wurde NICHT nach Stil-/Rechtschreibkonvention geglättet,
// sondern bewusst wortgleich zu der Fassung übernommen, die gegen ein
// echtes, mehrstufig nummeriertes Besprechungsprotokoll (PromanX/Phenix-
// Format: "01" Kapitel, "01.0" Unterkapitel, "01.0 01.03" der eigentliche
// Punkt) tatsächlich funktioniert hat — gegen Eriks lokales LM-Studio-Modell
// erwies sich das Ergebnis als erstaunlich instabil gegenüber minimalen
// Formulierungsänderungen: dieselbe Aufgabe lieferte je nach Umformulierung
// zwischen 0 und 11 erkannten Punkten, mal mit vollem Text, mal mit
// durchgehend LEEREM "text" (reproduzierbar bei temperature:0, also keine
// bloße Zufallsstreuung). Ursache war u. a. eine vorangestellte, allgemein
// gehaltene "erfinde nichts, lass im Zweifel leer"-Anweisung, die das
// Modell offenbar dazu brachte, aus Vorsicht auch "text" leer zu lassen,
// obwohl der Inhalt eindeutig im Dokument stand — das genaue Gegenteil des
// gemeldeten Fehlers ("kopiert die Texte nicht mit, erstellt nur die
// Überschriften"). Eine zweite, von Erik angestoßene Runde ergänzte GENAU
// EINE weitere, chirurgisch kurze Anweisung — mehrere eigenständige Punkte
// unter derselben Überschrift einzeln auszugeben, UND mehrere aufeinander-
// folgende, je datierte Textabsätze desselben Punkts (eine im Quelldokument
// selbst geführte Revisionshistorie über mehrere Besprechungen) zu einem
// zusammenhängenden "text" zusammenzuführen, statt sie als eigene, von
// ihrem Thema abgetrennte Punkte auszugeben — und bestand denselben
// Stabilitätstest (reales Dokument, temperature:0): korrekt erkannte
// Punkte mit vollständig zusammengeführtem Text statt verwaister, themenloser
// Fragmente. Jede WEITERE Ergänzung darüber hinaus (z. B. eine explizite
// Teilnehmer-Anleitung) hat in denselben Tests dagegen zuverlässig wieder
// zur Regression geführt — deshalb bleibt "teilnehmer" bewusst ungeleitet,
// das Schema allein genügt dafür. Ein eigener Blindgang dabei: gegen einen
// künstlich verkürzten Testausschnitt OHNE die echte Teilnehmer-/Verteiler-
// Tabelle des Dokuments geriet das Modell beim Versuch, "teilnehmer" trotzdem
// zu befüllen, in eine Wiederholungsschleife (tausendfach dasselbe Namens-
// Fragment, bis das Token-Limit die Antwort mitten im JSON abschnitt) — mit
// der echten Tabelle (wie jeder reale Import sie tatsächlich schickt) trat
// das nicht wieder auf, lief sogar spürbar schneller durch. frequency_penalty/
// presence_penalty unten bleiben trotzdem als zusätzliches Sicherheitsnetz
// gegen genau solche Wiederholungsschleifen bestehen.
const KI_SYSTEM_PROMPT = 'Extrahiere ALLE Besprechungspunkte aus diesem Protokoll-Text, auch wenn es viele sind. '
  + 'Das Dokument ist mehrstufig nummeriert (z.B. "01" Kapitel, "01.0" Unterkapitel, "01.0 01.03" der echte Punkt mit Text). '
  + 'Nur Zeilen mit eigenem Fließtext darunter werden ein Punkt - reine Kapitelüberschriften ohne Text NICHT. '
  + 'Stehen unter einer Überschrift mehrere eigene Punkte, gib jeden einzeln aus. Folgen auf einen Punkt weitere '
  + 'Absätze ohne neue eigene Nummer, gehören sie zu diesem Punkt dazu - auch wenn ein spaeterer Absatz einen '
  + 'anderen Status zeigt, bleibt es EIN Punkt mit dem Status des letzten Absatzes. '
  + '"status" ist offen, erledigt oder info - info wenn der Text den Punkt selbst so kennzeichnet (z.B. das Wort '
  + '"Info" direkt beim Punkt) oder der Punkt rein informativ ohne eigene Handlung ist, erledigt nur bei '
  + 'ausdruecklicher Erledigt-/Geschlossen-Kennzeichnung, sonst offen. '
  + 'Gib fuer jeden Punkt nummer, thema, text, zustaendig, termin, status, gruppe (leer lassen wenn unklar) zurueck. Erfinde nichts.';

// readUserAiKey/writeUserAiKey: Schlüssel+URL liegen PERSÖNLICH je Konto in
// user_ai_keys (siehe CREATE TABLE weiter oben bei den übrigen User-Kind-
// Tabellen), nicht firmenweit in app_settings — jeder Nutzer verwaltet
// seinen eigenen Zugang unter Einstellungen → Mein Konto
// (js/settings/settings.js), genau wie E-Mail und Passwort. Klartext in der
// SQLite-Datei, wie jeder andere Wert dort auch.
function readUserAiKey(userId, provider){
  const row = db.prepare('SELECT api_key, api_url, model FROM user_ai_keys WHERE user_id = ? AND provider = ?').get(userId, provider);
  return { apiKey: row ? row.api_key : '', apiUrl: row ? row.api_url : '', model: row ? row.model : '' };
}

function writeUserAiKey(userId, provider, patch){
  const bestehend = readUserAiKey(userId, provider);
  const apiKey = Object.prototype.hasOwnProperty.call(patch, 'apiKey') ? String(patch.apiKey || '') : bestehend.apiKey;
  const apiUrl = Object.prototype.hasOwnProperty.call(patch, 'apiUrl') ? String(patch.apiUrl || '') : bestehend.apiUrl;
  // model: leer = die im jeweiligen Aufrufer hartcodierte Vorgabe gilt
  // (gpt-4o-mini/gpt-4o bzw. claude-haiku/claude-sonnet-5) - nur bei einem
  // eigenständigen Anbieter mit abweichendem Modell-Katalog (z. B.
  // Mammouth.ai) muss das hier überschrieben werden.
  const model = Object.prototype.hasOwnProperty.call(patch, 'model') ? String(patch.model || '') : bestehend.model;
  db.prepare(`INSERT INTO user_ai_keys (user_id, provider, api_key, api_url, model) VALUES (?, ?, ?, ?, ?)
    ON CONFLICT(user_id, provider) DO UPDATE SET api_key = excluded.api_key, api_url = excluded.api_url, model = excluded.model`)
    .run(userId, provider, apiKey, apiUrl, model);
}

// KI_DEFAULT_URL: vor istLoopbackHost()/fetchMitTimeout() platziert (stand
// ursprünglich weiter unten bei normalisiereAiUrl()), weil fetchMitTimeout()
// unten die beiden Adressen jetzt selbst braucht, um einen ECHTEN
// Anbieter-Endpunkt von einem abweichenden (lokal ODER ein fremder
// Cloud-Proxy) zu unterscheiden — siehe istStandardCloudHost() und den
// Fund bei KI_TIMEOUT_MS_CLOUD_FREMD weiter unten.
const KI_DEFAULT_URL = {
  chatgpt: 'https://api.openai.com/v1/chat/completions',
  claude: 'https://api.anthropic.com/v1/messages'
};

// istLoopbackHost: gemeinsame Grundlage für istGueltigeAiUrl() (URL-Prüfung
// beim Speichern) und fetchMitTimeout() (Timeout-Wahl beim Aufruf) — beide
// müssen dieselbe Vorstellung von "läuft auf der eigenen Maschine" teilen.
function istLoopbackHost(hostname){
  return hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '::1' || hostname === '[::1]';
}

// istStandardCloudHost: true nur für die beiden ECHTEN Anbieter-Hosts aus
// KI_DEFAULT_URL (api.openai.com/api.anthropic.com) — die einzigen, bei
// denen "eine Antwort dauert ungewöhnlich lange" zuverlässig "hier ist
// etwas kaputt" bedeutet. Grundlage für fetchMitTimeout()s dritte Stufe
// (KI_TIMEOUT_MS_CLOUD_FREMD) direkt darunter.
function istStandardCloudHost(hostname){
  return hostname === new URL(KI_DEFAULT_URL.chatgpt).hostname || hostname === new URL(KI_DEFAULT_URL.claude).hostname;
}

// istGueltigeAiUrl: https wird grundsätzlich verlangt (der Schlüssel reist
// sonst im Klartext über ein Netz, das nicht die eigene Maschine ist) — mit
// EINER Ausnahme: http auf dem Loopback. Ein lokal laufender Server wie
// LM Studio oder Ollama bietet praktisch nie ein TLS-Zertifikat für
// localhost an; ihn auszuschließen hätte den naheliegendsten Anwendungsfall
// einer eigenen API-URL — ein kostenloses, lokales Modell statt eines
// kostenpflichtigen Cloud-Zugangs — unmöglich gemacht. Der Klartext
// verlässt dabei nie die eigene Maschine, das Risiko besteht also nicht.
// Rückgabe: bool.
function istGueltigeAiUrl(url){
  let parsed;
  try { parsed = new URL(url); } catch(e){ return false; }
  if(parsed.protocol === 'https:') return true;
  return parsed.protocol === 'http:' && istLoopbackHost(parsed.hostname);
}

async function fetchMitTimeout(url, options){
  // Drei Stufen statt zwei: echter Anbieter-Host (knapp, 45s) < abweichender
  // Remote-Host wie ein Drittanbieter-Proxy (mittel, 2min, s.
  // KI_TIMEOUT_MS_CLOUD_FREMD) < Loopback (großzügig, 30min) — siehe dortigen
  // Kommentar für den konkreten Fehlschlag, der die mittlere Stufe nötig machte.
  let istLokal = false;
  let istStandard = true;
  try {
    const hostname = new URL(url).hostname;
    istLokal = istLoopbackHost(hostname);
    istStandard = istStandardCloudHost(hostname);
  } catch(e){ /* ungültige URL: Vorgabe bleibt der knappe Standard-Timeout */ }
  const timeoutMs = istLokal ? KI_TIMEOUT_MS_LOKAL : (istStandard ? KI_TIMEOUT_MS_CLOUD : KI_TIMEOUT_MS_CLOUD_FREMD);
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), timeoutMs);
  try {
    const fetchOptions = Object.assign({}, options, { signal: controller.signal });
    if(istLokal) fetchOptions.dispatcher = LOKAL_DISPATCHER;
    return await fetch(url, fetchOptions);
  } finally {
    clearTimeout(timer);
  }
}

// normalisierePunktAusKi: eine KI-Antwortzeile in dieselbe Form wie ein
// erkennePunkteAusText()-Punkt bringen — beide Aufrufer (POST-Route,
// legeProtokollAn) müssen nicht wissen, woher ein Punkt stammt.
function normalisierePunktAusKi(p){
  return {
    nummer: String((p && p.nummer) || ''),
    gruppe: String((p && p.gruppe) || ''),
    thema: String((p && p.thema) || ''),
    text: String((p && p.text) || ''),
    zustaendig: String((p && p.zustaendig) || ''),
    termin: normalisiereTermin((p && p.termin) || ''),
    status: VALID_PROTOKOLL_PUNKT_STATUS.has(p && p.status) ? p.status : 'offen'
  };
}

// normalisiereTeilnehmerAusKi: Gegenstück zu normalisierePunktAusKi() für
// das zweite KI_PUNKT_SCHEMA-Feld. "anwesend" defaultet — anders als
// "erledigt" oben — auf true, nicht auf false: eine erkannte Person gilt als
// anwesend, außer der Prompt weist das Modell ausdrücklich an, sie als
// entschuldigt/abwesend zu kennzeichnen (dieselbe Grundannahme wie beim
// manuellen "+ Teilnehmer" in der Detailansicht, js/plan/plan-protokoll.js).
function normalisiereTeilnehmerAusKi(t){
  return {
    name: String((t && t.name) || ''),
    firma: String((t && t.firma) || ''),
    anwesend: !(t && t.anwesend === false)
  };
}

const KI_PUNKT_SCHEMA = {
  type: 'object',
  properties: {
    punkte: {
      type: 'array',
      items: {
        type: 'object',
        properties: {
          nummer: { type: 'string' },
          gruppe: { type: 'string' },
          thema: { type: 'string' },
          text: { type: 'string' },
          zustaendig: { type: 'string' },
          termin: { type: 'string' },
          status: { type: 'string', enum: ['offen', 'erledigt', 'info'] }
        },
        required: ['nummer', 'gruppe', 'thema', 'text', 'zustaendig', 'termin', 'status'],
        additionalProperties: false
      }
    },
    teilnehmer: {
      type: 'array',
      items: {
        type: 'object',
        properties: {
          name: { type: 'string' },
          firma: { type: 'string' },
          anwesend: { type: 'boolean' }
        },
        required: ['name', 'firma', 'anwesend'],
        additionalProperties: false
      }
    }
  },
  required: ['punkte', 'teilnehmer'],
  additionalProperties: false
};

// KI_DEFAULT_URL ist jetzt weiter oben definiert, direkt vor
// istLoopbackHost()/fetchMitTimeout() — siehe Kommentar dort.

// normalisiereAiUrl: wer eine eigene API-URL hinterlegt, tippt bei einem
// lokalen Server wie LM Studio/Ollama erfahrungsgemäß nur die Basisadresse
// (z. B. "http://localhost:1234"), nicht den vollen Completions-Pfad —
// beide Tools bewerben sich selbst über genau diese kurze Adresse. Ohne
// diese Ergänzung landet die Anfrage dort auf "/" statt auf
// "/v1/chat/completions" (bzw. "/v1/messages" bei Claude): der lokale
// Server antwortet trotzdem mit HTTP 200, aber mit einem Text, der keine
// gültige Chat-Completion ist — reproduzierbar mit Eriks eigenem Fehler
// ("Received request: POST to /" in LM Studios Log). Nur ein FEHLENDER
// oder leerer Pfad wird ergänzt; ein ausdrücklich angegebener Pfad (z. B.
// ein Firmen-Proxy mit eigener Route) bleibt unangetastet.
function normalisiereAiUrl(apiUrl, defaultUrl){
  if(!apiUrl) return defaultUrl;
  try {
    const parsed = new URL(apiUrl);
    const defaultPath = new URL(defaultUrl).pathname; // z. B. '/v1/chat/completions'
    const leer = !parsed.pathname || parsed.pathname === '/';
    // Viele OpenAI-kompatible Anbieter (Mammouth.ai, OpenRouter und weitere)
    // dokumentieren ihre Basis-URL nach der offiziellen OpenAI-SDK-Konvention
    // als ".../v1" - ohne den eigentlichen Completions-Pfad dahinter. Das
    // Eingabefeld (Einstellungen → Mein Konto) schlägt mit seinem Platzhalter
    // ("z. B. http://localhost:1234 für LM Studio") genau diese Art bloßer
    // Basis-URL vor, und wer sie nach der für den jeweiligen Anbieter
    // dokumentierten Form mit angehängtem "/v1" einträgt, bekam bisher einen
    // 404: Die Anfrage landete exakt auf ".../v1" statt auf
    // ".../v1/chat/completions" (reproduzierbar bei Mammouth.ai, dessen
    // FastAPI-typische {"detail":"Not Found"}-Antwort das auch so ausweist).
    // Nur ein Pfad, der GENAU auf "/v1" endet, wird so behandelt wie ein
    // leerer - ein abweichender, bewusst eigener Pfad (z. B. ein
    // Firmen-Proxy mit eigener Route) bleibt wie bisher unangetastet.
    const nurBasisPfad = /\/v1\/?$/.test(parsed.pathname) && defaultPath.startsWith('/v1/');
    if(leer || nurBasisPfad){
      parsed.pathname = defaultPath;
      return parsed.toString();
    }
    return apiUrl;
  } catch(e){
    return apiUrl;
  }
}

async function erkennePunkteMitChatGPT(text, apiKey, apiUrl, model){
  const zielUrl = normalisiereAiUrl(apiUrl, KI_DEFAULT_URL.chatgpt);
  let istLokal = false;
  try { istLokal = istLoopbackHost(new URL(zielUrl).hostname); } catch(e){ /* ungültige URL: bleibt false */ }

  const body = {
    // model (Konto-Einstellung, user_ai_keys.model) überschreibt die Vorgabe
    // nur, wenn gesetzt — nötig für einen eigenständigen Anbieter mit
    // abweichendem Modell-Katalog (z. B. Mammouth.ai), siehe
    // migrateAddUserAiKeyModel() oben.
    model: model || 'gpt-4o-mini',
    messages: [
      { role: 'system', content: KI_SYSTEM_PROMPT },
      { role: 'user', content: text }
    ],
    response_format: { type: 'json_schema', json_schema: { name: 'protokoll_punkte', strict: true, schema: KI_PUNKT_SCHEMA } },
    // Ohne eigenes max_tokens bricht mancher lokale Server (anders als die
    // echte OpenAI-API, die hier großzügig ist) die Antwort bei einem langen
    // Protokoll mit vielen Punkten vorzeitig ab, sobald ein internes
    // Standardlimit erreicht ist — die JSON-Antwort bleibt dabei gültig,
    // enthält aber nur die ersten paar Punkte statt aller.
    max_tokens: 16000,
    // temperature:0 macht die Erkennung reproduzierbar — bei Streuung (dem
    // Standardwert) lieferte ein und dieselbe Anfrage an Eriks lokales
    // Modell je nach Lauf 0 bis 11 erkannte Punkte, was Fehlersuche und
    // Nutzervertrauen gleichermaßen unmöglich macht. Für diese Aufgabe
    // (Fakten aus einem Text ziehen) ist Kreativität ohnehin unerwünscht.
    temperature: 0,
    // Sicherheitsnetz gegen Wiederholungsschleifen: bei einem Testlauf ohne
    // echte Teilnehmerdaten im Text geriet Eriks lokales Modell beim
    // Befüllen von "teilnehmer" in eine Endlosschleife (dasselbe
    // Namens-Fragment tausendfach), bis max_tokens die Antwort mitten im
    // JSON abschnitt — mit echten Teilnehmerdaten (wie jeder reale Import
    // sie liefert) trat das nicht auf, aber diese beiden Parameter machen
    // eine erneute Schleife unabhängig vom Dokumentinhalt unwahrscheinlicher.
    frequency_penalty: 0.4,
    presence_penalty: 0.2
  };
  // Manche lokale Server laden standardmäßig ein Reasoning-Modell (z. B.
  // Qwen3 in LM Studio), das vor jeder Antwort ausführlich "denkt" — für
  // diese Aufgabe direkt gegen ein echtes LM-Studio-Setup gemessen: 260 von
  // 264 Tokens (98,5 %) fürs Denken, 15s statt 0,4s für eine triviale
  // Anfrage; bei einem langen Besprechungsprotokoll mit vielen Punkten
  // reicht das leicht über jeden vertretbaren Timeout hinaus, obwohl das
  // Modell am Ende korrekt "durchläuft". reasoning_effort:'none' schaltet
  // das Denken ab (ebenfalls live verifiziert — mit dem echten System-
  // Prompt und Schema unten korrekt und in Sekunden statt Minuten). Nur
  // für lokale Ziele gesetzt: die echte OpenAI-API für gpt-4o-mini (kein
  // Reasoning-Modell) kennt den Parameter nicht und soll ihn nie sehen.
  if(istLokal) body.reasoning_effort = 'none';

  const res = await fetchMitTimeout(zielUrl, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + apiKey },
    body: JSON.stringify(body)
  });
  if(!res.ok){
    const body = await res.text().catch(() => '');
    throw new Error('ChatGPT antwortete mit HTTP ' + res.status + (body ? ': ' + body.slice(0, 200) : ''));
  }
  const data = await res.json();
  const content = data && data.choices && data.choices[0] && data.choices[0].message && data.choices[0].message.content;
  if(!content) throw new Error('ChatGPT lieferte keine Antwort.');
  let parsed;
  try { parsed = JSON.parse(content); } catch(e){ throw new Error('ChatGPT-Antwort war kein gültiges JSON.'); }
  if(!Array.isArray(parsed.punkte)) throw new Error('ChatGPT-Antwort hatte nicht die erwartete Form.');
  return {
    punkte: parsed.punkte.map(normalisierePunktAusKi),
    teilnehmer: Array.isArray(parsed.teilnehmer) ? parsed.teilnehmer.map(normalisiereTeilnehmerAusKi) : []
  };
}

async function erkennePunkteMitClaude(text, apiKey, apiUrl, model){
  const res = await fetchMitTimeout(normalisiereAiUrl(apiUrl, KI_DEFAULT_URL.claude), {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' },
    body: JSON.stringify({
      model: model || 'claude-haiku-4-5-20251001',
      // wie beim ChatGPT-Pfad: ein langes Protokoll mit vielen Punkten
      // braucht mehr als das ursprüngliche Minimum, sonst bricht die
      // Antwort vor dem letzten Punkt ab.
      max_tokens: 8192,
      // Wie beim ChatGPT-Pfad: reproduzierbares Ergebnis statt Streuung
      // zwischen Läufen (siehe Begründung bei KI_SYSTEM_PROMPT oben).
      temperature: 0,
      system: KI_SYSTEM_PROMPT,
      messages: [{ role: 'user', content: text }],
      tools: [{
        name: 'protokoll_punkte',
        description: 'Die aus dem Text erkannten Besprechungspunkte.',
        input_schema: KI_PUNKT_SCHEMA
      }],
      tool_choice: { type: 'tool', name: 'protokoll_punkte' }
    })
  });
  if(!res.ok){
    const body = await res.text().catch(() => '');
    throw new Error('Claude antwortete mit HTTP ' + res.status + (body ? ': ' + body.slice(0, 200) : ''));
  }
  const data = await res.json();
  const toolUse = Array.isArray(data.content) ? data.content.find(b => b.type === 'tool_use') : null;
  if(!toolUse || !toolUse.input || !Array.isArray(toolUse.input.punkte)){
    throw new Error('Claude-Antwort hatte nicht die erwartete Form.');
  }
  return {
    punkte: toolUse.input.punkte.map(normalisierePunktAusKi),
    teilnehmer: Array.isArray(toolUse.input.teilnehmer) ? toolUse.input.teilnehmer.map(normalisiereTeilnehmerAusKi) : []
  };
}

async function erkennePunkteMitKI(text, userId, provider){
  const { apiKey, apiUrl, model } = readUserAiKey(userId, provider);
  if(!apiKey) throw new Error('Kein API-Schlüssel hinterlegt.');
  const gekuerzterText = text.length > KI_MAX_TEXT_LAENGE ? text.slice(0, KI_MAX_TEXT_LAENGE) : text;
  if(provider === 'chatgpt') return erkennePunkteMitChatGPT(gekuerzterText, apiKey, apiUrl, model);
  if(provider === 'claude') return erkennePunkteMitClaude(gekuerzterText, apiKey, apiUrl, model);
  throw new Error('Unbekannter Anbieter: ' + provider);
}

// ---------- "TODOs aus Protokoll" (public/js/plan/plan-protokoll-todos.js) ----------
//
// Eigenständige, zweite KI-Stufe: nimmt bereits erkannte Besprechungspunkte
// (egal ob frisch aus einem Ad-hoc-PDF-Upload oder sonstwoher) und leitet
// daraus Aufgaben-VORSCHLÄGE ab (Titel, Beschreibung, Fälligkeit, Zuständig-
// Vorschlag) — anders als erkennePunkteMitKI() oben, das nur Punkte aus
// Fließtext EXTRAHIERT, beurteilt dieser Schritt, was davon tatsächlich zu
// tun ist: mehrere Punkte können zu einer Aufgabe zusammengehören, rein
// informative Punkte liefern keine. Komplett unabhängig von
// project_protokolle/protokoll_punkte — die Punkte kommen direkt im
// Request-Body, nichts wird hier gelesen oder geschrieben.

// normalisiereAufgabeAusKi: Analoges Gegenstück zu normalisierePunktAusKi()
// oben, für eine KI-Antwortzeile dieser zweiten Stufe.
function normalisiereAufgabeAusKi(a){
  return {
    titel: String((a && a.titel) || ''),
    beschreibung: String((a && a.beschreibung) || ''),
    faelligkeit: String((a && a.faelligkeit) || ''),
    zustaendigVorschlag: String((a && a.zustaendigVorschlag) || ''),
    quellRefs: Array.isArray(a && a.quellRefs) ? a.quellRefs.filter(r => Number.isInteger(r)) : []
  };
}

const KI_AUFGABEN_SCHEMA = {
  type: 'object',
  properties: {
    aufgaben: {
      type: 'array',
      items: {
        type: 'object',
        properties: {
          titel: { type: 'string' },
          beschreibung: { type: 'string' },
          faelligkeit: { type: 'string' },
          zustaendigVorschlag: { type: 'string' },
          quellRefs: { type: 'array', items: { type: 'integer' } }
        },
        required: ['titel', 'beschreibung', 'faelligkeit', 'zustaendigVorschlag', 'quellRefs'],
        additionalProperties: false
      }
    }
  },
  required: ['aufgaben'],
  additionalProperties: false
};

// KI_AUFGABEN_SYSTEM_PROMPT: eigener, von KI_SYSTEM_PROMPT bewusst getrennter
// Prompt — andere Aufgabe (Aufgaben aus bereits strukturierten Punkten
// ABLEITEN, nicht Punkte aus Fließtext EXTRAHIEREN). Wie bei KI_SYSTEM_PROMPT/
// PLAN_CHECK_SYSTEM_PROMPT gilt: der Wortlaut ist ein Startpunkt, kein
// Festbetrag — vor dem produktiven Einsatz mit einem echten externen
// Protokoll bei temperature:0 testen, Änderungen einzeln bewerten (siehe
// CLAUDE.md "### Protokolle").
const KI_AUFGABEN_SYSTEM_PROMPT = 'Du bekommst Besprechungspunkte eines Projektprotokolls (je Punkt: ref, thema, '
  + 'text, zustaendig, termin). Leite daraus konkrete, umsetzbare Aufgaben ab. Mehrere Punkte, die dieselbe Handlung '
  + 'betreffen, können in einer Aufgabe zusammengefasst werden; rein informative Punkte ohne notwendige Handlung '
  + 'liefern KEINE Aufgabe. Je Aufgabe: ein kurzer Titel (Tätigkeit zuerst), eine kurze Beschreibung, ein '
  + 'Fälligkeitsdatum NUR wenn im Text ein konkretes Datum genannt ist (sonst leer lassen, nichts erfinden), ein '
  + 'Vorschlag für die zuständige Person (wörtlich aus dem Feld "zustaendig" übernommen, nichts erfinden), und die '
  + 'refs der Punkte, aus denen sie entstand.';

// aufgabenTextFuerKi: baut den Nutzer-Content für beide Anbieter aus der
// Punkteliste — jeder Punkt trägt seine Array-Position als "ref", damit die
// Antwort referenzierbar ist, ohne dass ein id-Konzept nötig wäre (nichts
// hier ist persistiert).
function aufgabenTextFuerKi(punkte){
  return punkte.map((p, i) => `ref ${i}\nThema: ${p.thema || ''}\nText: ${p.text || ''}\n`
    + `Zuständig: ${p.zustaendig || ''}\nTermin: ${p.termin || ''}`).join('\n\n');
}

async function leiteAufgabenMitChatGPT(punkte, apiKey, apiUrl, model){
  const zielUrl = normalisiereAiUrl(apiUrl, KI_DEFAULT_URL.chatgpt);
  let istLokal = false;
  try { istLokal = istLoopbackHost(new URL(zielUrl).hostname); } catch(e){ /* ungültige URL: bleibt false */ }

  const body = {
    model: model || 'gpt-4o-mini',
    messages: [
      { role: 'system', content: KI_AUFGABEN_SYSTEM_PROMPT },
      { role: 'user', content: aufgabenTextFuerKi(punkte) }
    ],
    response_format: { type: 'json_schema', json_schema: { name: 'protokoll_aufgaben', strict: true, schema: KI_AUFGABEN_SCHEMA } },
    // Kleiner als bei der Punkte-Erkennung (erkennePunkteMitChatGPT oben):
    // die Ausgabe ist nur eine Handvoll kurzer Aufgaben, kein ganzes Protokoll.
    max_tokens: 4096,
    temperature: 0
  };
  if(istLokal) body.reasoning_effort = 'none';

  const res = await fetchMitTimeout(zielUrl, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + apiKey },
    body: JSON.stringify(body)
  });
  if(!res.ok){
    const errBody = await res.text().catch(() => '');
    throw new Error('ChatGPT antwortete mit HTTP ' + res.status + (errBody ? ': ' + errBody.slice(0, 200) : ''));
  }
  const data = await res.json();
  const content = data && data.choices && data.choices[0] && data.choices[0].message && data.choices[0].message.content;
  if(!content) throw new Error('ChatGPT lieferte keine Antwort.');
  let parsed;
  try { parsed = JSON.parse(content); } catch(e){ throw new Error('ChatGPT-Antwort war kein gültiges JSON.'); }
  if(!Array.isArray(parsed.aufgaben)) throw new Error('ChatGPT-Antwort hatte nicht die erwartete Form.');
  return parsed.aufgaben.map(normalisiereAufgabeAusKi);
}

async function leiteAufgabenMitClaude(punkte, apiKey, apiUrl, model){
  const res = await fetchMitTimeout(normalisiereAiUrl(apiUrl, KI_DEFAULT_URL.claude), {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' },
    body: JSON.stringify({
      model: model || 'claude-haiku-4-5-20251001',
      max_tokens: 4096,
      temperature: 0,
      system: KI_AUFGABEN_SYSTEM_PROMPT,
      messages: [{ role: 'user', content: aufgabenTextFuerKi(punkte) }],
      tools: [{
        name: 'protokoll_aufgaben',
        description: 'Die aus den Besprechungspunkten abgeleiteten Aufgaben.',
        input_schema: KI_AUFGABEN_SCHEMA
      }],
      tool_choice: { type: 'tool', name: 'protokoll_aufgaben' }
    })
  });
  if(!res.ok){
    const errBody = await res.text().catch(() => '');
    throw new Error('Claude antwortete mit HTTP ' + res.status + (errBody ? ': ' + errBody.slice(0, 200) : ''));
  }
  const data = await res.json();
  const toolUse = Array.isArray(data.content) ? data.content.find(b => b.type === 'tool_use') : null;
  if(!toolUse || !toolUse.input || !Array.isArray(toolUse.input.aufgaben)){
    throw new Error('Claude-Antwort hatte nicht die erwartete Form.');
  }
  return toolUse.input.aufgaben.map(normalisiereAufgabeAusKi);
}

async function leiteAufgabenMitKI(punkte, userId, provider){
  const { apiKey, apiUrl, model } = readUserAiKey(userId, provider);
  if(!apiKey) throw new Error('Kein API-Schlüssel hinterlegt.');
  if(provider === 'chatgpt') return leiteAufgabenMitChatGPT(punkte, apiKey, apiUrl, model);
  if(provider === 'claude') return leiteAufgabenMitClaude(punkte, apiKey, apiUrl, model);
  throw new Error('Unbekannter Anbieter: ' + provider);
}

// Route 1/2: liest ein hochgeladenes PDF (roh im Body, wie
// /project-protokolle/import) und erkennt daraus Besprechungspunkte — nutzt
// DIESELBE Erkennung wie der echte Protokoll-Import (erkennePunkteMitKI()/
// erkennePunkteAusText()), legt aber NICHTS an: kein project_protokolle-
// Eintrag, keine Datei auf der Festplatte (anders als der Import, der beides
// immer persistiert — diese Funktion ist bewusst ein Ad-hoc-Werkzeug ohne
// Archiv, siehe Kopfkommentar oben). Die erkannten Punkte gehen direkt an
// den Client zurück und werden von der zweiten Route unten (ohne erneuten
// Server-Lookup) weiterverarbeitet.
app.post('/plan-todos-aus-protokoll/einlesen', requireAuth, requireRecht('proj.plan'), express.raw({ type: '*/*', limit: '25mb' }), async (req, res) => {
  try {
    const buf = req.body;
    if(!Buffer.isBuffer(buf) || buf.length === 0){
      return res.status(400).json({ ok: false, error: 'Keine Datei empfangen.' });
    }
    let text;
    try { text = await extrahierePdfText(buf); }
    catch(err){ return res.status(400).json({ ok: false, error: 'Die Datei konnte nicht als PDF gelesen werden.' }); }

    let punkte, erkennungsart = 'textmuster', erkennungshinweis = '';
    const anbieter = req.query.anbieter;
    if(anbieter === 'chatgpt' || anbieter === 'claude'){
      try {
        const ergebnis = await erkennePunkteMitKI(text, req.user.id, anbieter);
        punkte = ergebnis.punkte;
        erkennungsart = anbieter;
      } catch(err){
        console.warn('KI-Erkennung (TODOs aus Protokoll) fehlgeschlagen, Rückfall auf Textmuster:', err.message);
        erkennungshinweis = err.message;
        punkte = erkennePunkteAusText(text);
      }
    } else {
      punkte = erkennePunkteAusText(text);
    }

    res.json({ ok: true, punkte, erkennungsart, erkennungshinweis });
  } catch(err){
    console.error('TODOs aus Protokoll (Einlesen) fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route 2/2: leitet aus den (vom Client ausgewählten) Punkten Aufgaben-
// Vorschläge ab. Die Punkte kommen direkt im Body — kein Bezug zu
// project_protokolle, siehe Kopfkommentar oben.
app.post('/plan-todos-aus-protokoll/aufgaben-vorschlag', requireAuth, requireRecht('proj.plan'), async (req, res) => {
  try {
    const { anbieter } = req.body || {};
    const punkte = Array.isArray((req.body || {}).punkte)
      ? req.body.punkte.filter(p => p && typeof p === 'object') : [];
    if(punkte.length === 0){
      return res.status(400).json({ ok: false, error: 'Keine Punkte ausgewählt.' });
    }

    let vorschlaege, erkennungsart = 'direkt', erkennungshinweis = '';
    if(anbieter === 'chatgpt' || anbieter === 'claude'){
      try {
        vorschlaege = await leiteAufgabenMitKI(punkte, req.user.id, anbieter);
        erkennungsart = anbieter;
      } catch(err){
        console.warn('KI-Ableitung (TODOs aus Protokoll) fehlgeschlagen, Rückfall auf 1:1-Übernahme:', err.message);
        erkennungshinweis = err.message;
        vorschlaege = null;
      }
    }
    if(!vorschlaege){
      // Direkter Rückfall: je ausgewähltem Punkt ein Vorschlag, derselbe
      // Rückfall-Geist wie erkennePunkteAusText() beim Import.
      vorschlaege = punkte.map((p, i) => ({
        titel: String(p.thema || '').trim() || String(p.text || '').slice(0, 80),
        beschreibung: String(p.text || ''),
        faelligkeit: String(p.termin || ''),
        zustaendigVorschlag: String(p.zustaendig || ''),
        quellRefs: [i]
      }));
    }

    vorschlaege = vorschlaege.map(v => Object.assign({}, v, { faelligkeit: normalisiereTermin(v.faelligkeit) }));
    res.json({ ok: true, vorschlaege, erkennungsart, erkennungshinweis });
  } catch(err){
    console.error('TODOs aus Protokoll (Aufgaben-Vorschlag) fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// ---------- Termin aus Mail (Drag & Drop in Terminplan/Aufgaben) ----------
//
// Eriks Wunsch: Mailtext (markiert oder als ganze .eml-Datei) auf den
// Terminplan ziehen, eine KI macht daraus Aufgaben. Wie "TODOs aus
// Protokoll" wird hier NICHTS gespeichert — die Route liefert nur
// Vorschläge, angelegt wird erst im Browser nach Prüfung im Aufgaben-Panel.
// Mit dem Mailtext als Notiz der Aufgabe (plan_todos.notiz).

// mailWoerterDekodieren: RFC-2047-Wörter in Kopfzeilen ("=?utf-8?B?…?=").
function mailWoerterDekodieren(s){
  return String(s || '').replace(/=\?([^?]+)\?([bBqQ])\?([^?]*)\?=(\s+(?==\?))?/g, (m, cs, enc, txt) => {
    try {
      const buf = enc.toUpperCase() === 'B'
        ? Buffer.from(txt, 'base64')
        : Buffer.from(txt.replace(/_/g, ' ').replace(/=([0-9A-Fa-f]{2})/g, (x, h) => String.fromCharCode(parseInt(h, 16))), 'latin1');
      return mailZeichensatz(buf, cs);
    } catch(e){ return m; }
  });
}

function mailZeichensatz(buf, charset){
  const cs = String(charset || 'utf-8').toLowerCase().replace(/^"|"$/g, '');
  try { return new TextDecoder(cs).decode(buf); }
  catch(e){ return buf.toString(cs.includes('8859') || cs.includes('1252') ? 'latin1' : 'utf8'); }
}

function mailKopfTeilen(roh){
  const trenn = roh.search(/\r?\n\r?\n/);
  const kopfText = trenn < 0 ? roh : roh.slice(0, trenn);
  const rumpf = trenn < 0 ? '' : roh.slice(trenn).replace(/^\r?\n\r?\n/, '');
  const kopf = {};
  kopfText.replace(/\r?\n[ \t]+/g, ' ').split(/\r?\n/).forEach(z => {
    const i = z.indexOf(':');
    if(i > 0){ const k = z.slice(0, i).trim().toLowerCase(); if(!(k in kopf)) kopf[k] = z.slice(i + 1).trim(); }
  });
  return { kopf, rumpf };
}

function mailKopfParam(wert, name){
  const m = String(wert || '').match(new RegExp(name + '\\s*=\\s*("([^"]*)"|[^;\\s]+)', 'i'));
  return m ? (m[2] !== undefined ? m[2] : m[1]) : '';
}

// mailTeilLesen: liefert {plain, html} eines (ggf. mehrteiligen) Mailteils.
function mailTeilLesen(roh, tiefe){
  const { kopf, rumpf } = mailKopfTeilen(roh);
  const typ = String(kopf['content-type'] || 'text/plain').toLowerCase();
  if(typ.startsWith('multipart/') && tiefe < 6){
    const grenze = mailKopfParam(kopf['content-type'], 'boundary');
    if(!grenze) return { plain: rumpf, html: '' };
    const teile = rumpf.split('--' + grenze).slice(1).filter(t => !t.startsWith('--'));
    const erg = { plain: '', html: '' };
    teile.forEach(t => {
      const r = mailTeilLesen(t.replace(/^\r?\n/, ''), tiefe + 1);
      if(!erg.plain && r.plain) erg.plain = r.plain;
      if(!erg.html && r.html) erg.html = r.html;
    });
    return erg;
  }
  if(/attachment/i.test(kopf['content-disposition'] || '')) return { plain: '', html: '' };
  if(!typ.startsWith('text/')) return { plain: '', html: '' };
  const enc = String(kopf['content-transfer-encoding'] || '').toLowerCase();
  let text;
  if(enc === 'base64' || enc === 'quoted-printable'){
    const buf = enc === 'base64'
      ? Buffer.from(rumpf.replace(/\s+/g, ''), 'base64')
      : Buffer.from(rumpf.replace(/=\r?\n/g, '').replace(/=([0-9A-Fa-f]{2})/g, (x, h) => String.fromCharCode(parseInt(h, 16))), 'latin1');
    text = mailZeichensatz(buf, mailKopfParam(kopf['content-type'], 'charset') || 'utf-8');
  } else {
    // 7bit/8bit: Der Browser hat die Datei bereits als Text gelesen (UTF-8) —
    // ein Umweg über Bytes zerstörte hier die Umlaute.
    text = rumpf;
  }
  return typ.startsWith('text/html') ? { plain: '', html: text } : { plain: text, html: '' };
}

function htmlZuText(html){
  return String(html || '')
    .replace(/<(script|style|head)[\s\S]*?<\/\1>/gi, '')
    .replace(/<br\s*\/?>/gi, '\n')
    .replace(/<\/(p|div|li|tr|h\d|blockquote)>/gi, '\n')
    .replace(/<[^>]+>/g, '')
    .replace(/&nbsp;/g, ' ').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"')
    .replace(/&#(\d+);/g, (m, n) => String.fromCharCode(Number(n))).replace(/&amp;/g, '&')
    .replace(/[ \t]+\n/g, '\n').replace(/\n{3,}/g, '\n\n').trim();
}

// leseEml: .eml-Datei (als Text) → {betreff, absender, datum, text}.
function leseEml(roh){
  const s = String(roh || '');
  const { kopf } = mailKopfTeilen(s);
  const teil = mailTeilLesen(s, 0);
  let datum = '';
  const d = new Date(kopf['date'] || '');
  if(!isNaN(d)) datum = d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0');
  return {
    betreff: mailWoerterDekodieren(kopf['subject'] || ''),
    absender: mailWoerterDekodieren(kopf['from'] || ''),
    datum,
    text: (teil.plain || htmlZuText(teil.html)).trim()
  };
}

// mailZitateAbschneiden: entfernt zitierte Vorgänger-Mails — sonst griffe
// die KI Termine aus alten Mails derselben Unterhaltung auf.
function mailZitateAbschneiden(text){
  const zeilen = String(text || '').replace(/\r\n/g, '\n').split('\n');
  let ende = zeilen.length;
  for(let i = 1; i < zeilen.length; i++){
    const z = zeilen[i].trim();
    const naechste = zeilen.slice(i + 1, i + 5).join('\n');
    if(/^-{2,}\s*(Ursprüngliche Nachricht|Original Message)/i.test(z)
      || /^(Am|On) .+(schrieb|wrote).*:$/i.test(z)
      || (/^(Von|From):\s/i.test(z) && /^(Gesendet|Sent|Datum|Date):/im.test(naechste))){
      ende = i; break;
    }
  }
  return zeilen.slice(0, ende).filter(z => !/^\s*>/.test(z)).join('\n').replace(/\n{3,}/g, '\n\n').trim();
}

const KI_MAIL_SCHEMA = {
  type: 'object',
  properties: {
    eintraege: {
      type: 'array',
      items: {
        type: 'object',
        properties: {
          art: { type: 'string', enum: ['aufgabe', 'meilenstein'] },
          titel: { type: 'string' },
          start: { type: 'string' },
          ende: { type: 'string' },
          zustaendig: { type: 'array', items: { type: 'string' } },
          aufwandStunden: { type: 'number' },
          zitat: { type: 'string' }
        },
        required: ['art', 'titel', 'start', 'ende', 'zustaendig', 'aufwandStunden', 'zitat'],
        additionalProperties: false
      }
    }
  },
  required: ['eintraege'],
  additionalProperties: false
};

// Wie bei den übrigen KI-Prompts: Startpunkt, vor Änderungen mit echten
// Mails bei temperature:0 einzeln prüfen (siehe CLAUDE.md "### Protokolle").
const KI_MAIL_SYSTEM_PROMPT = 'Du bekommst eine E-Mail aus einem Ingenieurbüro und Angaben zum Projekt. Mache daraus '
  + 'Einträge für den Terminplan des Projekts: je Termin, Frist oder zu erledigender Arbeit einen Eintrag. '
  + 'art: "meilenstein" für einen festen Stichtag ohne eigene Arbeit (Abgabe, Termin, Freigabe, Besprechung), '
  + '"aufgabe" für zu erledigende Arbeit. Titel kurz, Tätigkeit zuerst. Datumsangaben als JJJJ-MM-TT; relative Angaben wie "nächsten Freitag" '
  + 'rechnest du vom Datum der Mail aus. Ein einzelner Termin oder eine Frist: start und ende gleich. '
  + 'Ohne Datum in der Mail bleiben start und ende leer. zustaendig: nur Namen aus der Liste der Beteiligten, '
  + 'die in der Mail als verantwortlich genannt sind, sonst leer. aufwandStunden nur wenn genannt, sonst 0. zitat: der Satz aus der Mail, '
  + 'auf dem der Eintrag beruht. Enthält die Mail nichts für den Terminplan, gib eine leere Liste zurück.';

function mailTextFuerKi(m, kontext){
  const teile = [
    'Heute: ' + (kontext.heute || heuteIsoLokal()),
    'Datum der Mail: ' + (m.datum || 'unbekannt'),
    'Projekt: ' + (kontext.projekt || ''),
    'Beteiligte: ' + ((kontext.personen || []).join(', ') || 'keine'),
    'Leistungsphasen im Terminplan: ' + ((kontext.phasen || []).map(p => `${p.lph} ${p.start}–${p.ende}`).join('; ') || 'keine'),
    '',
    'Von: ' + (m.absender || ''),
    'Betreff: ' + (m.betreff || ''),
    '',
    m.text
  ];
  return teile.join('\n');
}

function normalisiereMailEintrag(e){
  const iso = v => { const s = normalisiereTermin(v); return /^\d{4}-\d{2}-\d{2}$/.test(s) ? s : ''; };
  let start = iso(e && e.start), ende = iso(e && e.ende);
  if(start && !ende) ende = start;
  if(ende && !start) start = ende;
  if(start && ende && ende < start){ const t = start; start = ende; ende = t; }
  return {
    art: (e && e.art) === 'meilenstein' ? 'meilenstein' : 'aufgabe',
    titel: String((e && e.titel) || '').trim().slice(0, 200),
    start, ende,
    zustaendig: Array.isArray(e && e.zustaendig) ? e.zustaendig.map(String).filter(Boolean) : [],
    aufwandStunden: Math.max(0, Number(e && e.aufwandStunden) || 0),
    zitat: String((e && e.zitat) || '').trim().slice(0, 500)
  };
}

async function mailEintraegeMitKI(m, kontext, userId, provider){
  const { apiKey, apiUrl, model } = readUserAiKey(userId, provider);
  if(!apiKey) throw new Error('Kein API-Schlüssel hinterlegt.');
  const inhalt = mailTextFuerKi(m, kontext);
  let liste;
  if(provider === 'chatgpt'){
    const zielUrl = normalisiereAiUrl(apiUrl, KI_DEFAULT_URL.chatgpt);
    let istLokal = false;
    try { istLokal = istLoopbackHost(new URL(zielUrl).hostname); } catch(e){ /* bleibt false */ }
    const body = {
      model: model || 'gpt-4o-mini',
      messages: [{ role: 'system', content: KI_MAIL_SYSTEM_PROMPT }, { role: 'user', content: inhalt }],
      response_format: { type: 'json_schema', json_schema: { name: 'terminplan_eintraege', strict: true, schema: KI_MAIL_SCHEMA } },
      max_tokens: 4096,
      temperature: 0
    };
    if(istLokal) body.reasoning_effort = 'none';
    const res = await fetchMitTimeout(zielUrl, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + apiKey },
      body: JSON.stringify(body)
    });
    if(!res.ok){
      const t = await res.text().catch(() => '');
      throw new Error('ChatGPT antwortete mit HTTP ' + res.status + (t ? ': ' + t.slice(0, 200) : ''));
    }
    const data = await res.json();
    const content = data && data.choices && data.choices[0] && data.choices[0].message && data.choices[0].message.content;
    let parsed;
    try { parsed = JSON.parse(content || ''); } catch(e){ throw new Error('ChatGPT-Antwort war kein gültiges JSON.'); }
    liste = parsed && parsed.eintraege;
  } else if(provider === 'claude'){
    const res = await fetchMitTimeout(normalisiereAiUrl(apiUrl, KI_DEFAULT_URL.claude), {
      method: 'POST',
      headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' },
      body: JSON.stringify({
        model: model || 'claude-haiku-4-5-20251001',
        max_tokens: 4096,
        temperature: 0,
        system: KI_MAIL_SYSTEM_PROMPT,
        messages: [{ role: 'user', content: inhalt }],
        tools: [{ name: 'terminplan_eintraege', description: 'Die Einträge für den Terminplan.', input_schema: KI_MAIL_SCHEMA }],
        tool_choice: { type: 'tool', name: 'terminplan_eintraege' }
      })
    });
    if(!res.ok){
      const t = await res.text().catch(() => '');
      throw new Error('Claude antwortete mit HTTP ' + res.status + (t ? ': ' + t.slice(0, 200) : ''));
    }
    const data = await res.json();
    const toolUse = Array.isArray(data.content) ? data.content.find(b => b.type === 'tool_use') : null;
    liste = toolUse && toolUse.input && toolUse.input.eintraege;
  } else {
    throw new Error('Unbekannter Anbieter: ' + provider);
  }
  if(!Array.isArray(liste)) throw new Error('Die KI-Antwort hatte nicht die erwartete Form.');
  return liste.map(normalisiereMailEintrag).filter(e => e.titel);
}

// Body: {anbieter, text?, eml?, kontext:{heute, projekt, personen[], phasen[{lph,start,ende}]}}
// — eml ist der Inhalt einer .eml-Datei als Text (der Browser liest sie ein).
app.post('/plan-eintrag-aus-mail', requireAuth, requireRecht('proj.plan'), async (req, res) => {
  try {
    const b = req.body || {};
    const kontext = (b.kontext && typeof b.kontext === 'object') ? b.kontext : {};
    let mail;
    if(typeof b.eml === 'string' && b.eml.trim()) mail = leseEml(b.eml);
    else mail = { betreff: '', absender: '', datum: '', text: String(b.text || '') };
    mail.text = mailZitateAbschneiden(mail.text).slice(0, 15000);
    if(!mail.text && !mail.betreff){
      return res.status(400).json({ ok: false, error: 'In der Mail wurde kein Text gefunden.' });
    }

    let eintraege = null, erkennungsart = 'ohne', erkennungshinweis = '';
    const anbieter = b.anbieter;
    if(anbieter === 'chatgpt' || anbieter === 'claude'){
      try {
        eintraege = await mailEintraegeMitKI(mail, kontext, req.user.id, anbieter);
        erkennungsart = anbieter;
      } catch(err){
        console.warn('Termin aus Mail: KI fehlgeschlagen:', err.message);
        erkennungshinweis = err.message;
      }
    } else {
      erkennungshinweis = 'Kein KI-Anbieter mit Schlüssel hinterlegt.';
    }
    if(!eintraege){
      // Rückfall: ein leerer Eintrag mit dem Betreff — das Panel öffnet
      // sich trotzdem, Termine trägt man selbst ein.
      const ersteZeile = mail.text.split('\n').map(z => z.trim()).find(Boolean) || '';
      eintraege = [normalisiereMailEintrag({ titel: mail.betreff || ersteZeile.slice(0, 80) })];
    }
    res.json({ ok: true, mail: { betreff: mail.betreff, absender: mail.absender, datum: mail.datum, text: mail.text },
      eintraege, erkennungsart, erkennungshinweis });
  } catch(err){
    console.error('Termin aus Mail fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// ---------- Projekt-Notizen (Reiter „Notizen“, js/plan/plan-notizen.js) ----------
//
// Eriks Wunsch (Entwurf A „Liste + Editor“): gemeinsame Notizen je Projekt,
// formatiert wie der Sitzungskommentar, anheftbar, Mail per Drag & Drop.
// Die Notizen hängen am PROJEKT (project_uid), nicht an einer Sitzung —
// sie überstehen den Wochenwechsel, ohne kopiert zu werden, und gelten auch
// für Planung-Terminpläne (Sandbox). Gespeichert wird je Notiz, nicht über
// /save-week. Lesen: jedes Konto mit Grundzugang; Schreiben: Recht
// proj.plan; Löschen: Verfasser oder Administrator.

db.exec(`CREATE TABLE IF NOT EXISTS projekt_notizen (
  id TEXT PRIMARY KEY,
  project_uid TEXT NOT NULL,
  titel TEXT NOT NULL DEFAULT '',
  html TEXT NOT NULL DEFAULT '',
  angeheftet INTEGER NOT NULL DEFAULT 0,
  quelle TEXT NOT NULL DEFAULT '',
  erstellt_von INTEGER NOT NULL DEFAULT 0,
  erstellt_am TEXT NOT NULL DEFAULT '',
  geaendert_von INTEGER NOT NULL DEFAULT 0,
  geaendert_am TEXT NOT NULL DEFAULT ''
)`);
db.exec('CREATE INDEX IF NOT EXISTS idx_projekt_notizen_uid ON projekt_notizen(project_uid)');

const NOTIZ_MAX_HTML = 200000;

function notizZeile(r){
  return {
    id: r.id, uid: r.project_uid, titel: r.titel, html: r.html, angeheftet: !!r.angeheftet, quelle: r.quelle,
    erstelltVon: r.erstellt_name || '', erstelltVonId: r.erstellt_von, erstelltAm: r.erstellt_am,
    geaendertVon: r.geaendert_name || '', geaendertAm: r.geaendert_am
  };
}
function notizLesen(id){
  const r = db.prepare(`SELECT n.*, COALESCE(u1.display_name, 'Gelöschter Benutzer') AS erstellt_name,
      COALESCE(u2.display_name, 'Gelöschter Benutzer') AS geaendert_name
    FROM projekt_notizen n LEFT JOIN users u1 ON u1.id = n.erstellt_von LEFT JOIN users u2 ON u2.id = n.geaendert_von
    WHERE n.id = ?`).get(String(id));
  return r ? notizZeile(r) : null;
}
function istAdministrator(user){ return !!(user && (rollenCache.get(user.role) || {}).fest); }

function notizAnlegen(req, uid, titel, html, quelle){
  const id = crypto.randomUUID();
  const jetzt = new Date().toISOString();
  db.prepare(`INSERT INTO projekt_notizen (id, project_uid, titel, html, angeheftet, quelle, erstellt_von, erstellt_am, geaendert_von, geaendert_am)
    VALUES (?, ?, ?, ?, 0, ?, ?, ?, ?, ?)`)
    .run(id, uid, String(titel || '').slice(0, 300), String(html || '').slice(0, NOTIZ_MAX_HTML), quelle || '', req.user.id, jetzt, req.user.id, jetzt);
  ereignisSenden({ typ: 'notizen', uid }, req);
  return notizLesen(id);
}

app.get('/projekt-notizen', requireAuth, (req, res) => {
  try {
    const uid = String(req.query.uid || '');
    if(!uid) return res.status(400).json({ ok: false, error: 'uid fehlt.' });
    const rows = db.prepare(`SELECT n.*, COALESCE(u1.display_name, 'Gelöschter Benutzer') AS erstellt_name,
        COALESCE(u2.display_name, 'Gelöschter Benutzer') AS geaendert_name
      FROM projekt_notizen n LEFT JOIN users u1 ON u1.id = n.erstellt_von LEFT JOIN users u2 ON u2.id = n.geaendert_von
      WHERE n.project_uid = ? ORDER BY n.angeheftet DESC, n.geaendert_am DESC`).all(uid);
    res.json({ ok: true, notizen: rows.map(notizZeile) });
  } catch(err){
    console.error('Notizen laden fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

app.post('/projekt-notizen', requireAuth, requireRecht('proj.plan'), (req, res) => {
  try {
    const b = req.body || {};
    const uid = String(b.uid || '');
    if(!uid) return res.status(400).json({ ok: false, error: 'uid fehlt.' });
    res.json({ ok: true, notiz: notizAnlegen(req, uid, b.titel, b.html, '') });
  } catch(err){
    console.error('Notiz anlegen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// PUT {titel?, html?, angeheftet?, basis?} — basis = geaendertAm des Stands,
// auf dem die Änderung beruht; weicht der gespeicherte ab, 409 mit dem
// aktuellen Stand (jemand anderes hat inzwischen gespeichert).
app.put('/projekt-notizen/:id', requireAuth, requireRecht('proj.plan'), (req, res) => {
  try {
    const alt = notizLesen(req.params.id);
    if(!alt) return res.status(404).json({ ok: false, error: 'Die Notiz gibt es nicht mehr.' });
    const b = req.body || {};
    if(typeof b.basis === 'string' && b.basis && b.basis !== alt.geaendertAm){
      return res.status(409).json({ ok: false, konflikt: true, notiz: alt,
        error: alt.geaendertVon + ' hat diese Notiz inzwischen geändert.' });
    }
    const titel = typeof b.titel === 'string' ? b.titel.slice(0, 300) : alt.titel;
    const html = typeof b.html === 'string' ? b.html.slice(0, NOTIZ_MAX_HTML) : alt.html;
    const angeheftet = typeof b.angeheftet === 'boolean' ? (b.angeheftet ? 1 : 0) : (alt.angeheftet ? 1 : 0);
    // Anheften allein ist keine inhaltliche Änderung: Zeitstempel und
    // Bearbeiter bleiben, damit die Sortierung „zuletzt geändert“ stimmt.
    const nurPin = typeof b.titel !== 'string' && typeof b.html !== 'string';
    const jetzt = nurPin ? alt.geaendertAm : new Date().toISOString();
    db.prepare(`UPDATE projekt_notizen SET titel = ?, html = ?, angeheftet = ?, geaendert_am = ?
      ${nurPin ? '' : ', geaendert_von = ' + Number(req.user.id)} WHERE id = ?`)
      .run(titel, html, angeheftet, jetzt, alt.id);
    ereignisSenden({ typ: 'notizen', uid: alt.uid }, req);
    res.json({ ok: true, notiz: notizLesen(alt.id) });
  } catch(err){
    console.error('Notiz speichern fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

app.delete('/projekt-notizen/:id', requireAuth, requireRecht('proj.plan'), (req, res) => {
  try {
    const alt = notizLesen(req.params.id);
    if(!alt) return res.json({ ok: true });
    if(alt.erstelltVonId !== req.user.id && !istAdministrator(req.user)){
      return res.status(403).json({ ok: false, error: 'Löschen darf nur, wer die Notiz angelegt hat, oder ein Administrator.' });
    }
    db.prepare('DELETE FROM projekt_notizen WHERE id = ?').run(alt.id);
    ereignisSenden({ typ: 'notizen', uid: alt.uid }, req);
    res.json({ ok: true });
  } catch(err){
    console.error('Notiz löschen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// POST /projekt-notizen/aus-mail {uid, text|eml} — Mail als neue Notiz, OHNE
// KI: Titel = Betreff (sonst erste Zeile), oben Absender und Datum, darunter
// der Text (zitierte Vorgänger-Mails abgeschnitten, wie bei „Termin aus Mail“).
app.post('/projekt-notizen/aus-mail', requireAuth, requireRecht('proj.plan'), (req, res) => {
  try {
    const b = req.body || {};
    const uid = String(b.uid || '');
    if(!uid) return res.status(400).json({ ok: false, error: 'uid fehlt.' });
    const mail = (typeof b.eml === 'string' && b.eml.trim()) ? leseEml(b.eml)
      : { betreff: '', absender: '', datum: '', text: String(b.text || '') };
    const text = mailZitateAbschneiden(mail.text).slice(0, 50000);
    if(!text && !mail.betreff) return res.status(400).json({ ok: false, error: 'In der Mail wurde kein Text gefunden.' });
    const ersteZeile = (text.split('\n').map(z => z.trim()).find(Boolean) || 'Mail').slice(0, 120);
    const escHtml = s => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
    const kopf = [mail.absender ? '<b>Von:</b> ' + escHtml(mail.absender) : '',
      mail.datum ? '<b>Datum:</b> ' + escHtml(teamsDatum(mail.datum)) : ''].filter(Boolean).join('<br>');
    const html = (kopf ? kopf + '<br><br>' : '') + escHtml(text).replace(/\n/g, '<br>');
    res.json({ ok: true, notiz: notizAnlegen(req, uid, mail.betreff || ersteZeile, html, 'mail') });
  } catch(err){
    console.error('Notiz aus Mail fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// ---------- Plan Checker (plan_checker_merkmale) ----------
//
// Eigenständiges Prüf-Werkzeug im Seitenleisten-Bereich "Studenten": lädt
// einen Bauplan als PDF hoch und lässt eine KI ihn gegen eine Liste von
// Merkmalen prüfen (z. B. "Maßketten vorhanden", "Plankopf vollständig").
// Anders als der Protokoll-Import oben geht es hier nicht um Text, sondern
// um optische Merkmale einer Zeichnung.
//
// Beide Anbieter werden (wieder) auf demselben Weg zugeführt, nach einem
// Zwischenschritt, der sich als unzureichend erwies: Die allererste Fassung
// rendere die PDF-Seite IMMER zu einem einzigen PNG und schickte das an
// beide Anbieter — Erik meldete daraufhin "extrem unzuverlässige" Erkennung
// von Maßketten, auch ein deutlich stärkeres Modell besserte das nicht, was
// auf ein Auflösungsproblem statt eine Modellgrenze hindeutete. Als
// Zwischenschritt bekam Claude testweise das PDF DIREKT (document-
// Content-Block, in der Annahme, Anthropics eigene Dokumenten-Verarbeitung
// löse Auflösung/Aufteilung besser) — half laut Erik aber nicht
// durchgreifend genug: ein erneuter Test zeigte den Plankopf zwar jetzt
// gefunden, aber Projektname, Planersteller, Maßstab, Datum und Plannummer
// blieben "in der vorliegenden Auflösung" nicht sämtlich lesbar. Das
// bestätigte den eigentlichen Engpass: JEDER Anbieter skaliert ein
// übermitteltes Bild bzw. eine PDF-Seite intern auf eine eigene Obergrenze
// herunter, egal auf welchem Weg es ankommt — ein einzelnes Bild der ganzen
// Seite kann Feinschrift in einem kleinen Blattausschnitt (wie dem Plankopf)
// deshalb grundsätzlich nicht zuverlässig lesbar machen.
//
// Jetzt rendern WIR beide Zuführungen selbst (renderPdfAlsBildsatz() weiter
// oben, aufgerufen aus pruefePlanMitKI() unten): eine Übersicht der ganzen
// Seite PLUS mehrere überlappende, einzeln hochaufgelöste Ausschnitte -
// sowohl an ChatGPT (als mehrere image_url-Blöcke) als auch an Claude (als
// mehrere image-Blöcke) auf dieselbe Weise geschickt. ChatGPT (über die hier
// genutzte Chat-Completions-API) sowie jeder lokale, über dieselbe
// Schnittstelle angesprochene Server (LM Studio, Ollama) oder Drittanbieter
// (z. B. Mammouth.ai) kennen in dieser Schnittstelle ohnehin grundsätzlich
// kein PDF-Format - nur Bilder; OpenAIs neuere "Responses API" könnte PDFs
// zwar direkt lesen, wird aber von lokalen Servern und den meisten
// Drittanbietern nicht nachgebildet, eine Umstellung darauf würde also genau
// die lokale/Drittanbieter-Nutzung brechen, die ausdrücklich mit abgedeckt
// sein soll, und bleibt deshalb aus.
//
// Nutzt dieselben Konten-Schlüssel (user_ai_keys, readUserAiKey() oben) wie
// der Protokoll-Import — keine eigene Schlüsselverwaltung nötig.
//
// Nichts wird dauerhaft gespeichert: weder das hochgeladene PDF noch die
// daraus gerenderten Bilder landen auf der Festplatte (anders als
// /project-files oder /project-protokolle/import, die beide immer
// persistieren, siehe dort) — das Ergebnis geht direkt in der Antwort
// zurück. Es gibt bewusst (noch) keinen Prüf-Verlauf: Das ist ein
// Ad-hoc-Werkzeug, kein Dokumentenarchiv.

// Bildunabhängig formuliert ("Planzeichnung" statt "Bild"), da beide
// Anbieter mehrere Bilder (Übersicht + Kacheln) derselben Zeichnung
// bekommen, nicht nur eines.
const PLAN_CHECK_SYSTEM_PROMPT = 'Du prüfst eine technische Planzeichnung (Architektur/TGA) auf das Vorhandensein '
  + 'bestimmter Merkmale. Du bekommst eine nummerierte Liste von Merkmalen mit Prüfanweisung. Gib für JEDES Merkmal aus der '
  + 'Liste genau einen Eintrag zurück, mit dem Titel exakt wie angegeben. "erfuellt" ist nur dann true, wenn das Merkmal auf '
  + 'der Zeichnung eindeutig zu erkennen ist - im Zweifel false. "begruendung" ist HÖCHSTENS 150 ZEICHEN LANG - eine feste '
  + 'Obergrenze, kein Stilwunsch. Zähle NIEMALS einzelne Werte auf (keine Maßzahlen, keine Höhenangaben, keine '
  + 'Koordinaten) - auch nicht als Beispiel ("z. B. ...") und auch nicht, wenn auf der Zeichnung sehr viele davon zu sehen '
  + 'sind: beschreibe stattdessen in einem knappen Satz, DASS und WO solche Angaben vorkommen. Erfinde nichts.';
// Wie bei KI_SYSTEM_PROMPT oben gilt: Formulierungsänderungen können das
// Ergebnis stark verschieben (siehe dortige Projekthistorie). Der erste
// Zusatz ("NIE eine Aufzählung einzelner Werte", ohne Zeichengrenze) kam nach
// einem echten Fehlschlag dazu: Ein lokal über LM Studio angebundenes Modell
// zählte für "Maßketten vorhanden" jede einzelne gefundene Maßzahl einzeln
// auf ("2,50 m, 3,12 m, 1,20 m, 2,10 m, ..."), wodurch die Antwort noch vor
// Abschluss des JSON an max_tokens (s. u.) abgeschnitten wurde und als Ganzes
// nicht mehr parsbar war ("ChatGPT-Antwort war kein gültiges JSON"). Reichte
// demselben Modell beim nächsten Fehlschlag aber IMMER NOCH nicht: Es zählte
// diesmal sogar "1,00, 2,00, 3,00 ... 22,00" durch und sprengte damit auch
// das inzwischen angehobene max_tokens erneut. Eine semantische Anweisung
// ("halt dich kurz") lässt sich offenbar umgehen, eine harte Zahl
// ("höchstens 150 Zeichen") ist für ein Modell mechanisch leichter zu prüfen
// - ebenfalls noch nicht an diesem konkreten Fehlschlag gegengetestet, siehe
// Hinweis bei max_tokens.

// PLAN_CHECK_BILD_ANZAHL: Gesamtzahl der an die KI gesendeten Bilder (1
// Übersicht + die Kacheln, s. renderPdfAlsBildsatz() oben) - bestimmt den
// gültigen Wertebereich für "bildIndex" im Schema direkt unten. Von Hand
// synchron zu PLAN_CHECK_KACHEL_SPALTEN/-ZEILEN gehalten statt daraus
// berechnet, damit die enum-Liste unten als lesbare Literalliste im Schema
// steht (für strict-JSON-Schema bei OpenAI ohnehin nötig).
const PLAN_CHECK_BILD_ANZAHL = 1 + PLAN_CHECK_KACHEL_SPALTEN * PLAN_CHECK_KACHEL_ZEILEN;

const PLAN_CHECK_SCHEMA = {
  type: 'object',
  properties: {
    ergebnisse: {
      type: 'array',
      items: {
        type: 'object',
        properties: {
          merkmal: { type: 'string' },
          erfuellt: { type: 'boolean' },
          begruendung: { type: 'string' },
          // bildIndex: Eriks Wunsch nach einem Screenshot je Merkmal, NACH
          // einem ersten Versuch mit pixelgenauen Bild-Ausschnitten
          // (Beschriftungsraster + Zuschnitt einer benannten Zelle), der sich
          // in der Praxis als nicht gut genug erwies ("das mit den
          // Bildausschnitten hat nicht gut funktioniert") - deutlich
          // einfacher und robuster: die KI wählt nur noch AUS den bereits
          // gesendeten Bildern dasjenige, das den Nachweis für das Merkmal
          // am besten zeigt (0 = Übersicht, 1..N = die Kacheln in der
          // gesendeten Reihenfolge). Reine Auswahl aus einer festen, kleinen
          // Liste statt einer selbst zu bestimmenden Koordinate oder
          // Zellenbezeichnung - und der Server muss dafür NICHTS mehr
          // nachträglich rendern, die Bilder liegen schon als Buffer vor
          // (s. pruefePlanMitKI() weiter unten).
          bildIndex: { type: 'integer', enum: Array.from({ length: PLAN_CHECK_BILD_ANZAHL }, (_, i) => i) }
        },
        required: ['merkmal', 'erfuellt', 'begruendung', 'bildIndex'],
        additionalProperties: false
      }
    }
  },
  required: ['ergebnisse'],
  additionalProperties: false
};

// baueMerkmalePrompt: formt die Merkmale-Liste (Grundliste + optionales
// Zusatz-Merkmal nur für diese eine Prüfung, siehe POST /plan-checker-pruefen)
// in den Anweisungstext für die KI. Parameter: merkmale (Array {titel, prompt}).
// Rückgabe: String. Erklärt zusätzlich die Bildreihenfolge (Übersicht zuerst,
// dann die hochaufgelösten Kachel-Ausschnitte, s. renderPdfAlsBildsatz()
// oben) - ohne diesen Hinweis hat das Modell keinen Grund, bei mehreren
// Bildern über dieselbe Zeichnung gezielt nach Feinschrift in den hinteren
// Bildern zu suchen, statt sich nur auf das erste zu verlassen. Erklärt
// zusätzlich bildIndex (s. PLAN_CHECK_SCHEMA oben).
function baueMerkmalePrompt(merkmale){
  const zeilen = merkmale.map((m, i) => (i + 1) + '. ' + m.titel + ': ' + m.prompt);
  return 'Prüfe die Planzeichnung auf folgende Merkmale:\n\n' + zeilen.join('\n')
    + '\n\nDu bekommst mehrere Bilder derselben Zeichnung, nummeriert von 0: Bild 0 ist eine Übersicht der ganzen '
    + 'Seite, die Bilder 1 bis ' + (PLAN_CHECK_BILD_ANZAHL - 1) + ' sind sich überlappende Ausschnitte in höherer '
    + 'Auflösung. Nutze die Ausschnitte gezielt, um kleine Details wie Maßzahlen oder Plankopf-Angaben zu lesen, die '
    + 'auf der Übersicht zu klein sind.'
    + '\n\nGib zu jedem Merkmal zusätzlich unter "bildIndex" die Nummer DESJENIGEN Bildes an, auf dem der '
    + 'Hauptnachweis für dieses Merkmal am besten zu erkennen ist. Lässt sich kein einzelnes Bild sinnvoll '
    + 'bevorzugen, gib 0 (die Übersicht) an.';
}

// pruefePlanMitChatGPT: bilderBase64 ist ein Array (Übersicht zuerst, dann
// die Kachel-Ausschnitte, s. renderPdfAlsBildsatz() weiter oben) - jedes
// Bild wird als eigener image_url-Block gesendet, in derselben Reihenfolge,
// die baueMerkmalePrompt() dem Modell textlich erklärt.
async function pruefePlanMitChatGPT(bilderBase64, merkmale, apiKey, apiUrl, model){
  const zielUrl = normalisiereAiUrl(apiUrl, KI_DEFAULT_URL.chatgpt);
  let istLokal = false;
  try { istLokal = istLoopbackHost(new URL(zielUrl).hostname); } catch(e){ /* ungültige URL: bleibt false */ }

  const bildBloecke = bilderBase64.map(b64 => ({
    // detail:'high' statt des Vorgabewerts 'auto' — erzwingt die
    // feinteiligere, gekachelte Bildverarbeitung von OpenAI für JEDES der
    // gesendeten Bilder. Ohne das kann das Modell bei einer dichten
    // technischen Zeichnung von sich aus die gröbere Verarbeitung wählen,
    // wodurch kleine Maßzahlen und Plankopf-Text unlesbar werden — genau das
    // Merkmal, auf das hier geprüft wird.
    type: 'image_url', image_url: { url: 'data:image/png;base64,' + b64, detail: 'high' }
  }));

  const body = {
    // gpt-4o statt gpt-4o-mini als VORGABE (anders als beim Protokoll-Import
    // oben, der reinen Fließtext liest): Erik meldete, dass die Erkennung
    // "extrem unzuverlässig" war - bei temperature:0 (s.u.) deutet
    // schwankendes Ergebnis für dieselbe Zeichnung auf eine Fähigkeitsgrenze
    // des Modells hin, nicht auf Prompt/Rendering (siehe auch die
    // Protokoll-Import-Erfahrung weiter oben: "ein stärkeres Modell hätte
    // mehr Spielraum - das bleibt eine Modell-Fähigkeits-Frage, keine
    // Prompt-Frage"). Feine Maßzahlen auf einer dichten technischen
    // Zeichnung zuverlässig zu lesen ist eine deutlich anspruchsvollere
    // Bildaufgabe als Fließtext aus einem Besprechungsprotokoll zu ziehen.
    // Konto-Einstellung (user_ai_keys.model) überschreibt auch diese Vorgabe,
    // wenn gesetzt - nötig für einen eigenständigen Anbieter mit
    // abweichendem Modell-Katalog (z. B. Mammouth.ai).
    model: model || 'gpt-4o',
    messages: [
      { role: 'system', content: PLAN_CHECK_SYSTEM_PROMPT },
      { role: 'user', content: [
        { type: 'text', text: baueMerkmalePrompt(merkmale) },
        ...bildBloecke
      ] }
    ],
    response_format: { type: 'json_schema', json_schema: { name: 'plan_pruefung', strict: true, schema: PLAN_CHECK_SCHEMA } },
    // 4096 war zu knapp, dann 8192 - ein lokal angebundenes Modell hielt sich
    // trotz zunehmend schärferer Anweisung (s. PLAN_CHECK_SYSTEM_PROMPT oben,
    // Projekthistorie dort) wiederholt nicht an die Kürze, und die Antwort
    // wurde mitten im JSON abgeschnitten. 16000 angeglichen an das Limit, das
    // sich für genau dasselbe Problem beim Protokoll-Import bereits bewährt
    // hat (erkennePunkteMitChatGPT() oben) - weiterhin nur ein Sicherheitsnetz
    // zusätzlich zur Prompt-Anweisung, keine Garantie: Ein Modell, das
    // entschlossen genug aufzählt, kann auch dieses Limit erreichen.
    max_tokens: 16000,
    temperature: 0
  };
  // Siehe erkennePunkteMitChatGPT() oben: manche lokale Server laden
  // standardmäßig ein Reasoning-Modell, das vor jeder Antwort "denkt" und
  // damit jeden Timeout sprengen kann — nur für lokale Ziele abgeschaltet.
  if(istLokal) body.reasoning_effort = 'none';

  const res = await fetchMitTimeout(zielUrl, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + apiKey },
    body: JSON.stringify(body)
  });
  if(!res.ok){
    const errBody = await res.text().catch(() => '');
    throw new Error('ChatGPT antwortete mit HTTP ' + res.status + (errBody ? ': ' + errBody.slice(0, 200) : ''));
  }
  const data = await res.json();
  const content = data && data.choices && data.choices[0] && data.choices[0].message && data.choices[0].message.content;
  if(!content) throw new Error('ChatGPT lieferte keine Antwort.');
  // Manche lokalen Server (LM Studio, Ollama) oder Modelle halten sich nicht
  // strikt an response_format:json_schema und umschließen die Antwort
  // trotzdem mit einem Markdown-Codeblock ("```json\n...\n```"); das reine
  // JSON innerhalb des Blocks wird dann aussortiert, bevor geparst wird.
  const bereinigt = content.trim().replace(/^```[a-zA-Z]*\s*/, '').replace(/```\s*$/, '');
  let parsed;
  try { parsed = JSON.parse(bereinigt); } catch(e){
    // finish_reason:'length' heißt konkret "max_tokens erreicht, bevor das
    // Modell fertig war" - der häufigste real beobachtete Grund für
    // ungültiges JSON hier (ein Modell, das trotz PLAN_CHECK_SYSTEM_PROMPT
    // einzelne Werte aufzählt, s. dortige Projekthistorie). Eine konkrete
    // Fehlermeldung dafür erspart das erneute Einschicken des rohen
    // Antworttexts zur Diagnose. Rohtext zusätzlich im Fehler, wie bei den
    // HTTP-Fehlern oben (errBody.slice(0, 200)) - andere Scheitern-Gründe
    // (z. B. ein Modell, das nur EIN Bild pro Anfrage verarbeiten kann und
    // bei mehreren Bildern mit Fließtext statt JSON antwortet) bleiben so
    // trotzdem sichtbar.
    const abgeschnitten = data.choices[0].finish_reason === 'length';
    const hinweis = abgeschnitten
      ? 'Die Antwort wurde abgeschnitten (Modell hat das Token-Limit erreicht, bevor es fertig war - vermutlich zu ausführliche Begründungen). '
      : '';
    throw new Error('ChatGPT-Antwort war kein gültiges JSON: ' + hinweis + content.slice(0, 300));
  }
  if(!Array.isArray(parsed.ergebnisse)) throw new Error('ChatGPT-Antwort hatte nicht die erwartete Form.');
  return parsed.ergebnisse;
}

// pruefePlanMitClaude: bekam zwischenzeitlich das PDF DIREKT
// (document-Content-Block) statt eines von uns gerenderten Bildes - Grund
// damals: Erik meldete, dass die Erkennung von Maßketten "extrem
// unzuverlässig" war, auch nach dem Wechsel von Haiku auf das deutlich
// stärkere Sonnet 5 KEINE Verbesserung, was gegen eine Modell-
// Fähigkeitsgrenze und FÜR ein Auflösungsproblem sprach (Claude skaliert laut
// Anthropic-Dokumentation auf ca. 1568px lange Kante bzw. ~1,15 Megapixel
// herunter). Die PDF-Direktübergabe half laut Erik aber NICHT durchgreifend
// genug: ein erneuter Test mit korrekt erkanntem Plankopf zeigte trotzdem
// "in der vorliegenden Auflösung" nicht sämtlich lesbare Feinschrift
// (Planersteller, Maßstab, Datum, Plannummer) - vermutlich, weil Anthropics
// eigene Dokumenten-Verarbeitung eine PDF-Seite intern ebenfalls erst zu
// einem einzigen Bild wandelt und DANN derselben Auflösungsgrenze
// unterliegt. bilderBase64 ist jetzt wie bei pruefePlanMitChatGPT() ein Array
// (Übersicht + hochaufgelöste Kachel-Ausschnitte, renderPdfAlsBildsatz()
// weiter oben) - dasselbe, selbst kontrollierte Verfahren für beide
// Anbieter, statt erneut auf unbekanntes anbieterinternes Verhalten zu
// vertrauen.
async function pruefePlanMitClaude(bilderBase64, merkmale, apiKey, apiUrl, model){
  const bildBloecke = bilderBase64.map(b64 => ({
    type: 'image', source: { type: 'base64', media_type: 'image/png', data: b64 }
  }));
  const res = await fetchMitTimeout(normalisiereAiUrl(apiUrl, KI_DEFAULT_URL.claude), {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' },
    body: JSON.stringify({
      // claude-sonnet-5 statt claude-haiku-4-5-20251001 als VORGABE (anders
      // als beim Protokoll-Import oben), auch wenn das allein die
      // Unzuverlässigkeit NICHT behoben hat (s.o.) - ein stärkeres Modell
      // bleibt trotzdem die richtige Vorgabe für diese anspruchsvolle
      // Bildaufgabe. Konto-Einstellung überschreibt auch diese Vorgabe.
      model: model || 'claude-sonnet-5',
      // 16000 - dasselbe Sicherheitsnetz, auf denselben Wert angehoben wie bei
      // pruefePlanMitChatGPT() oben (Projekthistorie dort), selbes Risiko gilt
      // grundsätzlich auch hier (eine zu ausführliche Begründung, die vor
      // Abschluss des JSON abgeschnitten wird).
      max_tokens: 16000,
      temperature: 0,
      system: PLAN_CHECK_SYSTEM_PROMPT,
      messages: [{ role: 'user', content: [
        ...bildBloecke,
        { type: 'text', text: baueMerkmalePrompt(merkmale) }
      ] }],
      tools: [{
        name: 'plan_pruefung',
        description: 'Das Prüfergebnis je Merkmal.',
        input_schema: PLAN_CHECK_SCHEMA
      }],
      tool_choice: { type: 'tool', name: 'plan_pruefung' }
    })
  });
  if(!res.ok){
    const errBody = await res.text().catch(() => '');
    throw new Error('Claude antwortete mit HTTP ' + res.status + (errBody ? ': ' + errBody.slice(0, 200) : ''));
  }
  const data = await res.json();
  const toolUse = Array.isArray(data.content) ? data.content.find(b => b.type === 'tool_use') : null;
  if(!toolUse || !toolUse.input || !Array.isArray(toolUse.input.ergebnisse)){
    throw new Error('Claude-Antwort hatte nicht die erwartete Form.');
  }
  return toolUse.input.ergebnisse;
}

// pruefePlanMitKI: rendert den Bildsatz (Übersicht + Kachel-Ausschnitte,
// renderPdfAlsBildsatz() weiter oben) jetzt EINMAL, GEMEINSAM für beide
// Anbieter — anders als zuvor, als nur ChatGPT ein eigenes Rendering bekam
// und Claude das PDF direkt (siehe Projekthistorie bei pruefePlanMitClaude()
// oben). Reihenfolge des zurückgegebenen Arrays: Übersicht zuerst, danach
// die Kacheln in Zeilen-/Spaltenreihenfolge — dieselbe Reihenfolge, die
// baueMerkmalePrompt() dem Modell textlich erklärt und die bildIndex im
// Ergebnis referenziert.
//
// Ergänzt NACH der KI-Antwort pro Ergebnis ein "screenshot"-Feld (Data-URL
// oder null) — Eriks Wunsch, im Plan-Checker-Ergebnis zu jedem Merkmal ein
// Bild zu zeigen. Ein erster Versuch (Beschriftungsraster auf der Übersicht
// + nachträglicher Zuschnitt einer von der KI genannten Rasterzelle) erwies
// sich in der Praxis als nicht gut genug ("das mit den Bildausschnitten hat
// nicht gut funktioniert") und wurde durch diese einfachere Variante
// ersetzt: Der Screenshot ist exakt eines der bereits gerenderten Bilder
// (bildsatz.uebersicht oder eine der bildsatz.kacheln), ausgewählt allein
// über den von der KI gelieferten bildIndex — KEIN zweiter Render-Durchlauf
// mehr nötig, die Bilder liegen als Buffer schon vor.
async function pruefePlanMitKI(pdfBuf, merkmale, userId, provider){
  const { apiKey, apiUrl, model } = readUserAiKey(userId, provider);
  if(!apiKey) throw new Error('Kein API-Schlüssel hinterlegt.');
  if(provider !== 'claude' && provider !== 'chatgpt') throw new Error('Unbekannter Anbieter: ' + provider);

  let bildsatz;
  try {
    bildsatz = await renderPdfAlsBildsatz(pdfBuf);
  } catch(err){
    console.error('PDF-Rendering fehlgeschlagen:', err);
    throw new Error('Die PDF-Datei konnte nicht gelesen werden.');
  }
  const bilder = [bildsatz.uebersicht, ...bildsatz.kacheln];
  const bilderBase64 = bilder.map(b => b.toString('base64'));

  const ergebnisse = provider === 'claude'
    ? await pruefePlanMitClaude(bilderBase64, merkmale, apiKey, apiUrl, model)
    : await pruefePlanMitChatGPT(bilderBase64, merkmale, apiKey, apiUrl, model);

  // Number.isInteger()-Prüfung statt blindem Vertrauen auf das Schema: ein
  // Drittanbieter/lokaler Server hält sich nicht immer an response_format
  // (s. Projekthistorie bei pruefePlanMitChatGPT() - derselbe Grund, aus dem
  // dort schon Markdown-Codeblöcke toleriert werden). Ein fehlender/
  // unbrauchbarer bildIndex liefert einfach keinen Screenshot statt die
  // Prüfung scheitern zu lassen.
  for(const e of ergebnisse){
    const idx = e.bildIndex;
    e.screenshot = Number.isInteger(idx) && idx >= 0 && idx < bilder.length
      ? 'data:image/png;base64,' + bilder[idx].toString('base64')
      : null;
  }

  return ergebnisse;
}

// textZuSicheremHtml: wandelt reinen Klartext (PDF/Word-Extraktion oder
// KI-Erkennung, erkennePunkteAusText()/erkennePunkteMitKI() oben) in
// dasselbe sanitizeStatusHtml()-taugliche HTML, das ein von Hand getippter
// Protokoll-Punkt über sein contenteditable-Feld ohnehin schon erzeugt
// (richtextFeldHtml(), public/js/utils.js) — protokoll_punkte.text gilt seit
// der Umstellung auf contenteditable (Eriks Wunsch nach echter statt mit
// Sternchen markierter Fett-/Kursivschrift) client-seitig immer als
// bereits-sicheres HTML; ohne dieses Escaping würde ein im Originaldokument
// vorkommendes "<"/">" beim Rendern als Markup fehlinterpretiert statt als
// Text angezeigt. Gegenstück zu esc() in public/js/utils.js.
function textZuSicheremHtml(s){
  return String(s == null ? '' : s)
    .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;').replace(/'/g, '&#39;')
    .replace(/\r\n|\r|\n/g, '<br>');
}

function legeProtokollAn(opts){
  const {
    projectNr, projectName, weekLabel, datum, betreff, ort, verfasserUserId,
    teilnehmer, zusatzPunkte, quelleDateiname, quelleStoredName
  } = opts;

  const id = crypto.randomUUID();
  const now = new Date().toISOString();
  let nummer = 1;

  db.exec('BEGIN');
  try {
    const maxRow = db.prepare('SELECT MAX(nummer) AS m FROM project_protokolle WHERE project_nr = ?').get(projectNr);
    nummer = (maxRow && maxRow.m) ? maxRow.m + 1 : 1;

    db.prepare(`INSERT INTO project_protokolle
        (id, project_nr, project_name, nummer, datum, betreff, ort, verfasser_user_id, week_label,
         quelle_dateiname, quelle_stored_name, created_at, updated_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
      .run(id, projectNr, projectName, nummer, String(datum), String(betreff || ''), String(ort || ''),
        verfasserUserId, weekLabel, String(quelleDateiname || ''), String(quelleStoredName || ''), now, now);

    const insTeilnehmer = db.prepare(`INSERT INTO protokoll_teilnehmer
      (id, protokoll_id, name, firma, anwesend, array_order) VALUES (?, ?, ?, ?, ?, ?)`);
    (Array.isArray(teilnehmer) ? teilnehmer : []).forEach((t, idx) => {
      const name = String((t && t.name) || '').trim();
      if(!name) return;
      insTeilnehmer.run(crypto.randomUUID(), id, name, String((t && t.firma) || ''), (t && t.anwesend) ? 1 : 0, idx);
    });

    const insPunkt = db.prepare(`INSERT INTO protokoll_punkte
        (id, protokoll_id, stamm_id, nummer, gruppe, neu, thema, text, zustaendig, termin, erledigt, erstellt_am, status, entfaellt_naechstes, array_order)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
    let order = 0;

    const prevRow = db.prepare(`SELECT id FROM project_protokolle
      WHERE project_nr = ? AND id != ? ORDER BY nummer DESC LIMIT 1`).get(projectNr, id);
    if(prevRow){
      // Fortschreiben (Eriks Wunsch, Nachtrag zur ursprünglichen Regel "nur
      // offen läuft weiter"): 'offen' und 'info' laufen unbegrenzt weiter;
      // 'erledigt' bekommt noch GENAU EINE Gnadenrunde — eine Kopie, die
      // selbst entfaellt_naechstes=0 trägt (also hier zum ersten Mal als
      // erledigt auftaucht oder zwischenzeitlich von Hand wieder auf
      // erledigt gesetzt wurde), läuft noch einmal mit; eine Kopie, die
      // bereits entfaellt_naechstes=1 trägt (schon einmal fortgeschrieben),
      // bleibt hier liegen. Die neue Kopie selbst bekommt entfaellt_naechstes
      // NUR gesetzt, wenn ihre Quelle 'erledigt' war — das ist der Hinweis
      // "entfällt im nächsten Protokoll" in genau diesem einen Protokoll;
      // offen/info-Kopien tragen 0 und laufen so unbegrenzt weiter.
      const vorherigePunkte = db.prepare(`SELECT * FROM protokoll_punkte
        WHERE protokoll_id = ? ORDER BY array_order`).all(prevRow.id);
      const fortzuschreiben = vorherigePunkte.filter(p =>
        p.status === 'offen' || p.status === 'info' || (p.status === 'erledigt' && !p.entfaellt_naechstes));
      // erstellt_am wandert UNVERÄNDERT mit (wie stamm_id) — ein fortgeschriebener
      // Punkt wurde hier nicht neu erstellt, nur übernommen.
      fortzuschreiben.forEach(p => {
        insPunkt.run(crypto.randomUUID(), id, p.stamm_id, p.nummer, p.gruppe, 0, p.thema, p.text, p.zustaendig, p.termin,
          p.status === 'erledigt' ? 1 : 0, p.erstellt_am || '', p.status, p.status === 'erledigt' ? 1 : 0, order++);
      });
    }

    // Zusätzlich erkannte/übergebene Punkte (Import) — immer neu=1, frische
    // stamm_id, hinter den fortgeschriebenen Punkten einsortiert. erstellt_am
    // ist das Datum DIESES Protokolls — hier entstehen diese Punkte zum
    // ersten Mal im System, unabhängig davon, ob das importierte Dokument
    // selbst älter ist. status kommt bei der KI-Erkennung direkt vom Modell
    // (normalisierePunktAusKi() hat ihn schon gegen VALID_PROTOKOLL_PUNKT_STATUS
    // geprüft); die Textmuster-Heuristik (erkennePunkteAusText()) kennt
    // weiterhin nur das ältere, boolesche erledigt (kein 'info' — sie liest
    // reinen Regex-Textmustern, keine Bedeutung) — dafür hier der Rückfall
    // auf das alte Verhalten, falls kein gültiger status mitkommt.
    (Array.isArray(zusatzPunkte) ? zusatzPunkte : []).forEach(p => {
      const status = VALID_PROTOKOLL_PUNKT_STATUS.has(p.status) ? p.status : (p.erledigt ? 'erledigt' : 'offen');
      // entfaellt_naechstes=0: ein importierter/neu erkannter Punkt taucht
      // hier zum ersten Mal auf, unabhängig vom erkannten status — selbst
      // ein als 'erledigt' erkannter Punkt bekommt dadurch noch seine
      // Gnadenrunde im nächsten Protokoll, statt sofort stillschweigend zu
      // verschwinden.
      insPunkt.run(crypto.randomUUID(), id, crypto.randomUUID(), String(p.nummer || ''), String(p.gruppe || ''), 1,
        String(p.thema || ''), textZuSicheremHtml(p.text || ''), String(p.zustaendig || ''), String(p.termin || ''),
        status === 'erledigt' ? 1 : 0, String(datum), status, 0, order++);
    });

    db.exec('COMMIT');
  } catch(err){
    db.exec('ROLLBACK');
    throw err;
  }

  console.log('Protokoll angelegt:', projectNr, '- Nr.', nummer);
  return id;
}

app.post('/project-protokolle', requireAuth, requireRecht('proj.protokolle'), (req, res) => {
  try {
    const projectNr = String(req.query.projectNr || '');
    if(!projectNr) return res.status(400).json({ ok: false, error: 'Projekt hat keine Projektnummer.' });
    const { datum, betreff, ort, teilnehmer } = req.body || {};
    if(!datum) return res.status(400).json({ ok: false, error: 'Datum erforderlich.' });

    const id = legeProtokollAn({
      projectNr, projectName: String(req.query.projectName || ''), weekLabel: String(req.query.weekLabel || ''),
      datum, betreff, ort, verfasserUserId: req.user.id, teilnehmer, zusatzPunkte: []
    });
    res.json({ ok: true, protokoll: loadProtokollDetail(id) });
  } catch(err){
    console.error('Protokoll anlegen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: externes Protokoll hochladen und automatisch in Punkte umwandeln.
// Raw-Binär-Body wie POST /project-files. Extrahiert den Text (PDF via
// pdf-parse, Word via mammoth), teilt ihn heuristisch in Punkte auf
// (erkennePunkteAusText()) und legt darüber ein ganz normales Protokoll an
// (legeProtokollAn() — dieselbe Fortschreiben-Logik wie beim manuellen
// Anlegen; die erkannten Punkte kommen zusätzlich dazu, als neu=1). Die
// Original-Datei bleibt unter UPLOADS_DIR gespeichert und über
// GET /project-protokolle/:id/quelldatei abrufbar — Erkennung ist ein
// Entwurf, keine Garantie, siehe CLAUDE.md "### Protokolle".
app.post('/project-protokolle/import', requireAuth, requireRecht('proj.protokolle'), express.raw({ type: '*/*', limit: '25mb' }), async (req, res) => {
  try {
    const projectNr = String(req.query.projectNr || '');
    if(!projectNr) return res.status(400).json({ ok: false, error: 'Projekt hat keine Projektnummer.' });
    if(!req.query.datum) return res.status(400).json({ ok: false, error: 'Datum erforderlich.' });

    const buf = req.body;
    if(!Buffer.isBuffer(buf) || buf.length === 0){
      return res.status(400).json({ ok: false, error: 'Keine Datei empfangen.' });
    }

    let filename = '';
    try { filename = decodeURIComponent(String(req.query.filename || '')); }
    catch(e){ filename = String(req.query.filename || ''); }
    const ext = extractFileExtension(filename);

    let text = '';
    if(ext !== 'pdf' && ext !== 'docx'){
      return res.status(400).json({ ok: false, error: 'Nur PDF- und Word-Dateien (.pdf, .docx) werden unterstützt.' });
    }
    // Eine beschädigte Datei ist ein Eingabefehler (400), kein Serverfehler.
    try {
      if(ext === 'pdf') text = await extrahierePdfText(buf);
      else text = ((await mammoth.extractRawText({ buffer: buf })).value) || '';
    } catch(err){
      return res.status(400).json({ ok: false, error: 'Die Datei konnte nicht gelesen werden (beschädigt oder kein echtes ' + ext.toUpperCase() + ').' });
    }

    // Teilnehmer kommen NUR aus der KI-Erkennung (siehe KI_SYSTEM_PROMPT) —
    // erkennePunkteAusText() ist reines Regex und kann keine Teilnehmerliste
    // von Fließtext unterscheiden, deshalb bleibt teilnehmerAusDokument beim
    // Textmuster-Pfad und bei jedem KI-Fehlschlag (Rückfall) leer; die
    // Person trägt sie dann wie schon bisher von Hand in der Detailansicht
    // nach. Bewusst KEIN Merge mit dem letzten Protokoll dieses Projekts
    // (anders als neuesProtokoll()'s Vorbelegung) — der Import soll genau
    // zeigen, was im hochgeladenen Dokument steht, nicht zwei Quellen
    // vermischen.
    let zusatzPunkte, teilnehmerAusDokument = [], erkennungsart = 'textmuster', erkennungshinweis = '';
    const gewuenschterAnbieter = req.query.erkennung;
    if(gewuenschterAnbieter === 'chatgpt' || gewuenschterAnbieter === 'claude'){
      try {
        const ergebnis = await erkennePunkteMitKI(text, req.user.id, gewuenschterAnbieter);
        zusatzPunkte = ergebnis.punkte;
        teilnehmerAusDokument = ergebnis.teilnehmer;
        erkennungsart = gewuenschterAnbieter;
      } catch(err){
        console.warn('KI-Erkennung fehlgeschlagen, Rückfall auf Textmuster:', err.message);
        erkennungshinweis = err.message;
        zusatzPunkte = erkennePunkteAusText(text);
      }
    } else {
      zusatzPunkte = erkennePunkteAusText(text);
    }

    const storedName = crypto.randomUUID() + (ext ? '.' + ext : '');
    fs.writeFileSync(path.join(uploadDirFor(), storedName), buf);

    const id = legeProtokollAn({
      projectNr, projectName: String(req.query.projectName || ''), weekLabel: String(req.query.weekLabel || ''),
      datum: req.query.datum, betreff: req.query.betreff, ort: req.query.ort,
      verfasserUserId: req.user.id, teilnehmer: teilnehmerAusDokument, zusatzPunkte,
      quelleDateiname: filename || storedName, quelleStoredName: storedName
    });

    console.log('Protokoll importiert:', projectNr, '-', zusatzPunkte.length, 'Punkte,', teilnehmerAusDokument.length, 'Teilnehmer erkannt aus', filename, '(' + erkennungsart + ')');
    res.json({ ok: true, protokoll: loadProtokollDetail(id), erkannteAnzahl: zusatzPunkte.length,
      erkannteTeilnehmerAnzahl: teilnehmerAusDokument.length, erkennungsart, erkennungshinweis });
  } catch(err){
    console.error('Protokoll-Import fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Original-Datei eines importierten Protokolls herunterladen —
// Gegenstück zu GET /project-files/:id/download. 404, wenn das Protokoll
// nicht importiert wurde (quelle_stored_name leer, siehe legeProtokollAn()).
app.get('/project-protokolle/:id/quelldatei', requireAuth, (req, res) => {
  try {
    const row = db.prepare('SELECT quelle_dateiname, quelle_stored_name FROM project_protokolle WHERE id = ?').get(req.params.id);
    if(!row || !row.quelle_stored_name){
      return res.status(404).json({ ok: false, error: 'Keine Quelldatei vorhanden.' });
    }
    res.download(path.join(UPLOADS_DIR, row.quelle_stored_name), row.quelle_dateiname || row.quelle_stored_name);
  } catch(err){
    console.error('Quelldatei-Download fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Protokoll speichern — ersetzt Teilnehmer- und Punkte-Zeilen komplett
// (löschen + neu einfügen, wie deleteWeekData()/serializeWeek()). nummer,
// gruppe, thema, text, zustaendig, termin, erledigt sind reine Anzeige-/
// Bearbeitungsfelder und werden immer vom Client übernommen. stamm_id/neu
// dagegen NIE vom Client vertraut: für einen Punkt mit bekannter id werden
// sie aus der bisherigen Zeile übernommen, ein Punkt ohne id ist neu
// (frische stamm_id, neu=1).
app.put('/project-protokolle/:id', requireAuth, requireRecht('proj.protokolle'), (req, res) => {
  try {
    const row = db.prepare('SELECT * FROM project_protokolle WHERE id = ?').get(req.params.id);
    if(!row) return res.status(404).json({ ok: false, error: 'Protokoll nicht gefunden.' });
    const { datum, betreff, ort, teilnehmer, punkte } = req.body || {};
    if(!datum) return res.status(400).json({ ok: false, error: 'Datum erforderlich.' });

    const now = new Date().toISOString();
    db.exec('BEGIN');
    try {
      db.prepare('UPDATE project_protokolle SET datum = ?, betreff = ?, ort = ?, updated_at = ? WHERE id = ?')
        .run(String(datum), String(betreff || ''), String(ort || ''), now, row.id);

      db.prepare('DELETE FROM protokoll_teilnehmer WHERE protokoll_id = ?').run(row.id);
      const insTeilnehmer = db.prepare(`INSERT INTO protokoll_teilnehmer
        (id, protokoll_id, name, firma, anwesend, array_order) VALUES (?, ?, ?, ?, ?, ?)`);
      (Array.isArray(teilnehmer) ? teilnehmer : []).forEach((t, idx) => {
        const name = String((t && t.name) || '').trim();
        if(!name) return;
        insTeilnehmer.run(crypto.randomUUID(), row.id, name, String((t && t.firma) || ''), (t && t.anwesend) ? 1 : 0, idx);
      });

      const bestehende = new Map();
      db.prepare('SELECT id, stamm_id, neu, erstellt_am, entfaellt_naechstes FROM protokoll_punkte WHERE protokoll_id = ?').all(row.id)
        .forEach(p => bestehende.set(p.id, p));

      db.prepare('DELETE FROM protokoll_punkte WHERE protokoll_id = ?').run(row.id);
      const insPunkt = db.prepare(`INSERT INTO protokoll_punkte
          (id, protokoll_id, stamm_id, nummer, gruppe, neu, thema, text, zustaendig, termin, erledigt, erstellt_am, status, entfaellt_naechstes, array_order)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
      // erstellt_am ist wie stamm_id/neu serverseitig maßgeblich, nie vom
      // Client übernommen: ein bekannter Punkt behält sein ursprüngliches
      // Datum, ein neu hinzugefügter bekommt das Datum DIESES Protokolls
      // (der gerade gespeicherte `datum`-Wert oben) — der Moment, in dem er
      // zum ersten Mal gespeichert wird. status wird dagegen VOM CLIENT
      // übernommen (offen/erledigt/info, über ein <select> gewählt) — anders
      // als neu/stamm_id/erstellt_am ist das kein Herkunfts-, sondern ein
      // jederzeit frei änderbares Inhaltsfeld, wie thema oder zustaendig.
      // erledigt bleibt als reine Ableitung von status bestehen (siehe
      // migrateAddProtokollPunktStatus()). entfaellt_naechstes ist wie
      // stamm_id/neu/erstellt_am serverseitig maßgeblich und NIE vom Client
      // übernommen — es ist kein frei editierbares Inhaltsfeld, sondern wird
      // ausschließlich von legeProtokollAn() beim Fortschreiben gesetzt
      // (siehe dort); ein hier bearbeiteter bekannter Punkt behält also
      // seinen bisherigen Wert unverändert, ein neuer startet bei 0.
      (Array.isArray(punkte) ? punkte : []).forEach((p, idx) => {
        const bekannt = p && p.id ? bestehende.get(p.id) : null;
        const pid = bekannt ? bekannt.id : crypto.randomUUID();
        const stammId = bekannt ? bekannt.stamm_id : crypto.randomUUID();
        const neu = bekannt ? bekannt.neu : 1;
        const erstelltAm = bekannt ? (bekannt.erstellt_am || '') : String(datum);
        const entfaelltNaechstes = bekannt ? bekannt.entfaellt_naechstes : 0;
        const status = VALID_PROTOKOLL_PUNKT_STATUS.has(p && p.status) ? p.status : 'offen';
        // text trägt wie der Wochen-Kommentar Formatierungs-HTML und wird
        // an der Schreibstelle bereinigt (sanitizeFormatHtml()); thema und
        // zustaendig sind reine Textfelder und werden beim Anzeigen escaped.
        insPunkt.run(pid, row.id, stammId, String((p && p.nummer) || ''), String((p && p.gruppe) || ''), neu,
          String((p && p.thema) || ''), sanitizeFormatHtml(p && p.text), String((p && p.zustaendig) || ''),
          String((p && p.termin) || ''), status === 'erledigt' ? 1 : 0, erstelltAm, status, entfaelltNaechstes, idx);
      });

      db.exec('COMMIT');
    } catch(err){
      db.exec('ROLLBACK');
      throw err;
    }

    res.json({ ok: true, protokoll: loadProtokollDetail(row.id) });
  } catch(err){
    console.error('Protokoll speichern fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Protokoll löschen — Auth genügt (kein admin-only), dieselbe
// Berechtigungsstufe wie das Löschen einer Aufgabe/eines Meilensteins.
// Idempotent wie DELETE /users/:id/absences/:absenceId (kein Fehler, wenn
// bereits gelöscht).
app.delete('/project-protokolle/:id', requireAuth, requireRecht('proj.protokolle'), (req, res) => {
  try {
    const row = db.prepare('SELECT id, quelle_stored_name FROM project_protokolle WHERE id = ?').get(req.params.id);
    if(!row) return res.json({ ok: true });
    db.exec('BEGIN');
    try {
      db.prepare('DELETE FROM protokoll_punkte WHERE protokoll_id = ?').run(row.id);
      db.prepare('DELETE FROM protokoll_teilnehmer WHERE protokoll_id = ?').run(row.id);
      db.prepare('DELETE FROM project_protokolle WHERE id = ?').run(row.id);
      db.exec('COMMIT');
    } catch(err){
      db.exec('ROLLBACK');
      throw err;
    }
    // Die Quelldatei eines importierten Protokolls gleich mit entfernen —
    // sonst bliebe sie ohne jeden Verweis in sessions/uploads liegen.
    if(row.quelle_stored_name){
      fs.unlink(path.join(uploadDirFor(), path.basename(row.quelle_stored_name)), () => {});
    }
    console.log('Protokoll gelöscht:', row.id);
    res.json({ ok: true });
  } catch(err){
    console.error('Protokoll löschen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// ---------- Aufgaben-Vorlagen je Leistungsphase (lph_templates) ----------

// VALID_LPHS: gültige Leistungsphasen-Schlüssel (muss zu LPHS in
// public/js/globals.js passen). Dient nur der Eingabeprüfung der
// Vorlagen-Routen — die Fortschrittswerte in project_lph werden bewusst NICHT
// gegen diese Liste geprüft (dort sind historisch gewachsene Schlüssel aus
// Altdaten möglich).
const VALID_LPHS = new Set(['LPH 1','LPH 2','LPH 3','LPH 4','LPH 5','LPH 6','LPH 7','LPH 8','LPH 9','W+M']);

// templateAnteil: Prozentwert eines Vorlagen-Schritts prüfen (Komma oder
// Punkt, 0–100, drei Nachkommastellen). Rückgabe: Zahl oder null (ungültig).
function templateAnteil(v){
  if(v === undefined || v === null || v === '') return 0;
  const n = Number(String(v).replace(',', '.'));
  if(!Number.isFinite(n) || n < 0 || n > 100) return null;
  return Math.round(n * 1000) / 1000;
}
// templateAnteilEingabe: Eingabe der Spalte „Anteil %“ — eine Zahl, oder
// „in a)“ / „in a + b“ / „in a u. b“ für einen Schritt, der in anderen
// enthalten ist (Siemon-Tabelle). Rückgabe: {anteil, enthaltenIn} oder null.
function templateAnteilEingabe(v){
  const t = String(v === undefined || v === null ? '' : v).trim();
  if(/^in\b/i.test(t)){
    const buchst = (t.slice(2).match(/[a-z]/gi) || []).map(x => x.toLowerCase())
      .filter(x => x !== 'u'); // „u.“ aus „a u. b“
    const enthaltenIn = [...new Set(buchst)].join(',');
    return enthaltenIn ? { anteil: 0, enthaltenIn } : null;
  }
  const anteil = templateAnteil(t);
  return anteil === null ? null : { anteil, enthaltenIn: '' };
}

// serializeTemplateRow: DB-Zeile -> öffentliche JSON-Form.
function serializeTemplateRow(row){
  return {
    id: row.id,
    lph: row.lph,
    gewerk: row.gewerk || '',
    anteil: Number(row.anteil) || 0,
    enthaltenIn: row.enthalten_in || '',
    title: row.title,
    offsetDays: row.offset_days,
    durationDays: row.duration_days,
    sortOrder: row.sort_order,
  };
}

// Route: alle Vorlagen lesen (jeder angemeldete Nutzer darf Vorlagen
// einfügen, daher nur requireAuth — nur das Pflegen ist Admin-Sache).
app.get('/lph-templates', requireAuth, (req, res) => {
  try {
    const rows = db.prepare('SELECT * FROM lph_templates ORDER BY lph, gewerk, sort_order, title').all();
    res.json({ ok: true, templates: rows.map(serializeTemplateRow) });
  } catch(err){
    console.error('Vorlagen laden fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: neue Vorlagen-Aufgabe anlegen. Admin-only (firmenweite Konfiguration).
app.post('/lph-templates', requireRecht('a.vorlagen'), (req, res) => {
  try {
    const { lph, gewerk, title, offsetDays, durationDays, anteil } = req.body || {};
    if(!VALID_LPHS.has(String(lph))){
      return res.status(400).json({ ok: false, error: 'Unbekannte Leistungsphase.' });
    }
    if(!VALID_DEPARTMENTS.has(String(gewerk))){
      return res.status(400).json({ ok: false, error: 'Unbekanntes Gewerk.' });
    }
    const cleanTitle = String(title || '').trim();
    if(!cleanTitle) return res.status(400).json({ ok: false, error: 'Titel fehlt.' });
    const offset = Number.isFinite(Number(offsetDays)) ? Math.max(0, Math.trunc(Number(offsetDays))) : 0;
    // Dauer 0 = ohne Termin: die Aufgabe wird ohne Start/Ende eingefügt.
    const duration = Number.isFinite(Number(durationDays)) ? Math.max(0, Math.trunc(Number(durationDays))) : 1;
    // sort_order: ans Ende der Liste dieser Leistungsphase und dieses Gewerks
    const maxRow = db.prepare('SELECT MAX(sort_order) AS m FROM lph_templates WHERE lph = ? AND gewerk = ?').get(String(lph), String(gewerk));
    const sortOrder = (maxRow && Number.isFinite(maxRow.m) ? maxRow.m : -1) + 1;
    const ein = templateAnteilEingabe(anteil);
    if(ein === null) return res.status(400).json({ ok: false, error: 'Anteil: eine Zahl von 0 bis 100 oder „in a)“.' });
    const id = crypto.randomUUID();
    db.prepare(`INSERT INTO lph_templates (id, lph, gewerk, title, offset_days, duration_days, sort_order, anteil, enthalten_in)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, String(lph), String(gewerk), cleanTitle, offset, duration, sortOrder, ein.anteil, ein.enthaltenIn);
    res.json({ ok: true, template: serializeTemplateRow({
      id, lph: String(lph), gewerk: String(gewerk), title: cleanTitle, offset_days: offset, duration_days: duration, sort_order: sortOrder,
      anteil: ein.anteil, enthalten_in: ein.enthaltenIn
    })});
  } catch(err){
    console.error('Vorlage anlegen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Vorlagen-Schritt ändern (Titel, Start-Versatz, Dauer). Admin-only.
// Nur übergebene Felder werden geändert. Bereits eingefügte Aufgaben bleiben
// unberührt (siehe Tabellen-Kommentar bei lph_templates).
app.patch('/lph-templates/:id', requireRecht('a.vorlagen'), (req, res) => {
  try {
    const row = db.prepare('SELECT * FROM lph_templates WHERE id = ?').get(String(req.params.id));
    if(!row) return res.status(404).json({ ok: false, error: 'Schritt nicht gefunden.' });
    const b = req.body || {};
    let title = row.title, offset = row.offset_days, duration = row.duration_days, anteil = Number(row.anteil) || 0,
      enthaltenIn = row.enthalten_in || '';
    if(b.anteil !== undefined){
      const ein = templateAnteilEingabe(b.anteil);
      if(ein === null) return res.status(400).json({ ok: false, error: 'Anteil: eine Zahl von 0 bis 100 oder „in a)“.' });
      anteil = ein.anteil; enthaltenIn = ein.enthaltenIn;
    }
    if(b.title !== undefined){
      title = String(b.title || '').trim();
      if(!title) return res.status(400).json({ ok: false, error: 'Titel fehlt.' });
    }
    if(b.offsetDays !== undefined){
      if(!Number.isFinite(Number(b.offsetDays))) return res.status(400).json({ ok: false, error: 'Start ungültig.' });
      offset = Math.max(0, Math.trunc(Number(b.offsetDays)));
    }
    if(b.durationDays !== undefined){
      if(!Number.isFinite(Number(b.durationDays))) return res.status(400).json({ ok: false, error: 'Dauer ungültig.' });
      duration = Math.max(0, Math.trunc(Number(b.durationDays))); // 0 = ohne Termin
    }
    db.prepare('UPDATE lph_templates SET title = ?, offset_days = ?, duration_days = ?, anteil = ?, enthalten_in = ? WHERE id = ?')
      .run(title, offset, duration, anteil, enthaltenIn, row.id);
    res.json({ ok: true, template: serializeTemplateRow({ ...row, title, offset_days: offset, duration_days: duration, anteil, enthalten_in: enthaltenIn }) });
  } catch(err){
    console.error('Vorlage ändern fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Vorlagen-Schritt um eine Stelle nach oben (richtung -1) oder unten
// (+1) verschieben — innerhalb derselben Leistungsphase und desselben
// Gewerks. Nummeriert die Liste dabei lückenlos neu. Admin-only.
app.post('/lph-templates/:id/verschieben', requireRecht('a.vorlagen'), (req, res) => {
  try {
    const row = db.prepare('SELECT * FROM lph_templates WHERE id = ?').get(String(req.params.id));
    if(!row) return res.status(404).json({ ok: false, error: 'Schritt nicht gefunden.' });
    const richtung = Number((req.body || {}).richtung) < 0 ? -1 : 1;
    const liste = db.prepare('SELECT id FROM lph_templates WHERE lph = ? AND gewerk = ? ORDER BY sort_order, title')
      .all(row.lph, row.gewerk).map(r => r.id);
    const i = liste.indexOf(row.id), j = i + richtung;
    if(j >= 0 && j < liste.length){
      [liste[i], liste[j]] = [liste[j], liste[i]];
      const upd = db.prepare('UPDATE lph_templates SET sort_order = ? WHERE id = ?');
      db.exec('BEGIN');
      try { liste.forEach((id, k) => upd.run(k, id)); db.exec('COMMIT'); }
      catch(e){ db.exec('ROLLBACK'); throw e; }
    }
    res.json({ ok: true });
  } catch(err){
    console.error('Vorlage verschieben fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Vorlagen-Aufgabe löschen. Admin-only. Idempotent (bereits gelöscht
// ist kein Fehler). Bereits eingefügte TODOs bleiben unberührt (siehe
// Tabellen-Kommentar bei lph_templates).
app.delete('/lph-templates/:id', requireRecht('a.vorlagen'), (req, res) => {
  try {
    db.prepare('DELETE FROM lph_templates WHERE id = ?').run(String(req.params.id));
    res.json({ ok: true });
  } catch(err){
    console.error('Vorlage löschen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// ---------- Plan-Checker-Merkmale (plan_checker_merkmale) ----------

function serializeMerkmalRow(row){
  return { id: row.id, titel: row.titel, prompt: row.prompt, sortOrder: row.sort_order };
}

// Route: alle Merkmale lesen (jeder angemeldete Nutzer braucht die Liste, um
// zu sehen, was geprüft wird — nur das Pflegen ist Admin-Sache).
app.get('/plan-checker-merkmale', requireAuth, (req, res) => {
  try {
    const rows = db.prepare('SELECT * FROM plan_checker_merkmale ORDER BY sort_order, titel').all();
    res.json({ ok: true, merkmale: rows.map(serializeMerkmalRow) });
  } catch(err){
    console.error('Merkmale laden fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: neues Merkmal anlegen. Admin-only (firmenweite Konfiguration).
app.post('/plan-checker-merkmale', requireRecht('a.checker'), (req, res) => {
  try {
    const { titel, prompt } = req.body || {};
    const cleanTitel = String(titel || '').trim();
    const cleanPrompt = String(prompt || '').trim();
    if(!cleanTitel) return res.status(400).json({ ok: false, error: 'Titel fehlt.' });
    if(!cleanPrompt) return res.status(400).json({ ok: false, error: 'Prüfanweisung fehlt.' });
    const maxRow = db.prepare('SELECT MAX(sort_order) AS m FROM plan_checker_merkmale').get();
    const sortOrder = (maxRow && Number.isFinite(maxRow.m) ? maxRow.m : -1) + 1;
    const id = crypto.randomUUID();
    db.prepare('INSERT INTO plan_checker_merkmale (id, titel, prompt, sort_order) VALUES (?, ?, ?, ?)')
      .run(id, cleanTitel, cleanPrompt, sortOrder);
    res.json({ ok: true, merkmal: { id, titel: cleanTitel, prompt: cleanPrompt, sortOrder } });
  } catch(err){
    console.error('Merkmal anlegen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Merkmal löschen. Admin-only. Idempotent.
app.delete('/plan-checker-merkmale/:id', requireRecht('a.checker'), (req, res) => {
  try {
    db.prepare('DELETE FROM plan_checker_merkmale WHERE id = ?').run(String(req.params.id));
    res.json({ ok: true });
  } catch(err){
    console.error('Merkmal löschen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: einen Plan prüfen. Roh-Binärkörper wie /project-protokolle/import
// (siehe RAW_BODY_ROUTES oben) — provider und ein optionales, nur für DIESE
// Prüfung geltendes Zusatz-Merkmal kommen als Query-Parameter, da der Body
// vollständig die Datei ist. Weder die PDF- noch die daraus gerenderten
// Bilddateien werden gespeichert (siehe Erläuterung bei pruefePlanMitKI()
// oben). Das Rendering zum Bildsatz (Übersicht + Kacheln) passiert NICHT
// hier, sondern innerhalb von pruefePlanMitKI() — für beide Anbieter gleich.
app.post('/plan-checker-pruefen', requireAuth, requireRecht('wz.checker'), express.raw({ type: '*/*', limit: '25mb' }), async (req, res) => {
  try {
    const buf = req.body;
    if(!Buffer.isBuffer(buf) || buf.length === 0){
      return res.status(400).json({ ok: false, error: 'Keine Datei empfangen.' });
    }
    // Einfache Format-Prüfung über die PDF-Magic-Bytes statt einer
    // Dateiendung (die Endung kommt hier aus keinem Formularfeld, der Body
    // IST die Datei) — ein PDF beginnt immer mit "%PDF".
    if(buf.slice(0, 4).toString('latin1') !== '%PDF'){
      return res.status(400).json({ ok: false, error: 'Nur PDF-Dateien werden unterstützt.' });
    }
    const provider = String(req.query.provider || '');
    if(provider !== 'chatgpt' && provider !== 'claude'){
      return res.status(400).json({ ok: false, error: 'Unbekannter KI-Anbieter.' });
    }

    const merkmale = db.prepare('SELECT titel, prompt FROM plan_checker_merkmale ORDER BY sort_order, titel').all();

    // Projekt-Abgleich (Eriks Wunsch): optional, genau wie das Zusatz-Merkmal
    // weiter unten nur für DIESE eine Prüfung und nicht gespeichert - kein
    // neues Feld in plan_checker_merkmale, sondern derselbe Mechanismus, nur
    // mit einem serverseitig gebauten statt frei getipptem Text. Das Projekt
    // selbst kommt aus dem bereits beim Client geladenen db.weeks (die
    // Auswahl im Frontend liest currentWeek().projects, kein eigener
    // Endpunkt) - der Server bekommt nur Nummer/Bezeichnung als Query-Param,
    // prüft sie aber NICHT gegen die Datenbank (reine Texteingabe für den
    // Prompt, wie das Zusatz-Merkmal auch). Bewusst nur Projektnummer +
    // Bezeichnung: Das sind die einzigen Projekt-Stammdaten, die es im
    // Datenmodell überhaupt gibt - ein Plankopf kennt zusätzlich
    // Planersteller, Maßstab, Plannummer, Datum, aber dafür gibt es keine
    // gespeicherte Vorgabe, gegen die man abgleichen könnte.
    const projektNr = String(req.query.projektNr || '').trim();
    const projektName = String(req.query.projektName || '').trim();
    if(projektNr || projektName){
      const soll = [
        projektNr ? `Projektnummer "${projektNr}"` : null,
        projektName ? `Projektbezeichnung "${projektName}"` : null
      ].filter(Boolean).join(' und ');
      // Erste Fassung fragte direkt "stimmt der Plankopf mit X überein?" -
      // ein echter Fehlschlag zeigte, dass das zu leicht als "bestätige X"
      // statt "lies ab und vergleiche dann" gelesen wird: Die KI gab exakt
      // die vorgegebenen Werte als angeblich abgelesene Werte zurück und
      // erklärte sie für übereinstimmend, obwohl im Plankopf tatsächlich eine
      // andere Nummer stand (Erik hat das am echten Ergebnis nachgewiesen).
      // Jetzt zweistufig erzwungen: ERST ablesen UND DAS GELESENE in der
      // Begründung wörtlich nennen, DANN erst vergleichen - macht die
      // Vorgabewerte nicht Teil der "Lese"-Aufgabe und macht einen
      // Bestätigungsfehler wie diesen für einen Menschen beim Lesen der
      // Begründung sofort erkennbar (genau wie Erik ihn gefunden hat).
      merkmale.push({
        titel: 'Plankopf stimmt mit Projekt überein',
        prompt: 'Lies zuerst die im Plankopf (Schriftfeld) TATSÄCHLICH abgedruckte Projektnummer und/oder '
          + 'Projektbezeichnung ab - unabhängig davon, was du gleich vergleichen sollst. Nenne diese tatsächlich '
          + 'abgelesenen Werte als ERSTES in der Begründung, wörtlich wie abgedruckt. Vergleiche ERST DANACH, ob '
          + `diese abgelesenen Werte zu ${soll} passen. Sinngemäße Übereinstimmung genügt (Abkürzungen, leicht `
          + 'abweichende Schreibweise, zusätzliche Wörter), eine erkennbar ANDERE Nummer oder ein erkennbar anderes '
          + 'Projekt dagegen nicht. "erfuellt" ist nur dann true, wenn die TATSÄCHLICH abgelesenen Werte passen - '
          + 'nicht schon deshalb, weil das erwartete Projekt plausibel klingt. Ist die Angabe im Plankopf nicht '
          + 'lesbar, sage das, statt die erwarteten Werte zu wiederholen.'
      });
    }

    const zusatz = String(req.query.zusatzMerkmal || '').trim();
    if(zusatz) merkmale.push({ titel: zusatz, prompt: zusatz });
    if(merkmale.length === 0){
      return res.status(400).json({ ok: false, error: 'Keine Merkmale zum Prüfen hinterlegt.' });
    }

    try {
      const ergebnisse = await pruefePlanMitKI(buf, merkmale, req.user.id, provider);
      res.json({ ok: true, ergebnisse });
    } catch(err){
      // Ein fehlgeschlagener KI-Aufruf (kein Schlüssel, Netzwerk, Zeitüber-
      // schreitung, unerwartete Antwort) ist ein gültiges, anzuzeigendes
      // Ergebnis — kein Serverfehler (gleiches Muster wie POST
      // /my-ai-settings/test).
      res.json({ ok: false, error: String(err && err.message || err) });
    }
  } catch(err){
    console.error('Plan-Prüfung fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// ---------- Honorar-Konfiguration (Anteile je LPH + Stundensatz) ----------

// ---------- Firmenweite Einstellungen (app_settings) ----------
//
// APP_SETTING_DEFS ist die EINE Stelle, an der ein Schlüssel definiert wird:
// Vorgabewert, Typ und Prüfung. readAppSettings() liefert daraus stets ein
// vollständiges Objekt (fehlende oder unbrauchbare Zeilen fallen auf die
// Vorgabe zurück), PUT /app-settings schreibt nur bekannte Schlüssel.
//
// Alle Werte hier waren vorher Konstanten im Code — teils im Server
// (Backups, Sitzungsdauer, Anmeldebremse), teils im Frontend (Aufwands-
// vorlage, Ampel-Schwellen, Balkenskala, Arbeitsstunden je Tag). Sie sind
// nicht deshalb hierher gewandert, weil sie sich oft ändern, sondern weil
// sie die Zahlen ALLER Nutzer verschieben und ihre Pflege damit eine
// Administrationsaufgabe ist, kein Eingriff in den Quelltext.

// DEFAULT_AUFWAND_VORLAGE: firmenweite Gewichtung je Leistungsphase und
// Rolle (0,0–1,0). Sie greift für jedes Projekt, dessen Aufwandsmaske für
// diese Phase/Rolle keinen eigenen Wert trägt — also für die meisten. LPH 9
// steht bewusst auf 0: die Faktoren sind fachlich nicht abgestimmt, und ein
// erfundener Wert flösse unbemerkt in die Auslastung ein.
const DEFAULT_AUFWAND_VORLAGE = {
  'LPH 1': { 'Planung': 0.4, 'Projektleitung': 0.2, 'Bauüberwachung': 0 },
  'LPH 2': { 'Planung': 0.4, 'Projektleitung': 0.2, 'Bauüberwachung': 0 },
  'LPH 3': { 'Planung': 1.0, 'Projektleitung': 0.3, 'Bauüberwachung': 0 },
  'LPH 4': { 'Planung': 0.0, 'Projektleitung': 0.3, 'Bauüberwachung': 0 },
  'LPH 5': { 'Planung': 1.0, 'Projektleitung': 0.4, 'Bauüberwachung': 0 },
  'LPH 6': { 'Planung': 0.2, 'Projektleitung': 0.7, 'Bauüberwachung': 0.3 },
  'LPH 7': { 'Planung': 0.1, 'Projektleitung': 0.3, 'Bauüberwachung': 0.5 },
  'LPH 8': { 'Planung': 0,   'Projektleitung': 0.2, 'Bauüberwachung': 1.0 },
  'LPH 9': { 'Planung': 0,   'Projektleitung': 0,   'Bauüberwachung': 0 }
};

// num / int: Prüf-Helfer für APP_SETTING_DEFS. Beide liefern null, wenn der
// Wert unbrauchbar ist — readAppSettings() nimmt dann die Vorgabe, und
// PUT /app-settings antwortet mit 400.
function settingNumber(min, max){
  return v => {
    const n = Number(v);
    return Number.isFinite(n) && n >= min && n <= max ? n : null;
  };
}
function settingInt(min, max){
  return v => {
    const n = Number(v);
    return Number.isInteger(n) && n >= min && n <= max ? n : null;
  };
}

const APP_SETTING_DEFS = {
  // Honorar/Terminplan
  stundensatz:            { def: 135,  parse: settingNumber(1, 100000),
                            label: 'Stundensatz (€)' },
  arbeitsstundenProTag:   { def: 8,    parse: settingNumber(1, 24),
                            label: 'Arbeitsstunden je Person und Werktag' },
  // Auslastung
  vollzeitStundenProWoche:{ def: 40,   parse: settingNumber(1, 80),
                            label: 'Wochenstunden einer vollen Stelle' },
  auslastungSchwelleGelb: { def: 0.75, parse: settingNumber(0.05, 5),
                            label: 'Ampel gelb ab' },
  auslastungSchwelleRot:  { def: 1.0,  parse: settingNumber(0.05, 5),
                            label: 'Ampel rot ab' },
  aufwandVorlage:         { def: DEFAULT_AUFWAND_VORLAGE, json: true, parse: parseAufwandVorlage,
                            label: 'Aufwand je Leistungsphase und Rolle' },
  // Die Auslastung rechnet in STUNDEN: offener Honorarwert der amtierenden
  // Phase geteilt durch den Stundensatz, verteilt auf die verbleibenden
  // Wochen. Projekte ohne hinterlegtes Honorar — im Bestand die Mehrheit —
  // brauchen dafür einen Ersatz: Ihre Größe wird als Zahl zwischen 0 und 1
  // am Projekt gepflegt und mit diesem Referenzhonorar multipliziert. 1,0
  // entspricht also einem Projekt in Höhe des Referenzwerts.
  referenzHonorar:        { def: 250000, parse: settingNumber(1000, 100000000),
                            label: 'Referenzhonorar für die Projektgröße' },
  // Verteilzeitraum: Über wie viele Wochen die offenen Stunden verteilt
  // werden, solange das Projekt keinen Terminplan hat, aus dem sich ein
  // Ende ergibt. Ohne einen solchen Horizont wäre die Wochenlast nicht
  // bestimmt — dieselben Reststunden bedeuten über vier Wochen etwas ganz
  // anderes als über vierzig.
  verteilzeitraumWochen:  { def: 12,   parse: settingInt(1, 260),
                            label: 'Verteilzeitraum ohne Terminplan (Wochen)' },
  // Sitzungen
  autoLockAktiv:          { def: 1,    parse: settingInt(0, 1),
                            label: 'Ältere Sitzungen automatisch sperren' },
  // Feiertage: das Bundesland bestimmt, welche gesetzlichen Feiertage
  // vorgeschlagen werden (holidaysForYear()). Gemerkt, damit es nicht bei
  // jedem Jahr neu gewählt werden muss.
  feiertagBundesland:     { def: 'NW', parse: parseBundesland,
                            label: 'Bundesland für die Feiertage' },
  // Betrieb
  maxBackups:             { def: DEFAULT_MAX_BACKUPS, parse: settingInt(1, 500),
                            label: 'Aufbewahrte automatische Backups' },
  sessionTage:            { def: DEFAULT_SESSION_TAGE, parse: settingInt(1, 365),
                            label: 'Gültigkeit einer Anmeldung (Tage)' },
  loginMaxVersuche:       { def: DEFAULT_LOGIN_MAX_ATTEMPTS, parse: settingInt(1, 100),
                            label: 'Fehlversuche bis zur Anmeldesperre' },
  loginSperreMinuten:     { def: DEFAULT_LOGIN_BLOCK_MINUTEN, parse: settingInt(1, 1440),
                            label: 'Dauer der Anmeldesperre (Minuten)' },
};

// parseAufwandVorlage: prüft die Aufwands-Matrix. Erlaubt sind nur bekannte
// Leistungsphasen und Rollen, Werte von 0 bis 1. Nicht genannte Phasen oder
// Rollen fehlen anschließend schlicht — das Frontend behandelt eine fehlende
// Angabe als Faktor 1,0 (voller Aufwand), damit Auslastung nicht
// stillschweigend verschwindet. Rückgabe: geprüftes Objekt oder null.
function parseAufwandVorlage(value){
  let obj = value;
  if(typeof obj === 'string'){
    try { obj = JSON.parse(obj); } catch(e){ return null; }
  }
  if(!obj || typeof obj !== 'object' || Array.isArray(obj)) return null;
  const out = {};
  for(const [lph, roles] of Object.entries(obj)){
    if(!VALID_LPHS.has(lph)) return null;
    if(!roles || typeof roles !== 'object' || Array.isArray(roles)) return null;
    const cleanRoles = {};
    for(const [role, v] of Object.entries(roles)){
      if(!VALID_DISCIPLINE_ROLES.has(role)) return null;
      const n = Number(v);
      if(!Number.isFinite(n) || n < 0 || n > 1) return null;
      cleanRoles[role] = n;
    }
    out[lph] = cleanRoles;
  }
  return out;
}

// parseBundesland: prüft ein Bundesland-Kürzel gegen GERMAN_STATES (weiter
// unten definiert; die Prüfung läuft erst zur Anfragezeit).
// Rückgabe: Kürzel oder null.
function parseBundesland(value){
  const v = String(value || '').toUpperCase();
  return GERMAN_STATES[v] ? v : null;
}

// readAppSettings: liefert ALLE firmenweiten Einstellungen als fertiges
// Objekt. Eine fehlende Zeile ist der Normalfall (die Vorgabe gilt); eine
// unbrauchbare Zeile — etwa aus einem älteren Stand — fällt ebenfalls auf die
// Vorgabe zurück, statt die Rechnung zu vergiften.
// Keine Parameter. Rückgabe: Objekt über alle Schlüssel von APP_SETTING_DEFS.
function readAppSettings(){
  const rows = db.prepare('SELECT key, value FROM app_settings').all();
  const stored = {};
  rows.forEach(r => { stored[r.key] = r.value; });

  const out = {};
  for(const [key, def] of Object.entries(APP_SETTING_DEFS)){
    if(!Object.prototype.hasOwnProperty.call(stored, key)){ out[key] = def.def; continue; }
    const parsed = def.parse(stored[key]);
    out[key] = parsed === null ? def.def : parsed;
  }
  return out;
}

// readAppSetting: ein einzelner Wert (Kurzform für die Aufrufer im Server).
// Parameter: key. Rückgabe: geprüfter Wert bzw. Vorgabe.
function readAppSetting(key){
  const def = APP_SETTING_DEFS[key];
  if(!def) return undefined;
  const row = db.prepare('SELECT value FROM app_settings WHERE key = ?').get(key);
  if(!row) return def.def;
  const parsed = def.parse(row.value);
  return parsed === null ? def.def : parsed;
}

// Route: alle firmenweiten Einstellungen lesen. Auth, nicht admin-only — das
// Frontend RECHNET damit (Auslastung, Terminplan) und braucht sie deshalb bei
// jedem Konto. Geändert werden dürfen sie nur von Administratoren, siehe PUT.
app.get('/app-settings', requireAuthOderKiosk, (req, res) => {
  try {
    res.json({ ok: true, settings: readAppSettings() });
  } catch(err){
    console.error('Einstellungen laden fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// GET/PUT /my-ai-settings: die beiden KI-API-Schlüssel des ANGEMELDETEN
// Kontos (req.user.id, nie eine vom Client mitgeschickte Kennung — exakt
// wie /change-email/POST). Jeder Nutzer verwaltet seinen eigenen Zugang
// unter Einstellungen → Mein Konto; kein admin-only mehr, siehe CLAUDE.md
// "### Protokolle". GET liefert je Anbieter, OB ein Schlüssel gesetzt ist
// (nie der Schlüssel selbst, wie ein Passwort) sowie die — nicht geheime —
// apiUrl zum Weiterbearbeiten.
// ---------- Kalender-Abo für Outlook (iCalendar) ----------
//
// Eriks Wunsch: die eigenen Termine in Outlook sehen. Jedes Konto bekommt
// unter Einstellungen → Mein Konto eine geheime Adresse
// /kalender/<token>.ics; Outlook abonniert sie („Aus dem Internet“) und holt
// sie selbst regelmäßig. NUR LESEN — geändert wird weiter in der App.
// Inhalt aus der jüngsten echten Sitzung: eigene offene Aufgaben mit Termin,
// Meilensteine der eigenen Projekte (zugeordnet oder mit eigener Aufgabe)
// und die eigenen Abwesenheiten. Ganztägige Einträge (VALUE=DATE), damit
// keine Zeitzone im Spiel ist.
//
// Der Token IST die Anmeldung (Outlook kann sich nicht einloggen) — deshalb
// lang und zufällig, jederzeit neu erzeugbar (alte Adresse ungültig) oder
// abschaltbar. Deaktivierte Konten und reine Wandtafel-Konten bekommen 404.

function kalenderUrl(req, token){
  return req.protocol + '://' + req.get('host') + '/kalender/' + token + '.ics';
}

app.get('/mein-kalender', requireAuth, (req, res) => {
  const row = db.prepare('SELECT kalender_token FROM users WHERE id = ?').get(req.user.id);
  const token = row && row.kalender_token;
  res.json({ ok: true, url: token ? kalenderUrl(req, token) : '' });
});

// POST {aus: true} schaltet ab, sonst wird eine NEUE Adresse erzeugt (die
// bisherige wird damit ungültig).
app.post('/mein-kalender', requireAuth, (req, res) => {
  try {
    const aus = !!(req.body && req.body.aus);
    const token = aus ? '' : crypto.randomBytes(24).toString('base64url');
    db.prepare('UPDATE users SET kalender_token = ? WHERE id = ?').run(token, req.user.id);
    res.json({ ok: true, url: token ? kalenderUrl(req, token) : '' });
  } catch(err){
    console.error('Kalender-Adresse speichern fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// icsText: Text nach RFC 5545 maskieren.
function icsText(s){
  return String(s || '').replace(/\\/g, '\\\\').replace(/;/g, '\\;').replace(/,/g, '\\,').replace(/\r?\n/g, '\\n');
}
// icsZeile: Zeilen über 75 Byte falten (Folgezeilen beginnen mit Leerzeichen).
function icsZeile(z){
  if(Buffer.byteLength(z, 'utf8') <= 75) return z;
  const teile = [];
  let rest = z;
  // Erste Zeile höchstens 75 Byte, Folgezeilen 74 (plus führendes Leerzeichen).
  const grenze = () => teile.length ? 74 : 75;
  while(Buffer.byteLength(rest, 'utf8') > grenze()){
    let n = Math.min(rest.length, grenze());
    while(Buffer.byteLength(rest.slice(0, n), 'utf8') > grenze()) n--;
    // Kein Ersatzpaar (Emoji o. ä.) zerschneiden.
    const c = rest.charCodeAt(n - 1);
    if(c >= 0xD800 && c <= 0xDBFF) n--;
    teile.push(rest.slice(0, n));
    rest = rest.slice(n);
  }
  teile.push(rest);
  return teile.join('\r\n ');
}
function icsDatum(iso){ return String(iso || '').replace(/-/g, ''); }
// icsTagDanach: DTEND ganztägiger Einträge ist der Tag NACH dem letzten Tag.
function icsTagDanach(iso){
  const d = new Date(iso + 'T12:00:00');
  d.setDate(d.getDate() + 1);
  return d.getFullYear() + String(d.getMonth() + 1).padStart(2, '0') + String(d.getDate()).padStart(2, '0');
}
const ICS_DATUM = /^\d{4}-\d{2}-\d{2}$/;

// kalenderEreignisse: die Einträge einer Person aus einer Sitzung plus ihren
// Abwesenheiten. Rein (ohne Datenbank), damit testbar. Parameter: ich
// (person_id), w (Sitzung oder null), abwesenheiten (Zeilen aus
// user_absences). Rückgabe: [{uid, start, ende, titel, projekt, text, frei}].
function kalenderEreignisse(ich, w, abwesenheiten){
  const ereignisse = [];
  if(w && ich){
    (w.projects || []).forEach(p => {
      const projekt = [p.nr, p.name].filter(Boolean).join(' ');
      const zugeordnet = Object.keys(p.assign || {}).some(k => k.split('|')[0] === ich && Number(p.assign[k]) > 0);
      const plan = p.plan || {};
      let eigeneAufgabe = false;
      (plan.todos || []).forEach(t => {
        if(!Array.isArray(t.assignees) || !t.assignees.includes(ich)) return;
        eigeneAufgabe = true;
        if(t.done || t.lph) return;
        const start = ICS_DATUM.test(t.start || '') ? t.start : (ICS_DATUM.test(t.end || '') ? t.end : '');
        const ende = ICS_DATUM.test(t.end || '') ? t.end : start;
        if(!start) return;
        ereignisse.push({
          uid: 'aufgabe-' + t.id, start, ende,
          titel: t.title || 'Aufgabe', projekt,
          text: 'Aufgabe in ' + projekt + (Number(t.progress) > 0 ? ' · ' + Number(t.progress) + ' % erledigt' : '')
            + (t.notiz ? '\n\n' + String(t.notiz).slice(0, 1500) : '')
        });
      });
      if(!zugeordnet && !eigeneAufgabe) return;
      (plan.milestones || []).forEach(m => {
        if(!ICS_DATUM.test(m.date || '')) return;
        ereignisse.push({
          uid: 'meilenstein-' + (p.projectUid || p.id) + '-' + m.id, start: m.date, ende: m.date,
          titel: '◆ ' + (m.name || 'Meilenstein'), projekt,
          text: 'Meilenstein in ' + projekt + (m.notiz ? '\n\n' + String(m.notiz).slice(0, 1500) : '')
        });
      });
    });
  }
  (abwesenheiten || []).forEach(a => {
    if(!ICS_DATUM.test(a.start || '')) return;
    ereignisse.push({
      uid: 'abwesenheit-' + a.id, start: a.start, ende: ICS_DATUM.test(a.end || '') ? a.end : a.start,
      titel: a.type || 'Abwesend', projekt: '', text: a.note || '', frei: true
    });
  });
  return ereignisse;
}

// kalenderText: die iCalendar-Datei (CRLF, gefaltete Zeilen).
function kalenderText(name, ereignisse){
  const jetzt = new Date().toISOString().replace(/[-:]/g, '').replace(/\.\d+Z$/, 'Z');
  const zeilen = [
    'BEGIN:VCALENDAR', 'VERSION:2.0', 'PRODID:-//Projektuebersicht//Kalender//DE', 'CALSCALE:GREGORIAN',
    'METHOD:PUBLISH', 'X-WR-CALNAME:' + icsText('Projektübersicht – ' + (name || '')),
    'X-WR-TIMEZONE:Europe/Berlin', 'REFRESH-INTERVAL;VALUE=DURATION:PT1H', 'X-PUBLISHED-TTL:PT1H'
  ];
  ereignisse.forEach(e => {
    zeilen.push('BEGIN:VEVENT',
      'UID:' + icsText(e.uid) + '@projektuebersicht',
      'DTSTAMP:' + jetzt,
      'DTSTART;VALUE=DATE:' + icsDatum(e.start),
      'DTEND;VALUE=DATE:' + icsTagDanach(e.ende < e.start ? e.start : e.ende),
      'SUMMARY:' + icsText(e.titel + (e.projekt ? ' (' + e.projekt + ')' : '')),
      'DESCRIPTION:' + icsText(e.text),
      // Als „frei“ eintragen: Ganztägige Aufgaben sollen die Verfügbarkeit
      // in Outlook nicht blockieren; Abwesenheiten zeigen „abwesend“.
      'TRANSP:TRANSPARENT',
      e.frei ? 'X-MICROSOFT-CDO-BUSYSTATUS:OOF' : 'X-MICROSOFT-CDO-BUSYSTATUS:FREE',
      'END:VEVENT');
  });
  zeilen.push('END:VCALENDAR');
  return zeilen.map(icsZeile).join('\r\n') + '\r\n';
}

app.get('/kalender/:datei', (req, res) => {
  try {
    const token = String(req.params.datei || '').replace(/\.ics$/i, '');
    if(token.length < 20) return res.status(404).end();
    const u = db.prepare('SELECT id, display_name, person_id, role, active FROM users WHERE kalender_token = ?').get(token);
    if(!u || !u.active || !hatRecht({ id: u.id, role: u.role }, 'app')) return res.status(404).end();
    const label = echteSitzungenSortiert().map(w => w.label).pop();
    const w = label ? loadWeeks(label)[0] : null;
    const abw = db.prepare('SELECT id, start, end, type, note FROM user_absences WHERE user_id = ?').all(u.id);
    res.set('Content-Type', 'text/calendar; charset=utf-8');
    res.set('Cache-Control', 'no-cache');
    res.set('Content-Disposition', 'inline; filename="projektuebersicht.ics"');
    res.send(kalenderText(u.display_name, kalenderEreignisse(u.person_id || '', w, abw)));
  } catch(err){
    console.error('Kalender ausliefern fehlgeschlagen:', err);
    res.status(500).end();
  }
});

app.get('/my-ai-settings', requireAuth, (req, res) => {
  try {
    const chatgpt = readUserAiKey(req.user.id, 'chatgpt');
    const claude = readUserAiKey(req.user.id, 'claude');
    res.json({
      ok: true,
      chatgpt: { configured: !!chatgpt.apiKey, apiUrl: chatgpt.apiUrl, model: chatgpt.model },
      claude: { configured: !!claude.apiKey, apiUrl: claude.apiUrl, model: claude.model }
    });
  } catch(err){
    console.error('KI-Einstellungen laden fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

app.put('/my-ai-settings', requireAuth, (req, res) => {
  try {
    const body = (req.body && typeof req.body === 'object') ? req.body : {};
    for(const provider of ['chatgpt', 'claude']){
      const patch = body[provider];
      if(!patch || typeof patch !== 'object') continue;
      if(Object.prototype.hasOwnProperty.call(patch, 'apiUrl') && patch.apiUrl && !istGueltigeAiUrl(patch.apiUrl)){
        return res.status(400).json({ ok: false, error: 'Die API-URL muss eine gültige https-Adresse sein (oder http auf localhost/127.0.0.1 für einen lokalen Server wie LM Studio/Ollama).' });
      }
      writeUserAiKey(req.user.id, provider, patch);
    }
    const chatgpt = readUserAiKey(req.user.id, 'chatgpt');
    const claude = readUserAiKey(req.user.id, 'claude');
    res.json({
      ok: true,
      chatgpt: { configured: !!chatgpt.apiKey, apiUrl: chatgpt.apiUrl, model: chatgpt.model },
      claude: { configured: !!claude.apiKey, apiUrl: claude.apiUrl, model: claude.model }
    });
  } catch(err){
    console.error('KI-Einstellungen speichern fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// POST /my-ai-settings/test: "Neu verbinden" — prüft die GESPEICHERTE
// Konfiguration des aufrufenden Kontos für einen Anbieter, indem
// tatsächlich eine kurze, echte Anfrage über erkennePunkteMitKI() läuft
// (dieselbe Funktion, die auch der Protokoll-Import nutzt — deckt damit
// automatisch Timeout-Wahl, reasoning_effort-Behandlung für lokale Ziele
// und URL-Normalisierung mit ab, ohne eigenen Testpfad pflegen zu müssen).
app.post('/my-ai-settings/test', requireAuth, async (req, res) => {
  try {
    const provider = req.body && req.body.provider;
    if(provider !== 'chatgpt' && provider !== 'claude'){
      return res.status(400).json({ ok: false, error: 'Unbekannter Anbieter.' });
    }
    await erkennePunkteMitKI('1. Testpunkt. Zustaendig: Test. Termin: 01.01.2026', req.user.id, provider);
    res.json({ ok: true });
  } catch(err){
    // Ein fehlgeschlagener Verbindungstest ist ein normales, erwartetes
    // Ergebnis, kein Serverfehler — deshalb 200 mit ok:false statt 4xx/5xx,
    // der Client unterscheidet Erfolg/Fehlschlag einheitlich über "ok".
    res.json({ ok: false, error: err.message || String(err) });
  }
});

// Route: firmenweite Einstellungen schreiben. Admin-only. Teilweise Updates
// (nur die im Rumpf genannten Schlüssel werden geschrieben); unbekannte
// Schlüssel und unbrauchbare Werte führen zu 400, bevor irgendetwas
// geschrieben wird — sonst bliebe die Hälfte einer Maske liegen.
// APP_SETTING_RECHT: welches Recht eine Einstellung ändern darf.
const APP_SETTING_RECHT = {
  stundensatz: 'a.honorar',
  arbeitsstundenProTag: 'a.termine', autoLockAktiv: 'a.termine',
  vollzeitStundenProWoche: 'a.auslastung', auslastungSchwelleGelb: 'a.auslastung', auslastungSchwelleRot: 'a.auslastung',
  aufwandVorlage: 'a.auslastung', referenzHonorar: 'a.auslastung', verteilzeitraumWochen: 'a.auslastung',
  feiertagBundesland: 'a.feiertage',
  maxBackups: 'a.betrieb', sessionTage: 'a.betrieb', loginMaxVersuche: 'a.betrieb', loginSperreMinuten: 'a.betrieb',
};
app.put('/app-settings', requireAuth, (req, res) => {
  try {
    const body = (req.body && typeof req.body === 'object') ? req.body : {};
    const writes = [];
    for(const [key, value] of Object.entries(body)){
      const def = APP_SETTING_DEFS[key];
      if(!def) return res.status(400).json({ ok:false, error: 'Unbekannte Einstellung: ' + key });
      // Jede Einstellung gehört zu einem Admin-Abschnitt und damit zu dessen
      // Recht (Rollen & Rechte) — geprüft je Feld, bevor irgendetwas schreibt.
      const recht = APP_SETTING_RECHT[key] || 'a.betrieb';
      if(!hatRecht(req.user, recht)) return rechtFehlt(res, recht);
      const parsed = def.parse(value);
      if(parsed === null) return res.status(400).json({ ok:false, error: 'Unbrauchbarer Wert für „' + def.label + '".' });
      writes.push([key, def.json ? JSON.stringify(parsed) : String(parsed)]);
    }
    // Gelb darf nicht über Rot liegen — sonst zeigte die Ampel nie Gelb.
    const merged = Object.assign(readAppSettings(), Object.fromEntries(
      writes.map(([k, v]) => [k, APP_SETTING_DEFS[k].parse(v)])
    ));
    if(merged.auslastungSchwelleGelb > merged.auslastungSchwelleRot){
      return res.status(400).json({ ok:false, error: 'Die gelbe Schwelle muss unter der roten liegen.' });
    }

    db.exec('BEGIN');
    try {
      const stmt = db.prepare(`INSERT INTO app_settings (key, value) VALUES (?, ?)
        ON CONFLICT(key) DO UPDATE SET value = excluded.value`);
      writes.forEach(([k, v]) => stmt.run(k, v));
      db.exec('COMMIT');
    } catch(err){
      db.exec('ROLLBACK');
      throw err;
    }
    res.json({ ok: true, settings: readAppSettings() });
  } catch(err){
    console.error('Einstellungen speichern fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// ---------- Feiertage ----------

// Gesetzliche Feiertage lassen sich vollstaendig BERECHNEN: Ein Teil liegt auf
// festen Kalendertagen, der Rest haengt am Osterdatum. Deshalb holt diese
// Anwendung sie nicht von einem Netzdienst — das haette eine Abhaengigkeit
// von fremder Verfuegbarkeit und einem Internetzugang des Servers bedeutet,
// den es im Buero-Netz nicht zwingend gibt. Berechnet ist das Ergebnis
// jederzeit gleich, funktioniert offline und braucht kein weiteres Paket
// (das Projekt kommt bewusst mit express und cors aus).
//
// Die errechneten Tage werden NICHT automatisch in die Tabelle geschrieben.
// Ein Administrator laesst sie sich vorschlagen und uebernimmt sie bewusst —
// Feiertage verschieben jeden gerechneten Terminplan, das soll nicht
// unbemerkt im Hintergrund passieren.

// GERMAN_STATES: die 16 Bundeslaender mit ihrem amtlichen Kuerzel.
const GERMAN_STATES = {
  BW: 'Baden-Württemberg',      BY: 'Bayern',
  BE: 'Berlin',                 BB: 'Brandenburg',
  HB: 'Bremen',                 HH: 'Hamburg',
  HE: 'Hessen',                 MV: 'Mecklenburg-Vorpommern',
  NI: 'Niedersachsen',          NW: 'Nordrhein-Westfalen',
  RP: 'Rheinland-Pfalz',        SL: 'Saarland',
  SN: 'Sachsen',                ST: 'Sachsen-Anhalt',
  SH: 'Schleswig-Holstein',     TH: 'Thüringen',
};

// easterSunday: Ostersonntag eines Jahres nach der gregorianischen
// Osterformel (Gauss/Meeus). Alle beweglichen Feiertage haengen daran.
// Parameter: year (Zahl). Rueckgabe: Date (UTC-Mitternacht).
function easterSunday(year){
  const a = year % 19;
  const b = Math.floor(year / 100);
  const c = year % 100;
  const d = Math.floor(b / 4);
  const e = b % 4;
  const f = Math.floor((b + 8) / 25);
  const g = Math.floor((b - f + 1) / 3);
  const h = (19 * a + b - d - g + 15) % 30;
  const i = Math.floor(c / 4);
  const k = c % 4;
  const l = (32 + 2 * e + 2 * i - h - k) % 7;
  const m = Math.floor((a + 11 * h + 22 * l) / 451);
  const month = Math.floor((h + l - 7 * m + 114) / 31);
  const day = ((h + l - 7 * m + 114) % 31) + 1;
  return new Date(Date.UTC(year, month - 1, day));
}

// isoFromDate / shiftDays: kleine Datums-Helfer fuer die Berechnung. Gerechnet
// wird durchgehend in UTC, damit keine Sommerzeit-Umstellung einen Tag
// verschiebt.
function isoFromDate(d){ return d.toISOString().slice(0, 10); }
function shiftDays(d, n){ return new Date(d.getTime() + n * 86400000); }

// bussUndBettag: Mittwoch vor dem 23. November (nur Sachsen).
// Parameter: year. Rueckgabe: Date.
function bussUndBettag(year){
  let d = new Date(Date.UTC(year, 10, 22));   // 22.11.
  while(d.getUTCDay() !== 3) d = shiftDays(d, -1);
  return d;
}

// holidaysForYear: die gesetzlichen Feiertage eines Jahres in einem
// Bundesland. Nicht enthalten sind die gemeindeabhaengigen Faelle
// (Fronleichnam in Teilen von Sachsen und Thueringen, Mariä Himmelfahrt in
// ueberwiegend katholischen Gemeinden Bayerns) — die haengen vom Wohnort ab
// und lassen sich nicht aus dem Bundesland ableiten; sie koennen von Hand
// ergaenzt werden.
// Parameter: year (Zahl), state (Kuerzel aus GERMAN_STATES).
// Rueckgabe: Array von { date, name }, nach Datum sortiert.
function holidaysForYear(year, state){
  const ostern = easterSunday(year);
  const fest = (m, d) => isoFromDate(new Date(Date.UTC(year, m - 1, d)));
  const ab = n => isoFromDate(shiftDays(ostern, n));

  // Jeder Eintrag: [Datum, Bezeichnung, Bundeslaender oder null = bundesweit]
  const alle = [
    [fest(1, 1),   'Neujahr',                      null],
    [fest(1, 6),   'Heilige Drei Könige',          ['BW','BY','ST']],
    [fest(3, 8),   'Internationaler Frauentag',    ['BE','MV']],
    [ab(-2),       'Karfreitag',                   null],
    [ab(0),        'Ostersonntag',                 ['BB']],
    [ab(1),        'Ostermontag',                  null],
    [fest(5, 1),   'Tag der Arbeit',               null],
    [ab(39),       'Christi Himmelfahrt',          null],
    [ab(49),       'Pfingstsonntag',               ['BB']],
    [ab(50),       'Pfingstmontag',                null],
    [ab(60),       'Fronleichnam',                 ['BW','BY','HE','NW','RP','SL']],
    [fest(8, 15),  'Mariä Himmelfahrt',            ['SL']],
    [fest(9, 20),  'Weltkindertag',                ['TH']],
    [fest(10, 3),  'Tag der Deutschen Einheit',    null],
    [fest(10, 31), 'Reformationstag',              ['BB','HB','HH','MV','NI','SH','SN','ST','TH']],
    [fest(11, 1),  'Allerheiligen',                ['BW','BY','NW','RP','SL']],
    [isoFromDate(bussUndBettag(year)), 'Buß- und Bettag', ['SN']],
    [fest(12, 25), '1. Weihnachtstag',             null],
    [fest(12, 26), '2. Weihnachtstag',             null],
  ];

  return alle
    .filter(([, , laender]) => laender === null || laender.includes(state))
    .map(([date, name]) => ({ date, name }))
    .sort((a, b) => a.date.localeCompare(b.date));
}

// Route: gesetzliche Feiertage eines Jahres vorschlagen. Auth (lesend, die
// Berechnung verraet nichts). Jeder Eintrag traegt zusaetzlich `vorhanden`,
// damit die Maske zeigen kann, was schon hinterlegt ist.
app.get('/holidays/suggest', requireAuth, (req, res) => {
  try {
    const year = Number(req.query.year);
    const state = String(req.query.state || readAppSetting('feiertagBundesland'));
    if(!Number.isInteger(year) || year < 1970 || year > 2200){
      return res.status(400).json({ ok:false, error:'Jahr muss zwischen 1970 und 2200 liegen.' });
    }
    if(!GERMAN_STATES[state]){
      return res.status(400).json({ ok:false, error:'Unbekanntes Bundesland: ' + state });
    }
    const vorhanden = new Set(db.prepare('SELECT date FROM holidays').all().map(r => r.date));
    const holidays = holidaysForYear(year, state).map(h => ({
      date: h.date, name: h.name, vorhanden: vorhanden.has(h.date),
    }));
    res.json({ ok:true, year, state, stateName: GERMAN_STATES[state], holidays, states: GERMAN_STATES });
  } catch(err){
    console.error('Feiertage berechnen fehlgeschlagen:', err);
    res.status(500).json({ ok:false, error: String(err) });
  }
});

// Route: berechnete Feiertage uebernehmen. Admin-only. Bereits hinterlegte
// Tage bleiben unveraendert — ein von Hand angepasster Name (etwa ein
// Brueckentag, den jemand auf denselben Tag gelegt hat) soll nicht
// ueberschrieben werden. Die Antwort meldet beides getrennt.
app.post('/holidays/import', requireRecht('a.feiertage'), (req, res) => {
  try {
    const year = Number((req.body || {}).year);
    const state = String((req.body || {}).state || readAppSetting('feiertagBundesland'));
    if(!Number.isInteger(year) || year < 1970 || year > 2200){
      return res.status(400).json({ ok:false, error:'Jahr muss zwischen 1970 und 2200 liegen.' });
    }
    if(!GERMAN_STATES[state]){
      return res.status(400).json({ ok:false, error:'Unbekanntes Bundesland: ' + state });
    }
    const liste = holidaysForYear(year, state);
    const stmt = db.prepare('INSERT OR IGNORE INTO holidays (date, name) VALUES (?, ?)');
    let angelegt = 0;
    db.exec('BEGIN');
    try {
      liste.forEach(h => { angelegt += stmt.run(h.date, h.name).changes; });
      db.exec('COMMIT');
    } catch(err){
      db.exec('ROLLBACK');
      throw err;
    }
    res.json({ ok:true, angelegt, uebersprungen: liste.length - angelegt, gesamt: liste.length });
  } catch(err){
    console.error('Feiertage übernehmen fehlgeschlagen:', err);
    res.status(500).json({ ok:false, error: String(err) });
  }
});


// Route: Feiertage lesen. Auth — das Frontend rechnet damit in Werktagen.
app.get('/holidays', requireAuthOderKiosk, (req, res) => {
  try {
    const rows = db.prepare('SELECT date, name FROM holidays ORDER BY date').all();
    // Die Bundesländer kommen gleich mit: Der Server ist die eine Stelle, an
    // der die Liste steht, und die Pflege-Maske braucht sie sofort — sonst
    // hätte ihre Auswahl bis zum ersten Vorschlag nur einen Eintrag.
    res.json({
      ok: true,
      holidays: rows.map(r => ({ date: r.date, name: r.name })),
      states: GERMAN_STATES,
    });
  } catch(err){
    console.error('Feiertage laden fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Feiertag anlegen oder umbenennen. Admin-only. Das Datum ist der
// Primärschlüssel, ein zweites Anlegen desselben Tages ersetzt also nur den
// Namen — das ist gewollt und erspart ein eigenes PATCH.
app.post('/holidays', requireRecht('a.feiertage'), (req, res) => {
  try {
    const { date, name } = req.body || {};
    if(typeof date !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(date)){
      return res.status(400).json({ ok:false, error:'Datum im Format JJJJ-MM-TT erforderlich.' });
    }
    const d = new Date(date + 'T00:00:00Z');
    if(Number.isNaN(d.getTime()) || d.toISOString().slice(0,10) !== date){
      return res.status(400).json({ ok:false, error:'Kein gültiges Datum.' });
    }
    const cleanName = String(name || '').trim().slice(0, 120);
    db.prepare(`INSERT INTO holidays (date, name) VALUES (?, ?)
      ON CONFLICT(date) DO UPDATE SET name = excluded.name`).run(date, cleanName);
    res.json({ ok: true, holiday: { date, name: cleanName } });
  } catch(err){
    console.error('Feiertag anlegen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Feiertag löschen. Admin-only, idempotent.
app.delete('/holidays/:date', requireRecht('a.feiertage'), (req, res) => {
  try {
    db.prepare('DELETE FROM holidays WHERE date = ?').run(String(req.params.date));
    res.json({ ok: true });
  } catch(err){
    console.error('Feiertag löschen fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});


// readStundensatz: liest den firmenweiten Stundensatz (Vorgabe und Prüfung
// stehen in APP_SETTING_DEFS).
function readStundensatz(){
  // Ein Schlüssel, eine Definition: der Stundensatz steht seit der
  // Einführung von APP_SETTING_DEFS dort (mit derselben Vorgabe 135) und
  // wird weiterhin über /honorar-config gepflegt, weil er fachlich zur
  // Honorar-Maske gehört.
  return readAppSetting('stundensatz');
}

// Route: Honorar-Konfiguration lesen — Anteile je Leistungsphase und
// Stundensatz. Auth (nicht admin-only): jeder angemeldete Nutzer darf einen
// Terminplan rechnen lassen, nur das Pflegen der Sätze ist Admin-Sache.
app.get('/honorar-config', requireAuthOderKiosk, (req, res) => {
  try {
    const rows = db.prepare('SELECT lph, percent FROM lph_honorar_anteile').all();
    const anteile = {};
    rows.forEach(r => { anteile[r.lph] = r.percent; });
    res.json({ ok: true, anteile, stundensatz: readStundensatz() });
  } catch(err){
    console.error('Honorar-Konfiguration laden fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});

// Route: Honorar-Konfiguration schreiben. Admin-only (firmenweite Vorgabe).
// `anteile` ist ein vollständiger Ersatz (delete + insert in einer
// Transaktion, gleiches Muster wie die Rollen in PATCH /admin/users/:id):
// eine im Objekt fehlende Leistungsphase gilt damit als "kein Anteil".
app.put('/honorar-config', requireRecht('a.honorar'), (req, res) => {
  try {
    const { anteile, stundensatz } = req.body || {};
    if(anteile !== undefined && (typeof anteile !== 'object' || anteile === null)){
      return res.status(400).json({ ok: false, error: 'anteile muss ein Objekt sein.' });
    }
    if(stundensatz !== undefined){
      const v = Number(stundensatz);
      if(!Number.isFinite(v) || v <= 0){
        return res.status(400).json({ ok: false, error: 'Stundensatz muss größer als 0 sein.' });
      }
    }
    // Vor dem Schreiben prüfen, damit eine einzelne unbrauchbare Zeile nicht
    // die halbe Konfiguration überschreibt.
    const clean = [];
    if(anteile){
      for(const [lph, pct] of Object.entries(anteile)){
        if(!VALID_LPHS.has(lph)){
          return res.status(400).json({ ok: false, error: 'Unbekannte Leistungsphase: ' + lph });
        }
        const v = Number(pct);
        if(!Number.isFinite(v) || v < 0 || v > 100){
          return res.status(400).json({ ok: false, error: 'Anteil für ' + lph + ' muss zwischen 0 und 100 liegen.' });
        }
        if(v > 0) clean.push([lph, v]);
      }
    }

    db.exec('BEGIN');
    try {
      if(anteile){
        db.prepare('DELETE FROM lph_honorar_anteile').run();
        const ins = db.prepare('INSERT INTO lph_honorar_anteile (lph, percent) VALUES (?, ?)');
        clean.forEach(([lph, v]) => ins.run(lph, v));
      }
      if(stundensatz !== undefined){
        db.prepare(`INSERT INTO app_settings (key, value) VALUES ('stundensatz', ?)
          ON CONFLICT(key) DO UPDATE SET value = excluded.value`).run(String(Number(stundensatz)));
      }
      db.exec('COMMIT');
    } catch(err){
      db.exec('ROLLBACK');
      throw err;
    }

    const rows = db.prepare('SELECT lph, percent FROM lph_honorar_anteile').all();
    const out = {};
    rows.forEach(r => { out[r.lph] = r.percent; });
    res.json({ ok: true, anteile: out, stundensatz: readStundensatz() });
  } catch(err){
    console.error('Honorar-Konfiguration speichern fehlgeschlagen:', err);
    res.status(500).json({ ok: false, error: String(err) });
  }
});


// Route: DB-Snapshot-Download. Erzeugt einen konsistenten Snapshot der
// SQLite-Datenbank (auch mit WAL) und stellt ihn als .db-Datei zum Download
// bereit (Backup für Archivierung/Wiederherstellung, z. B. per "DB Backup"-
// Button im Menü). Die temporäre Datei wird nach dem Senden gelöscht.
// NUR ADMINS: Der Snapshot enthält die komplette Datenbank und damit auch
// user_sessions.token im Klartext. Mit einem fremden Token könnte sich sonst
// jedes Mitglied als Administrator ausgeben (Rechteausweitung) — deshalb ist
// diese Route strenger abgesichert als der Rest der fachlichen Daten-Routen.
app.get('/backup', requireRecht('a.backup'), (req, res) => {
  const tmp = path.join(os.tmpdir(), 'projektuebersicht_backup_' + Date.now() + '.db');
  try {
    createDbSnapshot(tmp);
    // heuteIsoLokal() statt toISOString(): Letzteres rechnet nach UTC um und
    // datierte das Backup zwischen 0 und 2 Uhr Ortszeit auf den Vortag.
    const filename = 'projektuebersicht_backup_' + heuteIsoLokal() + '.db';
    res.download(tmp, filename, () => fs.unlink(tmp, () => {}));
    console.log('DB-Backup-Download:', filename);
  } catch(err){
    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', requireRecht('a.import'), express.raw({ type: '*/*', limit: '50mb' }), (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);
    try { pruefeBackupDatei(tmp); }
    catch(err){ return res.status(400).json({ ok: false, error: err.message }); }
    // Zustand VOR dem Restore sichern (danach wäre der Snapshot bereits der
    // importierte Stand und die Wiederherstellung unmöglich).
    runAutoBackup();
    restoreDbFromBackup(tmp);
    // Ältere Backups tragen Kommentare noch gewerkübergreifend in projects.
    migrateKommentareJeGewerk();
    kommentareVorsatzUmstellen();
    // Ältere Backups kennen das Feld leistungsphase noch nicht.
    phasenbalkenAusTitel();
    console.log('Datenbank aus Backup wiederhergestellt (' + buf.length + ' Bytes)');
    ereignisSenden({ typ: 'neu' }, req);
    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
app.get('/health', (req,res)=> res.json({
  ok: true,
  speicherMb: Math.round(process.memoryUsage().rss / 1048576),
  laufzeitMin: Math.round(process.uptime() / 60)
}));

// Route: Liefert die Hauptseite App.html
app.get('/', (req,res)=>{
  appSenden(req, res);
});

// Gültige Tab-Slugs für Deep-Link-Routen (muss zu TAB_SLUGS in js/globals.js passen)
// 'Projekte' bleibt bewusst gültig, obwohl der gleichnamige Bereich in der
// Projektliste aufgegangen ist: Weitergegebene Links sollen nicht mit 404
// enden. Die Oberfläche leitet den Abschnitt auf die Projektliste um
// (TAB_BY_SLUG in public/js/globals.js) und erzeugt ihn selbst nicht mehr.
const VALID_TAB_SLUGS = new Set(['Projektübersicht','Wochenbericht','Auslastung','Abwesenheiten','Projekte','Projektbeteiligte','Planung','PlanChecker','MeineAufgaben','Wandtafel','Einstellungen','Admin']);
// Slug der Projektplan-Seite (muss zu PLAN_SLUG in js/globals.js passen)
const PLAN_SLUG = 'Projektplan';

// Route: alte Direktlinks auf die entfallene Datei admin-users.html. Sie war
// bis zum Umbau eine eigene Seite mit nachgebauter Kopfzeile; die
// Benutzerverwaltung ist heute ein Abschnitt des Bereichs „Admin" auf der
// Hauptseite, damit die Seitenleiste stehen bleibt.
app.get('/admin-users.html', (req, res) => {
  res.redirect(301, '/Admin#benutzer');
});

// Route: alte Direktlinks auf die entfallene Datei project-plan.html. Sie
// war bis zum Umbau ein eigenes Dokument; heute ist der Projektbereich der
// Bereich #plan der Hauptseite. Die Parameter (weekLabel, projNr, projName)
// bleiben erhalten, damit ein alter Link weiterhin dasselbe Projekt öffnet.
app.get('/project-plan.html', (req, res) => {
  const params = new URLSearchParams(req.query);
  const projName = params.get('projName') || '';
  params.delete('projName');
  const qs = params.toString();
  res.redirect(301, '/' + PLAN_SLUG + '/' + encodeURIComponent(projName) + (qs ? '?' + qs : ''));
});

// Route: alte Direktlinks auf den früheren Dateinamen Test.html — ein nie
// umbenannter Platzhaltername aus der Frühphase des Projekts, inzwischen
// App.html. Anders als bei admin-users.html/project-plan.html gibt es kein
// anderes Ziel als "/" selbst: Test.html WAR die Hauptseite, nur unter einem
// unpassenden Namen.
app.get('/Test.html', (req, res) => {
  res.redirect(301, '/');
});

// Route: Deep-Links je Tab, z. B. "/Auslastung" oder "/Projektübersicht"
// (seit Entfernung der Abteilungstrennung nur noch ein Pfad-Segment, vorher
// "/<Abteilung>/<Tab>"). Liefert wie "/" die Hauptseite; unbekannte Tabs
// werden abgelehnt (404), damit keine App.html auf beliebigen Pfaden
// ausgeliefert wird.
app.get('/:tab', (req, res) => {
  const { tab } = req.params;
  if(tab === PLAN_SLUG){
    // Projektbereich eines Projekts, z. B. "/Projektplan?weekLabel=..." —
    // seit dem Umbau kein eigenes Dokument mehr, sondern der Bereich #plan
    // der Hauptseite (applyUrlRoute() in public/js/ui.js wertet die Adresse
    // clientseitig aus).
    return appSenden(req, res);
  }
  if(!VALID_TAB_SLUGS.has(tab)) return res.status(404).send('Nicht gefunden');
  appSenden(req, res);
});

// Route: Projektbereich mit Projektname im Pfad, z. B.
// "/Projektplan/Gymnasium%20Hemer?weekLabel=..." – das Pfad-Segment dient nur
// der lesbaren Adresse, die Identifikation erfolgt über weekLabel/projNr.
app.get('/Projektplan/:projName', (req, res) => {
  appSenden(req, res);
});

// Route: Weiterleitung alter, noch abteilungspräfixierter Projektplan-Links
// ("/HLS/Projektplan/Foo?weekLabel=...") auf das neue Schema, damit alte
// Lesezeichen nicht brechen. Muss VOR der generischen 2-Segment-Weiterleitung
// stehen (3 Segmente sind eindeutig).
app.get('/:legacyDept/Projektplan/:projName', (req, res) => {
  if(!VALID_DEPARTMENTS.has(req.params.legacyDept)) return res.status(404).send('Nicht gefunden');
  const qs = req.url.includes('?') ? req.url.slice(req.url.indexOf('?')) : '';
  res.redirect(301, '/Projektplan/' + encodeURIComponent(req.params.projName) + qs);
});

// Route: Weiterleitung alter zweisegmentiger Deep-Links ("/ELT/Auslastung")
// auf das neue einsegmentige Schema. Muss NACH "/Projektplan/:projName"
// stehen, sonst würde z.B. "/Projektplan/Foo" hier fälschlich als
// Abteilung="Projektplan" interpretiert.
app.get('/:legacyDept/:tab', (req, res) => {
  if(!VALID_DEPARTMENTS.has(req.params.legacyDept)) return res.status(404).send('Nicht gefunden');
  const qs = req.url.includes('?') ? req.url.slice(req.url.indexOf('?')) : '';
  res.redirect(301, '/' + encodeURIComponent(req.params.tab) + qs);
});

// Fehler aus Body-Parsern (z. B. Datei über dem Limit) als lesbares JSON statt
// der HTML-Fehlerseite von Express.
app.use((err, req, res, next) => {
  if(res.headersSent) return next(err);
  if(err && (err.type === 'entity.too.large' || err.status === 413)){
    const mb = err.limit ? Math.round(err.limit / 1048576) : null;
    return res.status(413).json({ ok: false, error: 'Datei zu groß' + (mb ? ' (höchstens ' + mb + ' MB).' : '.') });
  }
  console.error('Unbehandelter Fehler in', req.method, req.path, err);
  res.status(err && err.status || 500).json({ ok: false, error: 'Interner Fehler' });
});

// Serverstart mit Fehlerbehandlung (z.B. Port bereits belegt)
const server = app.listen(PORT, () => {
  console.log(`Projektübersicht server running on http://localhost:${PORT}`);
  // Automatisches Datenbank-Backup beim Start (sessions/backups/)
  runAutoBackup();
  // Automatischer Sitzungswechsel: einmal jetzt (holt einen Wochenwechsel
  // nach, der while der Server nicht lief passiert ist) und danach stündlich
  // erneut — mehr als genug Auflösung für einen Wechsel, der genau einmal
  // pro Woche eintritt. Muss NACH allen anderen Definitionen dieser Datei
  // stehen (braucht u. a. APP_SETTING_DEFS/readAppSettings(), die erst
  // weiter unten im Datei-Durchlauf definiert werden) — deshalb hier im
  // app.listen()-Rückruf statt in der früheren Migrations-/Bootstrap-
  // Reihenfolge weiter oben.
  ensureCurrentWeekRollover();
  // Konten, die nach dem Entstehen der aktuellen Sitzung angelegt wurden,
  // in deren Teilnehmerkreis nachtragen (siehe kontenInAktuelleSitzung()).
  kontenInAktuelleSitzung();
  setInterval(ensureCurrentWeekRollover, 60 * 60 * 1000);
  // Papierkorb gelöschter Projekte: Einträge nach 30 Tagen entfernen.
  setInterval(purgeGeloeschteProjekte, 60 * 60 * 1000);
  purgeBenachrichtigungen();
  setInterval(purgeBenachrichtigungen, 60 * 60 * 1000);
  // Betrieb auf dem Pi: Login-Sperrliste und WAL-Datei klein halten,
  // Speicher und Hänger überwachen (siehe betriebsWaechterStarten()).
  setInterval(betriebAufraeumen, 60 * 60 * 1000);
  betriebsWaechterStarten();
});

// betriebAufraeumen: abgelaufene Login-Sperren entfernen (die Liste wuchs
// sonst mit jeder Fehleingabe) und die WAL-Datei zurück in die Datenbank
// schreiben, damit sie auf der SD-Karte nicht wächst.
function betriebAufraeumen(){
  try {
    const grenze = Date.now() - loginBlockMs();
    loginAttempts.forEach((e, k) => { if(e.first < grenze) loginAttempts.delete(k); });
    // Merkliste der last_seen_at-Schreibzeiten (attachUser) nicht endlos
    // wachsen lassen: Einträge älter als eine Stunde braucht niemand mehr.
    const stundeHer = Date.now() - 60 * 60 * 1000;
    sitzungZuletztGeschrieben.forEach((t, k) => { if(t < stundeHer) sitzungZuletztGeschrieben.delete(k); });
    db.exec('PRAGMA wal_checkpoint(TRUNCATE)');
  } catch(err){ console.error('Aufräumen fehlgeschlagen:', err.message); }
}

// betriebsWaechterStarten: zwei Wächter für den unbeaufsichtigten Betrieb.
// (1) SPEICHER: Über SPEICHER_MAX_MB (Umgebungsvariable, im Docker-Container
//     gesetzt; ohne sie aus) beendet sich der Server sauber mit Code 1 —
//     Docker (restart: always) startet ihn mit frischem Speicher neu, bevor
//     der Kernel den Container hart abschießt.
// (2) HÄNGER: Ein Worker-Thread prüft den Herzschlag des Haupt-Threads. Steht
//     der Event-Loop länger als HAENGER_MAX_S (Vorgabe 90 s), beendet der
//     Worker den Prozess hart. Docker startet "unhealthy" Container NICHT
//     neu — ohne diesen Wächter bliebe ein hängender Server hängen.
function betriebsWaechterStarten(){
  const maxMb = Number(process.env.SPEICHER_MAX_MB) || 0;
  if(maxMb > 0){
    setInterval(() => {
      const mb = process.memoryUsage().rss / 1048576;
      if(mb > maxMb){
        console.error('Speicher-Wächter: ' + Math.round(mb) + ' MB > ' + maxMb + ' MB — Neustart.');
        shutdown('Speicher-Wächter', 1);
      }
    }, 30 * 1000).unref();
  }
  const haengerS = Number(process.env.HAENGER_MAX_S) || 90;
  const { Worker } = require('worker_threads');
  const herz = new Float64Array(new SharedArrayBuffer(8));
  herz[0] = Date.now();
  setInterval(() => { herz[0] = Date.now(); }, 5000).unref();
  const w = new Worker(`
    const { workerData } = require('worker_threads');
    const herz = new Float64Array(workerData.puffer);
    setInterval(() => {
      if(Date.now() - herz[0] > workerData.maxMs){
        // console im Worker läuft über den (hängenden) Haupt-Thread — direkt schreiben.
        require('fs').writeSync(2, 'Hänger-Wächter: Server reagiert seit ' + Math.round((Date.now() - herz[0]) / 1000) + ' s nicht — Neustart.\\n');
        process.kill(process.pid, 'SIGKILL');
      }
    }, 5000);
  `, { eval: true, workerData: { puffer: herz.buffer, maxMs: haengerS * 1000 }, resourceLimits: { maxOldGenerationSizeMb: 8 } });
  w.unref();
  w.on('error', err => console.error('Hänger-Wächter ausgefallen:', err.message));
}

// Unerwartete Fehler: protokollieren und mit Code 1 beenden — ein Prozess in
// unbekanntem Zustand soll nicht weiterlaufen, Docker startet ihn neu.
// Abgelehnte Promises betreffen dagegen fast immer nur eine Anfrage: nur
// protokollieren (Node beendete sonst den ganzen Server).
process.on('uncaughtException', (err) => {
  console.error('Unerwarteter Fehler — Server wird neu gestartet:', err);
  shutdown('uncaughtException', 1);
});
process.on('unhandledRejection', (grund) => {
  console.error('Nicht abgefangene Promise-Ablehnung:', grund);
});
server.on('error', (err) => {
  console.error('Server konnte nicht starten:', err.message);
  if(err.code === 'EADDRINUSE'){
    console.error(`Port ${PORT} ist bereits belegt. Bitte einen anderen PORT verwenden, z.B. PORT=3004 npm start`);
  }
  process.exit(1);
});

// Sauberes Beenden auf Strg+C/Cmd+C (SIGINT) oder `kill` (SIGTERM): schließt
// zuerst den HTTP-Server (keine neuen Verbindungen mehr, laufende werden zu
// Ende bedient) und danach die Datenbank (sauberer WAL-Checkpoint statt
// eines abrupten Abbruchs mitten im Schreiben). Ohne diesen Handler würde
// Node ebenfalls beenden — kein anderer Code hier überschreibt das
// Standardverhalten —, aber lautlos und ohne den Checkpoint.
let beendetBereits = false;
function shutdown(signal, code = 0){
  if(beendetBereits) return;
  beendetBereits = true;
  console.log(`\n${signal} empfangen, Server wird beendet…`);
  // Sicherheitsnetz: eine offene Keep-Alive-Verbindung kann server.close()
  // unbegrenzt blockieren (bekannte Node-Eigenheit) — nach 3s notfalls hart
  // beenden, damit der Prozess in jedem Fall nur bis zum Tastendruck läuft.
  const notbremse = setTimeout(() => process.exit(code), 3000);
  notbremse.unref();
  // Offene Live-Verbindungen (GET /ereignisse) hielten server.close() sonst
  // bis zur Notbremse auf.
  if(typeof server.closeAllConnections === 'function') server.closeIdleConnections();
  try { ereignisKunden.forEach(k => { try { k.res.end(); } catch(e){} }); } catch(e){}
  server.close(() => {
    try { db.close(); } catch(e){ /* bereits geschlossen */ }
    console.log('Server beendet.');
    process.exit(code);
  });
}
process.on('SIGINT', () => shutdown('SIGINT'));
process.on('SIGTERM', () => shutdown('SIGTERM'));