dogfather-universe/server/pruef-modi-katalog.mjs

/* =====================================================================
   DER AUFGABENKATALOG AUS TEIL 2 DES ANFORDERUNGSDOKUMENTS

   Kapitel 14: "Alle Aufgaben dieses Katalogs koennen 1:1 als Vorlagen in
   die App importiert werden -- inklusive Kategorie, empfohlener Rolle
   und Frequenz. So ist das Aufgaben-Board ab dem ersten Tag vollstaendig
   befuellt, statt leer zu starten."

   GEPRUEFT WIRD NICHT NUR, DASS ER DA IST. Ein Katalog, den man ansehen,
   aber nicht uebernehmen kann, ist eine Speisekarte ohne Kueche. Und ein
   uebernommener Eintrag, bei dem die Kategorie unterwegs verlorengeht,
   ist die Haelfte wert -- dann sortiert man 60-mal von Hand ein, was im
   Dokument bereits danebensteht.

   DAZU DIE VERBORGENHEIT: Wer den Katalog nicht bekommt, darf auch nicht
   erfahren, dass es ihn gibt. Eine Absage muss deshalb wortgleich mit
   der fuer eine erfundene Art sein.
   ===================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-kat2-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
   Ohne diese Zeile startet der eigene Server bei belegtem Port
   STILL nicht -- und alles Folgende misst gegen einen fremden
   Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
   als kaputt. */
const PORT = await eigenerPort(import.meta, "pruef-modi-katalog");
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 }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { ersatzschreibungen } from "./helfer-deutsch.mjs";
import { fileURLToPath } from "node:url";
import { eigenerPort } from "./helfer-port.mjs";
await import("./index.js");
notbremse(180_000, "pruef-modi-katalog");
await new Promise((r) => setTimeout(r, 700));
const BASIS = `http://127.0.0.1:${PORT}`;

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

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

function anlegen(name, rolle, code) {
  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", schluessel).update(code).digest("hex"), jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
const idDogi  = anlegen("Filipe", "admin", "CODE-DOGI-0001");
const idMan   = anlegen("Schulle", "manager", "CODE-MAN-0001");
const idCreat = anlegen("Tili", "creator", "CODE-ANNA-0001");
const idModi  = anlegen("Marina", "modi", "CODE-MODI-0001");
d.close();
void idDogi;
void idMan;

async function anmelden(rolle, code) {
  const a = await fetch(BASIS + "/workspace/api/anmelden", {
    method: "POST", headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ rolle, code }),
  });
  const keks = (a.headers.getSetCookie?.() || []).map((z) => z.split(";")[0]).join("; ");
  return { status: a.status, keks };
}
async function hole(keks, pfad, aufruf = {}) {
  const a = await fetch(BASIS + pfad, {
    ...aufruf, headers: { ...(aufruf.headers || {}), cookie: keks },
  });
  return { status: a.status, daten: await a.json().catch(() => null) };
}
const jsonKopf = { "Content-Type": "application/json" };

const modiAn = await anmelden("creator", "CODE-MODI-0001");
const dogiAn = await anmelden("admin", "CODE-DOGI-0001");
const manAn = await anmelden("manager", "CODE-MAN-0001");
const creatAn = await anmelden("creator", "CODE-ANNA-0001");

/* ---------- 1. Ist er vollstaendig da? ------------------------------- */
console.log("\n=== 1. Der Katalog, wie ihn das Dokument beschreibt ===\n");

let katalog = null;
{
  const a = await hole(modiAn.keks, "/workspace/api/vorlagen");
  katalog = a.daten?.katalog || null;
  /* SEIT DEM 16.09.2026 NACH KATEGORIE UND STUFE.

     Vorher standen hier neun PHASEN mit 60 Eintraegen -- und
     nachgezaehlt gehoerten 39 davon DogFather und der rechten Hand.
     Es war ein Aufbauplan, kein Arbeitskatalog. Der Aufbauplan gibt es
     weiterhin, unter `aufbauplan`; hier steht jetzt, was ein Mensch im
     Team TUT.

     ZAHLEN FEST HINGESCHRIEBEN, wie vorher: Eine Zahl, die sich selbst
     nachzaehlt, merkt nicht, wenn etwas herausfaellt. */
  ok(katalog && katalog.gruppen.length === 14,
    `${katalog?.gruppen?.length ?? 0} Kategorien (erwartet 14)`);
  ok(katalog && katalog.stufen.length === 3,
    `${katalog?.stufen?.length ?? 0} Stufen (erwartet 3)`);
  ok(katalog && katalog.aufgaben.length === 101,
    `${katalog?.aufgaben?.length ?? 0} Aufgaben (erwartet 101)`);

  /* JEDE KATEGORIE MUSS BELEGT SEIN. Vorher hatten vier von vierzehn
     eine Aufgabe oder keine (Events 1, Wachstum 1, Branding 1,
     Sonstiges 0) -- eine Kategorie ohne Inhalt ist ein leeres
     Versprechen im Auswahlfeld. */
  const je = {};
  for (const v of katalog?.aufgaben || []) je[v.gruppe] = (je[v.gruppe] || 0) + 1;
  const leer = (katalog?.gruppen || []).filter((g) => !je[g.schluessel]);
  ok(leer.length === 0,
    `jede Kategorie hat Aufgaben${leer.length ? ": leer sind " + leer.map((g) => g.name).join(", ") : ""}`);
  ok(Math.min(...Object.values(je)) >= 3,
    `auch die kleinste hat mindestens drei (${Math.min(...Object.values(je))})`);

  /* UND JEDE STUFE. Eine Stufe ohne Aufgaben waere ein Knopf, der eine
     leere Liste oeffnet. */
  const jeStufe = {};
  for (const v of katalog?.aufgaben || []) jeStufe[v.stufe] = (jeStufe[v.stufe] || 0) + 1;
  ok((katalog?.stufen || []).every((s) => jeStufe[s.schluessel] > 0),
    `jede Stufe ist belegt (${Object.entries(jeStufe).map(([k, n]) => `${k}:${n}`).join(" ")})`);

  ok((katalog?.aufgaben || []).every((v) => v.titel && v.text && v.gruppe && v.stufe && v.tage),
    "jede Aufgabe hat Titel, Text, Kategorie, Stufe und Frist");
  /* DER TEXT SAGT WARUM, nicht was. Ein Text, der kuerzer ist als der
     Titel, ist eine Wiederholung -- und die haette man sich sparen
     koennen. */
  const duenn = (katalog?.aufgaben || []).filter((v) => v.text.length < v.titel.length + 20);
  ok(duenn.length === 0,
    `jeder Text begruendet${duenn.length ? ": zu duenn bei " + duenn[0].schluessel : ""}`);
  ok(new Set((katalog?.aufgaben || []).map((v) => v.schluessel)).size
    === (katalog?.aufgaben || []).length, "keine Kennung doppelt");

  /* DER AUFBAUPLAN IST NICHT VERLORENGEGANGEN. */
  const plan = a.daten?.aufbauplan;
  ok(plan && plan.aufgaben.length === 60 && plan.gruppen.length === 9,
    `der Aufbauplan steht weiter zur Verfuegung (${plan?.aufgaben?.length ?? 0} in `
    + `${plan?.gruppen?.length ?? 0} Etappen)`);
}

/* Jede Kategorie im Katalog muss es auch wirklich geben -- sonst nimmt
   der Server sie beim Uebernehmen an und lehnt sie beim Aendern ab. */
{
  const a = await hole(modiAn.keks, "/workspace/api/aufgaben");
  const gueltig = new Set((a.daten?.kategorien || []).map((k) => k.wert));
  /* Die Kategorie heisst im ausgelieferten Katalog `gruppe` -- sie ist
     zugleich die Gruppe, nach der die Oberflaeche sortiert. Ein
     zweiter Name fuer dasselbe waere die Gelegenheit, dass beide
     auseinanderlaufen. */
  const unbekannt = [...new Set((katalog?.aufgaben || []).map((v) => v.gruppe))]
    .filter((k) => !gueltig.has(k));
  ok(gueltig.size > 0 && unbekannt.length === 0,
    unbekannt.length
      ? `unbekannte Kategorie(n) im Katalog: ${unbekannt.join(", ")}`
      : `alle ${gueltig.size} Kategorien passen zum Katalog`);
}

/* ---------- 2. Wer bekommt ihn nicht? -------------------------------- */
console.log("\n=== 2. Und wer ihn nicht bekommt ===\n");
for (const [name, an] of [["Manager", manAn], ["Creator", creatAn]]) {
  const a = await hole(an.keks, "/workspace/api/vorlagen");
  ok(a.status === 200 && a.daten?.katalog === null,
    `${name}: kein Katalog (${JSON.stringify(a.daten?.katalog)})`);
  /* Und der ANDERE Katalog ist bei ihnen sehr wohl da -- sonst waere
     oben auch gruen, wenn die ganze Antwort leer kaeme. */
  ok(a.daten?.aufgaben && Object.keys(a.daten.aufgaben).length > 0,
    `${name}: der Creator-Katalog dagegen schon`);
}
{
  const a = await hole(modiAn.keks, "/workspace/api/vorlagen");
  ok(a.daten?.aufgaben === null,
    "und der Modi bekommt umgekehrt den Creator-Katalog nicht");
}

/* ---------- 3. Uebernehmen ------------------------------------------- */
console.log("\n=== 3. Aus der Vorlage wird eine echte Aufgabe ===\n");
{
  const nr = katalog.aufgaben.findIndex((v) => v.gruppe === "chat");
  const vorlage = katalog.aufgaben[nr];
  const a = await hole(modiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "katalog", nr, gruppe: "chat" }),
  });
  ok(a.status === 200 && a.daten?.angelegt === 1, `übernommen (${a.status})`);

  const b = await hole(modiAn.keks, "/workspace/api/aufgaben");
  const neu = (b.daten?.aufgaben || []).find((x) => x.vorlage === vorlage.schluessel);
  ok(!!neu, `sie liegt auf seinem Brett (${neu?.titel || "nicht gefunden"})`);
  /* DIE KATEGORIE IST DER HALBE WERT DER VORLAGE. Ginge sie unterwegs
     verloren, muesste man 60-mal von Hand einsortieren, was im Dokument
     danebensteht -- und niemand merkte es, weil die Aufgabe ja da ist. */
  /* DIE KATEGORIE IST DER HALBE WERT DER VORLAGE -- und sie heisst im
     ausgelieferten Katalog `gruppe`, weil die Oberflaeche damit
     zeichnet. Ginge sie unterwegs verloren, muesste man von Hand
     einsortieren, was danebensteht. */
  ok(neu?.kategorie === vorlage.gruppe,
    `mit ihrer Kategorie (${neu?.kategorie} / erwartet ${vorlage.gruppe})`);
  ok(!!neu?.frist, `und mit Frist (${neu?.frist})`);
  ok(neu?.verantwortlich_id === idModi, "und er selbst ist verantwortlich");
}

/* Eine ganze Etappe auf einmal. */
{
  const wieViele = katalog.aufgaben.filter((v) => v.gruppe === "technik").length;
  const a = await hole(modiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "katalog_alle", gruppe: "technik" }),
  });
  ok(a.status === 200 && a.daten?.angelegt === wieViele,
    `eine ganze Kategorie auf einmal: ${a.daten?.angelegt} von ${wieViele}`);
}

/* ---------- 4. DogFather traegt fuer jemanden ein -------------------- */
console.log("\n=== 4. DogFather trägt für einen Modi ein ===\n");
{
  const nr = katalog.aufgaben.findIndex((v) => v.gruppe === "analyse");
  const a = await hole(dogiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "katalog", nr, gruppe: "analyse", person_id: idModi }),
  });
  ok(a.status === 200 && a.daten?.angelegt === 1, `für den Modi geht es (${a.status})`);

  /* Aber nicht an einen Creator -- sonst laege eine Aufgabe mit
     Modi-Kategorie an jemandem, der die Kategorien gar nicht kennt, und
     die Trennung waere von innen aufgeweicht. */
  const b = await hole(dogiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "katalog", nr, gruppe: "monat", person_id: idCreat }),
  });
  ok(b.status === 404, `an einen Creator dagegen nicht (${b.status})`);

  /* Und ohne Person gar nicht -- eine Aufgabe ohne Adressaten ist ein
     Zettel. */
  const c = await hole(dogiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "katalog", nr, gruppe: "monat" }),
  });
  ok(c.status === 400 && /Person/i.test(c.daten?.fehler || ""),
    `ohne Person wird gefragt (${c.status} ${c.daten?.fehler || ""})`);
}

/* ---------- 5. Der heikelste Fall ------------------------------------ */
console.log("\n=== 5. Ein Manager versucht es trotzdem ===\n");
{
  const a = await hole(manAn.keks, "/workspace/api/vorlagen/uebernehmen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "katalog", nr: 0, gruppe: "aufbau", person_id: idModi }),
  });
  const b = await hole(manAn.keks, "/workspace/api/vorlagen/uebernehmen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "gibtesnicht", nr: 0 }),
  });
  /* WORTGLEICH. Ein eigener Fehlertext waere die Auskunft, dass es die
     Art gibt -- und damit, dass es den Katalog gibt. */
  ok(a.status === b.status && JSON.stringify(a.daten) === JSON.stringify(b.daten),
    `klingt wie eine erfundene Art (${a.status} ${JSON.stringify(a.daten)})`);
}

/* ---------- 6. Im Browser -------------------------------------------- */
console.log("\n=== 6. Das Brett im echten Browser ===\n");
{
  const { chromium } = await import(
    "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
  const browser = await chromium.launch();
  try {
    const kontext = await browser.newContext({ viewport: { width: 1280, height: 1000 } });
    const seite = await kontext.newPage();
    const konsole = [];
    seite.on("console", (e) => { if (e.type() === "error") konsole.push(e.text()); });
    seite.on("pageerror", (e) => konsole.push("Absturz: " + e.message));
    await seite.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
    await seite.click('.rolle[data-rolle="creator"]');
    await seite.fill("#code", "CODE-MODI-0001");
    await seite.click("button[type=submit]");
    await seite.waitForURL("**/start.html", { timeout: 15000 });
    await seite.goto(BASIS + "/workspace/aufgaben.html", { waitUntil: "networkidle" });
    await seite.waitForTimeout(1200);

    /* Aufklappen, falls es zugeklappt startet. */
    const zu = await seite.evaluate(() =>
      document.getElementById("vorlagenbrett")?.dataset.auf !== "ja");
    if (zu) {
      await seite.click(".vorlagenbrett__kopf").catch(() => {});
      await seite.waitForTimeout(700);
    }

    const bild = await seite.evaluate(() => ({
      sichtbar: !document.getElementById("vorlagenbrett")?.hidden,
      /* ZWEI REIHEN SEIT DEM 16.09.2026: oben die Kategorien, darunter
         die Stufen. Getrennt gezaehlt -- eine gemeinsame Zahl haette
         nicht gesagt, WELCHE der beiden fehlt. */
      /* UEBER DIE BESCHRIFTUNG UNTERSCHIEDEN, nicht ueber eine
         Hilfsklasse (16.09.2026). Seit die Stufenreihe genauso aussieht
         wie die Kategorienreihe -- so wollte Filipe es -- gibt es im
         Aussehen keinen Unterschied mehr. Den gibt es aber im SINN, und
         der steht ohnehin da: in dem Wort, das ein Vorleseprogramm
         ansagt. Eine Klasse nur zum Wiederfinden waere eine zweite
         Wahrheit ueber dieselbe Sache. */
      kategorien: [...document.querySelectorAll(
        '[aria-label="Kategorie wählen"] .stufenleiter__name')]
        .map((z) => z.textContent.trim()),
      stufen: [...document.querySelectorAll(
        '[aria-label="Stufe wählen"] .stufenleiter__name')]
        .map((z) => z.textContent.trim()),
      karten: document.querySelectorAll(".vorlagenbrett__karte").length,
      /* WIE VIELE ZEILEN BRAUCHT DIE FRIST? Gemessen ueber einen
         Bereich um den TEXT, nicht ueber das Element.

         ERST FALSCH GEMESSEN, und die Gegenprobe hat es verraten:
         `element.getClientRects()` liefert hier IMMER genau ein
         Rechteck, weil ein Flex-Kind zu einem Block wird -- die
         Pruefung blieb gruen, auch mit dem Fehler wieder eingebaut.
         Ein Bereich ueber den Textknoten dagegen gibt pro Zeilenkasten
         ein Rechteck, und genau das ist die Frage: Steht "in 2 Tagen"
         auf einer Zeile oder als "in / 2 / Tagen" untereinander? */
      fristZeilen: [...document.querySelectorAll(".vorlagenbrett__frist")]
        .map((z) => {
          const b = document.createRange();
          b.selectNodeContents(z);
          return b.getClientRects().length;
        }),
      /* Und wie viele Karten tragen ueberhaupt den DRITTEN Eintrag, an
         dem es eng wurde. Ohne diese Zahl wuerde die Zeile darueber
         auch dann gruen, wenn der enge Fall gar nicht auf dem Schirm
         war. */
      engeKarten: document.querySelectorAll(".vorlagenbrett__schon").length,
      text: document.body.innerText,
      kopf: (document.querySelector(".kopfleiste .marke__text") || {}).textContent || "",
    }));
    ok(bild.sichtbar, "das Brett steht da");
    ok(bild.kategorien.length === 14,
    `mit vierzehn Kategorien (${bild.kategorien.join(" · ")})`);
  /* DREI STUFEN PLUS "Alle" -- der vierte Knopf ist die Ruecknahme.
     Ohne ihn kaeme man aus einer Stufe nicht wieder heraus, ohne die
     Kategorie zu wechseln. */
  ok(bild.stufen.length === 4 && bild.stufen[0] === "Alle",
    `und drei Stufen daneben (${bild.stufen.join(" · ")})`);
    ok(bild.karten > 0, `und ${bild.karten} Karten in der offenen Etappe`);
    /* Der Katalog des ANDEREN darf nirgends durchschlagen. */
    ok(!/vier Bereichen und vier Stufen/.test(bild.text),
      "kein Wort vom Creator-Katalog");
    /* DIE KOPFLEISTE. Auf jeder Seite steht dort fest "Creator
       Workspace" -- fuer jemanden, der moderiert statt einen Kanal
       aufzubauen, ist das schlicht der falsche Name. Aufgefallen auf
       dem Bildschirmfoto, wie schon die Zierzeile auf der Startseite. */
    ok(bild.kopf.includes("Team") && !bild.kopf.includes("Creator"),
      `die Kopfleiste nennt seinen Betrieb ("${bild.kopf.trim()}")`);
    /* Und der Seitenname dahinter steht noch da -- ihn beim Austausch
       zu verlieren waere lautlos passiert. */
    ok(/Aufgaben/.test(bild.kopf), "der Seitenname dahinter blieb erhalten");
    /* DIE FUSSZEILE DER KARTEN (16.09.2026, auf dem Bildschirmfoto
       gefunden). Bei einer schon uebernommenen Aufgabe stehen dort
       drei Dinge statt zwei, und "Frist: in 2 Tagen" brach mitten im
       Wort auf drei Zeilen um. Die Karten sind alle gleich breit --
       eine einzige gequetschte reicht, um den Fehler zu zeigen. */
    ok(bild.engeKarten > 0,
      `${bild.engeKarten} Karten tragen den dritten Fusseintrag (der enge Fall)`);
    const zuViel = bild.fristZeilen.filter((n) => n !== 1).length;
    ok(bild.fristZeilen.length > 0 && zuViel === 0,
      `jede der ${bild.fristZeilen.length} Fristangaben steht auf einer Zeile`
      + (zuViel ? ` -- ${zuViel} umgebrochen` : ""));

    /* UMLAUTE AUF DEM FERTIGEN BILDSCHIRM (16.09.2026).
       Am 16.09. stand unter jeder Kategorie eine Erklaerung in ASCII:
       "Was im Livechat passiert, waehrend gesendet wird. Loeschen,
       stummschalten, begruessen". Alles gruen, niemand hat es gemerkt.

       HIER und nicht im Quelltext, weil hier der Unterschied sichtbar
       wird, auf den es ankommt: `innerText` ist, was ein Mensch liest.
       Feldnamen, Stilklassen und Adressen -- die ASCII sein MUESSEN --
       stehen nicht drin. Im Quelltext derselben Skripte schlaegt
       dieselbe Liste 71 Mal an, und kein einziges Mal zu Recht.

       Die Kataloge und die festen Seitentexte prueft
       pruef-deutsche-texte, ohne Browser. */
    const ersatz = ersatzschreibungen(bild.text);
    ok(bild.text.length > 400 && ersatz.length === 0,
      ersatz.length
        ? `Ersatzschreibungen auf dem Brett: ${ersatz.join(", ")}`
        : `der Text auf dem Brett traegt Umlaute (${bild.text.length} Zeichen geprueft)`);
    /* GEGENPROBE, sonst hiesse "nichts gefunden" nur, dass nichts
       gesucht wurde -- etwa wenn `innerText` leer bliebe. */
    ok(ersatzschreibungen(`${bild.text} waehrend`).length === 1,
      "und ein eingeschmuggeltes waehrend wuerde auffallen");
    ok(konsole.length === 0,
      konsole.length ? `Fehler in der Konsole: ${konsole[0]}` : "keine Fehler in der Konsole");
    /* DER PFAD GEHOERT AN DIESE DATEI, nicht ans Arbeitsverzeichnis.
       Vorher stand hier ein blosser Dateiname: Das Bild landete dort,
       von wo aus gestartet wurde, waehrend die Zeile darunter
       "server/..." meldete. Man sucht es dann an der falschen Stelle
       -- oder findet ein altes und haelt es fuer das neue. */
    const bildPfad = fileURLToPath(new URL("pruef-modi-katalog.png", import.meta.url));
    await seite.screenshot({ path: bildPfad, fullPage: false });
    console.log("  --   Bildschirmfoto: server/pruef-modi-katalog.png");
    await kontext.close();
  } finally {
    await browser.close();
  }
}

/* =======================================================================
   6b. AN WEN? — die Auswahl steht dort, wo entschieden wird (16.09.2026)

   Filipe: „perfektionniere die kategorien wo ich aufgaben an die modis
   verteile und so."

   Bis heute kam die Person aus dem Formular GANZ OBEN auf der Seite:
   dort wählen, herunterscrollen, „Übernehmen" drücken. Wer das nicht
   weiß, bekommt „Bitte zuerst eine Person wählen" und sucht.

   Und man sah beim Vergeben nicht, wer schon wie viel offen hat. Zu
   wenig Zeit ist der meistgenannte Grund, warum Moderatoren aufhören;
   die Person, die verteilt, ist die einzige, die das verhindern kann.
   Dafür muss die Zahl dort stehen, wo entschieden wird — nicht auf
   einer Auswertung, die man hinterher aufruft.
   ======================================================================= */
console.log("");
console.log("=== 6b. An wen die Aufgabe geht ===");
console.log("");
{
  const { chromium } = await import(
    "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
  const browser = await chromium.launch();
  try {
    const kontext = await browser.newContext({ viewport: { width: 1280, height: 1100 } });
    const seite = await kontext.newPage();
    const konsole = [];
    seite.on("console", (e) => { if (e.type() === "error") konsole.push(e.text()); });
    seite.on("pageerror", (e) => konsole.push("Absturz: " + e.message));
    await seite.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
    await seite.click('.rolle[data-rolle="admin"]');
    await seite.fill("#code", "CODE-DOGI-0001");
    await seite.click("button[type=submit]");
    await seite.waitForURL("**/start.html", { timeout: 15000 });
    await seite.goto(BASIS + "/workspace/aufgaben.html", { waitUntil: "networkidle" });
    await seite.waitForTimeout(1400);
    const zu = await seite.evaluate(() =>
      document.getElementById("vorlagenbrett")?.dataset.auf !== "ja");
    if (zu) {
      await seite.click(".vorlagenbrett__kopf").catch(() => {});
      await seite.waitForTimeout(800);
    }

    const wahl = await seite.evaluate(() => {
      const reihen = [...document.querySelectorAll(".stufenleiter")];
      const letzte = document.querySelector('[aria-label="Person wählen"]');
      const zahl = /^[0-9]+$/;
      return {
        reihen: reihen.length,
        namen: [...(letzte?.querySelectorAll(".stufenleiter__name") || [])]
          .map((z) => z.textContent.trim()),
        zahlenOk: [...(letzte?.querySelectorAll(".stufenleiter__zahl") || [])]
          .every((z) => zahl.test(z.textContent.trim())),
        zahlen: [...(letzte?.querySelectorAll(".stufenleiter__zahl") || [])]
          .map((z) => z.textContent.trim()),
        /* Der Satz steht seit dem 16.09.2026 in `stufenleiter__hilfe`
           -- derselbe Baustein wie beim anderen Brett. Vorher war es
           `vorlagenbrett__stand`, und das ist die Zeile fuer Zahlen. */
        satz: [...document.querySelectorAll(".stufenleiter__hilfe")]
          .map((z) => z.textContent.trim())
          .find((t) => t.includes("Formular oben") || t.includes("gehen an")) || "",
      };
    });
    /* ZWEI FEINE REIHEN: die Stufen und die Personen. Eine einzelne
       Zahl haette nicht gesagt, welche der beiden fehlt. */
    /* DREI REIHEN: Kategorie, Stufe, Person. Die ersten beiden sehen
       jetzt aus wie drueben beim anderen Brett. */
    ok(wahl.reihen === 3, "drei Auswahlreihen (Kategorie, Stufe, Person): " + wahl.reihen);
    ok(wahl.namen.includes("Marina"),
      "der Modi steht zur Auswahl (" + wahl.namen.join(", ") + ")");
    ok(!wahl.namen.includes("Tili") && !wahl.namen.includes("Schulle"),
      "ein Creator und eine Managerin nicht — sie arbeiten im anderen Haus");
    ok(wahl.zahlenOk && wahl.zahlen.length === wahl.namen.length,
      "neben jedem Namen steht, wie viel offen ist (" + wahl.zahlen.join(", ") + ")");
    ok(wahl.satz.includes("Formular oben"),
      "und solange niemand gewählt ist, sagt die Seite es");

    /* JETZT WIRKLICH DRUECKEN -- und nachsehen, ob die Aufgabe bei
       DIESEM Menschen landet. Ein Knopf, den niemand betaetigt hat,
       ist kein geprueter Knopf. */
    await seite.evaluate(() => {
      const reihen = [...document.querySelectorAll(".stufenleiter")];
      const letzte = document.querySelector('[aria-label="Person wählen"]');
      [...letzte.querySelectorAll(".stufenleiter__knopf")]
        .find((k) => k.textContent.includes("Marina"))?.click();
    });
    await seite.waitForTimeout(600);
    const nachWahl = await seite.evaluate(() =>
      [...document.querySelectorAll(".stufenleiter__hilfe")]
        .map((z) => z.textContent.trim()).find((t) => t.includes("gehen an")) || "");
    ok(nachWahl.includes("Marina"), "nach dem Klick steht es da: " + nachWahl);

    const vorher = await seite.evaluate(() => document.querySelectorAll(".karte").length);
    await seite.evaluate(() => {
      [...document.querySelectorAll(".vorlagenbrett__karte")][0]
        ?.querySelector("button")?.click();
    });
    await seite.waitForTimeout(1800);
    const danach = await seite.evaluate(() => ({
      karten: document.querySelectorAll(".karte").length,
      fuerMarina: [...document.querySelectorAll(".karte")]
        .filter((k) => k.textContent.includes("Marina")).length,
    }));
    ok(danach.karten === vorher + 1,
      "die Aufgabe liegt auf dem Brett (" + vorher + " -> " + danach.karten + ")");
    ok(danach.fuerMarina > 0, "und zwar bei Marina (" + danach.fuerMarina + ")");
    ok(konsole.length === 0,
      konsole.length ? "Fehler in der Konsole: " + konsole[0].slice(0, 80)
        : "keine Fehler in der Konsole");
  } finally { await browser.close(); }
}

/* ---------- 7. Gegenprobe -------------------------------------------- */
console.log("\n=== 7. Gegenprobe: kann das hier ueberhaupt scheitern? ===\n");
{
  /* Eine Vorlagennummer, die es nicht gibt. Kaeme dafuer ein 200,
     wuerden die Haken oben nichts beweisen -- dann sagt der Server zu
     allem ja. */
  const a = await hole(modiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "katalog", nr: 9999, gruppe: "aufbau" }),
  });
  ok(a.status === 400, `eine erfundene Vorlagennummer wird abgelehnt (${a.status})`);
  const b = await hole(modiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "katalog_alle", gruppe: "gibtesnicht" }),
  });
  ok(b.status === 400, `und eine erfundene Etappe ebenso (${b.status})`);
}

console.log(`\n${fehler ? "FEHLGESCHLAGEN" : "BESTANDEN"} -- `
  + `${geprueft} geprueft, ${fehler} Fehler, ${offen} nicht nachsehbar`);
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
process.exit(fehler ? 1 : 0);