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

/* =====================================================================
   DER VERBORGENE MODI-ZUGANG

   Zwei Fragen, und sie sind nicht dieselbe:

     1. KOMMT EIN MODI HEREIN, ohne dass es dafuer eine Kachel gibt?
     2. MERKT SONST JEMAND ETWAS DAVON?

   Die zweite ist die schwierigere. Eine Liste zu filtern ist leicht;
   uebersehen wird die ZAHL daneben, die weiter alles mitzaehlt -- und
   eine Personenzahl, die nicht zur Liste passt, verraet genauso viel
   wie ein Name.

   MIT GEGENPROBE. Ganz unten wird die Regel absichtlich ausgehebelt
   (ein Modi bekommt in der Datenbank eine andere Rolle), und dann MUSS
   der Manager ihn sehen. Ohne diesen Teil waere nicht bewiesen, dass
   die Pruefung ueberhaupt anschlagen kann -- eine Pruefung, die immer
   bestaetigt, bestaetigt nichts.
   ===================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-modi-"));
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-verborgen");
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 { eigenerPort } from "./helfer-port.mjs";
await import("./index.js");
/* NACH index.js: Der Server haengt dort zwei Auffangnetze ein, die
   einen Absturz nur protokollieren. Fuer den Betrieb richtig, fuer eine
   Pruefung fatal -- ohne diese Zeile bliebe der Prozess ewig stehen. */
notbremse(180_000, "pruef-modi-verborgen");
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++; };
/* Der dritte Ausgang: Konnte nicht nachgesehen werden. Kein Befund,
   aber auch keine Bestaetigung -- und es wird gesagt, damit niemand
   glaubt, hier sei etwas geprueft worden. */
let offen = 0;
const unklar = (t) => { offen++; console.log("  --   " + t); };

/* ---------- 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 jetzt = new Date().toISOString();

/* Der Suchschluessel muss VOR dem Anlegen dastehen -- die Personen
   werden hier von Hand eingetragen, nicht ueber personAnlegen(). */
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);
const kennung = (code) => createHmac("sha256", schluessel).update(code).digest("hex");

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, kennung(code), jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}

const idDogi   = anlegen("Filipe", "admin", "CODE-DOGI-0001");
const idVan    = anlegen("VanVan", "admin", "CODE-VAN-0001");
const idSpicy  = anlegen("Cigdem", "spicy", "CODE-SPIC-0001");
const idMan    = anlegen("Schulle", "manager", "CODE-MAN-0001");
const idScout  = anlegen("Patrick", "scout", "CODE-SCOU-0001");
const idCreat  = anlegen("Tili", "creator", "CODE-ANNA-0001");
const idModi1  = anlegen("Marina", "modi", "CODE-MODI-0001");
const idModi2  = anlegen("Kim", "modi", "CODE-MODI-0002");
/* DIE STELLVERTRETUNG GEHOERT IN DIESELBE PRUEFUNG (10.09.2026).

   Sie ist seit heute die zweite verborgene Rolle. Ohne diese Zeile
   waere der ganze Lauf weiter gruen gewesen -- und haette die neue
   Rolle kein einziges Mal angesehen. Genau die Sorte gruener Haken,
   vor der die Hausregeln warnen: Er bestaetigt etwas, das er nicht
   geprueft hat.

   Sie wird bewusst in dieselben Listen aufgenommen wie die Modis, statt
   danebenzustehen: Was fuer einen Modi gilt, gilt fuer sie -- und wenn
   morgen jemand einen Weg hinzufuegt, deckt er beide ab, ohne dass es
   ihm jemand sagen muss. */
const idHand   = anlegen("Rieke", "hand", "CODE-HAND-0001");
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)")
  .run(idCreat, idScout, jetzt);
d.prepare("INSERT INTO scout_zuteilung (scout_id, manager_id, seit) VALUES (?,?,?)")
  .run(idScout, idMan, jetzt);
d.close();

const MODIS = [idModi1, idModi2, idHand];
void idSpicy;

/* ---------- Anmelden ueber die Schnittstelle ------------------------- */
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 daten = await a.json().catch(() => ({}));
  const keks = (a.headers.getSetCookie?.() || []).map((z) => z.split(";")[0]).join("; ");
  return { status: a.status, daten, keks };
}

console.log("\n=== 1. Der Eingang: eine Kachel gibt es nicht ===\n");

for (const kachel of ["creator", "scout", "manager", "spicy", "admin"]) {
  const a = await anmelden(kachel, "CODE-MODI-0001");
  ok(a.status === 200 && a.daten?.rolle === "modi",
    `Kachel "${kachel}" + Modi-Code -> angemeldet als ${a.daten?.rolle || a.status}`);
}

/* Der Umkehrschluss, und er ist der wichtigere: Der stille Weg darf
   NICHT dazu fuehren, dass auch alle anderen die Kachel ignorieren
   duerfen. Ein Manager mit der Kachel "creator" muss weiterhin
   scheitern -- sonst haette ich nebenbei die Rollenpruefung
   abgeschafft, ohne es zu merken. */
{
  const a = await anmelden("creator", "CODE-MAN-0001");
  ok(a.status === 401, `Manager-Code auf der Creator-Kachel bleibt abgewiesen (${a.status})`);
}

/* Wortgleichheit: "modi" von aussen anzugeben darf nicht anders klingen
   als eine erfundene Rolle. */
{
  const m = await anmelden("modi", "FALSCH-FALSCH-1");
  const x = await anmelden("gibtesnicht", "FALSCH-FALSCH-1");
  ok(m.status === 401 && x.status === 401
    && JSON.stringify(m.daten) === JSON.stringify(x.daten),
    "Rolle \"modi\" von aussen klingt wie eine erfundene "
    + `(${m.status} ${JSON.stringify(m.daten)} vs. ${x.status} ${JSON.stringify(x.daten)})`);
}

{
  const a = await anmelden("creator", "CODE-MODI-FALSCH");
  ok(a.status === 401, `ein falscher Modi-Code wird abgewiesen (${a.status})`);
}

/* ---------- 2. Die Unsichtbarkeit ------------------------------------ */
console.log("\n=== 2. Wer sieht die Modis? ===\n");

/* Jede Schnittstelle, die Personen ausgibt. Dieselbe Landkarte wie in
   pruef-verborgen.mjs -- wer eine neue baut, traegt sie in BEIDE ein. */
const WEGE = [
  ["Chat-Partner",       "/workspace/api/chat/partner",        (x) => x.personen],
  ["Personenwahl",       "/workspace/api/personen",            (x) => x.personen],
  ["Personenverwaltung", "/workspace/api/verwaltung/personen", (x) => x.personen],
  ["Betreuer-Auswahl",   "/workspace/api/verwaltung/personen", (x) => x.betreuer],
  /* NACHGESEHEN, NICHT ANGENOMMEN: Die Segmente der Zentrale tragen
     KEINE Nummer -- nur `{ name, rolle, stufe, heute, alt }`, und der
     Name ist auf den Vornamen gekuerzt. Wer hier nur nach `id` sucht,
     bekommt einen gruenen Haken, ohne etwas angesehen zu haben. Genau
     deshalb vergleicht der Treffer unten BEIDES. */
  ["Zentrale (Team)",    "/workspace/api/zentrale",            (x) => x.segmente],
];

/* Die Namen der Modis -- fuer die Wege, die keine Nummern liefern. */
const MODI_NAMEN = ["Marina", "Kim", "Rieke"];

const LEUTE = [
  ["DogFather",   "admin",   "CODE-DOGI-0001", true],
  ["VanVan",      "admin",   "CODE-VAN-0001",  true],
  ["Spicy Media", "spicy",   "CODE-SPIC-0001", false],
  ["Manager",     "manager", "CODE-MAN-0001",  false],
  ["Scout",       "scout",   "CODE-SCOU-0001", false],
  ["Creator",     "creator", "CODE-ANNA-0001", false],
  ["Modi Marina", "creator", "CODE-MODI-0001", true],
  ["Rechte Hand",  "creator", "CODE-HAND-0001", true],
];

async function hole(keks, pfad) {
  const a = await fetch(BASIS + pfad, { headers: { cookie: keks } });
  if (!a.ok) return { status: a.status, daten: null };
  return { status: 200, daten: await a.json().catch(() => null) };
}

for (const [name, kachel, code, darf] of LEUTE) {
  const an = await anmelden(kachel, code);
  if (an.status !== 200) { unklar(`${name}: Anmeldung misslang (${an.status})`); continue; }
  for (const [was, pfad, ziehen] of WEGE) {
    const { status, daten } = await hole(an.keks, pfad);
    if (status !== 200) {
      unklar(`${name.padEnd(12)} ${was.padEnd(20)} kein Zugriff (${status})`);
      continue;
    }
    let liste = [];
    try { liste = ziehen(daten) || []; } catch { liste = []; }
    const drin = liste.filter((z) => z
      && (MODIS.includes(z.id ?? z.person_id)
        || MODI_NAMEN.includes(String(z.name || "").trim().split(/\s+/)[0])));
    if (darf) {
      ok(true, `${name.padEnd(12)} ${was.padEnd(20)} sieht ${drin.length} Modi(s)`);
    } else {
      ok(drin.length === 0,
        `${name.padEnd(12)} ${was.padEnd(20)} `
        + (drin.length ? `SIEHT ${drin.length} MODI -- FEHLER` : "sieht keinen Modi"));
    }
  }
}

/* ---------- 3. Die Zahl daneben -------------------------------------- */
console.log("\n=== 3. Auch die ZAHL darf sie nicht mitzaehlen ===\n");
{
  const an = await anmelden("manager", "CODE-MAN-0001");
  const { status, daten } = await hole(an.keks, "/workspace/api/personen");
  if (status !== 200 || !Array.isArray(daten?.personen)) {
    unklar(`Personenwahl fuer den Manager nicht lesbar (${status})`);
  } else {
    const namen = daten.personen.map((z) => z.name);
    /* Die Zahl der geprueften Dinge gehoert in die BEDINGUNG, nicht nur
       in den Meldetext: Eine leere Liste wuerde sonst als "keine Modis
       drin" durchgehen, und die Pruefung waere wertlos. */
    ok(namen.length > 0 && !namen.includes("Marina") && !namen.includes("Kim"),
      `der Manager sieht ${namen.length} Personen, keine davon ein Modi `
      + `(${namen.join(", ")})`);
  }
}

/* ---------- 4. Sehen die Modis einander? ----------------------------- */
console.log("\n=== 4. Die Modis sind untereinander ein Team ===\n");
{
  const an = await anmelden("creator", "CODE-MODI-0001");
  const { status, daten } = await hole(an.keks, "/workspace/api/personen");
  if (status !== 200 || !Array.isArray(daten?.personen)) {
    unklar(`Personenwahl fuer den Modi nicht lesbar (${status})`);
  } else {
    const ids = daten.personen.map((z) => z.id);
    ok(ids.includes(idModi2), "Marina sieht Kim");
    ok(ids.includes(idDogi), "Marina sieht DogFather");
    /* VanVan bleibt fuer alle ausser DogFather verborgen -- das ist die
       Regel vom 09.09.2026, und sie gilt auch gegenueber Modis. */
    ok(!ids.includes(idVan), "Marina sieht VanVan NICHT (verborgener Zugang)");
    ok(!ids.includes(idMan) && !ids.includes(idScout) && !ids.includes(idCreat),
      "Marina sieht weder Manager noch Scout noch Creator");
  }
}

/* ---------- 5. Der echte Weg durch die Anwendung --------------------- */
console.log("\n=== 5. Anlegen wie im Betrieb: DogFather legt einen Modi an ===\n");
{
  const an = await anmelden("admin", "CODE-DOGI-0001");
  const kopf = { "Content-Type": "application/json", cookie: an.keks };

  /* a) Steht die Rolle ueberhaupt zur Auswahl -- und kommt sie vom
        Server, nicht aus einer Datei im Browser? */
  const { status, daten } = await hole(an.keks, "/workspace/api/verwaltung/personen");
  if (status !== 200) {
    unklar(`Verwaltung fuer DogFather nicht lesbar (${status})`);
  } else {
    const zusatz = daten?.zusatzrollen || [];
    ok(zusatz.some((z) => z.wert === "modi"),
      "DogFather bekommt die Rolle zur Auswahl angeboten "
      + `(${zusatz.map((z) => z.wert).join(", ") || "keine"})`);
  }

  /* b) Anlegen -- ueber genau den Weg, den die Oberflaeche benutzt. */
  const a = await fetch(BASIS + "/workspace/api/verwaltung/personen", {
    method: "POST", headers: kopf,
    body: JSON.stringify({ name: "Testmodi Neu", rolle: "modi" }),
  });
  const neuDaten = await a.json().catch(() => ({}));
  ok(a.status === 201 && neuDaten?.rolle === "modi" && typeof neuDaten?.code === "string",
    `angelegt (${a.status}, Rolle ${neuDaten?.rolle}, `
    + `Code ${neuDaten?.code ? "erhalten" : "FEHLT"})`);

  /* c) DER EIGENTLICHE PUNKT: Kommt der so angelegte Modi auch herein?

        Die Abschnitte oben haben die Personen VON HAND eingetragen und
        den Suchschluessel selbst ausgerechnet. Damit ist nicht bewiesen,
        dass personAnlegen() ihn im Betrieb auch wirklich schreibt -- und
        ohne ihn findet der stille Zugang niemanden. Waere die Zeile dort
        vergessen worden, waeren oben trotzdem alle Haken gruen und kein
        einziger echter Modi kaeme herein. */
  if (neuDaten?.code) {
    const b = await anmelden("creator", neuDaten.code);
    ok(b.status === 200 && b.daten?.rolle === "modi",
      "und meldet sich mit seinem Code an, ueber eine fremde Kachel "
      + `(${b.status}, ${b.daten?.rolle})`);
  } else {
    unklar("ohne Code laesst sich die Anmeldung nicht pruefen");
  }

  /* d) Und ist auch der Neue fuer den Manager unsichtbar? */
  const m = await anmelden("manager", "CODE-MAN-0001");
  const sicht = await hole(m.keks, "/workspace/api/personen");
  if (sicht.status !== 200 || !Array.isArray(sicht.daten?.personen)) {
    unklar(`Personenwahl fuer den Manager nicht lesbar (${sicht.status})`);
  } else {
    const namen = sicht.daten.personen.map((z) => z.name);
    ok(namen.length > 0 && !namen.includes("Testmodi Neu"),
      `der Manager sieht ihn nicht (${namen.length} Personen: ${namen.join(", ")})`);
  }
}
/* ---------- 6. Die Startseite eines Modis ---------------------------- */
console.log("\n=== 6. Was ein Modi auf seiner Startseite sieht ===\n");
{
  const an = await anmelden("creator", "CODE-MODI-0001");
  const { status, daten } = await hole(an.keks, "/workspace/api/ich");
  if (status !== 200) {
    unklar(`/api/ich nicht lesbar (${status})`);
  } else {
    const b = daten?.bereiche;
    ok(Array.isArray(b) && b.length > 0,
      `der Server schickt ihm ${Array.isArray(b) ? b.length : "keine"} Kacheln`);
    /* Nichts aus der Agentur. Nicht "moeglichst wenig", sondern keine
       einzige -- diese Seiten drehen sich um betreute Creator, um
       Rechte oder um Automationen. */
    const verboten = ["personen.html", "scouting.html", "automation.html",
      "report.html", "calls.html", "uebersicht.html", "content.html"];
    const drin = (b || []).map((x) => x.ziel).filter((z) => verboten.includes(z));
    ok(Array.isArray(b) && drin.length === 0,
      drin.length ? `ABER AUCH: ${drin.join(", ")} -- FEHLER` : "und nichts aus der Agentur");
    /* Die Beschriftung gehoert zum Empfaenger: "Alle Creator auf einen
       Blick" waere fuer jemanden ohne Creator schlicht falsch. */
    ok((b || []).every((x) => x.name && x.unter && x.zeichen && x.ziel),
      "jede Kachel hat Beschriftung, Zeichen und Ziel");
  }

  /* GEGENPROBE ZUR QUELLE: Fuer eine bekannte Rolle muss `null`
     herauskommen -- nicht eine leere Liste. Die Oberflaeche
     unterscheidet die beiden, und verwechselte man sie, haetten alle
     anderen ab sofort eine leere Startseite. */
  const m = await anmelden("manager", "CODE-MAN-0001");
  const mi = await hole(m.keks, "/workspace/api/ich");
  ok(mi.status === 200 && mi.daten?.bereiche === null,
    `beim Manager steht dort null, nicht [] (${JSON.stringify(mi.daten?.bereiche)})`);
}

/* ---------- 7. Und im echten Browser? -------------------------------- */
console.log("\n=== 7. Dieselbe Seite mit einem 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: 390, height: 844 } });
    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" });
    /* Irgendeine Kachel -- fuer einen Modi gibt es keine eigene. */
    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.waitForTimeout(1200);

    const bild = await seite.evaluate(() => ({
      kacheln: [...document.querySelectorAll(".gruppe a[href]")].map((a) => a.getAttribute("href")),
      gruppen: [...document.querySelectorAll(".gruppe__kopf")].map((k) => k.textContent.trim().slice(0, 40)),
      rolle: (document.getElementById("zgruss-rolle") || {}).textContent || "",
      rollentext: (document.getElementById("rollentext") || {}).textContent || "",
      marke: (document.querySelector(".zmarke") || {}).textContent || "",
      rauten: document.querySelectorAll(".zmarke .zraute").length,
    }));

    /* Die ZAHL gehoert in die Bedingung, nicht nur in den Text: Eine
       leere Seite wuerde sonst als "nichts Verbotenes dabei" durchgehen. */
    ok(bild.kacheln.length >= 8,
      `${bild.kacheln.length} Kacheln stehen wirklich auf der Seite (${bild.gruppen.join(" | ")})`);
    ok(bild.kacheln.some((h) => h.startsWith("aufgaben.html")),
      "darunter das Aufgabenbrett -- das Herzstueck aus Kapitel 6");
    ok(!bild.kacheln.some((h) => /personen|scouting|automation|report/.test(h)),
      "und nichts aus der Agentur");
    /* Der Anzeigename kommt aus /api/ich, nicht aus einer Datei im
       Browser -- sonst stuende das Wort in einer Datei, die jeder
       bekommt. Dass er hier steht, ist der Nachweis, dass der Weg geht. */
    ok(bild.rolle.trim() === "MODI",
      `die Plakette sagt "${bild.rolle.trim()}" (kommt vom Server)`);
    /* EIN SATZ, KEIN WORT. Die fuenf bekannten Rollen bekommen unter
       der Begruessung eine Erklaerung ("Creator · dein eigener
       Bereich"). Stuende dort nur "Modi", saehe die Seite nicht
       verborgen aus, sondern unfertig -- und genau das stand da, bis
       diese Pruefung es gemeldet hat. */
    ok(bild.rollentext.includes("·") && bild.rollentext.trim().length > 12,
      `und die Zeile darunter ist ein ganzer Satz ("${bild.rollentext.trim()}")`);
    /* DIE MARKE UEBER DEM TITEL. Ein Modi gehoert nicht zur Agentur --
       stand dort "Spicy Media", war die Seite fuer ihn schlicht falsch
       beschriftet. Gefunden auf dem Bildschirmfoto, nicht im Code. */
    ok(bild.marke.includes("Team Dogi") && !bild.marke.includes("Spicy"),
      `die Zierzeile nennt seinen Betrieb ("${bild.marke.trim()}")`);
    /* Und die beiden Zierrauten sind noch da: Sie beim Austausch des
       Textes zu verlieren waere lautlos passiert. */
    ok(bild.rauten === 2, `die beiden Zierrauten stehen noch (${bild.rauten})`);
    ok(konsole.length === 0,
      konsole.length ? `Fehler in der Konsole: ${konsole[0]}` : "keine Fehler in der Konsole");

    await seite.screenshot({ path: "pruef-modi-start.png", fullPage: true });
    console.log("  --   Bildschirmfoto: server/pruef-modi-start.png");
    await kontext.close();
  } finally {
    await browser.close();
  }
}
/* ---------- 8. Was einem Modi GEHOERT, sieht sonst niemand ----------- */
console.log("\n=== 8. Aufgaben, Einträge und Dateien eines Modis ===\n");
{
  /* DREI TABELLEN, DREI EIGENE SICHTBARKEITSREGELN. Fuer Personen ist
     die Regel zentral (verborgeneIds); fuer ZEILEN gibt es sie dreimal
     -- in workspace-aufgaben.js, workspace-bereiche.js und
     workspace-dateien.js. Alle drei geben Spicy Media "alles ausser dem,
     was DogFather gehoert" -- und ein Modi-Eintrag gehoert ihm nicht.

     Der Kalender ist bewusst nicht dabei: termineSichtbar() gibt jedem
     nur Eigenes, dort kann nichts durchsickern. Nachgesehen, nicht
     angenommen. */
  const an = await anmelden("creator", "CODE-MODI-0001");
  const MERKMAL = "GEHEIMER MODI-EINTRAG";

  /* (a) Eine Aufgabe -- ueber den normalen Weg. */
  const t1 = await fetch(BASIS + "/workspace/api/aufgaben", {
    method: "POST", headers: { "Content-Type": "application/json", cookie: an.keks },
    body: JSON.stringify({ titel: MERKMAL + " Aufgabe" }),
  });
  ok(t1.status === 201, `der Modi legt eine Aufgabe an (${t1.status})`);

  /* (b) Ein Bereichs-Eintrag -- ebenfalls ueber den normalen Weg. */
  const t2 = await fetch(BASIS + "/workspace/api/bereich/live", {
    method: "POST", headers: { "Content-Type": "application/json", cookie: an.keks },
    body: JSON.stringify({ art: "vorbereitung", titel: MERKMAL + " Eintrag", text: "nur für das Team" }),
  });
  const t2daten = await t2.json().catch(() => ({}));
  if (t2.status !== 201 && t2.status !== 200) {
    unklar(`kein Bereichs-Eintrag moeglich (${t2.status}: ${JSON.stringify(t2daten)})`);
  } else {
    ok(true, `und einen Bereichs-Eintrag (${t2.status})`);
  }

  /* (c) Eine Datei -- direkt in die Tabelle. Der normale Weg braeuchte
     einen echten Datei-Upload; hier geht es nicht um das Hochladen,
     sondern allein um die Frage, WER die Zeile danach sieht. */
  {
    const dd = new DatabaseSync(process.env.WORKSPACE_DB);
    dd.prepare(`INSERT INTO dateien
        (name_original, name_datei, groesse, typ, status, creator_id, hochgeladen_von, erstellt)
        VALUES (?,?,?,?,'entwurf',NULL,?,?)`)
      .run(MERKMAL + " Datei", "modi-probe.txt", 12, "text/plain", idModi1, jetzt);
    dd.close();
    ok(true, "und eine Datei liegt auf seinen Namen");
  }

  const WEGE2 = [
    ["Aufgaben", "/workspace/api/aufgaben", (x) => x.aufgaben],
    ["Einträge", "/workspace/api/bereich/live", (x) => x.eintraege || x.liste],
    ["Dateien", "/workspace/api/dateien", (x) => x.dateien],
  ];
  for (const [name, kachel, code, darf] of [
    ["DogFather", "admin", "CODE-DOGI-0001", true],
    ["Spicy Media", "spicy", "CODE-SPIC-0001", false],
    ["Manager", "manager", "CODE-MAN-0001", false],
    ["Scout", "scout", "CODE-SCOU-0001", false],
    ["Creator", "creator", "CODE-ANNA-0001", false],
  ]) {
    const w = await anmelden(kachel, code);
    for (const [was, pfad, ziehen] of WEGE2) {
      const r = await hole(w.keks, pfad);
      if (r.status !== 200) { unklar(`${name.padEnd(12)} ${was.padEnd(9)} kein Zugriff (${r.status})`); continue; }
      let liste = [];
      try { liste = ziehen(r.daten) || []; } catch { liste = []; }
      const drin = liste.some((z) =>
        String(z.titel || z.name_original || z.name || "").includes(MERKMAL));
      if (darf) ok(true, `${name.padEnd(12)} ${was.padEnd(9)} sieht es (${drin ? "ja" : "nein"})`);
      else ok(!drin, `${name.padEnd(12)} ${was.padEnd(9)} `
        + (drin ? "SIEHT ES -- LECK" : "sieht es nicht"));
    }
  }
}

/* ---------- 9. Die Gegenprobe ----------------------------------------
   Sie steht ABSICHTLICH GANZ UNTEN: Sie haengt eine Person
   absichtlich aus der Regel aus. Lief sie weiter oben, tauchte
   diese Person in jeder Liste DANACH auf -- und jeder spaetere
   Abschnitt maesse einen Zustand, den es im Betrieb nicht gibt.
   -------------------------------------------------------------------- */
console.log("\n=== 9. Gegenprobe: kann diese Pruefung ueberhaupt anschlagen? ===\n");
{
  const d2 = new DatabaseSync(process.env.WORKSPACE_DB);
  d2.prepare("UPDATE personen SET rolle = 'creator' WHERE id = ?").run(idModi1);
  /* Betreuung dazu, sonst waere der Creator fuer den Manager auch ohne
     die Verbergen-Regel unsichtbar -- und die Gegenprobe pruefte nichts. */
  d2.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)")
    .run(idModi1, idScout, jetzt);
  d2.close();

  const an = await anmelden("manager", "CODE-MAN-0001");
  const { status, daten } = await hole(an.keks, "/workspace/api/personen");
  if (status !== 200 || !Array.isArray(daten?.personen)) {
    unklar(`Gegenprobe nicht durchfuehrbar (${status})`);
  } else {
    const sichtbar = daten.personen.some((z) => z.id === idModi1);
    ok(sichtbar, sichtbar
      ? "ohne die Rolle 'modi' sieht der Manager dieselbe Person sehr wohl "
        + "-- die Pruefung oben kann also anschlagen"
      : "GEGENPROBE FEHLGESCHLAGEN: auch ohne die Regel bleibt die Person "
        + "unsichtbar. Die Pruefung oben beweist damit nichts.");
  }
}


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