dogfather-universe/server/pruef-aufgabenbrett.mjs

/* Prueft das Aufgabenbrett fuer alle vier Rollen.

   Wunsch vom 01.09.2026: "verbessere die Aufgabenseite auch bei Manager,
   Scout und Creator. Die Scouts und Manager sollen vielleicht ein
   bisschen mehr Optionen haben, wie ihre zugeteilten Creator. Aber auch
   die Creator sollen es besser und detaillierter sehen.
   ABER NUR DIE ROLLE DOGFATHER SOLL WIRKLICH WEITERHIN ALLEINE ALLES
   SEHEN KOENNEN. DIE ANDEREN SOLLEN NUR IHRE ZUGETEILTEN AUFGABEN VON
   IHREN CREATOR SEHEN."

   DER WICHTIGSTE TEIL DIESER PRUEFUNG IST DER ZWEITE SATZ, nicht der
   erste. Eine huebschere Filterleiste ist eine Annehmlichkeit; eine
   Rechteregel, die zu viel zeigt, ist ein Schaden. Deshalb steht die
   Abgrenzung vorn und wird an KONKRETEN Aufgaben geprueft, deren Titel
   verraten, wem sie gehoeren.

   Zwei Aenderungen an den Rechten werden hier festgehalten:

   1. Ein MANAGER sah auf diesem Brett bisher GAR NICHTS -- er fiel in
      den Default-Zweig ("unbekannte Rolle sieht nichts"). Ein leeres
      Brett sieht aus wie "nichts zu tun", nicht wie ein Fehler; deshalb
      ist das lange niemandem aufgefallen.

   2. In Kalender, Dateien und Bereichen sah ein Manager dagegen ALLES
      (istLeitung). Beides ist jetzt dasselbe: nur die zugeteilten
      Creator. Nur DogFather sieht alles.

   Was ein Manager DARF (freigeben, aendern), ist davon unberuehrt --
   das wird hier ausdruecklich mitgeprueft, damit die Sichtbarkeits-
   aenderung ihm nicht stillschweigend die halben Rechte nimmt. */

import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-brett-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
process.env.PORT = "4216";
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";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
   zwei Auffangnetze ein, die einen Absturz nur protokollieren --
   richtig fuer den Betrieb, fatal fuer eine Pruefung. Ohne diese
   Zeile bleibt der Prozess nach einem Fehler ewig stehen, weil der
   Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
notbremse(480_000, "pruef-aufgabenbrett");
await new Promise((r) => setTimeout(r, 700));
const BASIS = "http://127.0.0.1:4216";
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 300_000).unref?.();

/* ORTSZEIT, nicht UTC. Die Anwendung rechnet "heute" nach der Uhr des
   Benutzers; toISOString() liefert dagegen UTC und damit zwischen
   Mitternacht und 2 Uhr den VORTAG. In diesem Fenster schlug diese
   Pruefung fehl, ohne dass etwas kaputt war. */
const tagText = (d = new Date()) =>
  `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`
  + `-${String(d.getDate()).padStart(2, "0")}`;

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

await fetch(BASIS + "/workspace/api/anmelden", {
  method: "POST", headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
for (let i = 0; i < 60; i++) {
  try {
    const p = new DatabaseSync(process.env.WORKSPACE_DB);
    try { p.prepare("SELECT 1 FROM personen LIMIT 1").get(); break; } finally { p.close(); }
  } catch { await new Promise((r) => setTimeout(r, 250)); }
}
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
const heute = tagText();
const gestern = tagText(new Date(Date.now() - 86400_000));
const morgen = tagText(new Date(Date.now() + 86400_000));

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, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768, jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
const idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
const idMara = anlegen("Mara", "manager", "CODE-MANA-0001");
const idPat  = anlegen("Patrick", "scout", "CODE-SCOU-0001");
const idTili = anlegen("Tili", "creator", "CODE-ANNA-0001");
const idLuna = anlegen("Luna", "creator", "CODE-LUNA-0001");
const idRoy  = anlegen("Roy", "creator", "CODE-ROYY-0001");

/* Mara (Manager) betreut Tili UND Luna -- damit hat sie mehr als einen
   Creator und die Creator-Reihe erscheint wirklich.
   Patrick (Scout) betreut Roy. */
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idTili, idMara, jetzt);
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idMara, jetzt);
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idRoy, idPat, jetzt);

const neu = (titel, creator, verant, frist = null, status = "offen") =>
  d.prepare(`INSERT INTO aufgaben (titel, beschreibung, status, prioritaet, frist,
    creator_id, verantwortlich_id, erstellt, erstellt_von) VALUES (?,?,?,?,?,?,?,?,?)`)
    .run(titel, "", status, "mittel", frist, creator, verant, jetzt, idDogi);

neu("TILI-OFFEN", idTili, idMara);
neu("TILI-UEBERFAELLIG", idTili, idMara, gestern);
neu("LUNA-OFFEN", idLuna, idMara);
neu("LUNA-HEUTE", idLuna, idMara, heute);
neu("ROY-OFFEN", idRoy, idPat);
neu("ROY-UEBERFAELLIG", idRoy, idPat, gestern);
neu("NUR-DOGI", null, idDogi, morgen);
/* Eine Aufgabe, die Tili SELBST verantwortet -- ein Creator muss auch
   die sehen, nicht nur die "ueber" ihn. */
neu("TILI-SELBST", idTili, idTili);
d.close();

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 }),
  });
  return (a.headers.getSetCookie?.() || []).map((x) => x.split(";")[0]).join("; ");
}
const brett = async (keks) => {
  const a = await fetch(BASIS + "/workspace/api/aufgaben", { headers: { cookie: keks } });
  if (!a.ok) return { status: a.status, titel: [] };
  return { status: a.status, titel: ((await a.json()).aufgaben || []).map((x) => x.titel).sort() };
};

const kDogi = await anmelden("admin", "CODE-DOGI-0001");
const kMara = await anmelden("manager", "CODE-MANA-0001");
const kPat  = await anmelden("scout", "CODE-SCOU-0001");
const kTili = await anmelden("creator", "CODE-ANNA-0001");

/* ================================================================
   1. WER SIEHT WAS -- der wichtigste Abschnitt
   ================================================================ */
console.log("\n=== Nur DogFather sieht alles");

const dogi = await brett(kDogi);
ok(dogi.titel.length === 8, `DogFather sieht alle acht (${dogi.titel.length})`);

const mara = await brett(kMara);
ok(mara.titel.length === 5,
   `der Manager sieht seine fuenf: Tili + Luna (${mara.titel.join(", ")})`);
ok(!mara.titel.includes("NUR-DOGI"),
   "  und NICHT die Aufgabe, die nur DogFather gehoert");
ok(!mara.titel.some((t) => t.startsWith("ROY")),
   "  und NICHT die Creator eines anderen Betreuers");

const pat = await brett(kPat);
ok(pat.titel.length === 2 && pat.titel.every((t) => t.startsWith("ROY")),
   `der Scout sieht nur seinen Creator (${pat.titel.join(", ")})`);
ok(!pat.titel.some((t) => t.startsWith("TILI") || t.startsWith("LUNA")),
   "  und nichts von den Creatorn des Managers");

const tili = await brett(kTili);
ok(tili.titel.length === 3 && tili.titel.every((t) => t.startsWith("TILI")),
   `der Creator sieht nur seine eigenen (${tili.titel.join(", ")})`);
ok(tili.titel.includes("TILI-SELBST"),
   "  auch die, die er selbst verantwortet");
ok(!tili.titel.some((t) => t.startsWith("LUNA")),
   "  und nichts von einem anderen Creator desselben Betreuers");

/* DIE GEGENPROBE ZUR AENDERUNG: Vorher sah ein Manager auf diesem Brett
   GAR NICHTS. Waere die Regel weiterhin so, waere die Zahl oben 0 --
   deshalb wird sie hier ausdruecklich als "mehr als null" festgehalten. */
ok(mara.titel.length > 0,
   "Gegenprobe zur alten Regel: der Manager sieht ueberhaupt etwas (vorher: nichts)");

/* ================================================================
   2. AUCH IN DEN ANDEREN BEREICHEN nur die zugeteilten
   ================================================================ */
console.log("\n=== Und in den anderen Bereichen ebenso");
{
  const d2 = new DatabaseSync(process.env.WORKSPACE_DB);
  for (const [titel, creator] of [["TILI-EINTRAG", idTili], ["ROY-EINTRAG", idRoy]]) {
    d2.prepare(`INSERT INTO eintraege (bereich, art, titel, text, status, dringlichkeit,
      datum, creator_id, erstellt, erstellt_von) VALUES ('live','vorbereitung',?,?,?,?,?,?,?,?)`)
      .run(titel, "", "offen", "niedrig", heute, creator, jetzt, idDogi);
  }
  d2.close();
  const eintraege = async (keks) => {
    const a = await fetch(BASIS + "/workspace/api/bereich/live", { headers: { cookie: keks } });
    if (!a.ok) return [];
    return ((await a.json()).eintraege || []).map((x) => x.titel).sort();
  };
  const eD = await eintraege(kDogi);
  const eM = await eintraege(kMara);
  ok(eD.length === 2, `DogFather sieht beide Bereichseintraege (${eD.join(", ")})`);
  ok(eM.length === 1 && eM[0] === "TILI-EINTRAG",
     `der Manager nur den seines Creators (${eM.join(", ")})`);
}

/* ================================================================
   3. WAS EIN MANAGER WEITERHIN DARF
   Die Sichtbarkeit wurde eingeschraenkt -- die RECHTE nicht. Ohne diese
   Pruefung haette der Wunsch "er soll weniger sehen" stillschweigend
   auch "er darf weniger" bedeutet, und das stand nirgends.
   ================================================================ */
console.log("\n=== Der Manager darf weiterhin, was er durfte");
{
  const a = await fetch(BASIS + "/workspace/api/aufgaben", {
    method: "POST", headers: { cookie: kMara, "Content-Type": "application/json" },
    body: JSON.stringify({ titel: "MARA-NEU", prioritaet: "mittel", creator_id: idTili }),
  });
  ok(a.ok, `er kann eine Aufgabe anlegen (${a.status})`);

  const p = await fetch(BASIS + "/workspace/api/personen", { headers: { cookie: kMara } });
  ok(p.ok, `er sieht weiterhin die Personenliste (${p.status})`);
}

/* ================================================================
   4. DIE SEITE SELBST
   ================================================================ */
console.log("\n=== Das Brett im Browser");
const { chromium } = await import(
  "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
const browser = await chromium.launch();

async function seiteAls(rolle, code, breite = 1280) {
  const kontext = await browser.newContext({ viewport: { width: breite, height: 1100 } });
  const konsole = [];
  const seite = await kontext.newPage();
  seite.on("console", (m) => { if (m.type() === "error") konsole.push(m.text()); });
  seite.on("pageerror", (e) => konsole.push("pageerror: " + e.message));
  await seite.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
  await seite.click(`.rolle[data-rolle="${rolle}"]`);
  await seite.fill("#code", code);
  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);
  return { kontext, seite, konsole };
}

const lesen = (seite) => seite.evaluate(() => ({
  lage: document.getElementById("lage")?.hidden === false
    ? document.querySelector(".lage__satz")?.textContent : null,
  stufe: document.getElementById("lage")?.dataset.stufe,
  meins: document.querySelector(".lage__meins")?.textContent || null,
  schnitte: [...document.querySelectorAll(".schnitt")].map((b) => ({
    name: b.querySelector("span")?.textContent,
    zahl: b.querySelector(".schnitt__zahl")?.textContent,
    aus: b.disabled,
  })),
  creator: [...document.querySelectorAll(".creator-knopf")].map((b) =>
    b.querySelector(".creator-knopf__name")?.textContent),
  creatorReiheDa: document.getElementById("creator-reihe")?.hidden === false,
  karten: document.querySelectorAll(".karte").length,
  ueber: document.documentElement.scrollWidth - document.documentElement.clientWidth,
  /* Ist der Stil angekommen? Die Klassen stehen in aufgaben.css -- diese
     Seite laedt sie, aber genau das ist hier schon zweimal schiefgegangen. */
  gestaltet: (() => {
    const b = document.querySelector(".schnitt");
    if (!b) return null;
    const st = getComputedStyle(b);
    return parseFloat(st.borderTopWidth) >= 1 && parseFloat(st.borderTopLeftRadius) >= 8;
  })(),
}));

/* ---- Der Manager: mehr Optionen, aber nur seine Creator ---- */
const bMara = await seiteAls("manager", "CODE-MANA-0001");
const rM = await lesen(bMara.seite);
ok(rM.lage !== null, `der Manager bekommt einen Lagesatz ("${rM.lage}")`);
ok(rM.stufe === "warnung", `und er warnt, weil etwas ueberfaellig ist (${rM.stufe})`);
ok(rM.gestaltet === true, "die Stile sind angekommen (Rand und Ecken gemessen)");
ok(rM.schnitte.length === 4,
   `vier Ausschnitte: ${rM.schnitte.map((s) => `${s.name}=${s.zahl}`).join(" · ")}`);
ok(rM.schnitte.some((s) => s.name === "Nur meine"),
   "  darunter 'Nur meine' – die hat ein Betreuer");
const ueberf = rM.schnitte.find((s) => s.name === "Überfällig");
ok(ueberf?.zahl === "1", `  'Überfällig' zeigt die richtige Zahl (${ueberf?.zahl})`);
ok(rM.creatorReiheDa && rM.creator.join(", ") === "Alle, Tili, Luna",
   `die Creator-Reihe zeigt genau seine beiden (${rM.creator.join(", ")})`);
ok(!rM.creator.includes("Roy"),
   "  und NICHT den Creator eines anderen Betreuers");
ok(rM.ueber <= 0, `nichts steht ueber (${rM.ueber}px)`);

/* Einschraenken auf einen Creator -- und wirklich weniger sehen. */
const vorher = rM.karten;
await bMara.seite.click('.creator-knopf:has(.creator-knopf__name:text-is("Luna"))')
  .catch(async () => {
    await bMara.seite.evaluate(() => {
      [...document.querySelectorAll(".creator-knopf")]
        .find((b) => b.textContent.includes("Luna"))?.click();
    });
  });
await bMara.seite.waitForTimeout(400);
const nachher = await bMara.seite.evaluate(() => ({
  karten: document.querySelectorAll(".karte").length,
  titel: [...document.querySelectorAll(".karte__titel")].map((e) => e.textContent).sort(),
}));
ok(nachher.karten < vorher && nachher.titel.every((t) => t.startsWith("LUNA")),
   `ein Klick auf einen Creator zeigt nur dessen Aufgaben `
   + `(${vorher} -> ${nachher.karten}: ${nachher.titel.join(", ")})`);
ok(bMara.konsole.length === 0,
   `keine Fehler in der Konsole${bMara.konsole.length ? " -> " + bMara.konsole.join(" | ") : ""}`);
await bMara.seite.screenshot({ path: "pruef-aufgabenbrett.png", fullPage: false });
await bMara.kontext.close();

/* ---- Der Creator: mehr Detail, aber keine fremden Optionen ---- */
const bTili = await seiteAls("creator", "CODE-ANNA-0001");
const rT = await lesen(bTili.seite);
ok(rT.lage !== null, `der Creator bekommt denselben Lagesatz ("${rT.lage}")`);
ok(rT.schnitte.length === 3,
   `drei Ausschnitte – ohne 'Nur meine' (${rT.schnitte.map((s) => s.name).join(" · ")})`);
ok(!rT.schnitte.some((s) => s.name === "Nur meine"),
   "  denn bei ihm ist ohnehin alles seins");
ok(!rT.creatorReiheDa,
   "keine Creator-Reihe – ein Filter mit einem Eintrag ist ein Knopf, der nichts tut");
ok(rT.meins === null, "und keine 'davon bei dir'-Marke");
/* KEINE FESTE ZAHL. Der erste Anlauf erwartete hier drei -- und lag
   falsch, weil der Abschnitt davor ("darf der Manager noch anlegen?")
   eine vierte Aufgabe fuer denselben Creator erzeugt. Die Pruefung war
   damit von ihrer eigenen Reihenfolge abhaengig, und das ist eine
   Zeitbombe: Wer spaeter einen Abschnitt einfuegt, bekommt einen
   Fehlschlag, der nichts mit seiner Aenderung zu tun hat.

   Verglichen wird jetzt gegen die Schnittstelle -- das Brett muss genau
   so viele Karten zeigen, wie der Server ihm gibt. Das ist ohnehin die
   bessere Frage: nicht "sind es drei", sondern "verschluckt die Seite
   etwas". */
const tiliJetzt = await brett(kTili);
ok(rT.karten === tiliJetzt.titel.length,
   `das Brett zeigt genau, was der Server ihm gibt `
   + `(${rT.karten} Karten, ${tiliJetzt.titel.length} vom Server)`);
ok(tiliJetzt.titel.every((t) => t.startsWith("TILI") || t.startsWith("MARA")),
   `und alles davon gehoert zu ihm (${tiliJetzt.titel.join(", ")})`);
ok(bTili.konsole.length === 0,
   `keine Fehler in der Konsole${bTili.konsole.length ? " -> " + bTili.konsole.join(" | ") : ""}`);
await bTili.kontext.close();

/* ---- DogFather: dieselbe Leiste, aber ueber ALLE Creator ----
   Ausdruecklich nachgereicht ("die Seite Aufgabe auch bei DogFather
   machen bitte"). Er ist keine Creator-Rolle, bekommt die Leiste also
   ohnehin -- geprueft wird, dass sie bei ihm auch WIRKLICH alles
   umfasst und nicht nur die, die ihm zugeteilt waeren. */
const bDogi = await seiteAls("admin", "CODE-DOGI-0001");
const rD = await lesen(bDogi.seite);
ok(rD.lage !== null, `DogFather bekommt den Lagesatz ("${rD.lage}")`);
ok(rD.schnitte.length === 4,
   `vier Ausschnitte: ${rD.schnitte.map((x) => `${x.name}=${x.zahl}`).join(" · ")}`);
ok(rD.creatorReiheDa, "und die Creator-Reihe");
ok(["Tili", "Luna", "Roy"].every((n) => rD.creator.includes(n)),
   `sie umfasst ALLE Creator, nicht nur zugeteilte (${rD.creator.join(", ")})`);
ok(rD.karten >= 8, `er sieht weiterhin alles (${rD.karten} Karten)`);
/* Die Beschriftung: "Deine Creator" waere bei ihm eine falsche Auskunft. */
const schild = await bDogi.seite.evaluate(() =>
  document.querySelector(".creator-reihe__schild")?.textContent);
ok(schild === "Alle Creator",
   `die Reihe heisst bei ihm "Alle Creator" statt "Deine" ("${schild}")`);
ok(bDogi.konsole.length === 0,
   `keine Fehler in der Konsole${bDogi.konsole.length ? " -> " + bDogi.konsole.join(" | ") : ""}`);
await bDogi.kontext.close();

/* ---- Der Scout: eine Creator-Reihe waere hier sinnlos ---- */
const bPat = await seiteAls("scout", "CODE-SCOU-0001");
const rP = await lesen(bPat.seite);
ok(!rP.creatorReiheDa,
   "der Scout mit nur einem Creator bekommt die Reihe ebenfalls nicht");
ok(rP.karten === 2, `sieht seine zwei (${rP.karten})`);
await bPat.kontext.close();

/* ---- Handy ---- */
const bHandy = await seiteAls("manager", "CODE-MANA-0001", 390);
const rH = await lesen(bHandy.seite);
ok(rH.ueber <= 0, `auf dem Handy steht nichts ueber (${rH.ueber}px)`);
ok(rH.schnitte.length === 4, `die Ausschnitte sind auch dort da (${rH.schnitte.length})`);
await bHandy.kontext.close();

/* ---------------------------------------------------------------------
   DRINGEND SCHLAEGT WICHTIG (09.09.2026)

   Filipe: "das system von den aufgaben, die bedienung. wie gesagt
   perfektionier das."

   Beim Durchgehen der Bedienung gefunden: Die Liste war nach
   PRIORITAET sortiert, dann nach Frist. Auf dem Brett stand damit eine
   seit Tagen ueberfaellige Aufgabe mit Prioritaet "mittel" UNTER einer,
   die als "hoch" eingetragen ist und erst in Wochen faellig wird. Wer
   die Spalte von oben liest, faengt dann mit dem Falschen an.

   Eine Prioritaet ist eine Einschaetzung von damals, eine
   ueberschrittene Frist eine Tatsache von heute.
   --------------------------------------------------------------------- */
console.log("\n=== Die Reihenfolge auf dem Brett");
{
  const dd = new DatabaseSync(process.env.WORKSPACE_DB);
  const tagT = (v) => { const x = new Date(Date.now() + v * 86400000);
    return `${x.getFullYear()}-${String(x.getMonth() + 1).padStart(2, "0")}`
      + `-${String(x.getDate()).padStart(2, "0")}`; };
  /* Absichtlich in der ungünstigsten Reihenfolge angelegt: Die
     ueberfaellige zuerst mit NIEDRIGER Prioritaet, die weit entfernte
     mit HOHER. Nach der alten Sortierung stuende die weit entfernte
     oben. */
  dd.prepare(`INSERT INTO aufgaben (titel, beschreibung, status, prioritaet, frist,
              creator_id, verantwortlich_id, erstellt, erstellt_von)
              VALUES (?,?,'offen',?,?,?,?,?,?)`)
    .run("SORT-ueberfaellig-niedrig", "", "niedrig", tagT(-4), idTili, idTili, jetzt, idDogi);
  dd.prepare(`INSERT INTO aufgaben (titel, beschreibung, status, prioritaet, frist,
              creator_id, verantwortlich_id, erstellt, erstellt_von)
              VALUES (?,?,'offen',?,?,?,?,?,?)`)
    .run("SORT-fern-hoch", "", "hoch", tagT(30), idTili, idTili, jetzt, idDogi);
  dd.close();

  const a = await fetch(BASIS + "/workspace/api/aufgaben", { headers: { cookie: kTili } });
  const liste = (await a.json()).aufgaben.filter((x) => x.titel.startsWith("SORT-"));
  ok(liste.length === 2, `beide Probeaufgaben da (${liste.length})`);
  ok(liste[0]?.titel === "SORT-ueberfaellig-niedrig",
     `die überfällige steht oben, obwohl sie "niedrig" ist `
     + `(Reihenfolge: ${liste.map((x) => x.titel).join(" vor ")})`);

  /* GEGENPROBE: Bei gleicher Lage entscheidet weiterhin die Prioritaet.
     Ohne sie hiesse "Frist zuerst", dass die Prioritaet gar nichts mehr
     tut -- und das waere die andere Uebertreibung. */
  const dd2 = new DatabaseSync(process.env.WORKSPACE_DB);
  for (const [t, pr] of [["SORTB-niedrig", "niedrig"], ["SORTB-hoch", "hoch"]]) {
    dd2.prepare(`INSERT INTO aufgaben (titel, beschreibung, status, prioritaet, frist,
                 creator_id, verantwortlich_id, erstellt, erstellt_von)
                 VALUES (?,?,'offen',?,?,?,?,?,?)`)
      .run(t, "", pr, tagT(10), idTili, idTili, jetzt, idDogi);
  }
  dd2.close();
  const b = await fetch(BASIS + "/workspace/api/aufgaben", { headers: { cookie: kTili } });
  const zwei = (await b.json()).aufgaben.filter((x) => x.titel.startsWith("SORTB-"));
  ok(zwei[0]?.titel === "SORTB-hoch",
     `bei gleicher Frist entscheidet weiter die Priorität `
     + `(${zwei.map((x) => x.titel).join(" vor ")})`);

  /* Und die Marke "wichtig" steht auf der Karte -- die Prioritaet war
     vorher nur ein 3 px breiter Rand neben der farbigen Spaltenkante
     und damit praktisch unsichtbar. */
  const b2 = await seiteAls("creator", "CODE-ANNA-0001");
  const marken = await b2.seite.evaluate(() => {
    const k = [...document.querySelectorAll("#brett .karte")];
    return { mitMarke: k.filter((x) => x.querySelector(".karte__wichtig")).length,
             gesamt: k.length,
             hochOhne: k.filter((x) => x.dataset.prio === "hoch"
               && x.dataset.status !== "erledigt" && !x.querySelector(".karte__wichtig")).length,
             niedrigMit: k.filter((x) => x.dataset.prio !== "hoch"
               && x.querySelector(".karte__wichtig")).length };
  });
  ok(marken.mitMarke > 0 && marken.hochOhne === 0,
     `jede wichtige Aufgabe traegt die Marke (${marken.mitMarke} von ${marken.gesamt})`);
  ok(marken.niedrigMit === 0,
     `und keine unwichtige traegt sie (${marken.niedrigMit})`);
  await b2.kontext.close();
}

await browser.close();
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
console.log(fehler ? `\n${fehler} Prüfung(en) fehlgeschlagen.` : "\nAlles in Ordnung.");
process.exit(fehler ? 1 : 0);