dogfather-universe/server/workspace-push.js

/* =====================================================================
   workspace-push.js — Benachrichtigungen, die wirklich ankommen.

   Wunsch Filipe (05.09.2026), mit dem Bild eines "Benachrichtigungen
   aus"-Knopfes: *"ich will auch sowas und dass es perfekt funktioniert
   auf der seite fuer jeden."*

   ---------------------------------------------------------------------
   WAS DAS LOEST

   Bis hierher erscheinen Hinweise NUR, wenn man die Seite aufruft. Wer
   nicht hinschaut, verpasst sie -- und genau das ist der Normalfall:
   Man macht den Workspace auf, wenn man ohnehin daran denkt. Der
   Perfektionsplan sagt dazu: *"Das Deck verspricht Erinnerungen. Wer
   nicht hinschaut, verpasst sie."*

   ---------------------------------------------------------------------
   OHNE FREMDEN DIENST, OHNE KONTO, OHNE GEBUEHR

   Push API und Service Worker sind Browserstandard. Der Server braucht
   nur ein eigenes Schluesselpaar (VAPID); die Nachricht wird fuer jedes
   Geraet einzeln verschluesselt. Google, Mozilla und Apple leiten sie
   weiter, sehen aber nur Zeichensalat -- der Inhalt bleibt zwischen
   diesem Server und dem Browser.

   Die Rechnung dafuer steht in workspace-push-krypto.js und ist gegen
   die Testvektoren von RFC 8291 und 8292 geprueft.

   ---------------------------------------------------------------------
   VIER REGELN, DIE DARUEBER ENTSCHEIDEN, OB ES BENUTZT WIRD

   1. NICHTS ZWEIMAL. Jede Erinnerung wird je Person und Sache genau
      einmal verschickt (Tabelle push_verschickt). Viermal am Tag
      dieselbe Meldung ist der schnellste Weg, dass jemand alles
      abschaltet -- und dann fehlt auch die wichtige.

   2. NACHTS NICHT. Zwischen 22 und 7 Uhr wird nichts zugestellt.
      Aufgehoben wird nichts: Was morgens noch gilt, geht morgens raus;
      was sich erledigt hat, ist zu Recht weg.

   3. JE ART ABSCHALTBAR, nicht alles oder nichts.

   4. EINE BENACHRICHTIGUNG HAT IMMER EIN ZIEL. Wer sie antippt, landet
      an der Stelle, um die es geht -- nicht auf der Startseite.

   ---------------------------------------------------------------------
   WICHTIG FUERS IPHONE

   Dort funktioniert Push NUR, wenn die Seite zum Home-Bildschirm
   hinzugefuegt wurde. Im Safari-Reiter gibt es keine Berechtigung --
   der Knopf sagt das dann auch genau so, statt einen Fehler zu zeigen.
   ===================================================================== */

import express from "express";
import {
  db, protokolliere, echteIp, sitzungLesen, istDogFather,
  einstellung, einstellungSetzen, heuteLokal,
  gehoertAufDieseAdresse, TEAM_DOGI_ROLLEN,
} from "./workspace.js";
import { schluesselErzeugen, schicken } from "./workspace-push-krypto.js";
import { rhythmus as befindenRhythmus } from "./workspace-befinden.js";
import { SEITEN } from "./rechte.js";

export const pushRouter = express.Router();

const jetzt = () => new Date().toISOString();

/* ---------------------------------------------------------------------
   DIE ARTEN. Was es gibt, steht hier -- nicht in der Datenbank: Es ist
   eine bewusste Auswahl, keine Nutzdaten. Wer eine neue Art braucht,
   traegt sie hier ein und sie erscheint von selbst in den
   Einstellungen.
   ------------------------------------------------------------------ */
export const ARTEN = [
  { schluessel: "aufgabe_faellig", name: "Aufgabe wird morgen fällig", vorgabe: true },
  { schluessel: "aufgabe_ueberfaellig", name: "Aufgabe ist überfällig", vorgabe: true },
  { schluessel: "termin_gleich", name: "Termin in einer Stunde", vorgabe: true },
  /* DER WECKER (07.09.2026). Bewusst eine EIGENE Art neben
     "termin_gleich": Die eine ist eine Vorgabe des Hauses fuer jeden
     Termin, der andere ist eine Entscheidung DIESER Person fuer DIESEN
     Termin. Wer die feste Stunden-Erinnerung abschaltet, will damit
     nicht seine selbst gesetzten Wecker verlieren. */
  { schluessel: "termin_wecker", name: "Selbst gesetzter Wecker", vorgabe: true },
  { schluessel: "protokoll_fehlt", name: "Gespräch ohne Protokoll", vorgabe: true },
  { schluessel: "followup", name: "Follow-up in der Pipeline fällig", vorgabe: true },
  /* Chat (06.09.2026). Steht bewusst VOR der Probe: Es ist die Art,
     die am haeufigsten kommt, und wer die Liste ueberfliegt, sucht
     zuerst sie. */
  { schluessel: "chat_nachricht", name: "Neue Nachricht im Chat", vorgabe: true },
  /* ---- ANRUFE SIND EINE EIGENE ART (18.09.2026) ------------------

     Filipe: „sie bekommt nur eine benarichtigung das eine neue
     nachricht ist aber sonst nichts irgendwas laeuft da gewaltig
     schief."

     Es lief zweierlei schief, und beides haengt an dieser Zeile.

     ERSTENS ging das Klingeln als „chat_nachricht" hinaus. Wer im
     Chat viel schreibt und die Benachrichtigungen dafuer abstellt,
     stellt damit auch Anrufe ab -- ohne es zu wissen. Das sind zwei
     verschiedene Entscheidungen.

     ZWEITENS -- und das war der eigentliche Grund -- galt fuer sie die
     RUHEZEIT. Ab 22 Uhr wird nichts mehr verschickt. Um 23:44 kam
     deshalb gar keine Benachrichtigung an; ihr Geraet konnte nicht
     klingeln, weil es nichts zu klingeln gab.

     Fuer eine Aufgabenerinnerung ist das genau richtig. Ein Anruf ist
     etwas anderes: Ihn loest ein Mensch in diesem Moment aus, und er
     wartet auf eine Antwort. Ein Telefon, das nachts stumm bleibt,
     ist kein Telefon. Wer nachts nicht gestoert werden will, schaltet
     jetzt diese Art ab -- eine Entscheidung, die man selbst trifft,
     statt einer Regel, die man nicht kennt. */
  { schluessel: "anruf", name: "Jemand ruft an", vorgabe: true },
  /* DER TAGESRUF (08.09.2026, screen10). Filipe: "eine taetige meldung
     einmal am tag zu aktivieren wenn noch aufgaben auf sind."

     ALS EINZIGE ART MIT `vorgabe: false`, und das ist keine
     Nachlaessigkeit: Er ist ausdruecklich etwas zum AKTIVIEREN. Alle
     anderen Arten antworten auf ein Ereignis, das gerade passiert ist
     (eine Aufgabe wird faellig, jemand schreibt). Der Tagesruf kommt
     ungefragt zur selben Zeit, ob es etwas Neues gibt oder nicht --
     so etwas schaltet man sich selbst ein, sonst ist es Werbung.

     `wertVorgabe` ist die Uhrzeit. Neun Uhr, weil die Ruhezeit bis
     sieben geht und ein Ruf um 7:01 niemanden erreicht, der um acht
     aufsteht. */
  { schluessel: "tagesruf", name: "Einmal am Tag: was noch offen ist",
    vorgabe: false, wertVorgabe: "09:00", wertArt: "uhrzeit" },
  /* DIE BEFINDENS-ANFRAGE (17.09.2026). Filipe: "mach da mehr so eine
     automatisierte anfrage regelmaessig."

     MIT `vorgabe: true`, anders als der Tagesruf: Sie antwortet nicht
     auf ein Ereignis, aber sie kommt auch nicht taeglich -- alle 14
     Tage, und nur, wenn wirklich etwas offen ist. Und sie ist der
     einzige Weg, auf dem jemand ueberhaupt erfaehrt, dass wieder
     gefragt wird. Waere sie zum Einschalten, bekaeme sie genau der
     nicht, der sie am noetigsten braucht.

     ABSCHALTEN GEHT NATUERLICH TROTZDEM -- wie bei jeder Art, in den
     Einstellungen. Das ist der Unterschied zwischen einer Vorgabe und
     einem Zwang. */
  { schluessel: "befinden", name: "Alle zwei Wochen: wie geht es dir?", vorgabe: true },
  /* DER VERTRAULICHE MELDEWEG (19.09.2026).

     Sie geht in BEIDE Richtungen: An die Leitung, wenn etwas
     hereinkommt -- und an den Melder, wenn eine Antwort da ist. Genau
     das ist der Punkt: Wer etwas Unangenehmes geschrieben hat, will
     nicht stuendlich nachsehen muessen, ob schon jemand geantwortet
     hat.

     IM TEXT STEHT NIE, WORUM ES GEHT. Eine Benachrichtigung erscheint
     auf einem Sperrbildschirm, den auch andere sehen. */
  { schluessel: "hilfe", name: "Vertrauliche Meldung: neu oder beantwortet", vorgabe: true },
  { schluessel: "test", name: "Probe-Benachrichtigung", vorgabe: true },
];
const ARTEN_SCHLUESSEL = new Set(ARTEN.map((a) => a.schluessel));

/** Wie ein Vorlauf heisst, wenn er im Meldungskopf steht.
 *
 *  In Minuten gerechnet, in Worten gemeldet: "In einer Woche" liest
 *  sich beim Aufwachen besser als "10080 Minuten vorher". Die Staffel
 *  ist dieselbe, die die Oberflaeche anbietet -- kaeme hier eine
 *  ungerade Zahl an, faellt sie auf den allgemeinen Satz zurueck statt
 *  auf einen falschen. */
export function vorlauf(minuten) {
  const m = Number(minuten) || 0;
  if (m >= 10080) return "Erinnerung: in einer Woche";
  if (m >= 4320) return "Erinnerung: in drei Tagen";
  if (m >= 1440) return "Erinnerung: morgen";
  if (m >= 720) return "Erinnerung: heute";
  if (m >= 120) return `Erinnerung: in ${Math.round(m / 60)} Stunden`;
  if (m >= 60) return "Erinnerung: in einer Stunde";
  if (m > 0) return `Erinnerung: in ${m} Minuten`;
  return "Erinnerung: jetzt";
}

/* RUHEZEIT. Nichts zwischen 22 und 7 Uhr.

   DIE GRENZEN SIND SEIT DEM 07.09.2026 EINSTELLBAR, und der Grund ist
   eine Pruefung, die sich selbst ins Knie geschossen hat: Die
   Weckerpruefung lief um 23:42 und meldete vier Fehler -- der Melder
   schwieg, weil Ruhezeit war. Sie hat also den Kalender gemessen, nicht
   die Software, und waere um 10 Uhr gruen gewesen. Genau die Zeitbombe,
   die in der Projektnotiz steht.

   Eine Pruefung darf ihre Voraussetzung herstellen duerfen. Deshalb
   liest die Ruhezeit jetzt aus der Umgebung -- Vorgabe unveraendert
   22 bis 7, und im Betrieb setzt niemand etwas anderes. Die Alternative
   waere gewesen, in der Pruefung eine Zeit zu faelschen; das faelscht
   dann irgendwann auch etwas anderes mit.

   Nebennutzen: Wenn das Team eines Tages andere Zeiten will, ist es
   eine Umgebungsvariable und kein Programmierauftrag. */
const RUHE_AB = Number(process.env.PUSH_RUHE_AB ?? 22);
const RUHE_BIS = Number(process.env.PUSH_RUHE_BIS ?? 7);
export function istRuhezeit(d = new Date()) {
  const s = d.getHours();
  return s >= RUHE_AB || s < RUHE_BIS;
}

/* ---------------------------------------------------------------------
   Das Schluesselpaar des Servers. Einmal erzeugt, danach in den
   Einstellungen -- NICHT im Code und nicht in einer Datei im Repo.
   Der private Teil verlaesst den Server nie.
   ------------------------------------------------------------------ */
export function paarHolen() {
  let roh = einstellung("vapid_paar");
  if (roh) {
    try {
      const p = JSON.parse(roh);
      if (p?.oeffentlich && p?.privat) return p;
    } catch { /* kaputt -- unten neu erzeugen */ }
  }
  const neu = schluesselErzeugen();
  einstellungSetzen("vapid_paar", JSON.stringify(neu));
  console.log("[push] Neues VAPID-Schluesselpaar erzeugt.");
  return neu;
}

/** Die Absenderangabe fuer VAPID. Der Push-Dienst schreibt hierhin,
 *  wenn dauerhaft etwas nicht stimmt. */
const ABSENDER = process.env.PUSH_ABSENDER || "mailto:[email protected]";

/* ---------------------------------------------------------------------
   Will diese Person diese Art bekommen?
   ------------------------------------------------------------------ */
export function willHaben(personId, art) {
  const z = db().prepare(
    "SELECT an FROM push_einstellungen WHERE person_id = ? AND art = ?").get(personId, art);
  if (z) return !!z.an;
  return ARTEN.find((a) => a.schluessel === art)?.vorgabe ?? true;
}

/** Der eingestellte Wert einer Art -- oder die Vorgabe.
 *
 *  Dieselbe Bauart wie `willHaben`: Fehlt die Zeile, gilt was in
 *  `ARTEN` steht. Eine Vorgabe in der Datenbank waere eine zweite
 *  Wahrheit, die bei jeder Aenderung vergessen wird.
 */
export function wertVon(personId, art) {
  const z = db().prepare(
    "SELECT wert FROM push_einstellungen WHERE person_id = ? AND art = ?").get(personId, art);
  const vorgabe = ARTEN.find((a) => a.schluessel === art)?.wertVorgabe ?? null;
  return z?.wert ?? vorgabe;
}

/** Ist "hh:mm" eine Uhrzeit, die es gibt?
 *
 *  Geprueft wird der BEREICH, nicht nur die Form: "99:99" passt auf
 *  jedes naive Muster und ist trotzdem keine Uhrzeit. Aus dem Netz
 *  kommt, was jemand schickt -- nicht, was die Oberflaeche anbietet.
 */
/** Ist der Tagesruf jetzt faellig? -- die Entscheidung allein.
 *
 *  HERAUSGELOEST, DAMIT SIE PRUEFBAR IST. Im Rundgang steckte sie
 *  zwischen einer Datenbankabfrage und einem Push-Versand; um sie zu
 *  pruefen, haette man beides aufbauen muessen -- also haette man sie
 *  nicht geprueft. Eine Entscheidung, die nur aus Zahlen besteht,
 *  gehoert in eine Funktion, die nur aus Zahlen besteht.
 *
 *  DAS FENSTER IST DREI STUNDEN BREIT. Der Takt laeuft alle fuenf
 *  Minuten; ein einfaches "jetzt >= eingestellte Zeit" wuerde nach
 *  einem Serverausfall den Ruf fuer neun Uhr um zwanzig Uhr
 *  zustellen -- eine Erinnerung an einen Tag, der vorbei ist. Wer sie
 *  um 21 Uhr bekommt, schaltet sie ab. Faellt der Tag aus, ist das die
 *  ehrlichere Antwort als eine Meldung zur falschen Zeit.
 *
 *  @param jetztMinuten Minuten seit Mitternacht, Ortszeit.
 *  @param zeit         "hh:mm", die eingestellte Uhrzeit.
 */
export const TAGESRUF_FENSTER = 180;
export function tagesrufFaellig(jetztMinuten, zeit) {
  if (!istUhrzeit(zeit)) return false;
  const [h, m] = zeit.split(":").map(Number);
  const seit = jetztMinuten - (h * 60 + m);
  return seit >= 0 && seit <= TAGESRUF_FENSTER;
}

export function istUhrzeit(t) {
  if (typeof t !== "string" || !/^\d{2}:\d{2}$/.test(t)) return false;
  const [h, m] = t.split(":").map(Number);
  return h >= 0 && h <= 23 && m >= 0 && m <= 59;
}

/* ---------------------------------------------------------------------
   VERSCHICKEN — der einzige Weg nach draussen.

   Alles laeuft hier durch: Ruhezeit, Einstellung, Doppelsperre,
   Aufraeumen toter Anmeldungen. Eine zweite Stelle, die selbst
   verschickt, wuerde eine dieser Regeln irgendwann vergessen.
   ------------------------------------------------------------------ */
/* =====================================================================
   EINE BENACHRICHTIGUNG MUSS IRGENDWOHIN FUEHREN (16.09.2026)

   Seit dem 15.09. entscheidet die Adresse, welche Seiten es gibt: Auf
   crew. gibt es die Agenturseiten nicht. Fuer Seiten, Hinweise und
   Suchtreffer ist das umgesetzt -- fuer Push nicht, und zwar aus einem
   Grund, der stimmt: Eine Benachrichtigung entsteht, wenn NIEMAND auf
   einer Adresse steht. Sie geht an ein Geraet, und das oeffnet die
   Adresse, als die es installiert wurde.

   Die Frage laesst sich trotzdem beantworten, nur anders: nicht ueber
   die Adresse, sondern ueber den MENSCHEN. Wer im Team ist (rechte
   Hand, Modi), kommt nur auf crew. herein -- das steht in
   sitzungPasstZurAdresse und gilt in beide Richtungen. Fuer ihn gibt
   es die Agenturseiten nirgends, auf keinem Geraet.

   Also: Ein Ziel, das dieser Mensch nirgends oeffnen kann, wird zur
   Startseite. Dort steht, was fuer ihn ansteht -- das ist immer noch
   eine Auskunft, waehrend eine Weiterleitung ins Leere wie ein Fehler
   aussieht.

   DOGFATHER UND SPICY ARBEITEN IN BEIDEN HAEUSERN. Fuer sie gilt jedes
   Ziel, das in EINEM der beiden existiert -- welches Geraet sie gerade
   in der Hand haben, weiss hier niemand, und die Seitenschranke faengt
   den Rest ab.

   WARUM NICHT DIE BENACHRICHTIGUNG GANZ UNTERDRUECKEN: Weil sie meist
   trotzdem stimmt. Ein Modi, der als Teilnehmer in einem Call steht,
   SOLL erfahren, dass er gleich anfaengt -- nur nicht auf einer Seite
   landen, die es fuer ihn nicht gibt. */
function zielFuer(personId, ziel) {
  const heim = "/workspace/start.html";
  if (!ziel) return heim;
  try {
    const p = db().prepare("SELECT rolle FROM personen WHERE id = ?").get(personId);
    if (!p) return heim;
    /* Nur das Team ist auf eine Adresse festgelegt. Alle anderen
       arbeiten im Agenturhaus, und dort gibt es jede Seite. */
    if (!TEAM_DOGI_ROLLEN.has(p.rolle)) return ziel;
    const pfad = String(ziel).split("?")[0].split("#")[0];
    return gehoertAufDieseAdresse({ rolle: p.rolle, haus: "crew" }, pfad) ? ziel : heim;
  } catch (f) {
    /* IM ZWEIFEL DIE STARTSEITE. Eine Benachrichtigung, die wegen
       eines Datenbankfehlers gar nicht erst rausgeht, waere der
       groessere Schaden. */
    console.error("[push] Ziel pruefen:", f?.message);
    return heim;
  }
}

export async function benachrichtige(personId, art, { titel, text, ziel, merkmal }) {
  if (!ARTEN_SCHLUESSEL.has(art)) return { verschickt: 0, grund: "unbekannte_art" };
  if (!willHaben(personId, art)) return { verschickt: 0, grund: "abgeschaltet" };

  /* Die Probe darf immer durch -- sie beantwortet die Frage "kommt
     ueberhaupt etwas an?", und die stellt man sich auch um 23 Uhr.

     UND EIN ANRUF AUCH (18.09.2026). Die Ruhezeit ist gegen
     Erinnerungen gebaut: Dinge, die der Server von sich aus schickt,
     weil eine Frist naeher rueckt. Ein Anruf ist das Gegenteil -- ein
     Mensch drueckt gerade auf den Hoerer und wartet.

     Gefunden hat das Filipes Satz „sie bekommt nur eine
     benarichtigung ... irgendwas laeuft da gewaltig schief", um 23:44
     Uhr. Serverseitig war alles in Ordnung; der Anruf wurde nur nie
     ausgeliefert, weil es nach 22 Uhr war. Wer nachts seine Ruhe will,
     schaltet die Art „Jemand ruft an" ab. */
  const dringend = art === "test" || art === "anruf";
  if (!dringend && istRuhezeit()) return { verschickt: 0, grund: "ruhezeit" };

  /* Schon einmal geschickt? */
  if (merkmal) {
    const da = db().prepare(
      "SELECT 1 FROM push_verschickt WHERE person_id = ? AND merkmal = ?").get(personId, merkmal);
    if (da) return { verschickt: 0, grund: "schon_geschickt" };
  }

  const anmeldungen = db().prepare(
    "SELECT * FROM push_anmeldungen WHERE person_id = ?").all(personId);
  if (!anmeldungen.length) return { verschickt: 0, grund: "keine_geraete" };

  const paar = paarHolen();
  /* Das Ziel wird EINMAL bestimmt und mitgegeben -- damit eine Pruefung
     nachsehen kann, wohin wirklich geschickt wurde, ohne die
     Nachricht aufmachen zu muessen. */
  const zielEcht = zielFuer(personId, ziel);
  const inhalt = JSON.stringify({ titel, text, art, ziel: zielEcht });

  let raus = 0;
  for (const a of anmeldungen) {
    const e = await schicken(a, inhalt, paar, ABSENDER);
    if (e.ok) {
      raus++;
      db().prepare("UPDATE push_anmeldungen SET zuletzt_ok = ?, fehler = 0 WHERE endpunkt = ?")
        .run(jetzt(), a.endpunkt);
    } else if (e.weg) {
      /* Der Push-Dienst sagt: dieses Geraet gibt es nicht mehr.
         Aufheben waere sinnlos und wuerde bei jedem Lauf erneut
         scheitern. */
      db().prepare("DELETE FROM push_anmeldungen WHERE endpunkt = ?").run(a.endpunkt);
    } else {
      db().prepare("UPDATE push_anmeldungen SET fehler = fehler + 1 WHERE endpunkt = ?")
        .run(a.endpunkt);
    }
  }

  if (raus && merkmal) {
    db().prepare("INSERT OR REPLACE INTO push_verschickt (person_id, merkmal, zeit) VALUES (?,?,?)")
      .run(personId, merkmal, jetzt());
  }
  return { verschickt: raus, grund: raus ? "ok" : "nicht_zugestellt", ziel: zielEcht };
}

/* ---------------------------------------------------------------------
   WAS STEHT AN? — der Takt.

   Fragt dieselben Daten ab, aus denen auch die Hinweisliste auf der
   Startseite entsteht. Bewusst KEINE eigenen Daten: Was erledigt wird,
   verschwindet von selbst, und es gibt nichts zu pflegen, das
   veralten kann.
   ------------------------------------------------------------------ */
export async function laufen() {
  const d = db();
  const heute = heuteLokal();
  const morgen = new Date(Date.parse(heute + "T00:00:00Z") + 86400_000).toISOString().slice(0, 10);
  let gesamt = 0;

  const senden = async (personId, art, sache) => {
    const e = await benachrichtige(personId, art, sache);
    gesamt += e.verschickt;
  };

  try {
    /* --- Aufgaben, die morgen faellig sind ---------------------------- */
    for (const a of d.prepare(`
      SELECT a.id, a.titel, a.verantwortlich_id FROM aufgaben a
      WHERE a.status NOT IN ('erledigt', 'abgebrochen') AND a.frist = ? AND a.verantwortlich_id IS NOT NULL`).all(morgen)) {
      await senden(a.verantwortlich_id, "aufgabe_faellig", {
        titel: "Morgen fällig",
        text: a.titel,
        ziel: "/workspace/aufgaben.html",
        merkmal: `aufgabe_faellig:${a.id}:${morgen}`,
      });
    }

    /* --- Aufgaben, die ueberfaellig sind ------------------------------ */
    for (const a of d.prepare(`
      SELECT a.id, a.titel, a.frist, a.verantwortlich_id FROM aufgaben a
      WHERE a.status NOT IN ('erledigt', 'abgebrochen') AND a.frist IS NOT NULL AND a.frist < ?
        AND a.verantwortlich_id IS NOT NULL`).all(heute)) {
      await senden(a.verantwortlich_id, "aufgabe_ueberfaellig", {
        titel: "Überfällig",
        text: a.titel,
        ziel: "/workspace/aufgaben.html",
        /* Das Datum gehoert ins Merkmal: Eine Aufgabe, die drei Wochen
           liegen bleibt, soll nicht dreimal am Tag erinnern -- aber
           einmal am Tag schon. */
        merkmal: `aufgabe_ueberfaellig:${a.id}:${heute}`,
      });
    }

    /* --- DER TAGESRUF: einmal am Tag, was noch offen ist --------------

       Filipe (screen10): "eine taetige meldung einmal am tag zu
       aktivieren wenn noch aufgaben auf sind."

       NUR WER IHN EINGESCHALTET HAT. Die Vorgabe ist `false`, also
       gibt es die Zeile nur, wenn jemand sie angelegt hat -- die
       Abfrage ist damit zugleich die Teilnehmerliste. Kein Rundgang
       ueber alle Personen, um dann 95 Prozent wieder wegzuwerfen.

       EIN FENSTER VON DREI STUNDEN, und das ist der eigentliche
       Gedanke hier. Der Takt laeuft alle fuenf Minuten; ein einfaches
       "jetzt >= eingestellte Zeit" wuerde nach einem Serverausfall
       den Ruf fuer neun Uhr um zwanzig Uhr zustellen -- eine
       Erinnerung an einen Tag, der vorbei ist. Wer sie um 21 Uhr
       bekommt, schaltet sie ab. Also: bis drei Stunden danach ja,
       spaeter nicht mehr. Der Tag faellt dann aus, und das ist die
       ehrlichere Antwort als eine Meldung zur falschen Zeit.

       Die Ruhezeit prueft `benachrichtige` selbst. Wer sechs Uhr
       einstellt, bekommt den Ruf um sieben (Ruhezeit bis 7) -- immer
       noch im Fenster.

       "WENN NOCH AUFGABEN AUF SIND" heisst: bei null Aufgaben kommt
       nichts. Eine taegliche Meldung "du hast nichts zu tun" ist
       genau die Sorte Nachricht, die dazu fuehrt, dass man die
       naechste nicht mehr liest. */
    const n = new Date();
    const jetztMinuten = n.getHours() * 60 + n.getMinutes();
    for (const e of d.prepare(
      "SELECT person_id, wert FROM push_einstellungen WHERE art = 'tagesruf' AND an = 1").all()) {
      const zeit = e.wert || ARTEN.find((a) => a.schluessel === "tagesruf")?.wertVorgabe || "09:00";
      if (!tagesrufFaellig(jetztMinuten, zeit)) continue;

      const z = d.prepare(`
        SELECT COUNT(*) AS offen,
               SUM(CASE WHEN frist IS NOT NULL AND frist < ? THEN 1 ELSE 0 END) AS spaet
        FROM aufgaben
        WHERE verantwortlich_id = ? AND status NOT IN ('erledigt', 'abgebrochen')`)
        .get(heute, e.person_id);
      if (!z || !z.offen) continue;

      /* Der Satz nennt die Zahl und, wenn es sie gibt, die
         Ueberfaelligen -- das ist die Information, wegen der man
         hinsieht. "Du hast offene Aufgaben" allein zwingt zum
         Nachschauen und hilft niemandem. */
      const spaet = z.spaet || 0;
      await senden(e.person_id, "tagesruf", {
        titel: z.offen === 1 ? "Eine Aufgabe ist noch offen" : `${z.offen} Aufgaben sind noch offen`,
        text: spaet ? (spaet === 1 ? "Davon eine überfällig." : `Davon ${spaet} überfällig.`)
                    : "Nichts davon ist überfällig.",
        ziel: "/workspace/aufgaben.html",
        merkmal: `tagesruf:${heute}`,
      });
    }

    /* --- Termine in der naechsten Stunde ------------------------------ */
    const gleich = new Date(Date.now() + 60 * 60_000);
    const p = (n) => String(n).padStart(2, "0");
    const bis = `${gleich.getFullYear()}-${p(gleich.getMonth() + 1)}-${p(gleich.getDate())}`
      + `T${p(gleich.getHours())}:${p(gleich.getMinutes())}`;
    const jetztText = (() => {
      const n = new Date();
      return `${n.getFullYear()}-${p(n.getMonth() + 1)}-${p(n.getDate())}`
        + `T${p(n.getHours())}:${p(n.getMinutes())}`;
    })();

    for (const t of d.prepare(`
      SELECT t.id, t.titel, t.beginn, t.art FROM termine t
      WHERE t.erledigt = 0 AND t.beginn >= ? AND t.beginn <= ?`).all(jetztText, bis)) {
      /* An ALLE Teilnehmer, nicht nur an das Haupt-Gegenueber -- seit
         ein Termin mehrere haben kann (05.09.2026). */
      const leute = d.prepare(
        "SELECT person_id FROM termin_teilnehmer WHERE termin_id = ?").all(t.id).map((r) => r.person_id);
      for (const pid of new Set(leute)) {
        await senden(pid, "termin_gleich", {
          titel: t.art === "call" ? "Call in Kürze" : "Termin in Kürze",
          text: `${t.titel} · ${t.beginn.slice(11, 16)} Uhr`,
          ziel: t.art === "call" ? "/workspace/calls.html" : "/workspace/kalender.html",
          merkmal: `termin_gleich:${t.id}`,
        });
      }
    }

    /* --- DIE SELBST GESETZTEN WECKER ----------------------------------

       Ein Wecker steht als ABSTAND in der Datenbank (minuten_vorher),
       nicht als Zeitpunkt. Die Weckzeit wird deshalb hier gerechnet --
       und ist damit auch nach einer Terminverschiebung richtig, ohne
       dass irgendjemand etwas nachziehen muss.

       ZWEI GRENZEN, und beide sind noetig:

         faellig    die Weckzeit ist erreicht (beginn - abstand <= jetzt)
         nicht zu spaet   der Termin liegt noch VOR uns

       Ohne die zweite wuerde beim ersten Lauf nach einer Auszeit des
       Dienstes jeder alte Wecker der letzten Wochen nachtraeglich
       klingeln -- ein Schwall Meldungen zu Terminen, die laengst vorbei
       sind. Das ist der Fall, den man beim Bauen nie sieht und der beim
       ersten Neustart nach einem Ausfall sofort auffaellt.

       DIE RUHEZEIT VERSCHLUCKT NICHTS. `benachrichtige` merkt sich erst
       nach dem Verschicken, dass etwas raus ist -- was zwischen 22 und
       7 Uhr faellig wird, geht also am Morgen raus, sobald der Termin
       noch bevorsteht. Ein Wecker, der nachts still ist und dafuer
       morgens klingelt, ist genau richtig; einer, der verschluckt wird,
       waere schlimmer als keiner.

       Rechnen auf Textebene geht hier NICHT (Abstand in Minuten), also
       mit Date -- aber ausschliesslich lokal, nie ueber toISOString. */
    const alsText = (dt) => {
      const p2 = (n) => String(n).padStart(2, "0");
      return `${dt.getFullYear()}-${p2(dt.getMonth() + 1)}-${p2(dt.getDate())}`
        + `T${p2(dt.getHours())}:${p2(dt.getMinutes())}`;
    };
    for (const w of d.prepare(`
      SELECT w.termin_id, w.person_id, w.minuten_vorher,
             t.titel, t.beginn, t.art
        FROM termin_wecker w
        JOIN termine t ON t.id = w.termin_id
       WHERE t.erledigt = 0 AND t.beginn > ?`).all(jetztText)) {
      const beginn = new Date(String(w.beginn).replace(" ", "T"));
      if (Number.isNaN(beginn.getTime())) continue;
      const weckzeit = new Date(beginn.getTime() - w.minuten_vorher * 60_000);
      if (alsText(weckzeit) > jetztText) continue;          // noch nicht so weit

      await senden(w.person_id, "termin_wecker", {
        titel: vorlauf(w.minuten_vorher),
        text: `${w.titel} · ${String(w.beginn).slice(8, 10)}.${String(w.beginn).slice(5, 7)}. `
          + `um ${String(w.beginn).slice(11, 16)} Uhr`,
        ziel: w.art === "call" ? "/workspace/calls.html" : "/workspace/kalender.html",
        /* Der Abstand gehoert ins Merkmal. Ohne ihn wuerde der erste
           Wecker eines Termins alle weiteren als "schon geschickt"
           sperren -- und genau das Mehrfach-Wecken, um das es geht,
           faende nie statt. */
        merkmal: `wecker:${w.termin_id}:${w.minuten_vorher}`,
      });
    }

    /* --- Gespraeche ohne Protokoll ------------------------------------ */
    for (const t of d.prepare(`
      SELECT t.id, t.titel, t.erstellt_von FROM termine t
      LEFT JOIN protokolle pr ON pr.termin_id = t.id
      WHERE t.art IN ('call','review') AND t.beginn < ? AND pr.id IS NULL
        AND t.beginn > ? AND t.erstellt_von IS NOT NULL`)
      .all(jetztText, heute + "T00:00")) {
      await senden(t.erstellt_von, "protokoll_fehlt", {
        titel: "Protokoll fehlt",
        text: t.titel,
        ziel: "/workspace/calls.html",
        merkmal: `protokoll_fehlt:${t.id}`,
      });
    }

    /* --- Faellige Follow-ups in der Pipeline --------------------------- */
    for (const l of d.prepare(`
      SELECT l.id, l.name, l.scout_id FROM leads l
      WHERE l.naechster_followup IS NOT NULL AND l.naechster_followup <= ?
        AND l.status NOT IN ('uebergeben','abgelehnt') AND l.scout_id IS NOT NULL`).all(heute)) {
      await senden(l.scout_id, "followup", {
        titel: "Nachfassen",
        text: l.name,
        ziel: "/workspace/scouting.html",
        merkmal: `followup:${l.id}:${heute}`,
      });
    }

    /* --- WIE GEHT ES DIR? Alle zwei Wochen, von selbst ---------------

       Filipe (17.09.2026): "mach da mehr so eine automatisierte
       anfrage regelmaessig."

       WER GEFRAGT WIRD, steht nicht hier: Es sind genau die Rollen,
       die befinden.html ueberhaupt aufrufen duerfen -- und die stehen
       in rechte.js. Eine eigene Liste hier waere eine zweite, und die
       eine vergessene waere jemand, der nie gefragt wird, ohne dass es
       auffaellt. (Genau so ist am 11.09. eine Rolle durch den Rost
       gefallen.)

       OB FAELLIG, ENTSCHEIDET rhythmus() aus workspace-befinden.js --
       dieselbe Funktion, die auch die Seite selbst fragt. Nicht "aelter
       als 14 Tage" nachgerechnet: Die echte Regel ist "alt genug ODER
       nie fertig geworden", und die haette ich hier vergessen.

       HOECHSTENS EINMAL IN SIEBEN TAGEN, ueber das Merkmal mit der
       Kalenderwoche. Ohne das kaeme die Erinnerung ab Tag 14 JEDEN Tag,
       weil "faellig" faellig bleibt, bis jemand antwortet -- und eine
       Erinnerung, die jeden Tag kommt, ist nach drei Tagen keine
       Erinnerung mehr, sondern Laerm, den man abschaltet. */
    const befindenRollen = (SEITEN["/workspace/befinden.html"] || []);
    if (befindenRollen.length) {
      const platz = befindenRollen.map(() => "?").join(", ");
      /* Die Woche als Nummer -- gerechnet aus dem Datum, nicht aus
         einer Bibliothek: Gebraucht wird "hoechstens einmal je sieben
         Tage", nicht die kalendarisch richtige Wochennummer. */
      const woche = Math.floor(Date.parse(heute + "T00:00:00Z") / (7 * 86400_000));
      for (const person of d.prepare(
        `SELECT id, name FROM personen WHERE aktiv = 1 AND rolle IN (${platz})`)
        .all(...befindenRollen)) {
        let lage;
        try { lage = befindenRhythmus(person.id); } catch { continue; }
        if (!lage?.faellig) continue;
        await senden(person.id, "befinden", {
          titel: "Wie geht es dir?",
          text: lage.letzte
            ? "Die zwei Wochen sind um – es dauert zwei Minuten."
            : "Zwölf Fragen über dich. Die Antworten sieht niemand außer dir.",
          ziel: "/workspace/befinden.html",
          merkmal: `befinden:${person.id}:${woche}`,
        });
      }
    }

    /* Alte Merkmale aufraeumen -- nach 60 Tagen braucht sie niemand
       mehr, und die Tabelle soll nicht ewig wachsen. */
    const grenze = new Date(Date.now() - 60 * 86400_000).toISOString();
    d.prepare("DELETE FROM push_verschickt WHERE zeit < ?").run(grenze);
  } catch (fehler) {
    console.error("[push] Lauf:", fehler?.message);
  }
  return gesamt;
}

/* ---------------------------------------------------------------------
   Der Takt. Wie bei der Sicherung: im Prozess, kein Systemdienst, kein
   Cron -- eine Sache weniger, die stillschweigend ausfallen kann.
   ------------------------------------------------------------------ */
let takt = null;
export function pushStarten() {
  if (takt) return;
  /* Alle fuenf Minuten. Feiner braucht es nicht: Die feinste
     Erinnerung ist "Termin in einer Stunde". */
  takt = setInterval(() => { laufen().catch(() => {}); }, 5 * 60_000);
  takt.unref?.();
  setTimeout(() => { laufen().catch(() => {}); }, 20_000).unref?.();
}

/* =====================================================================
   Die Schnittstellen
   ===================================================================== */

function angemeldet(req, res, next) {
  const person = sitzungLesen(req);
  if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
  req.person = person;
  next();
}

function gleicheHerkunft(req, res, next) {
  const herkunft = req.get("origin");
  if (!herkunft) return next();
  let erlaubt;
  try { erlaubt = new URL(herkunft).host === req.get("host"); } catch { erlaubt = false; }
  if (!erlaubt) return res.status(403).json({ fehler: "fremde_herkunft" });
  next();
}

pushRouter.use("/workspace/api/push", angemeldet);

/** Was der Browser braucht, um sich anzumelden: der oeffentliche
 *  Schluessel. Der private bleibt hier. */
pushRouter.get("/workspace/api/push/schluessel", (req, res) => {
  try {
    res.json({ schluessel: paarHolen().oeffentlich });
  } catch (fehler) {
    console.error("[push] Schluessel:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Der eigene Stand: angemeldete Geraete und die Einstellungen. */
pushRouter.get("/workspace/api/push/stand", (req, res) => {
  try {
    const geraete = db().prepare(`
      SELECT endpunkt, geraet, erstellt, zuletzt_ok FROM push_anmeldungen
      WHERE person_id = ? ORDER BY erstellt`).all(req.person.id);
    const arten = ARTEN.map((a) => ({
      ...a, an: willHaben(req.person.id, a.schluessel),
      /* Nur dort, wo die Art ueberhaupt einen Wert kennt -- sonst
         staende bei sieben Arten ein `wert: null` in der Antwort und
         jemand baut irgendwann ein Eingabefeld dafuer. */
      ...(a.wertArt ? { wert: wertVon(req.person.id, a.schluessel) } : {}),
    }));
    res.json({
      /* Nur die Anzahl und ein Kuerzel nach aussen -- der volle
         Endpunkt ist die Zustelladresse dieses Geraets und hat in der
         Oberflaeche nichts zu suchen. */
      geraete: geraete.map((g) => ({
        kennung: g.endpunkt.slice(-12),
        geraet: g.geraet || "Unbekanntes Gerät",
        erstellt: g.erstellt, zuletzt_ok: g.zuletzt_ok,
      })),
      arten,
      ruhe: { ab: RUHE_AB, bis: RUHE_BIS, jetzt: istRuhezeit() },
    });
  } catch (fehler) {
    console.error("[push] Stand:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Ein Geraet anmelden. */
pushRouter.post("/workspace/api/push/anmelden", gleicheHerkunft, express.json({ limit: "8kb" }), (req, res) => {
  try {
    const { endpunkt, p256dh, auth, geraet } = req.body || {};
    if (typeof endpunkt !== "string" || !/^https:\/\//.test(endpunkt) || endpunkt.length > 1000) {
      return res.status(400).json({ fehler: "Die Adresse sieht nicht richtig aus." });
    }
    if (typeof p256dh !== "string" || typeof auth !== "string" || !p256dh || !auth) {
      return res.status(400).json({ fehler: "Es fehlen die Schlüssel des Browsers." });
    }

    /* INSERT OR REPLACE auf dem Endpunkt: Meldet sich derselbe Browser
       erneut, wird der Eintrag ersetzt statt verdoppelt -- sonst kaeme
       jede Nachricht mehrfach an. */
    db().prepare(`
      INSERT OR REPLACE INTO push_anmeldungen
        (endpunkt, person_id, p256dh, auth, geraet, erstellt, zuletzt_ok, fehler)
      VALUES (?,?,?,?,?,?,NULL,0)`).run(
      endpunkt, req.person.id, p256dh, auth,
      String(geraet || "").slice(0, 80) || null, jetzt());

    protokolliere("push_angemeldet", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: String(geraet || "").slice(0, 60),
    });
    res.status(201).json({ ok: true });
  } catch (fehler) {
    console.error("[push] Anmelden:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Ein Geraet abmelden. */
pushRouter.post("/workspace/api/push/abmelden", gleicheHerkunft, express.json({ limit: "8kb" }), (req, res) => {
  try {
    const endpunkt = String(req.body?.endpunkt || "");
    /* NUR die eigenen -- sonst koennte man fremde Geraete stumm
       schalten, wenn man deren Adresse kennt. */
    const e = db().prepare("DELETE FROM push_anmeldungen WHERE endpunkt = ? AND person_id = ?")
      .run(endpunkt, req.person.id);
    protokolliere("push_abgemeldet", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
    });
    res.json({ ok: true, entfernt: Number(e.changes) });
  } catch (fehler) {
    console.error("[push] Abmelden:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Eine Art an- oder abschalten. */
pushRouter.put("/workspace/api/push/art", gleicheHerkunft, express.json({ limit: "8kb" }), (req, res) => {
  try {
    const art = String(req.body?.art || "");
    if (!ARTEN_SCHLUESSEL.has(art)) return res.status(400).json({ fehler: "Diese Art gibt es nicht." });
    const an = req.body?.an ? 1 : 0;

    /* DER WERT WIRD NUR ANGEFASST, WENN EINER MITKAM.

       `undefined` und `null` sind hier zweierlei: Wer nur den Schalter
       umlegt, schickt kein `wert` -- die eingestellte Uhrzeit muss
       dann stehen bleiben. Wuerde ich hier stumpf `req.body.wert`
       schreiben, loeschte jedes Ein- und Ausschalten die Uhrzeit, und
       beim naechsten Einschalten staende wieder neun Uhr da. Ein
       stiller Datenverlust, den niemand meldet, weil er wie eine
       Vorgabe aussieht. */
    const definiert = Object.prototype.hasOwnProperty.call(req.body || {}, "wert");
    let wert = null;
    if (definiert) {
      const kennt = ARTEN.find((a) => a.schluessel === art)?.wertArt;
      if (!kennt) return res.status(400).json({ fehler: "Diese Art hat keinen Wert." });
      wert = req.body.wert;
      if (kennt === "uhrzeit" && !istUhrzeit(wert)) {
        return res.status(400).json({ fehler: "Das ist keine Uhrzeit (hh:mm)." });
      }
    }

    if (definiert) {
      db().prepare(`INSERT INTO push_einstellungen (person_id, art, an, wert) VALUES (?,?,?,?)
        ON CONFLICT(person_id, art) DO UPDATE SET an = excluded.an, wert = excluded.wert`)
        .run(req.person.id, art, an, wert);
    } else {
      db().prepare(`INSERT INTO push_einstellungen (person_id, art, an) VALUES (?,?,?)
        ON CONFLICT(person_id, art) DO UPDATE SET an = excluded.an`).run(req.person.id, art, an);
    }
    res.json({ ok: true, art, an: !!an, wert: wertVon(req.person.id, art) });
  } catch (fehler) {
    console.error("[push] Art:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Eine Probe an die eigenen Geraete. Beantwortet die einzige Frage,
 *  die man wirklich hat: Kommt etwas an? */
pushRouter.post("/workspace/api/push/probe", gleicheHerkunft, async (req, res) => {
  try {
    const e = await benachrichtige(req.person.id, "test", {
      titel: "Es funktioniert",
      text: "So sieht eine Benachrichtigung aus dem Workspace aus.",
      ziel: "/workspace/start.html",
    });
    res.json(e);
  } catch (fehler) {
    console.error("[push] Probe:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});