/* =====================================================================
   Der Übergang — Buddy und erste Schicht (15.09.2026)

   Filipe: „ich will dass du die 2 kategorien perfektionnierst. ich will
   die noch viel besser, perfektionniert, viel geiler und krasser. es
   soll so einfach wie möglich sein für jeden."

   ---------------------------------------------------------------------
   WAS HIER GEPRÜFT WIRD UND WARUM

   In der Beschreibung der Stufe „Probe" stand seit dem ersten Tag
   „fester Buddy". Ein Feld dafür gab es nicht. Genau an dieser Stelle
   — zwischen dem „ja" und der ersten echten Schicht — verlieren Teams
   die Leute, die sie gerade gewonnen haben.

   Ein Versprechen im Text ist keine Eigenschaft des Systems. Erst eine
   Regel, die NEIN sagen kann, ist eine. Also:

     Kommt jemand ohne Buddy auf die Probe?           (darf nicht)
     Kommt jemand ohne Datum auf die Probe?           (darf nicht)
     Bleibt die Karte dabei stehen, wo sie war?       (muss)
     Überleben Buddy und Datum den Schritt ins Team?  (müssen)
     Fängt die Standzeit beim Ändern neu an?          (darf nicht)

   Aufrufen mit:  node server/pruef-uebergang.mjs
   ===================================================================== */

import { mkdtempSync, rmSync, readFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { request as httpAnfrage } from "node:http";
import { eigenerPort } from "./helfer-port.mjs";

const PORT = await eigenerPort(import.meta, "pruef-uebergang");

const ordner = mkdtempSync(join(tmpdir(), "ws-ueber-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
process.env.PORT = String(PORT);
process.env.SITE_ACCESS_SECRET = "lokaler-test";
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");
notbremse(240_000, "pruef-uebergang");
await new Promise((r) => setTimeout(r, 700));

process.on("uncaughtException", (f) => { console.error("ABSTURZ:", f); process.exit(7); });
process.on("unhandledRejection", (f) => { console.error("ABSTURZ (Versprechen):", f); process.exit(7); });

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

const CREW = "crew.dogfather-universe.com";
const HAUS = "workspace.dogfather-universe.com";

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes, createHmac } = await import("node:crypto");
const tal = await import("./workspace-talent-punkte.js");

const oeffne = () => new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();

/* Tagesdatum in Ortszeit -- dieselbe Rechnung wie im Server. Ein Test,
   der in UTC rechnet, waere zwischen Mitternacht und zwei Uhr morgens
   einen Tag daneben und wuerde nachts rot, ohne dass etwas kaputt ist. */
const tag = (n = 0) => {
  const d = new Date();
  d.setDate(d.getDate() + n);
  const z = (x) => String(x).padStart(2, "0");
  return `${d.getFullYear()}-${z(d.getMonth() + 1)}-${z(d.getDate())}`;
};

let idDogi, idHand, idFrida, idMara, idNina, idTalent, idZweit;
{
  const d = oeffne();
  const s = randomBytes(32).toString("hex");
  d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
    + " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
    .run("code_kennung_schluessel", s, jetzt);
  const 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", s).update(code).digest("hex"), jetzt);
    return d.prepare("SELECT last_insert_rowid() AS id").get().id;
  };
  idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
  idHand = anlegen("Rieke", "hand", "CODE-HAND-0001");
  idFrida = anlegen("Frida", "modi", "CODE-MODI-0001");
  idNina = anlegen("Nina", "modi", "CODE-MODI-0002");
  /* EINE MANAGERIN ALS GEGENPROBE: Sie arbeitet im anderen Haus und
     kann niemanden durch eine Schicht begleiten, die sie nicht macht. */
  idMara = anlegen("Mara", "manager", "CODE-MANA-0001");

  const neuTalent = (titel) => {
    d.prepare("INSERT INTO eintraege (bereich, art, titel, text, datum, erstellt, erstellt_von, einsatz)"
      + " VALUES ('talente','ruhig',?,?,?,?,?,?)")
      .run(titel, "Faellt seit Wochen auf.", jetzt.slice(0, 10), jetzt, idDogi, "Dienstag im Stream");
    return d.prepare("SELECT last_insert_rowid() AS id").get().id;
  };
  idTalent = neuTalent("Kessi aus dem Chat");
  idZweit = neuTalent("Bo aus dem Chat");
  d.close();
}

function ruf(pfad, host, methode, kopf = {}, koerper = null) {
  return new Promise((fertig, schief) => {
    const a = httpAnfrage({ host: "127.0.0.1", port: PORT, path: pfad, method: methode,
      headers: { Host: host, ...(koerper ? { "Content-Type": "application/json" } : {}), ...kopf } },
    (antwort) => {
      let text = "";
      antwort.on("data", (s) => { text += s; });
      antwort.on("end", () => fertig({ code: antwort.statusCode, text, kopf: antwort.headers }));
    });
    a.on("error", schief);
    if (koerper) a.write(JSON.stringify(koerper));
    a.end();
  });
}
const json = (a) => { try { return JSON.parse(a.text); } catch { return {}; } };
async function anmelden(rolle, code, host) {
  const r = await ruf("/workspace/api/anmelden", host, "POST", {}, { rolle, code });
  return [].concat(r.kopf?.["set-cookie"] || []).map((c) => c.split(";")[0]).join("; ");
}
const kDogi = await anmelden("admin", "CODE-DOGI-0001", HAUS);
const kHand = await anmelden("hand", "CODE-HAND-0001", CREW);
ok(!!kDogi && !!kHand, "DogFather und die rechte Hand sind angemeldet");

const lage = () => ruf("/workspace/api/talente/lage", HAUS, "GET", { cookie: kDogi }).then(json);
const karteVon = async (id) => (await lage()).kandidaten.find((k) => k.id === id);
const stufeSetzen = (id, koerper, keks = kDogi) =>
  ruf(`/workspace/api/talente/${id}/stufe`, HAUS, "PUT", { cookie: keks }, koerper);

/* =======================================================================
   1. WER EINARBEITEN KANN — und wer nicht
   ======================================================================= */
melde("");
melde("=== 1. Wer einarbeiten kann ===");
{
  const l = await lage();
  const namen = (l.buddys || []).map((b) => b.name);
  ok(namen.length === 4, `${namen.length} Menschen können einarbeiten`);
  /* DIE REIHENFOLGE DES HAUSES, nicht die der Datenbank: DogFather,
     dann die rechte Hand, dann die Modis -- und innerhalb einer Rolle
     nach Namen. */
  ok(namen.join(", ") === "Filipe, Rieke, Frida, Nina",
    `in der Reihenfolge des Hauses (${namen.join(", ")})`);
  ok(!namen.includes("Mara"),
    "eine Managerin nicht — sie arbeitet im anderen Haus");
  ok((l.erster_tag || []).length === tal.ERSTER_TAG.length,
    `und am ersten Tag gibt es ${l.erster_tag?.length} Dinge, nicht dreißig`);
  ok(l.schicht_weit_tage === tal.SCHICHT_WEIT_TAGE,
    `ab ${l.schicht_weit_tage} Tagen gilt ein Termin als weit weg`);
}

/* =======================================================================
   2. OHNE BUDDY UND DATUM KEINE PROBE
   ======================================================================= */
melde("");
melde("=== 2. Ohne die zwei geht es nicht ===");
{
  await stufeSetzen(idTalent, { stufe: "beobachtet" });
  await stufeSetzen(idTalent, { stufe: "angesprochen" });
  const vorher = await karteVon(idTalent);
  ok(vorher.stufe === "angesprochen", `die Karte steht auf „${vorher.stufe_name}“`);

  const leer = await stufeSetzen(idTalent, { stufe: "probe" });
  ok(leer.code === 400, `ohne alles geht die Probe nicht los (${leer.code})`);
  const f = json(leer).fehlt || [];
  ok(f.includes("buddy") && f.includes("erste_schicht"),
    `und die Absage nennt beides (${f.join(", ")})`);

  /* DAS EIGENTLICHE: DIE KARTE DARF SICH NICHT BEWEGT HABEN. Eine
     Absage, nach der die Stufe trotzdem steht, ist schlimmer als keine
     -- dann steht „Probe" da und niemand arbeitet jemanden ein. */
  const danach = await karteVon(idTalent);
  ok(danach.stufe === "angesprochen",
    `die Karte steht unverändert auf „${danach.stufe_name}“`);
  ok(danach.uebergang === null, "und es steht nichts halb Ausgefülltes da");

  const halb = await stufeSetzen(idTalent, { stufe: "probe", buddy_id: idFrida });
  ok(halb.code === 400 && (json(halb).fehlt || []).includes("erste_schicht"),
    "mit Buddy, aber ohne Datum: auch nicht");
  const halb2 = await stufeSetzen(idTalent, { stufe: "probe", erste_schicht: tag(3) });
  ok(halb2.code === 400 && (json(halb2).fehlt || []).includes("buddy"),
    "mit Datum, aber ohne Buddy: auch nicht");
}

/* =======================================================================
   3. UND WAS ALS BUDDY ODER DATUM NICHT GILT
   ======================================================================= */
melde("");
melde("=== 3. Was nicht gilt ===");
{
  const fremd = await stufeSetzen(idTalent,
    { stufe: "probe", buddy_id: idMara, erste_schicht: tag(3) });
  ok(fremd.code === 400 && (json(fremd).fehlt || []).includes("buddy_unbekannt"),
    "eine Managerin als Buddy: abgelehnt");

  const wort = await stufeSetzen(idTalent,
    { stufe: "probe", buddy_id: idFrida, erste_schicht: "nächsten Samstag" });
  ok(wort.code === 400 && (json(wort).fehlt || []).includes("datum_unlesbar"),
    "„nächsten Samstag“ ist kein Datum");

  const alt = await stufeSetzen(idTalent,
    { stufe: "probe", buddy_id: idFrida, erste_schicht: tag(-30) });
  ok(alt.code === 400 && (json(alt).fehlt || []).includes("datum_zu_alt"),
    "ein Datum von vor dreißig Tagen: abgelehnt");

  const weit = await stufeSetzen(idTalent,
    { stufe: "probe", buddy_id: idFrida, erste_schicht: tag(tal.SCHICHT_MAX_TAGE + 5) });
  ok(weit.code === 400 && (json(weit).fehlt || []).includes("datum_zu_weit"),
    `weiter als ${tal.SCHICHT_MAX_TAGE} Tage: kein Termin mehr`);

  /* GEGENPROBE ZUM RÜCKWÄRTS-DATUM: Wer eine laufende Probe nachträgt,
     muss das Datum von damals eintragen können -- sonst schreibt er
     heute hinein, und die Standzeit stimmt ab da nie wieder. */
  const gestern = await stufeSetzen(idTalent,
    { stufe: "probe", buddy_id: idFrida, erste_schicht: tag(-3) });
  ok(gestern.code === 200, `drei Tage rückwärts geht (${gestern.code})`);
  const k = await karteVon(idTalent);
  ok(k.uebergang?.bis_schicht === -3,
    `und die Karte weiß, dass es drei Tage her ist (${k.uebergang?.bis_schicht})`);
  ok(k.uebergang?.satz === "Erste Schicht war vor 3 Tagen.",
    `in einem Satz, den man laut vorlesen kann: „${k.uebergang?.satz}“`);
}

/* =======================================================================
   4. MIT BEIDEN: DIE PROBE LÄUFT
   ======================================================================= */
melde("");
melde("=== 4. Die Probe läuft ===");
{
  const r = await stufeSetzen(idZweit, { stufe: "beobachtet" });
  await stufeSetzen(idZweit, { stufe: "angesprochen" });
  const los = await stufeSetzen(idZweit,
    { stufe: "probe", buddy_id: idHand, erste_schicht: tag(2) });
  ok(r.code === 200 && los.code === 200, `mit Buddy und Datum geht es (${los.code})`);

  const k = await karteVon(idZweit);
  ok(k.stufe === "probe", `die Karte steht auf „${k.stufe_name}“`);
  ok(k.uebergang?.buddy_name === "Rieke", `Rieke arbeitet ein (${k.uebergang?.buddy_name})`);
  ok(k.uebergang?.erste_schicht === tag(2), `erste Schicht am ${k.uebergang?.erste_schicht}`);
  ok(k.uebergang?.satz === "Erste Schicht in 2 Tagen.", `„${k.uebergang?.satz}“`);
  ok(k.uebergang?.buddy_weg === false, "und der Buddy ist da");

  /* EIN WEIT ENTFERNTER TERMIN WIRD NICHT VERBOTEN, ABER GESAGT. */
  const weit = await ruf(`/workspace/api/talente/${idZweit}/uebergang`, HAUS, "PUT",
    { cookie: kDogi }, { buddy_id: idHand, erste_schicht: tag(tal.SCHICHT_WEIT_TAGE + 6) });
  ok(weit.code === 200, `ein Termin in drei Wochen ist erlaubt (${weit.code})`);
  const kw = await karteVon(idZweit);
  ok(/weit weg/.test(kw.uebergang?.satz || ""),
    `aber die Karte sagt es: „${(kw.uebergang?.satz || "").slice(0, 60)}…“`);
}

/* =======================================================================
   5. ÄNDERN SETZT DIE STANDZEIT NICHT ZURÜCK
   ======================================================================= */
melde("");
melde("=== 5. Ändern ist kein Neuanfang ===");
{
  /* Die Standzeit einer Karte ist die Auskunft ueber UNS. Wer sie
     durch ein Aendern des Buddys zurueckstellt, loescht genau die
     Verschleppung, die sichtbar werden soll. */
  const d = oeffne();
  d.prepare("UPDATE talent_stufe SET seit = ? WHERE eintrag_id = ?")
    .run(new Date(Date.now() - 40 * 86400000).toISOString(), idZweit);
  d.close();

  const vorher = await karteVon(idZweit);
  ok(vorher.tage === 40, `die Karte liegt seit ${vorher.tage} Tagen auf der Probe`);
  ok(vorher.liegt === true, "und gilt damit als liegengeblieben");

  const r = await ruf(`/workspace/api/talente/${idZweit}/uebergang`, HAUS, "PUT",
    { cookie: kDogi }, { buddy_id: idNina, erste_schicht: tag(1) });
  ok(r.code === 200, `Buddy und Termin ändern geht (${r.code})`);
  const nach = await karteVon(idZweit);
  ok(nach.uebergang?.buddy_name === "Nina", `jetzt arbeitet Nina ein (${nach.uebergang?.buddy_name})`);
  ok(nach.tage === 40, `und die Standzeit steht unverändert bei ${nach.tage} Tagen`);
  ok(nach.stufe === "probe", "die Stufe hat sich dabei nicht bewegt");

  /* DIE ABSAGE GILT AUCH HIER -- eine zweite Tür mit weniger Regeln
     wäre genau die, durch die es irgendwann durchgeht. */
  const leer = await ruf(`/workspace/api/talente/${idZweit}/uebergang`, HAUS, "PUT",
    { cookie: kDogi }, {});
  ok(leer.code === 400, `auch hier geht es nicht ohne die zwei (${leer.code})`);
  const immerNoch = await karteVon(idZweit);
  ok(immerNoch.uebergang?.buddy_name === "Nina", "und nichts wurde dabei gelöscht");
}

/* =======================================================================
   6. DER SCHRITT INS TEAM NIMMT BEIDES MIT
   ======================================================================= */
melde("");
melde("=== 6. Ins Team ===");
{
  const r = await stufeSetzen(idZweit, { stufe: "imteam" });
  ok(r.code === 200, `ins Team geht ohne die zwei Felder (${r.code})`);
  const k = await karteVon(idZweit);
  ok(k.stufe === "imteam", `die Karte steht auf „${k.stufe_name}“`);
  /* SIE SIND DIE GESCHICHTE DIESER PROBE, kein Formularfeld. Wer sie
     beim letzten Schritt verliert, weiss hinterher nicht mehr, wer
     eingearbeitet hat. */
  ok(k.uebergang?.buddy_name === "Nina",
    `und weiß weiterhin, wer eingearbeitet hat (${k.uebergang?.buddy_name})`);
  ok(k.uebergang?.erste_schicht === tag(1), "auch die erste Schicht steht noch da");
}

/* =======================================================================
   7. WENN DER BUDDY GEHT
   ======================================================================= */
melde("");
melde("=== 7. Wenn der Buddy geht ===");
{
  const d = oeffne();
  d.prepare("UPDATE personen SET aktiv = 0 WHERE id = ?").run(idFrida);
  d.close();
  const k = await karteVon(idTalent);
  ok(k.uebergang?.buddy_weg === true,
    "ein stillgelegter Zugang zählt nicht mehr als Buddy");
  ok(k.uebergang?.buddy_name === "Frida",
    "der Name bleibt trotzdem stehen — sonst weiß niemand, wer es war");

  /* UND WER GELÖSCHT WIRD, NIMMT DIE PROBE EINES ANDEREN NICHT MIT. */
  const d2 = oeffne();
  d2.prepare("DELETE FROM personen WHERE id = ?").run(idFrida);
  const uebrig = d2.prepare("SELECT buddy_id, erste_schicht, stufe FROM talent_stufe WHERE eintrag_id = ?")
    .get(idTalent);
  d2.close();
  ok(uebrig?.stufe === "probe", "die Karte steht weiterhin auf der Probe");
  ok(uebrig?.buddy_id === null, "nur der Buddy ist leer — nicht die Karte");
  ok(!!uebrig?.erste_schicht, "und das Datum steht noch da");
  const k2 = await karteVon(idTalent);
  ok(k2.uebergang?.buddy_weg === true && k2.uebergang?.buddy_name === null,
    "die Karte sagt jetzt: bitte neu bestimmen");
}

/* =======================================================================
   8. IM BROWSER
   ======================================================================= */
melde("");
melde("=== 8. Im Browser ===");
{
  const { chromium } = await import(
    "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
  const browser = await chromium.launch();
  const kontext = await browser.newContext({ viewport: { width: 1280, height: 1100 } });
  await kontext.addCookies(kDogi.split("; ").filter(Boolean).map((teil) => {
    const i = teil.indexOf("=");
    return { name: teil.slice(0, i), value: teil.slice(i + 1), domain: "127.0.0.1", path: "/" };
  }));
  const seite = await kontext.newPage();
  const konsole = [];
  seite.on("console", (m) => { if (m.type() === "error" && !/favicon|ERR_/i.test(m.text())) konsole.push(m.text()); });
  seite.on("pageerror", (e) => konsole.push("Absturz: " + e.message));

  await seite.goto(`http://127.0.0.1:${PORT}/workspace/talente.html`, { waitUntil: "networkidle" });
  await seite.waitForTimeout(900);

  const stand = await seite.evaluate(() => {
    const karten = [...document.querySelectorAll(".t-karte")];
    const probe = karten.find((k) => k.dataset.stufe === "probe");
    return {
      karten: karten.length,
      bloecke: document.querySelectorAll(".t-uebergang").length,
      wer: probe?.querySelector(".t-uebergang__wer")?.textContent || "",
      satz: probe?.querySelector(".t-uebergang__satz")?.textContent || "",
      ersterTag: probe?.querySelectorAll(".t-uebergang__punkt").length || 0,
      aendern: !!probe?.querySelector(".t-uebergang__aendern"),
      weg: probe?.querySelector(".t-uebergang")?.dataset.weg || "",
    };
  });
  ok(stand.karten === 2, `${stand.karten} Karten stehen auf der Seite`);
  ok(stand.bloecke >= 1, `${stand.bloecke} davon zeigen Buddy und Termin`);
  ok(/neu bestimmen/.test(stand.wer),
    `und die Karte ohne Buddy sagt es im Klartext: „${stand.wer}“`);
  ok(stand.weg === "ja", "sie ist außerdem am Rand markiert");
  ok(stand.ersterTag === tal.ERSTER_TAG.length,
    `die drei Dinge für den ersten Tag stehen dabei (${stand.ersterTag})`);
  ok(stand.aendern === true, "und ein Knopf, um beides zu ändern");

  /* DAS FRAGEFELD: Es muss aufgehen, BEVOR die Stufe sich bewegt. */
  await seite.goto(`http://127.0.0.1:${PORT}/workspace/talente.html`, { waitUntil: "networkidle" });
  await seite.waitForTimeout(700);
  const frage = await seite.evaluate(async () => {
    const karten = [...document.querySelectorAll(".t-karte")];
    const probe = karten.find((k) => k.dataset.stufe === "probe");
    probe?.querySelector(".t-uebergang__aendern")?.click();
    await new Promise((r) => setTimeout(r, 200));
    const f = document.querySelector(".t-uebergang--frage");
    return {
      da: !!f,
      auswahl: f?.querySelectorAll("select option").length || 0,
      datumsfeld: f?.querySelector('input[type="date"]')?.type || "",
      vorbelegt: f?.querySelector("select")?.value || "",
    };
  });
  ok(frage.da === true, "der Knopf öffnet das Fragefeld");
  ok(frage.auswahl === 4, `mit drei Namen zur Auswahl und einem leeren (${frage.auswahl})`);
  ok(frage.datumsfeld === "date",
    "und einem echten Datumsfeld — auf dem Handy also dem Kalender des Geräts");
  /* KEINER IST VORAUSGEWÄHLT, WENN ES KEINEN GIBT. Diese Karte hat
     ihren Buddy verloren -- ein vorausgefülltes Feld wäre hier das
     Gegenteil von hilfreich: Man klickt sich durch und hat am Ende
     jemanden bestimmt, ohne ihn gefragt zu haben. */
  ok(frage.vorbelegt === "", "und keiner ist vorausgewählt — hier muss jemand wirklich wählen");

  /* ===== DER ROLLENNAME STEHT NICHT MEHR IM SKRIPT (16.09.2026) =====

     `talente.js` hatte `rolle: 'modi'` als festen Text -- und der Server
     liefert jede Datei unter workspace/ an jeden aus, der die Adresse
     kennt. Nachgemessen am 16.09. auf der echten Seite: ohne jede
     Anmeldung 200 und 25 KB Quelltext.

     Jetzt fragt die Seite den Namen ab. Das ist eine Codeänderung an
     der Stelle, an der aus einem Talent ein Mensch mit Zugang wird --
     der letzte Schritt des Trichters, und der einzige, den man nicht
     zurücknehmen kann. Also wird er gemessen, nicht angenommen. */
  const wissen = await seite.evaluate(async () => {
    const a = await fetch("/workspace/api/talente/lage", { credentials: "same-origin" });
    const l = await a.json();
    const quelle = await (await fetch("/workspace/assets/js/talente.js")).text();
    return {
      rolle: l?.zugang?.rolle || "",
      name: l?.zugang?.name || "",
      imSkript: /rolle:\s*'modi'/.test(quelle),
    };
  });
  ok(!!wissen.rolle && !!wissen.name,
    `der Server sagt der Seite, welcher Zugang entsteht (${wissen.rolle} / ${wissen.name})`);
  ok(wissen.imSkript === false,
    "und im ausgelieferten Skript steht der Name nicht mehr");

  /* UND DER KNOPF MUSS TROTZDEM DA SEIN. Der Wert wird jetzt erst beim
     Zeichnen gerechnet -- mein erster Entwurf rechnete ihn zu früh,
     und dann wäre er dauerhaft falsch gewesen und der Knopf nie
     erschienen. Gefunden hat das die Reihenfolge im Quelltext, nicht
     der Testlauf; deshalb steht die Frage ab jetzt hier. */
  await seite.goto(`http://127.0.0.1:${PORT}/workspace/talente.html`, { waitUntil: "networkidle" });
  await seite.waitForTimeout(900);
  const knopf = await seite.evaluate(() => {
    const k = [...document.querySelectorAll(".t-karte")]
      .find((x) => x.dataset.stufe === "probe");
    return {
      karte: !!k,
      text: k?.querySelector(".t-schritt__knopf")?.textContent.trim() || "",
    };
  });
  ok(knopf.karte, "eine Karte auf der Probe steht auf der Seite");
  ok(/Zugang anlegen/.test(knopf.text),
    `und DogFather sieht den Knopf dafür („${knopf.text}“)`);

  ok(konsole.length === 0,
    konsole.length ? "Fehler im Browser: " + konsole[0].slice(0, 90) : "keine Fehler im Browser");
  await browser.close();
}

/* =======================================================================
   9. DER TEXT SAGT, WAS DAS SYSTEM TUT
   ======================================================================= */
melde("");
melde("=== 9. Text und Verhalten stimmen überein ===");
{
  const probe = tal.TALENT_STUFEN.find((s) => s.schluessel === "probe");
  ok(/Buddy/.test(probe.bedeutet),
    "in der Stufenbeschreibung steht weiterhin „fester Buddy“");
  const angesprochen = tal.TALENT_STUFEN.find((s) => s.schluessel === "angesprochen");
  ok(/erste Schicht/.test(angesprochen.schritt),
    `und der Schritt davor nennt sie beim Namen: „${angesprochen.schritt.slice(0, 60)}…“`);

  const js = readFileSync(new URL("../workspace/assets/js/talente.js", import.meta.url), "utf8");
  ok(/uebergangFragen/.test(js), "die Oberfläche fragt beides vorher ab");
  /* UND SIE VERLÄSST SICH NICHT DARAUF. Was nur im Browser steht, gilt
     nur für den, der den Browser benutzt -- Abschnitt 2 hat es an der
     Schnittstelle nachgemessen. */
  ok(/t-uebergang__aendern/.test(js), "und lässt beides später ändern");
}

/* ------------------------------------------------------------------- */
melde("");
melde(`${geprueft} Pruefungen, ${fehler} Fehler`);
melde(fehler ? "NICHT IN ORDNUNG" : "ALLES IN ORDNUNG");
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* Aufraeumrest */ }
process.exit(fehler ? 1 : 0);