dogfather-universe/server/pruef-manager-ziele.mjs

/* =====================================================================
   MANAGER-ZIELE (02.10.2026)
   =====================================================================

   Geprüft wird, was Filipe bestellt hat — und fünf Dinge, die er nicht
   bestellt hat, weil sie sonst niemandem auffallen:

     * JEDE Sperre muss auch NEIN sagen können. Eine Prüfung, die nur
       den Erfolgsfall ansieht, beweist nichts: `every()` liefert auf
       einem leeren Feld `true`, und ein Trigger, dessen Spaltenname
       falsch ist, lehnt die Änderung ab, ohne je gelaufen zu sein
       (RunOne, 01.09.2026). Zu jeder „geht"-Prüfung steht hier eine
       „geht nicht"-Prüfung.

     * DIE DATUMSLOGIK WIRD MIT EINGESETZTEN TAGEN GEMESSEN, nie gegen
       die Wanduhr. `gate-oeffnung.mjs` im Shop war grün, bis der
       Kalender sie überholte, und dann rot, ohne dass etwas kaputt
       war. Hier liegen die Tage als Zahl im Aufruf — diese Prüfung
       sagt am 16. November dasselbe wie heute.

     * DIE ZAHL DER GEPRÜFTEN DINGE STEHT IN DER BEDINGUNG, nicht nur
       im Meldetext. „Alle Rollen abgewiesen" ist auf einer leeren
       Liste wahr.

     * DIE BEIDEN HÄUSER BLEIBEN GETRENNT. Auf der Crew-Adresse gibt es
       diese Kachel nicht, auch nicht für DogFather.

     * DER MONATSSCHNITT ÄNDERT DEN VERLAUF NICHT. Wer die Zielzahlen
       erhöht, darf einen abgeschlossenen Monat nicht nachträglich auf
       „nicht erreicht" drehen.
   ===================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-mz-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");

import { notbremse } from "./helfer-notbremse.mjs";
const { eigenerPort } = await import("./helfer-port.mjs");
const PORT = await eigenerPort(import.meta, "die Pruefung der Manager-Ziele");

process.env.PORT = `${PORT}`;
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";

const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
await import("./index.js");
notbremse(240_000, "pruef-manager-ziele");
await new Promise((r) => setTimeout(r, 900));
const BASIS = `http://127.0.0.1:${PORT}`;
const API = "/workspace/api/manager-ziele";

let fehler = 0, geprueft = 0;
const ok = (b, t) => { geprueft++; console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };
const melde = (t) => console.log(t);

/* DER DRITTE AUSGANG. Kann die Prüfung ihre Voraussetzung nicht
   herstellen, ist das WEDER in Ordnung NOCH ein Befund am Code --
   sie muss es sagen und abbrechen, statt grün zu melden. */
function braucht(bedingung, was) {
  if (bedingung) return;
  console.log(`\nABBRUCH: konnte nicht nachsehen — ${was}`);
  console.log("Das ist KEIN Befund am Code. Die Pruefung konnte ihre");
  console.log("Voraussetzung nicht herstellen und sagt das, statt zu schweigen.\n");
  try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
  process.exit(2);
}

/* ---------- Personen anlegen ---------------------------------------- */
const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes, createHmac } = await import("node:crypto");
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetztIso = new Date().toISOString();
const kennSchluessel = randomBytes(32).toString("hex");
d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
  + " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
  .run("code_kennung_schluessel", kennSchluessel, jetztIso);

/* ERSTELLT: ein Jahr alt. Sonst wären alle erst im Folgemonat
   pflichtig (Regel 09 der Vorlage) und jede Ampelprüfung wäre
   neutral — die Prüfung sähe grün aus und hätte nichts gemessen. */
const ALT = new Date(Date.now() - 365 * 86400_000).toISOString();

function anlegen(name, rolle, code, erstellt = ALT) {
  const salt = randomBytes(16).toString("hex");
  const hash = scryptSync(code, salt, 64,
    { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
  d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n,"
    + " code_kennung, aktiv, erstellt) VALUES (?,?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768,
      createHmac("sha256", kennSchluessel).update(code).digest("hex"), erstellt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}

const ROLLEN = [
  ["admin", "Filipe"], ["spicy", "Spicy Media"], ["manager", "Patrick"],
  ["scout", "Kevin"], ["scout", "Sandra"], ["creator", "Luna"],
  ["hand", "VanVan"], ["modi", "Miss"],
];
const CODES = {}, IDS = {};
for (const [i, [rolle, name]] of ROLLEN.entries()) {
  const schluessel = IDS[rolle] === undefined ? rolle : `${rolle}2`;
  CODES[schluessel] = `CODE-Z${String(i).padStart(2, "0")}-000001`;
  IDS[schluessel] = anlegen(name, rolle, CODES[schluessel]);
}
d.close();

/* ---------- Anmelden ------------------------------------------------- */
const { request } = await import("node:http");
const CREW_HOST = "crew.dogfather-universe.com";

function roh(pfad, host, koerper, methode) {
  return new Promise((fertig, schief) => {
    const daten = koerper ? JSON.stringify(koerper) : null;
    const a = request({
      host: "127.0.0.1", port: PORT, path: pfad,
      method: methode || (daten ? "POST" : "GET"),
      headers: {
        ...(host ? { Host: host } : {}),
        Origin: host ? `https://${host}` : BASIS,
        ...(daten ? { "Content-Type": "application/json",
          "Content-Length": Buffer.byteLength(daten) } : {}),
      },
    }, (antwort) => {
      let text = "";
      antwort.on("data", (t) => { text += t; });
      antwort.on("end", () => fertig({ code: antwort.statusCode, kopf: antwort.headers, text }));
    });
    a.on("error", schief);
    if (daten) a.write(daten);
    a.end();
  });
}

/** Derselbe Aufruf mit Hausadresse UND Sitzung. `fetch` verwirft den
 *  Host-Kopf (er steht auf der Liste der verbotenen Kopfzeilen), also
 *  geht das nur ueber node:http. */
function rohMitKeks(pfad, host, keks) {
  return new Promise((fertig, schief) => {
    const a = request({
      host: "127.0.0.1", port: PORT, path: pfad, method: "GET",
      headers: { Host: host, Origin: `https://${host}`, Cookie: keks || "" },
    }, (antwort) => {
      let text = "";
      antwort.on("data", (t) => { text += t; });
      antwort.on("end", () => fertig({ code: antwort.statusCode, text }));
    });
    a.on("error", schief);
    a.end();
  });
}

async function anmelden(schluessel, rolle, host = null) {
  const r = await roh("/workspace/api/anmelden", host, { rolle, code: CODES[schluessel] });
  if (r.code !== 200) return null;
  return [].concat(r.kopf["set-cookie"] || []).map((z) => z.split(";")[0]).join("; ") || null;
}

const kekse = {};
melde("\n=== Alle Rollen kommen herein ===");
for (const schluessel of Object.keys(CODES)) {
  const rolle = schluessel.replace(/2$/, "");
  kekse[schluessel] = await anmelden(schluessel, rolle);
  ok(!!kekse[schluessel], `${schluessel}: angemeldet`);
}
braucht(Object.values(kekse).every(Boolean), "nicht alle Rollen konnten sich anmelden");

async function hol(schluessel, pfad, einst = {}) {
  return fetch(BASIS + pfad, {
    ...einst,
    headers: {
      Cookie: kekse[schluessel] || "", Origin: BASIS,
      ...(einst.body ? { "Content-Type": "application/json" } : {}),
      ...(einst.headers || {}),
    },
  });
}
const schick = (schluessel, pfad, methode, rumpf) =>
  hol(schluessel, pfad, { method: methode, body: JSON.stringify(rumpf) });

/* =====================================================================
   1 · WER DARF HEREIN — und wer ausdrücklich nicht
   ===================================================================== */
melde("\n=== Sichtbarkeit: vier Rollen ja, der Rest nein ===");
const DUERFEN = ["admin", "spicy", "manager", "scout"];
const DUERFEN_NICHT = ["creator", "hand", "modi"];

let drin = 0;
for (const r of DUERFEN) {
  const a = await hol(r, `${API}/stand`);
  if (a.status === 200) drin++;
  ok(a.status === 200, `${r} kommt an den Stand (${a.status})`);
}
/* DIE ZAHL STEHT IN DER BEDINGUNG. „Alle durchgelassen" wäre auf einer
   leeren Liste wahr. */
ok(drin === DUERFEN.length, `genau ${DUERFEN.length} Rollen kommen herein (${drin})`);

let draussen = 0;
for (const r of DUERFEN_NICHT) {
  const a = await hol(r, `${API}/stand`);
  if (a.status === 404) draussen++;
  ok(a.status === 404, `${r} bekommt 404 (nicht 403) (${a.status})`);
}
ok(draussen === DUERFEN_NICHT.length,
  `genau ${DUERFEN_NICHT.length} Rollen bleiben draussen (${draussen})`);

melde("\n=== Die Seite selbst ist ebenfalls zu ===");
const seiteCreator = await hol("creator", "/workspace/manager-ziele.html", { redirect: "manual" });
ok(seiteCreator.status === 302,
  `Creator wird von der Seite weggeschickt (${seiteCreator.status})`);
const seiteScout = await hol("scout", "/workspace/manager-ziele.html", { redirect: "manual" });
ok(seiteScout.status === 200, `Scout bekommt die Seite (${seiteScout.status})`);

melde("\n=== Zwei getrennte Haeuser: auf crew. gibt es die Kachel nicht ===");
const crewKeks = await anmelden("admin", "admin", CREW_HOST);
braucht(!!crewKeks, "DogFather konnte sich auf der Crew-Adresse nicht anmelden");
/* DER KEKS MUSS MIT. Beim ersten Lauf stand hier 401 statt 404 --
   und das sah aus wie ein Befund an der Haustrennung. Es war einer an
   meiner Messung: Ohne Sitzung kommt man ueberall nicht herein, das
   beweist nichts ueber DIESE Kachel. */
const crewStand = await rohMitKeks(`${API}/stand`, CREW_HOST, crewKeks);
ok(crewStand.code === 404,
  `DogFather bekommt auf crew. ein 404 auf die Schnittstelle (${crewStand.code})`);
const crewMitKeks = await rohMitKeks("/workspace/start.html", CREW_HOST, crewKeks);
ok(crewMitKeks.code === 200,
  `…und ist dort trotzdem angemeldet (${crewMitKeks.code}) — die Sitzung war es nicht`);

/* =====================================================================
   2 · DIE AMPEL — reine Rechnung, mit eingesetzten Tagen
   ===================================================================== */
melde("\n=== Die Ampel (eingesetzte Tage, nicht die Wanduhr) ===");
const mz = await import("./workspace-manager-ziele.js");

/* Ein Monat mit 31 Tagen. `bisEnde = letzter - tag`. */
const L = 31;
ok(mz.stufeFuer(3, 3, 5, L) === "gruen",     "Ziel erreicht am 5. -> gruen");
ok(mz.stufeFuer(4, 3, 5, L) === "gruen",     "uebererfuellt (4/3) -> gruen");
ok(mz.stufeFuer(0, 3, 1, L) === "neutral",   "Tag 1, offen -> neutral");
ok(mz.stufeFuer(1, 3, 15, L) === "neutral",  "Tag 15, offen -> neutral");
ok(mz.stufeFuer(1, 3, 16, L) === "orange",   "Tag 16, offen -> orange");
ok(mz.stufeFuer(1, 3, 23, L) === "orange",   "Tag 23 (8 Tage uebrig) -> noch orange");
ok(mz.stufeFuer(1, 3, 24, L) === "rot",      "Tag 24 (7 Tage uebrig) -> rot");
ok(mz.stufeFuer(1, 3, 31, L) === "rot",      "letzter Tag, offen -> rot");
ok(mz.stufeFuer(0, 0, 31, L) === "aus",      "Ziel 0 -> aus, nie eine Warnung");
/* GEGENPROBE: Die Rechnung muss auch dann rot sagen koennen, wenn der
   16. gar nicht erreicht wurde -- in einem kurzen Monat. */
ok(mz.stufeFuer(0, 1, 21, 28) === "rot",     "Februar, Tag 21 (7 uebrig) -> rot");
ok(mz.stufeFuer(0, 1, 13, 28) === "neutral", "Februar, Tag 13 -> neutral");

ok(mz.stufenText("rot", 0) === "Dringend – heute ist der letzte Tag",
  "der letzte Tag bekommt seinen eigenen Satz");
ok(mz.stufenText("rot", 1) === "Dringend – noch 1 Tag", "Einzahl bei einem Tag");
ok(mz.stufenText("rot", 5) === "Dringend – noch 5 Tage", "Mehrzahl ab zwei Tagen");
ok(mz.stufenText("orange", 9) === "Sollte bis Monatsmitte erledigt sein",
  "der Orange-Satz steht woertlich wie in der Vorlage");
ok(mz.stufenText("neutral", 20) === "", "neutral sagt ausdruecklich nichts");

ok(mz.schlechteste(["gruen", "neutral", "rot"]) === "rot",
  "die Kachel traegt die schlechteste Farbe");
ok(mz.schlechteste(["gruen", "aus"]) === "gruen",
  "eine abgeschaltete Aufgabe verschlechtert nichts");

melde("\n=== Monatsrechnung ===");
ok(mz.letzterTagVon("2026-02") === 28, "Februar 2026 hat 28 Tage");
ok(mz.letzterTagVon("2024-02") === 29, "Februar 2024 hat 29 Tage");
ok(mz.letzterTagVon("2026-10") === 31, "Oktober hat 31 Tage");
ok(mz.monatPlus("2026-12", 1) === "2027-01", "Dezember + 1 = Januar des Folgejahres");
ok(mz.monatPlus("2026-01", -1) === "2025-12", "Januar - 1 = Dezember des Vorjahres");
/* Die Zeitzone: ein Zeitpunkt, der in UTC noch zum Vortag gehoert,
   aber in Berlin schon zum naechsten Tag. Ohne Europe/Berlin faende
   diese Zeile den falschen Tag -- und am Monatsersten den falschen
   Monat. */
ok(mz.tagBerlin(new Date("2026-06-30T23:30:00Z")) === "2026-07-01",
  "23:30 UTC am 30.06. ist in Berlin schon der 1. Juli");

/* =====================================================================
   3 · EINTRAGEN
   ===================================================================== */
melde("\n=== Eintragen ===");
const standVorher = await (await hol("scout", `${API}/stand`)).json();
braucht(standVorher && Array.isArray(standVorher.aufgaben),
  "der Stand kam nicht als Liste zurueck");
const MONAT = standVorher.monat;
const HEUTE = standVorher.heute;
ok(standVorher.aufgaben.length === 4, `vier Aufgaben (${standVorher.aufgaben.length})`);
ok(standVorher.pflichtig === true, "ein ein Jahr alter Scout ist pflichtig");

const vorherCreator = standVorher.aufgaben.find((a) => a.schluessel === "creator");
ok(vorherCreator.ziel === 3, `Vorgabe fuer Creator ist 3 (${vorherCreator.ziel})`);
ok(vorherCreator.zahl === 0, "noch nichts eingetragen");

const neu1 = await schick("scout", `${API}/eintrag`, "POST",
  { aufgabe: "creator", datum: HEUTE, name: "@LunaTanzt", notiz: "über Discord gefunden" });
const neu1d = await neu1.json();
ok(neu1.status === 201, `Creator-Eintrag angelegt (${neu1.status})`);
ok(neu1d.stand?.aufgaben?.find((a) => a.schluessel === "creator")?.zahl === 1,
  "der Zaehler steht sofort auf 1 (ohne Neuladen)");

for (const [aufgabe, rumpf] of [
  ["meeting", { datum: HEUTE }],
  ["schulung", { datum: HEUTE, art: "talk" }],
  ["werbung", { datum: HEUTE, art: "agentur", link: "https://www.tiktok.com/@dogi/video/123" }],
]) {
  const a = await schick("scout", `${API}/eintrag`, "POST", { aufgabe, ...rumpf });
  ok(a.status === 201, `${aufgabe}: angelegt (${a.status})`);
}

const standNachher = await (await hol("scout", `${API}/stand`)).json();
ok(standNachher.gesamt.erledigt === 4,
  `Gesamtfortschritt 4 von 8 (${standNachher.gesamt.erledigt} von ${standNachher.gesamt.ziel})`);
ok(standNachher.gesamt.ziel === 8, "Zielsumme 3+2+2+1 = 8");
ok(standNachher.aufgaben.find((a) => a.schluessel === "werbung").stufe === "gruen",
  "Werbung (1 von 1) steht auf gruen");

/* =====================================================================
   4 · WAS ABGELEHNT WERDEN MUSS — die Gegenproben
   ===================================================================== */
melde("\n=== Abgelehnt wird, was abgelehnt gehoert ===");
const morgen = new Date(Date.parse(HEUTE + "T12:00:00Z") + 86400_000).toISOString().slice(0, 10);
const fremderMonat = `${mz.monatPlus(MONAT, -1)}-15`;

const absagen = [
  ["Datum in der Zukunft", { aufgabe: "meeting", datum: morgen }, "datum_zukunft"],
  ["Datum aus dem Vormonat", { aufgabe: "meeting", datum: fremderMonat }, "datum_fremder_monat"],
  ["gar kein Datum", { aufgabe: "meeting", datum: "" }, "datum_fehlt"],
  ["Creator ohne Namen", { aufgabe: "creator", datum: HEUTE, name: " " }, "name_fehlt"],
  ["Werbung ohne Link", { aufgabe: "werbung", datum: HEUTE, art: "eigen", link: "" }, "link_ungueltig"],
  ["Werbung mit javascript:", { aufgabe: "werbung", datum: HEUTE, art: "eigen",
    link: "javascript:alert(1)" }, "link_ungueltig"],
  ["Werbung mit blossem Wort", { aufgabe: "werbung", datum: HEUTE, art: "eigen",
    link: "tiktok" }, "link_ungueltig"],
  ["Schulung ohne Art", { aufgabe: "schulung", datum: HEUTE, art: "" }, "art_fehlt"],
  ["Aufgabe, die es nicht gibt", { aufgabe: "kaffee", datum: HEUTE }, "aufgabe_unbekannt"],
];
let abgelehnt = 0;
for (const [was, rumpf, grund] of absagen) {
  const a = await schick("scout", `${API}/eintrag`, "POST", rumpf);
  const j = await a.json().catch(() => ({}));
  const richtig = a.status === 400 && j.fehler === grund;
  if (richtig) abgelehnt++;
  ok(richtig, `${was} -> abgelehnt mit „${grund}" (${a.status}/${j.fehler})`);
}
ok(abgelehnt === absagen.length,
  `alle ${absagen.length} Absagen kamen mit dem richtigen Grund (${abgelehnt})`);

/* EINE GUELTIGE FREMDE ADRESSE MUSS DURCH -- Filipe am 02.10.2026:
   „jede gültige Internetadresse". Ohne diese Zeile bewiese der Block
   darueber nur, dass die Pruefung streng ist, nicht dass sie richtig
   ist. */
const fremdLink = await schick("scout", `${API}/eintrag`, "POST",
  { aufgabe: "werbung", datum: HEUTE, art: "eigen", link: "https://www.instagram.com/p/abc" });
ok(fremdLink.status === 201,
  `eine Instagram-Adresse wird angenommen (${fremdLink.status}) — nicht nur TikTok`);

melde("\n=== Dubletten ===");
const doppelt = await schick("scout", `${API}/eintrag`, "POST",
  { aufgabe: "creator", datum: HEUTE, name: "lunatanzt" });
const doppeltD = await doppelt.json().catch(() => ({}));
ok(doppelt.status === 409 && doppeltD.fehler === "schon_eingetragen",
  `„lunatanzt" gilt als derselbe wie „@LunaTanzt" (${doppelt.status})`);

const anderer = await schick("scout2", `${API}/eintrag`, "POST",
  { aufgabe: "creator", datum: HEUTE, name: "@LunaTanzt" });
const andererD = await anderer.json().catch(() => ({}));
ok(anderer.status === 201, `eine ANDERE Person darf denselben Namen eintragen (${anderer.status})`);
ok(!!andererD.warnung, "…bekommt aber einen Hinweis, dass es jemand anders auch hat");

const neuerName = await schick("scout", `${API}/eintrag`, "POST",
  { aufgabe: "creator", datum: HEUTE, name: "@ZweiterCreator" });
ok(neuerName.status === 201, `ein anderer Name geht weiterhin (${neuerName.status})`);

/* =====================================================================
   5 · AENDERN UND LOESCHEN
   ===================================================================== */
melde("\n=== Aendern und Loeschen ===");
const liste = await (await hol("scout", `${API}/eintraege?monat=${MONAT}&aufgabe=creator`)).json();
braucht(liste.eintraege?.length >= 2, "es gibt zu wenige Eintraege zum Aendern");
const einId = liste.eintraege.find((e) => e.name === "@ZweiterCreator").id;

const geaendert = await schick("scout", `${API}/eintrag/${einId}`, "PATCH",
  { datum: HEUTE, name: "@ZweiterCreatorNeu", notiz: "Name berichtigt" });
ok(geaendert.status === 200, `eigener Eintrag geaendert (${geaendert.status})`);

const fremdAendern = await schick("manager", `${API}/eintrag/${einId}`, "PATCH",
  { datum: HEUTE, name: "@Geklaut" });
ok(fremdAendern.status === 403,
  `ein Manager kann einen fremden Eintrag NICHT aendern (${fremdAendern.status})`);

const adminAendern = await schick("admin", `${API}/eintrag/${einId}`, "PATCH",
  { datum: HEUTE, name: "@VonDogfatherBerichtigt" });
ok(adminAendern.status === 200, `DogFather darf korrigieren (${adminAendern.status})`);

const dd = new DatabaseSync(process.env.WORKSPACE_DB, { readOnly: true });
const protokolliert = dd.prepare(
  "SELECT COUNT(*) n FROM protokoll WHERE aktion = 'manager_ziele_korrigiert'").get().n;
dd.close();
ok(protokolliert >= 1, `jede Korrektur steht im Protokoll (${protokolliert})`);

const fremdLoeschen = await hol("manager", `${API}/eintrag/${einId}`, { method: "DELETE" });
ok(fremdLoeschen.status === 403,
  `ein Manager kann einen fremden Eintrag NICHT loeschen (${fremdLoeschen.status})`);

const vorLoeschen = await (await hol("scout", `${API}/stand`)).json();
const geloescht = await hol("scout", `${API}/eintrag/${einId}`, { method: "DELETE" });
const geloeschtD = await geloescht.json().catch(() => ({}));
ok(geloescht.status === 200, `eigener Eintrag geloescht (${geloescht.status})`);
ok(geloeschtD.stand?.aufgaben?.find((a) => a.schluessel === "creator")?.zahl
   === vorLoeschen.aufgaben.find((a) => a.schluessel === "creator").zahl - 1,
  "der Zaehler geht nach dem Loeschen um genau eins zurueck");

/* =====================================================================
   6 · DER MONATSSCHNITT — die Sperre muss wirklich sperren
   ===================================================================== */
melde("\n=== Vergangene Monate sind zu ===");
const VORMONAT = mz.monatPlus(MONAT, -1);

/* Eine Zeile aus dem Vormonat einsetzen. Das geht NUR mit geoeffneter
   Freigabe -- und genau das ist schon die erste Gegenprobe: Ohne sie
   lehnt der Trigger ab. */
const db2 = new DatabaseSync(process.env.WORKSPACE_DB);
let triggerHaelt = false;
try {
  db2.prepare("INSERT INTO mz_eintrag (person_id, aufgabe, monat, datum, erstellt)"
    + " VALUES (?,?,?,?,?)").run(IDS.scout, "meeting", VORMONAT, `${VORMONAT}-05`, jetztIso);
} catch (f) {
  triggerHaelt = String(f?.message || "").includes("monat_gesperrt");
}
ok(triggerHaelt,
  "die DATENBANK lehnt einen Eintrag im Vormonat ab (nicht erst der Code)");

const weit = new Date(Date.now() + 600_000).toISOString().replace("T", " ").slice(0, 19);
db2.prepare("UPDATE mz_freigabe SET offen = 1, bis = ? WHERE eins = 1").run(weit);
/* Name und Rolle stehen mit drin -- genau so, wie der Server es tut.
   Ohne sie waere dieser Eintrag der einzige ohne, und die Pruefung
   weiter unten („an allen Eintraegen stehen Name und Rolle") haette
   einen Fehler gemeldet, den nur diese Zeile verursacht hat. */
db2.prepare("INSERT INTO mz_eintrag (person_id, von_name, von_rolle, aufgabe, monat, datum, erstellt)"
  + " VALUES (?,?,?,?,?,?,?)")
  .run(IDS.scout, "Kevin", "scout", "meeting", VORMONAT, `${VORMONAT}-05`, jetztIso);
const altId = db2.prepare("SELECT last_insert_rowid() AS id").get().id;
db2.prepare("UPDATE mz_freigabe SET offen = 0, bis = NULL WHERE eins = 1").run();
db2.close();
braucht(!!altId, "es liess sich keine Zeile im Vormonat anlegen");

const altAendern = await schick("scout", `${API}/eintrag/${altId}`, "PATCH",
  { datum: `${VORMONAT}-06` });
ok(altAendern.status === 409,
  `ein Scout kann im Vormonat nichts mehr aendern (${altAendern.status})`);
const altLoeschen = await hol("scout", `${API}/eintrag/${altId}`, { method: "DELETE" });
ok(altLoeschen.status === 409,
  `…und auch nichts loeschen (${altLoeschen.status})`);

const altAdmin = await schick("admin", `${API}/eintrag/${altId}`, "PATCH",
  { datum: `${VORMONAT}-07`, notiz: "Korrektur im Nachhinein" });
ok(altAdmin.status === 200,
  `DogFather darf auch im Vormonat korrigieren (${altAdmin.status})`);

/* UND DIE FREIGABE IST DANACH WIEDER ZU. Ein Schloss, das offen
   bleibt, ist dasselbe wie keines. */
const db3 = new DatabaseSync(process.env.WORKSPACE_DB, { readOnly: true });
const freigabe = db3.prepare("SELECT offen FROM mz_freigabe WHERE eins = 1").get();
db3.close();
ok(freigabe.offen === 0, `die Freigabe steht nach der Korrektur wieder auf zu (${freigabe.offen})`);

const altNochmal = await schick("scout", `${API}/eintrag/${altId}`, "PATCH",
  { datum: `${VORMONAT}-08` });
ok(altNochmal.status === 409,
  `der Scout kommt auch danach nicht hinein (${altNochmal.status}) — die Freigabe wirkte nur einmal`);

/* SPICY MEDIA DARF SEIT DEM 02.10.2026 DASSELBE WIE DOGFATHER.
   Filipe auf die Rueckfrage, wer korrigieren darf: „ja spicy und
   dogfather". Geprueft wird beides -- dass Spicy hineinkommt UND
   dass die Freigabe danach wieder zu ist. Nur das erste zu pruefen
   hiesse, eine geoeffnete Tuer fuer einen Erfolg zu halten. */
const altSpicy = await schick("spicy", `${API}/eintrag/${altId}`, "PATCH",
  { datum: `${VORMONAT}-09`, notiz: "Korrektur durch Spicy Media" });
ok(altSpicy.status === 200,
  `Spicy Media darf im Vormonat ebenfalls korrigieren (${altSpicy.status})`);
const db2b = new DatabaseSync(process.env.WORKSPACE_DB, { readOnly: true });
const freigabeNachSpicy = db2b.prepare("SELECT offen FROM mz_freigabe WHERE eins = 1").get();
db2b.close();
ok(freigabeNachSpicy.offen === 0,
  `…und die Freigabe ist auch danach wieder zu (${freigabeNachSpicy.offen})`);

/* UND DIE GRENZE HAELT WEITERHIN: Ein Manager ist keine Leitung. */
const altManager = await schick("manager", `${API}/eintrag/${altId}`, "PATCH",
  { datum: `${VORMONAT}-10` });
ok(altManager.status === 403 || altManager.status === 409,
  `ein Manager kommt dort weiterhin nicht hinein (${altManager.status})`);

/* =====================================================================
   7 · DIE ZIELZAHLEN
   ===================================================================== */
melde("\n=== Zielzahlen: aenderbar, aber erst ab naechstem Monat ===");
const zieleScout = await hol("scout", `${API}/ziele`);
ok(zieleScout.status === 403, `ein Scout sieht die Zielzahlen nicht (${zieleScout.status})`);
const zieleManager = await hol("manager", `${API}/ziele`);
ok(zieleManager.status === 403, `ein Manager auch nicht (${zieleManager.status})`);

for (const r of ["admin", "spicy"]) {
  const a = await hol(r, `${API}/ziele`);
  ok(a.status === 200, `${r} darf die Zielzahlen sehen (${a.status})`);
}

const vorAenderung = await (await hol("scout", `${API}/stand`)).json();
const zielVorher = vorAenderung.aufgaben.find((a) => a.schluessel === "creator").ziel;

const gesetzt = await schick("spicy", `${API}/ziele`, "PUT",
  { ziele: { scout: { creator: 9 }, admin: { creator: 0 } } });
const gesetztD = await gesetzt.json().catch(() => ({}));
ok(gesetzt.status === 200, `Spicy Media darf die Zielzahlen setzen (${gesetzt.status})`);
ok(gesetztD.monat === mz.monatPlus(MONAT, 1),
  `gespeichert wird fuer den NAECHSTEN Monat (${gesetztD.monat})`);

const nachAenderung = await (await hol("scout", `${API}/stand`)).json();
ok(nachAenderung.aufgaben.find((a) => a.schluessel === "creator").ziel === zielVorher,
  `der laufende Monat bleibt bei ${zielVorher} — eine Aenderung wirkt NICHT rueckwirkend`);

const zieleJetzt = await (await hol("admin", `${API}/ziele`)).json();
ok(zieleJetzt.naechster.find((r) => r.rolle === "scout").ziele.creator === 9,
  "im naechsten Monat steht beim Scout die 9");
ok(zieleJetzt.jetzt.find((r) => r.rolle === "scout").ziele.creator === zielVorher,
  "im laufenden Monat steht dort weiterhin die alte Zahl");

const unsinn = await schick("admin", `${API}/ziele`, "PUT", { ziele: { scout: { creator: 500 } } });
ok(unsinn.status === 400, `eine Zielzahl von 500 wird abgelehnt (${unsinn.status})`);
const negativ = await schick("admin", `${API}/ziele`, "PUT", { ziele: { scout: { creator: -1 } } });
ok(negativ.status === 400, `eine negative Zielzahl wird abgelehnt (${negativ.status})`);

/* =====================================================================
   8 · DIE TEAM-UEBERSICHT UND DER EXPORT
   ===================================================================== */
melde("\n=== Team-Uebersicht ===");
for (const r of ["manager", "scout"]) {
  const a = await hol(r, `${API}/team`);
  ok(a.status === 403, `${r} sieht die Team-Uebersicht nicht (${a.status})`);
}
const team = await hol("admin", `${API}/team`);
const teamD = await team.json();
ok(team.status === 200, `DogFather sieht die Team-Uebersicht (${team.status})`);
ok(teamD.leute.length === 5,
  `fuenf pflichtige Personen in der Liste (${teamD.leute.length}) — Creator, Hand und Modi fehlen zu Recht`);
ok(teamD.leute.every((p) => ["spicy", "admin", "manager", "scout"].includes(p.rolle)),
  "und keine einzige fremde Rolle darunter");

const spicyTeam = await hol("spicy", `${API}/team`);
ok(spicyTeam.status === 200, `Spicy Media ebenfalls (${spicyTeam.status})`);

const fremdeSicht = await hol("scout", `${API}/stand?person=${IDS.scout2}`);
const fremdeSichtD = await fremdeSicht.json();
ok(fremdeSichtD.person?.id === IDS.scout,
  "ein Scout, der eine fremde Nummer in die Adresse schreibt, sieht trotzdem nur sich selbst");

melde("\n=== CSV-Export ===");
const csvScout = await hol("scout", `${API}/export.csv`);
ok(csvScout.status === 403, `ein Scout bekommt keinen Export (${csvScout.status})`);
const csv = await hol("admin", `${API}/export.csv?monat=${MONAT}`);
/* IN BYTES GEMESSEN, nicht in Zeichen. `Response.text()` entfernt ein
   fuehrendes BOM beim Dekodieren -- die Pruefung meldete deshalb beim
   ersten Lauf "kein BOM", obwohl es da war. Das war ein Fehler an der
   Messung, nicht am Export. */
const csvBytes = new Uint8Array(await csv.clone().arrayBuffer());
const csvText = await csv.text();
ok(csv.status === 200, `DogFather bekommt den Export (${csv.status})`);
ok(csvBytes[0] === 0xEF && csvBytes[1] === 0xBB && csvBytes[2] === 0xBF,
  `die Datei beginnt mit dem BOM (${[...csvBytes.slice(0, 3)].map((b) => b.toString(16)).join(" ")}) — sonst zeigt deutsches Excel kaputte Umlaute`);
ok(csvText.split("\n")[0].includes(";"),
  "getrennt wird mit Semikolon — sonst steht alles in einer Spalte");
const csvZeilen = csvText.trim().split(/\r?\n/);
ok(csvZeilen.length === teamD.leute.length + 1,
  `eine Kopfzeile und ${teamD.leute.length} Personen (${csvZeilen.length} Zeilen)`);
ok((csv.headers.get("content-disposition") || "").includes(`manager-ziele-${MONAT}.csv`),
  "der Dateiname trägt den Monat");

/* =====================================================================
   9 · DIE PIPELINE-BRUECKE
   ===================================================================== */
melde("\n=== Die Bruecke zur Scout-Pipeline ===");
const db4 = new DatabaseSync(process.env.WORKSPACE_DB);
db4.prepare(`INSERT INTO leads (name, handle, status, scout_id, erstellt, erstellt_von, uebergeben_am)
             VALUES (?,?,?,?,?,?,?)`)
  .run("Mara K.", "@maratanzt", "uebergeben", IDS.scout, jetztIso, IDS.scout, `${HEUTE}T10:00:00Z`);
const leadId = db4.prepare("SELECT last_insert_rowid() AS id").get().id;
/* Ein Lead, der jemand ANDEREM gehoert -- fuer die Gegenprobe. */
db4.prepare(`INSERT INTO leads (name, handle, status, scout_id, erstellt, erstellt_von, uebergeben_am)
             VALUES (?,?,?,?,?,?,?)`)
  .run("Fremd F.", "@fremd", "uebergeben", IDS.scout2, jetztIso, IDS.scout2, `${HEUTE}T10:00:00Z`);
const fremdLeadId = db4.prepare("SELECT last_insert_rowid() AS id").get().id;
db4.close();
braucht(!!leadId && !!fremdLeadId, "die Leads liessen sich nicht anlegen");

const vorschlaege = await (await hol("scout", `${API}/vorschlaege`)).json();
ok(vorschlaege.vorschlaege.some((v) => v.id === leadId),
  "der eigene uebergebene Lead steht als Vorschlag da");
ok(!vorschlaege.vorschlaege.some((v) => v.id === fremdLeadId),
  "ein fremder Lead steht NICHT darin");

const uebernommen = await schick("scout", `${API}/eintrag`, "POST",
  { aufgabe: "creator", datum: HEUTE, name: "@maratanzt", lead_id: leadId });
ok(uebernommen.status === 201, `der Lead laesst sich uebernehmen (${uebernommen.status})`);

const danach = await (await hol("scout", `${API}/vorschlaege`)).json();
ok(!danach.vorschlaege.some((v) => v.id === leadId),
  "…und verschwindet danach aus den Vorschlaegen");

/* GEGENPROBE: Eine fremde Lead-Nummer im Rumpf darf nicht uebernommen
   werden -- der Eintrag entsteht, aber OHNE die Verbindung. Eine
   Nummer in einem Formular ist kein Besitznachweis. */
const mitFremd = await schick("scout", `${API}/eintrag`, "POST",
  { aufgabe: "creator", datum: HEUTE, name: "@nochwer", lead_id: fremdLeadId });
ok(mitFremd.status === 201, `der Eintrag entsteht trotzdem (${mitFremd.status})`);
const db5 = new DatabaseSync(process.env.WORKSPACE_DB, { readOnly: true });
const ohneVerbindung = db5.prepare(
  "SELECT lead_id FROM mz_eintrag WHERE name = ?").get("@nochwer");
const mitVerbindung = db5.prepare(
  "SELECT lead_id FROM mz_eintrag WHERE name = ?").get("@maratanzt");
db5.close();
ok(ohneVerbindung?.lead_id === null,
  "…aber die fremde Lead-Verbindung wird verworfen");
ok(mitVerbindung?.lead_id === leadId,
  "die eigene Verbindung dagegen bleibt gespeichert");

const treffer = await (await hol("scout", `${API}/namen?q=mara`)).json();
ok(treffer.treffer.some((t) => t.id === leadId),
  "beim Tippen schlaegt die eigene Pipeline den Namen vor");
const trefferFremd = await (await hol("scout", `${API}/namen?q=fremd`)).json();
ok(!trefferFremd.treffer.length,
  "fremde Leads werden beim Tippen NICHT vorgeschlagen");

/* =====================================================================
   10 · DIE ERINNERUNGEN
   ===================================================================== */
melde("\n=== Die Erinnerungen (eingesetzte Tage) ===");
const { ARTEN } = await import("./workspace-push.js");
ok(ARTEN.some((a) => a.schluessel === "manager_ziele"),
  "es gibt eine eigene, abschaltbare Benachrichtigungsart");

/* `zielRufe` bekommt das Datum als Argument -- dadurch misst diese
   Prüfung dasselbe, egal an welchem Tag sie läuft. Gerechnet wird in
   Berlin, deshalb 12:00 UTC: Da ist der Tag in beiden Zeitzonen
   derselbe. */
const amTag = (tag) => new Date(`${MONAT}-${String(tag).padStart(2, "0")}T12:00:00Z`);
const letzterTag = mz.letzterTagVon(MONAT);

const rufe1 = mz.zielRufe(amTag(1));
ok(rufe1.length > 0, `am 1. geht eine Meldung an alle mit offenen Zielen (${rufe1.length})`);
ok(rufe1.every((r) => r.merkmal.includes(`${MONAT}-01`) || r.merkmal.endsWith(":fertig")),
  "das Merkmal enthaelt den TAG — dadurch kann es hoechstens eine pro Tag geben");
ok(rufe1.some((r) => r.titel === "Neuer Monat"), "…mit dem Titel aus der Vorlage");
ok(rufe1.every((r) => r.ziel === "/workspace/manager-ziele.html"),
  "jede Meldung fuehrt direkt zur Kachel");

const RUF_TAGE = [
  [1, "Neuer Monat"], [10, "Kurze Erinnerung"],
  [15, "Heute ist Stichtag Monatsmitte"], [16, "Monatsmitte ist vorbei"],
  [letzterTag - 7, "Dringend – noch 7 Tage"],
  [letzterTag - 2, "Noch 2 Tage"], [letzterTag - 1, "Noch 1 Tag"],
  [letzterTag, "Letzter Tag des Monats"],
];
let getroffen = 0;
for (const [tag, titel] of RUF_TAGE) {
  const r = mz.zielRufe(amTag(tag)).filter((x) => !x.merkmal.endsWith(":fertig"));
  const passt = r.some((x) => x.titel === titel);
  if (passt) getroffen++;
  ok(passt, `Tag ${tag}: „${titel}" (${r[0]?.titel || "nichts"})`);
}
ok(getroffen === RUF_TAGE.length,
  `alle ${RUF_TAGE.length} Anlaesse der Vorlage sind belegt (${getroffen})`);

/* GEGENPROBE: An einem Tag OHNE Anlass darf nichts herausgehen. Ohne
   diese Zeile bewiese der Block darueber nur, dass immer etwas kommt. */
const stillerTag = mz.zielRufe(amTag(7)).filter((x) => !x.merkmal.endsWith(":fertig"));
ok(stillerTag.length === 0,
  `am 7. ist Ruhe (${stillerTag.length} Meldungen) — es wird nicht jeden Tag gemahnt`);

/* UND WER ALLES HAT, BEKOMMT GENAU EINEN GLUECKWUNSCH. Dafuer wird
   einer Person alles abgenommen: Ziel 0 ueberall heisst „nichts
   offen". */
const db6 = new DatabaseSync(process.env.WORKSPACE_DB);
for (const a of ["creator", "meeting", "schulung", "werbung"]) {
  db6.prepare(`INSERT INTO mz_ziel (monat, rolle, aufgabe, ziel, gesetzt_am)
               VALUES (?,?,?,?,?)
               ON CONFLICT(monat, rolle, aufgabe) DO UPDATE SET ziel = 0`)
    .run(MONAT, "manager", a, 0, jetztIso);
}
db6.close();
const fertig = mz.zielRufe(amTag(10)).filter((r) => r.personId === IDS.manager);
ok(fertig.length === 0,
  "wer gar keine Ziele hat, bekommt weder Mahnung noch Glueckwunsch");

/* =====================================================================
   11 · DIE HINWEISE AUF DER STARTSEITE
   ===================================================================== */
melde("\n=== Die Zahl auf der Kachel ===");
const hinweise = await (await hol("scout", "/workspace/api/hinweise")).json();
const meine = (hinweise.hinweise || []).filter((h) => String(h.art).startsWith("mz_"));
ok(meine.length > 0, `der Scout bekommt einen Hinweis zu den Monatszielen (${meine.length})`);
ok(meine.every((h) => h.ziel === "manager-ziele.html"),
  "…und er fuehrt auf die richtige Seite");

const hinweiseCreator = await (await hol("creator", "/workspace/api/hinweise")).json();
const creatorMz = (hinweiseCreator.hinweise || []).filter((h) => String(h.art).startsWith("mz_"));
ok(creatorMz.length === 0,
  `ein Creator bekommt keinen (${creatorMz.length}) — kein Weg zu einer Seite, die er nicht hat`);

/* GEGENPROBE: Die Summe der Hinweise muss zur Zahl der offenen
   Aufgaben passen. Zwei Zaehler waeren zwei Wahrheiten. */
const standJetzt = await (await hol("scout", `${API}/stand`)).json();
const summe = meine.reduce((s, h) => s + h.anzahl, 0);
ok(summe === standJetzt.gesamt.offen,
  `die Kachelzahl (${summe}) ist dieselbe wie auf der Seite (${standJetzt.gesamt.offen})`);

/* =====================================================================
   12 · WER NEU DAZUKOMMT, WIRD NICHT GEMAHNT
   ===================================================================== */
melde("\n=== Wer im Laufe des Monats dazukommt ===");
const dbNeu = new DatabaseSync(process.env.WORKSPACE_DB);
const heuteNr = Number(HEUTE.slice(8, 10));
dbNeu.close();

const neuerCode = "CODE-Z99-000001";
const dbA = new DatabaseSync(process.env.WORKSPACE_DB);
const salt = randomBytes(16).toString("hex");
const hash = scryptSync(neuerCode, salt, 64,
  { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
dbA.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n,"
  + " code_kennung, aktiv, erstellt) VALUES (?,?,?,?,?,?,1,?)")
  .run("Ganz Neu", "scout", hash, salt, 32768,
    createHmac("sha256", kennSchluessel).update(neuerCode).digest("hex"),
    `${HEUTE}T09:00:00Z`);
const neuId = dbA.prepare("SELECT last_insert_rowid() AS id").get().id;
dbA.close();
CODES.scout3 = neuerCode;
kekse.scout3 = await anmelden("scout3", "scout");
braucht(!!kekse.scout3, "der neue Scout konnte sich nicht anmelden");

const standNeu = await (await hol("scout3", `${API}/stand`)).json();
if (heuteNr === 1) {
  ok(standNeu.pflichtig === true,
    "wer am 1. dazukommt, ist sofort pflichtig — er hat den vollen Monat");
} else {
  ok(standNeu.pflichtig === false,
    `wer am ${heuteNr}. dazukommt, bekommt diesen Monat keine Warnungen`);
  const rufeNeu = mz.zielRufe(amTag(Math.max(heuteNr, 16)))
    .filter((r) => r.personId === neuId);
  ok(rufeNeu.length === 0, "…und auch keine Erinnerung");
  ok(standNeu.aufgaben.every((a) => a.stufe === "neutral" || a.stufe === "aus"),
    "…alle seine Zeilen stehen auf neutral, keine einzige warnt");
}

/* =====================================================================
   12b · DER SCHNELL-EINTRAG
   =====================================================================

   Filipe am 02.10.2026: „so wenig wie moeglich zu tippen. fertige
   sachen, bereit um ab zu gehen."

   DER WICHTIGSTE FALL IST DIE TEILWEISE ABLEHNUNG. Drei Namen
   einwerfen, von denen einer schon dasteht -- wenn dann die ganze
   Liste zurueckgewiesen wird, tippt man alles noch einmal. Genau
   deshalb wird hier geprueft, dass die anderen zwei durchgehen UND
   dass gesagt wird, welcher nicht.
   ===================================================================== */
melde("\n=== Der Schnell-Eintrag ===");

/* Ein eigener Mensch dafuer, damit die Zaehlungen der vorherigen
   Abschnitte nicht durcheinandergeraten. */
const SCHNELL_CODE = "CODE-Z90-000001";
const dbS = new DatabaseSync(process.env.WORKSPACE_DB);
{
  const salz = randomBytes(16).toString("hex");
  const h = scryptSync(SCHNELL_CODE, salz, 64,
    { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
  dbS.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n,"
    + " code_kennung, aktiv, erstellt) VALUES (?,?,?,?,?,?,1,?)")
    .run("Schnell Schnell", "scout", h, salz, 32768,
      createHmac("sha256", kennSchluessel).update(SCHNELL_CODE).digest("hex"), ALT);
}
dbS.close();
CODES.schnell = SCHNELL_CODE;
kekse.schnell = await anmelden("schnell", "scout");
braucht(!!kekse.schnell, "der Testzugang fuer den Schnell-Eintrag kam nicht herein");

/* ---- Ohne jede Angabe: ein einziger Aufruf, ein Eintrag ---------- */
const ohneAngabe = await schick("schnell", `${API}/eintraege`, "POST",
  { aufgabe: "meeting", datum: HEUTE });
const ohneAngabeD = await ohneAngabe.json();
ok(ohneAngabe.status === 201,
  `ein Meeting ohne eine einzige Angabe (${ohneAngabe.status})`);
ok(ohneAngabeD.angelegt.length === 1, "genau ein Eintrag entstanden");
ok(ohneAngabeD.stand.aufgaben.find((a) => a.schluessel === "meeting").zahl === 1,
  "der Zaehler steht sofort auf 1 — ohne Dialog, ohne Neuladen");

/* ---- Zweimal am selben Tag: Hinweis, keine Sperre ---------------- */
const zweimal = await schick("schnell", `${API}/eintraege`, "POST",
  { aufgabe: "meeting", datum: HEUTE });
const zweimalD = await zweimal.json();
ok(zweimal.status === 201,
  `ein zweites Meeting am selben Tag wird NICHT verboten (${zweimal.status})`
  + " — zwei an einem Tag sind moeglich");
ok(zweimalD.warnungen?.[0]?.art === "zweimal_am_tag",
  "…aber es wird gesagt, dass jetzt zwei dastehen (Doppeltipper am Ein-Klick-Knopf)");
/* GEGENPROBE: Beim ERSTEN kommt diese Warnung nicht -- sonst waere sie
   keine Warnung, sondern ein Begleittext. */
const erstmal = await schick("schnell", `${API}/eintraege`, "POST",
  { aufgabe: "schulung", datum: HEUTE, art: "talk" });
const erstmalD = await erstmal.json();
ok(!erstmalD.warnungen?.length,
  "beim ersten Eintrag des Tages kommt keine Warnung");
/* Und aufgeraeumt, damit die Zaehlungen danach stimmen. */
for (const e of [...zweimalD.angelegt, ...erstmalD.angelegt]) {
  await hol("schnell", `${API}/eintrag/${e.id}`, { method: "DELETE" });
}

/* ---- Drei Namen in einem Wurf ----------------------------------- */
const drei = await schick("schnell", `${API}/eintraege`, "POST",
  { aufgabe: "creator", datum: HEUTE, namen: ["@eins", "@zwei", "@drei"] });
const dreiD = await drei.json();
ok(drei.status === 201, `drei Namen auf einmal (${drei.status})`);
ok(dreiD.angelegt.length === 3, `drei Eintraege entstanden (${dreiD.angelegt.length})`);
ok(dreiD.stand.aufgaben.find((a) => a.schluessel === "creator").zahl === 3,
  "…und der Zaehler steht auf 3");
ok(dreiD.stand.aufgaben.find((a) => a.schluessel === "creator").stufe === "gruen",
  "…womit das Ziel in EINEM Vorgang erreicht ist");

/* ---- Teilweise Ablehnung: der wichtigste Fall -------------------- */
const teils = await schick("schnell", `${API}/eintraege`, "POST",
  { aufgabe: "creator", datum: HEUTE, namen: ["@eins", "@vier", "@fuenf"] });
const teilsD = await teils.json();
ok(teils.status === 201,
  `die Liste geht durch, obwohl einer schon dasteht (${teils.status})`);
ok(teilsD.angelegt.length === 2,
  `die beiden neuen sind drin (${teilsD.angelegt.length})`);
ok(teilsD.abgelehnt.length === 1,
  `der doppelte ist einzeln abgelehnt (${teilsD.abgelehnt.length})`);
ok(teilsD.abgelehnt[0]?.was === "@eins",
  `…und es steht da, WELCHER (${teilsD.abgelehnt[0]?.was})`);
ok(String(teilsD.abgelehnt[0]?.text || "").includes("@eins"),
  "…im Klartext, nicht als Fehlerschluessel");

/* GEGENPROBE: Geht gar nichts durch, ist es kein Erfolg. Ein 201
   ueber eine leere Liste waere eine Zusage, die nicht stimmt. */
const nichts = await schick("schnell", `${API}/eintraege`, "POST",
  { aufgabe: "creator", datum: HEUTE, namen: ["@eins"] });
ok(nichts.status === 409,
  `eine Liste, von der nichts durchgeht, meldet KEINEN Erfolg (${nichts.status})`);

/* ---- Die Grenze von zwanzig ------------------------------------- */
const viele = Array.from({ length: 26 }, (_, i) => `@menge${i}`);
const zuviel = await schick("schnell", `${API}/eintraege`, "POST",
  { aufgabe: "creator", datum: HEUTE, namen: viele });
const zuvielD = await zuviel.json();
ok(zuvielD.angelegt.length === 20,
  `aus 26 Namen werden 20 (${zuvielD.angelegt.length}) — ein versehentlich`
  + " eingefuegter Textblock legt keine 300 Zeilen an");
ok(!!zuvielD.zuviel, "…und es wird gesagt, dass gekuerzt wurde");

/* ---- Ein ungueltiger Link in einer Liste ------------------------ */
const linkListe = await schick("schnell", `${API}/eintraege`, "POST",
  { aufgabe: "werbung", datum: HEUTE, art: "agentur",
    links: ["https://www.tiktok.com/@x/video/1", "kaputt", "https://example.org/v/2"] });
const linkListeD = await linkListe.json();
ok(linkListeD.angelegt.length === 2,
  `zwei gueltige Links durch (${linkListeD.angelegt.length})`);
ok(linkListeD.abgelehnt.length === 1 && linkListeD.abgelehnt[0].fehler === "link_ungueltig",
  "der kaputte einzeln abgelehnt, mit Grund");

/* ---- Die Schranke gilt auch hier -------------------------------- */
const creatorSchnell = await schick("creator", `${API}/eintraege`, "POST",
  { aufgabe: "meeting", datum: HEUTE });
ok(creatorSchnell.status === 404,
  `ein Creator kommt auch ueber den Schnellweg nicht hinein (${creatorSchnell.status})`);

/* ---- Und die Datumsgrenzen ebenfalls ---------------------------- */
const schnellZukunft = await schick("schnell", `${API}/eintraege`, "POST",
  { aufgabe: "meeting", datum: morgen });
const schnellZukunftD = await schnellZukunft.json();
ok(schnellZukunft.status === 409
   && schnellZukunftD.abgelehnt?.[0]?.fehler === "datum_zukunft",
  `ein Datum in der Zukunft wird auch hier abgelehnt (${schnellZukunft.status})`);

/* ---- Die zuletzt gewaehlte Art kommt zurueck -------------------- */
const standSchnell = await (await hol("schnell", `${API}/stand`)).json();
const werbungZeile = standSchnell.aufgaben.find((a) => a.schluessel === "werbung");
ok(werbungZeile?.letzteArt === "agentur",
  `die zuletzt benutzte Art wird mitgeschickt (${werbungZeile?.letzteArt})`
  + " — damit ist sie beim naechsten Mal schon gewaehlt");
const schulungZeile = standSchnell.aufgaben.find((a) => a.schluessel === "schulung");
ok(schulungZeile?.letzteArt === "schulung",
  `ohne eigenen Eintrag gilt die erste Art als Vorgabe (${schulungZeile?.letzteArt})`);

/* ---- Rueckgaengig: was der Schnellweg anlegt, nimmt er zurueck --- */
const zumZuruecknehmen = ohneAngabeD.angelegt[0].id;
const zurueck = await hol("schnell", `${API}/eintrag/${zumZuruecknehmen}`, { method: "DELETE" });
const zurueckD = await zurueck.json().catch(() => ({}));
ok(zurueck.status === 200, `Rueckgaengig geht (${zurueck.status})`);
ok(zurueckD.stand?.aufgaben.find((a) => a.schluessel === "meeting")?.zahl === 0,
  "…und der Zaehler steht wieder bei 0");

/* =====================================================================
   12c · AB WANN JEMAND PFLICHTIG IST -- ueber den ECHTEN Weg
   =====================================================================

   Vorlage, Punkt 09: „Wer erst im Laufe des Monats eine der Rollen
   bekommt, erhaelt in diesem Monat keine Warnungen."

   WARUM HIER DIE RICHTIGE ROUTE BENUTZT WIRD und nicht ein
   handgeschriebener Protokolleintrag: Der Pflichtbeginn wird aus dem
   Protokolltext gelesen (`detail` enthaelt „#<id> <name>: alt ->
   neu"). Wuerde die Pruefung diesen Text selbst schreiben, pruefte
   sie ihre eigene Annahme -- und merkte nie, wenn die
   Personenverwaltung ihn eines Tages anders schreibt.

   DER FEHLER, DEN DAS GEFUNDEN HAT (02.10.2026): Die Abfrage suchte
   `WHERE person_id = ?`. Im Protokoll steht dort aber der, der die
   Aenderung GEMACHT hat -- also DogFather. Fuer den Betroffenen fand
   sie deshalb nie etwas, und bei DogFather schob jede fremde
   Rollenaenderung SEINEN Pflichtbeginn. Beides sah plausibel aus.
   ===================================================================== */
melde("\n=== Ab wann jemand pflichtig ist ===");

const dbP0 = new DatabaseSync(process.env.WORKSPACE_DB, { readOnly: true });
const vorherStart = dbP0.prepare(
  "SELECT person_id, erster_monat, gesetzt_am, grund FROM mz_start").all();
dbP0.close();
const dogiVorher = vorherStart.find((z) => z.person_id === IDS.admin);
braucht(vorherStart.length > 0, "es steht noch kein Pflichtbeginn in der Tabelle");

/* Ein eigener Mensch, dessen Rolle gleich wandert. */
const WANDER_CODE = "CODE-Z80-000001";
const dbW = new DatabaseSync(process.env.WORKSPACE_DB);
{
  const salz = randomBytes(16).toString("hex");
  const h = scryptSync(WANDER_CODE, salz, 64,
    { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
  dbW.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n,"
    + " code_kennung, aktiv, erstellt) VALUES (?,?,?,?,?,?,1,?)")
    .run("Wanderer", "scout", h, salz, 32768,
      createHmac("sha256", kennSchluessel).update(WANDER_CODE).digest("hex"), ALT);
}
const idWander = dbW.prepare("SELECT last_insert_rowid() AS id").get().id;
dbW.close();
CODES.wander = WANDER_CODE;
kekse.wander = await anmelden("wander", "scout");
braucht(!!kekse.wander, "der Wanderer kam nicht herein");

/* Einmal den Stand abrufen, damit sein Pflichtbeginn festgehalten wird. */
const wanderVorher = await (await hol("wander", `${API}/stand`)).json();
ok(wanderVorher.pflichtig === true,
  "ein ein Jahr alter Scout ist pflichtig (Ausgangspunkt)");

/* ---- Jetzt der ECHTE Rollenwechsel, zweimal ---------------------- */
const rolleSetzen = (ziel) => schick("admin",
  `/workspace/api/verwaltung/personen/${idWander}/rolle`, "PUT", { rolle: ziel });

const rolleWeg = await rolleSetzen("creator");
ok(rolleWeg.status === 200, `DogFather macht ihn zum Creator (${rolleWeg.status})`);
const zurueckRolle = await rolleSetzen("scout");
ok(zurueckRolle.status === 200, `…und wieder zum Scout (${zurueckRolle.status})`);

/* Das Rollenwechseln meldet alle Sitzungen dieser Person ab -- also
   noch einmal anmelden, sonst misst der naechste Aufruf nur ein 401. */
kekse.wander = await anmelden("wander", "scout");
braucht(!!kekse.wander, "nach dem Rollenwechsel kam er nicht wieder herein");

const wanderNachher = await (await hol("wander", `${API}/stand`)).json();
const dbP = new DatabaseSync(process.env.WORKSPACE_DB, { readOnly: true });
const wanderStart = dbP.prepare(
  "SELECT erster_monat, grund FROM mz_start WHERE person_id = ?").get(idWander);
const dogiNachher = dbP.prepare(
  "SELECT erster_monat, grund FROM mz_start WHERE person_id = ?").get(IDS.admin);
dbP.close();

ok(wanderStart?.grund === "rollenwechsel",
  `der Pflichtbeginn kommt jetzt aus SEINEM Rollenwechsel (${wanderStart?.grund})`);
ok(wanderStart?.erster_monat === mz.monatPlus(MONAT, 1)
   || (HEUTE.slice(8) === "01" && wanderStart?.erster_monat === MONAT),
  `er ist erst ab dem Folgemonat pflichtig (${wanderStart?.erster_monat})`);
ok(wanderNachher.pflichtig === false || HEUTE.slice(8) === "01",
  "…und bekommt in diesem Monat keine Warnungen mehr");
ok(wanderNachher.aufgaben.every((a) => a.stufe === "neutral" || a.stufe === "aus"),
  "…keine einzige seiner Zeilen warnt");

/* GEGENPROBE 1: DogFather hat die Aenderung gemacht -- SEIN
   Pflichtbeginn darf sich davon nicht bewegen. Genau das war der
   Fehler. */
ok(dogiNachher?.erster_monat === dogiVorher?.erster_monat,
  `DogFathers Pflichtbeginn ist unveraendert (${dogiVorher?.erster_monat}`
  + ` -> ${dogiNachher?.erster_monat}) — er hat die Aenderung nur GEMACHT`);

/* GEGENPROBE 2: Wer gar nicht angefasst wurde, behaelt seinen Wert.
   Ohne diese Zeile hiesse „der eine hat sich geaendert" vielleicht
   „alle haben sich geaendert". */
const dbP2 = new DatabaseSync(process.env.WORKSPACE_DB, { readOnly: true });
const scoutStart = dbP2.prepare(
  "SELECT erster_monat, grund FROM mz_start WHERE person_id = ?").get(IDS.scout);
dbP2.close();
const scoutVorher = vorherStart.find((z) => z.person_id === IDS.scout);
ok(scoutStart?.erster_monat === scoutVorher?.erster_monat,
  `ein unbeteiligter Scout behaelt seinen Wert (${scoutStart?.erster_monat})`);

/* GEGENPROBE 3: Der Eintrag wird NICHT bei jedem Abruf neu gerechnet.
   Sonst waere der Pflichtbeginn keine Festlegung, sondern eine
   Momentaufnahme. */
await hol("wander", `${API}/stand`);
const dbP3 = new DatabaseSync(process.env.WORKSPACE_DB, { readOnly: true });
const nochmal = dbP3.prepare(
  "SELECT gesetzt_am FROM mz_start WHERE person_id = ?").get(idWander);
dbP3.close();
await new Promise((r) => setTimeout(r, 20));
await hol("wander", `${API}/stand`);
const dbP4 = new DatabaseSync(process.env.WORKSPACE_DB, { readOnly: true });
const undnochmal = dbP4.prepare(
  "SELECT gesetzt_am FROM mz_start WHERE person_id = ?").get(idWander);
dbP4.close();
ok(nochmal?.gesetzt_am === undnochmal?.gesetzt_am,
  "ein zweiter Abruf rechnet ihn nicht neu — er steht fest");

/* =====================================================================
   13 · WER GEHT, NIMMT SEINE ZAHLEN NICHT MIT
   =====================================================================

   Vorlage, Punkt 09: „Wer die Rolle verliert, sieht die Kachel nicht
   mehr; die Daten bleiben fuer den DogFather erhalten."

   DREI WEGE, AUF DENEN JEMAND VERSCHWINDEN KANN, und alle drei muessen
   die Zahlen stehen lassen: Rollenwechsel, Stilllegung, Loeschung.
   Der dritte ist der gefaehrliche -- er loescht wirklich eine Zeile
   in `personen`, und mit ON DELETE CASCADE waere der Monatsverlauf
   lautlos mitgegangen.
   ===================================================================== */
melde("\n=== Wer die Rolle verliert ===");

const dbV = new DatabaseSync(process.env.WORKSPACE_DB);
/* Sandra (scout2) hat weiter oben einen Creator eingetragen. Jetzt
   wird sie Creator -- sie verliert damit die Kachel. */
dbV.prepare("UPDATE personen SET rolle = 'creator' WHERE id = ?").run(IDS.scout2);
dbV.close();

const teamNachWechsel = await (await hol("admin", `${API}/team?monat=${MONAT}`)).json();
const sandra = teamNachWechsel.leute.find((x) => x.id === IDS.scout2);
ok(!!sandra, "wer die Rolle verliert, steht weiter in der Team-Uebersicht");
ok(sandra?.ehemalig === true, '…und ist als „nicht mehr dabei" gekennzeichnet');
ok(sandra?.rolle === "scout",
  `…und wird an der Rolle von DAMALS gemessen (${sandra?.rolle}), nicht an der von heute`);
ok(sandra?.aufgaben.find((a) => a.schluessel === "creator")?.zahl >= 1,
  "…seine Zahlen stehen unveraendert da");

/* Und die Kachel ist fuer sie zu. */
const sandraKeks = await anmelden("scout2", "creator");
braucht(!!sandraKeks, "die Person konnte sich nach dem Rollenwechsel nicht anmelden");
kekse.scout2 = sandraKeks;
const sandraStand = await hol("scout2", `${API}/stand`);
ok(sandraStand.status === 404,
  `…sie selbst kommt nicht mehr an die Kachel (${sandraStand.status})`);

melde("\n=== Und wer geloescht wird ===");
const dbL = new DatabaseSync(process.env.WORKSPACE_DB);
dbL.exec("PRAGMA foreign_keys = ON");
const vorherZeilen = dbL.prepare(
  "SELECT COUNT(*) n FROM mz_eintrag WHERE person_id = ?").get(IDS.scout2).n;
braucht(vorherZeilen > 0, "die zu loeschende Person hatte gar keine Eintraege");
dbL.prepare("DELETE FROM personen WHERE id = ?").run(IDS.scout2);
const uebrig = dbL.prepare(
  "SELECT COUNT(*) n FROM mz_eintrag WHERE person_id IS NULL AND von_name IS NOT NULL").get().n;
const weg = dbL.prepare("SELECT COUNT(*) n FROM personen WHERE id = ?").get(IDS.scout2).n;
dbL.close();
ok(weg === 0, "die Person ist wirklich geloescht (sonst beweist der Rest nichts)");
ok(uebrig === vorherZeilen,
  `ihre ${vorherZeilen} Eintraege stehen noch da, ohne Person (${uebrig})`);

const teamNachLoeschen = await (await hol("admin", `${API}/team?monat=${MONAT}`)).json();
const verwaist = teamNachLoeschen.leute.find((x) => x.id === null);
ok(!!verwaist, "DogFather sieht die verwaisten Eintraege als eigene Zeile");
ok(verwaist?.name === "Sandra",
  `…unter dem mitgeschriebenen Namen (${verwaist?.name})`);

/* =====================================================================
   14 · DER UMBAU VON CASCADE AUF SET NULL
   =====================================================================

   Die Tabelle wurde am 02.10.2026 zuerst mit ON DELETE CASCADE
   ausgeliefert. Der Umbau muss auf einem solchen Bestand laufen --
   und zwar OHNE eine Zeile und ohne eine Spalte zu verlieren. Genau
   das ist am 11.09.2026 im Creator Workspace schiefgegangen: 24
   Spalten hinein, 21 heraus, ohne Fehlermeldung, bei unveraenderter
   Zeilenzahl.
   ===================================================================== */
melde("\n=== Der Umbau auf einem alten Bestand ===");
const { managerZieleTabellen } = await import("./manager-ziele-tabellen.js");
const altOrdner = mkdtempSync(join(tmpdir(), "ws-mz-alt-"));
const altPfad = join(altOrdner, "alt.db");
const dbA2 = new DatabaseSync(altPfad);
/* Der Stand von heute Mittag, Wort fuer Wort: NOT NULL und CASCADE,
   ohne von_name und von_rolle. */
dbA2.exec(`
  CREATE TABLE personen (id INTEGER PRIMARY KEY, name TEXT, rolle TEXT, erstellt TEXT);
  CREATE TABLE leads (id INTEGER PRIMARY KEY, name TEXT);
  CREATE TABLE mz_eintrag (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    person_id INTEGER NOT NULL REFERENCES personen(id) ON DELETE CASCADE,
    aufgabe TEXT NOT NULL CHECK (aufgabe IN ('creator','meeting','schulung','werbung')),
    monat TEXT NOT NULL, datum TEXT NOT NULL,
    name TEXT, name_klein TEXT, link TEXT, link_klein TEXT,
    art TEXT, notiz TEXT, lead_id INTEGER, doppelt_bei INTEGER,
    erstellt TEXT NOT NULL, geaendert TEXT, geaendert_von INTEGER);
  INSERT INTO personen (id,name,rolle,erstellt) VALUES (1,'Alt','scout','2026-01-01T00:00:00Z');
  INSERT INTO mz_eintrag (person_id,aufgabe,monat,datum,name,notiz,erstellt)
    VALUES (1,'creator','2026-10','2026-10-01','@bleibtdrin','wichtige Notiz','x');
`);
const altSpaltenVorher = dbA2.prepare("PRAGMA table_info(mz_eintrag)").all().length;
const altZeilenVorher = dbA2.prepare("SELECT COUNT(*) n FROM mz_eintrag").get().n;

managerZieleTabellen(dbA2);

const altSpaltenNachher = dbA2.prepare("PRAGMA table_info(mz_eintrag)").all().map((x) => x.name);
const altZeilenNachher = dbA2.prepare("SELECT COUNT(*) n FROM mz_eintrag").get().n;
const altVerweis = dbA2.prepare("PRAGMA foreign_key_list(mz_eintrag)").all()
  .find((v) => v.from === "person_id");
const altInhalt = dbA2.prepare("SELECT name, notiz FROM mz_eintrag").get();

ok(String(altVerweis?.on_delete).toUpperCase() === "SET NULL",
  `aus CASCADE wurde SET NULL (${altVerweis?.on_delete})`);
ok(altZeilenNachher === altZeilenVorher,
  `keine Zeile verloren (${altZeilenVorher} -> ${altZeilenNachher})`);
ok(altSpaltenNachher.length >= altSpaltenVorher,
  `keine Spalte verloren (${altSpaltenVorher} -> ${altSpaltenNachher.length})`);
ok(altSpaltenNachher.includes("von_name") && altSpaltenNachher.includes("von_rolle"),
  "die beiden neuen Spalten sind da");
ok(altInhalt?.name === "@bleibtdrin" && altInhalt?.notiz === "wichtige Notiz",
  "und der INHALT steht noch drin (nicht nur die Zeile)");

/* Die Indizes muessen den Umbau ueberlebt haben -- sie haengen an der
   Tabelle und verschwinden mit ihr. */
const altIndizes = dbA2.prepare(
  "SELECT COUNT(*) n FROM sqlite_master WHERE type='index' AND tbl_name='mz_eintrag'"
  + " AND name LIKE 'idx_mz%'").get().n;
ok(altIndizes >= 5, `die ${altIndizes} Indizes sind wieder da`);
const altTrigger = dbA2.prepare(
  "SELECT COUNT(*) n FROM sqlite_master WHERE type='trigger' AND tbl_name='mz_eintrag'").get().n;
ok(altTrigger === 3, `und die drei Sperr-Trigger ebenfalls (${altTrigger})`);

/* GEGENPROBE: Ein zweiter Lauf darf NICHTS mehr tun. Ein Umbau, der
   bei jedem Serverstart wieder losliefe, waere eine Zeitbombe. */
const vorZweitem = dbA2.prepare("SELECT COUNT(*) n FROM mz_eintrag").get().n;
managerZieleTabellen(dbA2);
const nachZweitem = dbA2.prepare("SELECT COUNT(*) n FROM mz_eintrag").get().n;
ok(vorZweitem === nachZweitem,
  `ein zweiter Lauf laesst alles, wie es ist (${vorZweitem} -> ${nachZweitem})`);

/* DIE LOESCHUNG EINER PERSON MIT ALTEN EINTRAEGEN.

   Der wichtigste Fall dieses ganzen Blocks, und er ist beim Bauen
   schiefgegangen: ON DELETE SET NULL ist kein Loeschen, sondern ein
   UPDATE auf mz_eintrag.person_id. Der Sperr-Trigger hat das als
   Aenderung an einem abgeschlossenen Monat gesehen und abgebrochen --
   damit waere das Loeschen einer Person in workspace-personen.js
   gescheitert, an einer Stelle, die mit Monatszielen nichts zu tun
   hat. Hier steht der Eintrag ausdruecklich in einem Monat, der NICHT
   der laufende ist (mz_lage steht in dieser Wegwerf-Datenbank auf
   '0000-00'). */
dbA2.exec("PRAGMA foreign_keys = ON");
let loeschenGing = true;
try {
  dbA2.prepare("DELETE FROM personen WHERE id = 1").run();
} catch (f) {
  loeschenGing = false;
  console.log("    (Grund: " + f?.message + ")");
}
ok(loeschenGing,
  "eine Person mit Eintraegen aus einem ABGESCHLOSSENEN Monat laesst sich loeschen");

/* GEGENPROBE: Der Inhalt eines alten Monats bleibt trotzdem gesperrt.
   Ohne diese Zeile waere nur bewiesen, dass die Sperre nachgibt --
   nicht, dass sie noch etwas haelt. */
let inhaltGesperrt = false;
try {
  dbA2.prepare("UPDATE mz_eintrag SET notiz = 'heimlich' WHERE name = '@bleibtdrin'").run();
} catch (f) {
  inhaltGesperrt = String(f?.message || "").includes("monat_gesperrt");
}
ok(inhaltGesperrt,
  "…aber den INHALT eines alten Monats laesst dieselbe Sperre weiterhin nicht aendern");

const nachLoeschen = dbA2.prepare("SELECT person_id, name, notiz FROM mz_eintrag").get();
ok(nachLoeschen?.notiz === "wichtige Notiz",
  "…und die Notiz steht unveraendert da");
dbA2.close();
try { rmSync(altOrdner, { recursive: true, force: true }); } catch { /* egal */ }
ok(nachLoeschen && nachLoeschen.person_id === null && nachLoeschen.name === "@bleibtdrin",
  "nach dem Loeschen der Person bleibt der Eintrag, nur ohne Besitzer");

/* =====================================================================
   15 · WAS AM EINTRAG MITGESCHRIEBEN WIRD
   ===================================================================== */
melde("\n=== Name und Rolle stehen am Eintrag ===");
const dbN = new DatabaseSync(process.env.WORKSPACE_DB, { readOnly: true });
const mitNamen = dbN.prepare(
  "SELECT COUNT(*) n FROM mz_eintrag WHERE von_name IS NOT NULL AND von_rolle IS NOT NULL").get().n;
const gesamtEintraege = dbN.prepare("SELECT COUNT(*) n FROM mz_eintrag").get().n;
dbN.close();
ok(gesamtEintraege > 0, `es gibt ueberhaupt Eintraege zum Pruefen (${gesamtEintraege})`);
ok(mitNamen === gesamtEintraege,
  `an allen ${gesamtEintraege} Eintraegen stehen Name und Rolle (${mitNamen})`);

/* =====================================================================
   16 · KEIN KNOPF, DER NICHTS TUT
   ===================================================================== */
melde("\n=== Wer korrigieren darf (seit 02.10.2026: Spicy UND DogFather) ===");

/* DIE ANGEZEIGTE ERLAUBNIS UND DIE TATSAECHLICHE MUESSEN DIESELBE
   SEIN. Eine Liste, die „darfst du" sagt und danach 403 liefert, ist
   schlimmer als eine ohne Knoepfe -- man klickt zweimal, bevor man
   es glaubt. Deshalb wird hier zu JEDER Anzeige auch der Vollzug
   gemessen. */
const sichten = {};
for (const r of ["spicy", "admin", "manager"]) {
  sichten[r] = await (await hol(r,
    `${API}/eintraege?monat=${MONAT}&aufgabe=creator&person=${IDS.scout}`)).json();
}
ok(sichten.spicy.bearbeitbar === true,
  "Spicy Media bekommt an einer fremden Liste Bearbeiten-Knoepfe");
ok(sichten.admin.bearbeitbar === true, "DogFather ebenfalls");
/* BEIM MANAGER WAR MEINE ERSTE PRUEFUNG FALSCH, nicht der Code: Er
   bekommt `bearbeitbar: true` -- weil er gar keine fremde Liste
   bekommt, sondern seine EIGENE. Die Nummer in der Adresse wird fuer
   ihn schlicht nicht beachtet. Das ist das richtige Verhalten und
   die falsche Frage; gemessen gehoert, dass bei ihm nichts Fremdes
   ankommt. */
const fremdeIds = new Set(sichten.admin.eintraege.map((e) => e.id));
ok(fremdeIds.size > 0,
  `es gibt ueberhaupt fremde Eintraege, die durchsickern koennten (${fremdeIds.size})`);
ok(!sichten.manager.eintraege.some((e) => fremdeIds.has(e.id)),
  `ein Manager sieht keinen einzigen davon (${sichten.manager.eintraege.length} eigene)`);

const eigeneSicht = await (await hol("scout",
  `${API}/eintraege?monat=${MONAT}&aufgabe=creator`)).json();
ok(eigeneSicht.bearbeitbar === true, "und jeder an seiner eigenen");

/* EIN EINTRAG, DEN ES WIRKLICH NOCH GIBT. Beim ersten Lauf stand hier
   ein geloeschter -- die Antwort lautete 404 statt 403, und das sah
   aus wie ein haltender Riegel. */
const lebtNoch = eigeneSicht.eintraege[0]?.id;
braucht(!!lebtNoch, "es gibt keinen Eintrag, an dem sich das messen liesse");

const spicyVersuch = await schick("spicy", `${API}/eintrag/${lebtNoch}`, "PATCH",
  { datum: HEUTE, name: "@vonSpicyKorrigiert" });
ok(spicyVersuch.status === 200,
  `Spicy Media korrigiert einen fremden Eintrag wirklich (${spicyVersuch.status})`);

const dbK = new DatabaseSync(process.env.WORKSPACE_DB, { readOnly: true });
const angekommen = dbK.prepare("SELECT name FROM mz_eintrag WHERE id = ?").get(lebtNoch);
const vonSpicy = dbK.prepare(
  `SELECT COUNT(*) n FROM protokoll
    WHERE aktion = 'manager_ziele_korrigiert' AND rolle = 'spicy'`).get().n;
dbK.close();
ok(angekommen?.name === "@vonSpicyKorrigiert",
  "…und die Aenderung steht wirklich in der Datenbank");
ok(vonSpicy >= 1,
  `…und sie ist unter ihrem Namen protokolliert (${vonSpicy} Eintraege)`);

/* GEGENPROBE: Die Grenze liegt bei der Leitung, nicht bei „irgendwer
   mit einem Zugang". Ohne diese beiden Zeilen hiesse „Spicy darf"
   moeglicherweise „jeder darf". */
const managerVersuch = await schick("manager", `${API}/eintrag/${lebtNoch}`, "PATCH",
  { datum: HEUTE, name: "@vonManager" });
ok(managerVersuch.status === 403,
  `ein Manager wird weiterhin abgewiesen (${managerVersuch.status})`);
const scout2Versuch = await schick("schnell", `${API}/eintrag/${lebtNoch}`, "PATCH",
  { datum: HEUTE, name: "@vonFremdemScout" });
ok(scout2Versuch.status === 403,
  `ein fremder Scout ebenfalls (${scout2Versuch.status})`);

const dbK2 = new DatabaseSync(process.env.WORKSPACE_DB, { readOnly: true });
const unveraendert = dbK2.prepare("SELECT name FROM mz_eintrag WHERE id = ?").get(lebtNoch);
dbK2.close();
ok(unveraendert?.name === "@vonSpicyKorrigiert",
  "…und nach beiden Absagen steht immer noch der Wert von Spicy da");

/* Und Loeschen folgt derselben Grenze -- geprueft, nicht angenommen:
   PATCH und DELETE sind zwei Routen, und zwei Routen koennen
   auseinanderlaufen. */
const managerLoeschen = await hol("manager", `${API}/eintrag/${lebtNoch}`, { method: "DELETE" });
ok(managerLoeschen.status === 403,
  `ein Manager kann einen fremden Eintrag auch nicht loeschen (${managerLoeschen.status})`);
const spicyLoeschen = await hol("spicy", `${API}/eintrag/${lebtNoch}`, { method: "DELETE" });
ok(spicyLoeschen.status === 200,
  `Spicy Media kann ihn loeschen (${spicyLoeschen.status})`);

/* =====================================================================
   SCHLUSS
   ===================================================================== */
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
melde(`\n${geprueft} Pruefungen, ${fehler} Fehler`);
process.exit(fehler ? 1 : 0);