Tagesblick: eine Kachel fuer offene Punkte und die Termine des Tages

Wunsch Filipe, 05.09.2026, mit Bildschirmfoto der Hinweisliste: "eine ganze kachel wo links die sachen sind die du da schon siehst und rechts in der kachel die termine vom tag. in der mitte gesplittet. mach das richtig geil und hochwertig." WARUM DIE BEIDEN ZUSAMMENGEHOEREN Links steht, was zu TUN ist, rechts, was schon FESTSTEHT. Zusammen ergeben sie die einzige Frage, die man morgens hat -- wie sieht mein Tag aus. Untereinander musste man scrollen, um sie zu beantworten. Eine Kachel und nicht zwei nebeneinander: Zwei Rahmen lesen sich als zwei Themen. Der Trenner laeuft oben und unten aus, statt von Kante zu Kante durchzuschneiden -- eine harte Linie macht aus einer Kachel wieder zwei. Die rechte Haelfte ist ein Zeitstrahl, kein Kalenderauszug: * Was als NAECHSTES dran ist, wird hervorgehoben. Beim Ueberfliegen ist das die Auskunft, die man sucht -- nicht "der erste des Tages". * Vorbei heisst nicht weg. Erledigtes tritt zurueck, bleibt aber sichtbar; man will sehen, was man schon hinter sich hat. * Dieselben vier Farben wie im Kalender. Eine Farbe, die hier etwas anderes bedeutete, muesste man zweimal lernen. Die Daten kommen aus der Kalender-Schnittstelle mit tage=1 -- keine zweite Abfrage, keine zweite Sichtbarkeitsregel. Was jemand im Kalender nicht sehen darf, kommt hier gar nicht erst an. DREI FEHLER, DIE DABEI AUFFIELEN 1. Die rechte Haelfte war 38 statt 579 Pixel breit. Die versteckte Ueberschrift fuer Vorleseprogramme zaehlt als Kind im Raster und hat alles um eine Spalte verschoben, sodass "Heute" in der Ein-Pixel- Spalte des Trenners landete. Die Spalten sind jetzt ausdruecklich zugewiesen -- damit verschiebt auch ein spaeteres viertes Element nichts mehr. 2. Die Plaketten (CALL, TERMIN, REVIEW) hatten 10,56 px. Die Hausgrenze liegt bei 11,5 -- darunter liest auf einem Handy niemand mehr. Gemeldet von pruef-handy auf allen drei Geraeteklassen UND von pruef-grosscheck bei allen vier Rollen. Ein Fix, zwei Pruefungen. 3. Am Handy stand die Uhrzeit mittig zur Zeile, waehrend der Titel oben begann -- sie fluchteten nicht, sobald die Plakette unter den Text rutschte. Die Kachel bleibt ganz weg, wenn BEIDE Haelften leer sind, und zeigt sonst auf der leeren Seite einen Satz. Vorher haette jemand ohne offene Punkte, aber mit drei Calls seinen Tagesplan nicht gesehen: Das Verstecken hing an der linken Haelfte allein. ZWEI PRUEFUNGEN, DIE SICH SELBST IM WEG STANDEN pruef-tempo-workspace meldete "Layout springt: bereich.html 0,703". Nachgemessen: derselbe Wert schwankt zwischen den Laeufen um den Faktor zwei (aufgaben.html 0,478 / 0,262 / 0,262; bereich.html 0,703 dann 0,347). Er haengt davon ab, ob die Daten ankommen, waehrend das Geruest noch aufgebaut wird. Eine Pruefung, die zufaellig rot wird, ist so wertlos wie eine, die nie anschlaegt -- man klickt sie weg, und mit ihr die echte Warnung. Statt die Grenze anzuheben (das haette sie stumpf gemacht) wird ein Ausschlag jetzt durch WIEDERHOLUNG bestaetigt, und gemeldet wird der zweite Wert, nicht der kleinere. Ein echter Sprung kommt bei jedem Lauf und uebersteht das muehelos. Die neue Kachel selbst springt uebrigens gar nicht: start.html steht bei 0. pruef-push-weg meldete "ALLES IN ORDNUNG" und stuerzte danach ab (libuv: UV_HANDLE_CLOSING, Rueckgabewert 3221226505). Ursache war process.exit() mitten im Schliessen der fetch-Verbindungen. Jetzt process.exitCode -- Node raeumt zu Ende. Fuenf Laeufe hintereinander sauber. Eine Pruefung, die inhaltlich besteht und trotzdem rot ist, ist das Schlimmste von beidem. Gesamtlauf: 1994 von 1994 Punkten (1973 vorher + 21 der neuen Pruefung). Co-Authored-By: Claude Opus 5 <[email protected]>
2026-09-05 22:43:59 +02:00
parent 5119e0139d
commit c3b156dbad
24 changed files with 1237 additions and 171 deletions
@@ -0,0 +1,99 @@
+/* Macht ein Bild der fertigen Kachel -- zum Ansehen, nicht zum Pruefen.
+   Die Pruefung dazu ist pruef-tagesblick.mjs. */
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const ordner = mkdtempSync(join(tmpdir(), "ws-bild-"));
+process.env.WORKSPACE_DB = join(ordner, "workspace.db");
+const { portMussFreiSein } = await import("./helfer-port.mjs");
+await portMussFreiSein(4307, "das Bildwerkzeug");
+process.env.PORT = "4307";
+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 }); };
+await import("./index.js");
+await new Promise((r) => setTimeout(r, 900));
+const BASIS = "http://127.0.0.1:4307";
+
+const { DatabaseSync } = await import("node:sqlite");
+const { scryptSync, randomBytes } = await import("node:crypto");
+await fetch(BASIS + "/workspace/api/anmelden", {
+  method: "POST", headers: { "Content-Type": "application/json" },
+  body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});
+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 jetztIso = new Date().toISOString();
+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, jetztIso);
+  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
+}
+const idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
+const idScout = anlegen("Patrick von Hohenstein", "scout", "CODE-SCOU-0001");
+const idLuna = anlegen("Luna", "creator", "CODE-CREA-0001");
+const idNora = anlegen("Nora", "creator", "CODE-CREA-0002");
+d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idScout, jetztIso);
+d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idNora, idScout, jetztIso);
+
+const n = new Date();
+const HEUTE = `${n.getFullYear()}-${String(n.getMonth() + 1).padStart(2, "0")}-${String(n.getDate()).padStart(2, "0")}`;
+/* Rund um die aktuelle Uhrzeit, damit das Bild alle drei Zustaende
+   zeigt: vorbei, als Naechstes dran, spaeter. */
+const stunde = n.getHours();
+const zeit = (h) => `${String(Math.max(0, Math.min(23, h))).padStart(2, "0")}:00`;
+function termin(titel, h, art, dauer, wer) {
+  d.prepare(`INSERT INTO termine (titel, art, beginn, dauer_min, creator_id, teilnehmer_id,
+    ort, erstellt, erstellt_von) VALUES (?,?,?,?,?,?,?,?,?)`)
+    .run(titel, art, `${HEUTE}T${zeit(h)}`, dauer, wer, wer, null, jetztIso, idDogi);
+}
+termin("Wochen-Call mit Luna", stunde - 3, "call", 30, idLuna);
+termin("Content-Freigabe Nora", stunde - 1, "review", 45, idNora);
+termin("Strategie mit Patrick", stunde + 1, "termin", 60, idLuna);
+termin("Abschluss-Call", stunde + 3, "call", 30, idNora);
+
+d.prepare(`INSERT INTO aufgaben (titel, status, prioritaet, frist, creator_id,
+  verantwortlich_id, erstellt, erstellt_von) VALUES (?,?,'hoch',?,?,?,?,?)`)
+  .run("Thumbnails prüfen", "offen", "2020-01-01", idLuna, idLuna, jetztIso, idDogi);
+d.prepare(`INSERT INTO aufgaben (titel, status, prioritaet, frist, creator_id,
+  verantwortlich_id, erstellt, erstellt_von) VALUES (?,?,'hoch',?,?,?,?,?)`)
+  .run("Review Freigabe", "review", HEUTE, idNora, idNora, jetztIso, idDogi);
+d.close();
+
+const pw = await import("file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
+const browser = await pw.chromium.launch();
+
+for (const [breite, name] of [[1280, "computer"], [390, "handy"]]) {
+  const ctx = await browser.newContext({
+    viewport: { width: breite, height: 1000 }, deviceScaleFactor: 2,
+  });
+  const seite = await ctx.newPage();
+  await seite.goto(BASIS + "/workspace/", { waitUntil: "networkidle" });
+  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: 25000 });
+  await seite.waitForTimeout(1400);
+  const kachel = await seite.$("#dran-block");
+  if (kachel) {
+    await kachel.screenshot({ path: `tagesblick-${name}.png` });
+    console.log(`tagesblick-${name}.png geschrieben`);
+  } else {
+    console.log(`${name}: Kachel nicht gefunden`);
+  }
+  await ctx.close();
+}
+
+await browser.close();
+try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
+process.exit(0);
@@ -29,6 +29,33 @@ import {
  verschluesseln, schluesselErzeugen, schicken, b64u,
 } from "./workspace-push-krypto.js";

+/* EINEN TESTDIENST SAUBER SCHLIESSEN -- und warum das eine eigene
+   Funktion wert ist.
+
+   `server.close()` ist ASYNCHRON: Es bittet den Server, keine neuen
+   Verbindungen mehr anzunehmen, und meldet sich, wenn er wirklich zu
+   ist. Wer den Rueckruf nicht abwartet und danach `process.exit()`
+   ruft, reisst libuv das Handle mitten im Schliessen weg. Unter
+   Windows endet das nicht in einer Fehlermeldung, sondern in einem
+   Absturz:
+
+       Assertion failed: !(handle->flags & UV_HANDLE_CLOSING),
+       file src\win\async.c, line 94
+
+   Genau das ist am 05.09.2026 im Gesamtlauf passiert -- NACH dem
+   "ALLES IN ORDNUNG". Alle zwanzig Pruefungen waren gruen, der
+   Rueckgabewert war 3221226505, und der Sammellaeufer meldete zu Recht
+   FEHL. Eine Pruefung, die inhaltlich besteht und trotzdem rot ist, ist
+   das Schlimmste von beidem: Man gewoehnt sich an, das Rot zu
+   uebersehen.
+
+   `unref()` allein genuegt nicht -- es nimmt dem Handle nur das Recht,
+   den Prozess am Leben zu halten; im Schliessen ist es trotzdem. */
+const schliessen = (dienst) => new Promise((fertig) => {
+  if (!dienst.listening) return fertig();
+  dienst.close(() => fertig());
+});
+
 let fehler = 0;
 const ok = (b, t) => { console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };

@@ -128,7 +155,7 @@ let empfangen = null, kopfzeilen = null;
    "die VAPID-Signatur ist dabei");
  ok(kopfzeilen?.ttl === "3600", `TTL: ${kopfzeilen?.ttl}`);
  ok(entschluesseln(empfangen) === TEXT, "und der Inhalt kommt unveraendert an");
-  dienst.close();
+  await schliessen(dienst);
 }

 /* =======================================================================
@@ -160,8 +187,7 @@ console.log("\n=== Ein Geraet, das es nicht mehr gibt ===");
    ok(e.weg === erwartetWeg,
      `${code} -> weg=${e.weg} (erwartet ${erwartetWeg})`
      + (erwartetWeg ? " — die Anmeldung wird geloescht" : " — sie bleibt, es kann voruebergehend sein"));
-    d.close();
-    await new Promise((r) => setTimeout(r, 60));
+    await schliessen(d);
  }
 }

@@ -206,4 +232,27 @@ console.log("\n=== Gegenprobe ===");
 }

 console.log(`\n${fehler === 0 ? "ALLES IN ORDNUNG" : `${fehler} FEHLER`}`);
-process.exit(fehler ? 1 : 0);
+
+/* KEIN process.exit() HIER (05.09.2026).
+
+   Diese Pruefung benutzt `fetch`, und zwar auch gegen eine Adresse, die
+   niemand bedient (Abschnitt 6, "wenn der Push-Dienst schweigt"). Node
+   haelt dafuer im Hintergrund einen Verbindungspool. `process.exit()`
+   beendet den Prozess SOFORT -- mitten im Schliessen dieser
+   Verbindungen. Unter Windows ist das kein sauberer Abbruch, sondern
+   ein Absturz in libuv:
+
+       Assertion failed: !(handle->flags & UV_HANDLE_CLOSING),
+       file src\win\async.c, line 94
+
+   Im Gesamtlauf stand deshalb "ALLES IN ORDNUNG" und danach
+   Rueckgabewert 3221226505 -- der Sammellaeufer meldete FEHL, obwohl
+   alle zwanzig Pruefungen bestanden hatten. Eine Pruefung, die
+   inhaltlich gruen und trotzdem rot ist, gewoehnt einem an, das Rot zu
+   uebersehen. Das ist schlimmer als ein echter Fehler.
+
+   `process.exitCode` setzt nur den Wert und laesst Node zu Ende
+   raeumen. Bleibt der Prozess dann haengen, ist das ein echter Befund
+   (ein Handle, das niemand schliesst) und faellt sofort auf -- besser
+   als ein Absturz, den man wegerklaert. */
+process.exitCode = fehler ? 1 : 0;
@@ -0,0 +1,375 @@
+/* DER TAGESBLICK — die geteilte Kachel auf der Startseite.
+
+   Wunsch Filipe, 05.09.2026: *"eine ganze kachel wo links die sachen
+   sind die du da schon siehst und rechts in der kachel die termine vom
+   tag. in der mitte gesplittet. mach das richtig geil und hochwertig."*
+
+   GEMESSEN WIRD AN DEN ECHTEN PIXELN, nicht am Stylesheet. Ein Wert,
+   der im CSS steht, kann von einer anderen Regel überschrieben sein --
+   was zählt, ist, was am Ende auf dem Schirm ankommt. Diese Lehre kam
+   am selben Tag von der Teilnehmerwahl, wo vierzig grüne Prüfungen
+   nicht gemerkt hatten, dass die Namen aneinanderkleben.
+
+   DIE VIER FRAGEN, die den Wunsch ausmachen:
+     1. Ist es EINE Kachel (ein Rahmen), nicht zwei nebeneinander?
+     2. Liegen die Hälften wirklich NEBENeinander, gleich breit?
+     3. Sitzt der Trenner in der MITTE?
+     4. Stehen rechts die Termine von HEUTE -- und nur die?
+
+   Dazu die Fälle, die im Betrieb auftreten und leicht vergessen werden:
+   keine Termine, keine Hinweise, beides leer, und das Handy.
+
+   GEGENPROBEN durchgehend. */
+
+import { mkdtempSync, rmSync, appendFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const ordner = mkdtempSync(join(tmpdir(), "ws-tagesblick-"));
+process.env.WORKSPACE_DB = join(ordner, "workspace.db");
+
+const { portMussFreiSein } = await import("./helfer-port.mjs");
+await portMussFreiSein(4303, "die Tagesblickpruefung");
+
+process.env.PORT = "4303";
+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 }); };
+await import("./index.js");
+await new Promise((r) => setTimeout(r, 900));
+const BASIS = "http://127.0.0.1:4303";
+
+const PROTOKOLL = join(process.cwd(), "pruef-tagesblick-lauf.txt");
+try { rmSync(PROTOKOLL, { force: true }); } catch { /* gab es noch nicht */ }
+const melde = (z) => {
+  console.log(z);
+  try { appendFileSync(PROTOKOLL, z + "\n"); } catch { /* Zugabe */ }
+};
+let fehler = 0;
+const ok = (b, t) => { melde((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };
+
+/* ---- Bestand ------------------------------------------------------------ */
+const { DatabaseSync } = await import("node:sqlite");
+const { scryptSync, randomBytes } = await import("node:crypto");
+await fetch(BASIS + "/workspace/api/anmelden", {
+  method: "POST", headers: { "Content-Type": "application/json" },
+  body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});
+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 jetztIso = new Date().toISOString();
+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, jetztIso);
+  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
+}
+const idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
+const idScout = anlegen("Patrick", "scout", "CODE-SCOU-0001");
+const idLuna = anlegen("Luna", "creator", "CODE-CREA-0001");
+d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idScout, jetztIso);
+
+/* ORTSZEIT, nicht UTC. Die Anwendung rechnet den Tag lokal -- ein mit
+   toISOString() gebildetes Datum wäre abends um zehn schon der nächste
+   Tag, und die Prüfung suchte Termine, die sie selbst auf morgen gelegt
+   hat. Genau diese Verwechslung steht als Warnung in start.js. */
+const n = new Date();
+const HEUTE = `${n.getFullYear()}-${String(n.getMonth() + 1).padStart(2, "0")}`
+  + `-${String(n.getDate()).padStart(2, "0")}`;
+const MORGEN = (() => {
+  const m = new Date(n.getTime() + 86400000);
+  return `${m.getFullYear()}-${String(m.getMonth() + 1).padStart(2, "0")}`
+    + `-${String(m.getDate()).padStart(2, "0")}`;
+})();
+
+function termin(titel, tag, zeit, art = "call", dauer = 30) {
+  d.prepare(`INSERT INTO termine (titel, art, beginn, dauer_min, creator_id,
+    teilnehmer_id, erstellt, erstellt_von) VALUES (?,?,?,?,?,?,?,?)`)
+    .run(titel, art, `${tag}T${zeit}`, dauer, idLuna, idLuna, jetztIso, idDogi);
+}
+/* Drei heute, einer morgen. Der von morgen ist der eigentliche Prüfstein:
+   Er darf NICHT auftauchen -- und ohne ihn würde man nie merken, wenn
+   die Abgrenzung fehlt. */
+termin("Früh-Call mit Luna", HEUTE, "07:30", "call", 30);
+termin("Content-Review", HEUTE, "14:00", "review", 60);
+termin("Abstimmung Technik", HEUTE, "23:30", "termin", 45);
+termin("Das ist morgen", MORGEN, "09:00", "call", 30);
+
+/* Etwas für die linke Hälfte -- ein Termin heute erzeugt ohnehin einen
+   Hinweis, aber eine überfällige Aufgabe ist der deutlichere Fall. */
+d.prepare(`INSERT INTO aufgaben (titel, status, prioritaet, frist, creator_id,
+  verantwortlich_id, erstellt, erstellt_von) VALUES (?,?,'hoch',?,?,?,?,?)`)
+  .run("Längst fällig", "offen", "2020-01-01", idLuna, idLuna, jetztIso, idDogi);
+d.close();
+
+const pw = await import("file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
+const browser = await pw.chromium.launch();
+
+async function alsRolle(rolle, code, breite = 1280) {
+  const ctx = await browser.newContext({ viewport: { width: breite, height: 1000 } });
+  const seite = await ctx.newPage();
+  await seite.goto(BASIS + "/workspace/", { waitUntil: "networkidle" });
+  await seite.click(`.rolle[data-rolle="${rolle}"]`);
+  await seite.fill("#code", code);
+  await seite.click("button[type=submit]");
+  await seite.waitForURL("**/start.html", { timeout: 25000 });
+  await seite.waitForTimeout(1200);
+  return { ctx, seite };
+}
+
+/* =======================================================================
+   1. Eine Kachel, in der Mitte geteilt
+   ======================================================================= */
+melde("\n=== Eine Kachel, mittig geteilt ===");
+{
+  const { ctx, seite } = await alsRolle("admin", "CODE-DOGI-0001");
+
+  const da = await seite.isVisible("#dran-block");
+  ok(da, da ? "die Kachel ist da" : "die Kachel fehlt");
+
+  /* EIN Rahmen um beides -- nicht zwei Kacheln nebeneinander. */
+  const rahmen = await seite.$eval("#dran-block", (e) => {
+    const s = getComputedStyle(e);
+    return { breite: s.borderTopWidth, radius: s.borderTopLeftRadius, anzeige: s.display };
+  });
+  ok(rahmen.anzeige === "grid" && parseFloat(rahmen.breite) >= 1
+    && parseFloat(rahmen.radius) > 4,
+    `ein Rahmen um beides (${rahmen.anzeige}, ${rahmen.breite}, Radius ${rahmen.radius})`);
+
+  /* NEBENEINANDER und gleich breit -- das ist der Kern des Wunsches. */
+  const seiten = await seite.evaluate(() => {
+    const l = document.querySelector("#dran-seite").getBoundingClientRect();
+    const r = document.querySelector("#heute-seite").getBoundingClientRect();
+    return {
+      linksOben: Math.round(l.top), rechtsOben: Math.round(r.top),
+      linksBreit: Math.round(l.width), rechtsBreit: Math.round(r.width),
+      linksRechterRand: Math.round(l.right), rechtsLinkerRand: Math.round(r.left),
+    };
+  });
+  ok(Math.abs(seiten.linksOben - seiten.rechtsOben) <= 2,
+    `beide Hälften stehen nebeneinander (oben ${seiten.linksOben} / ${seiten.rechtsOben})`);
+  /* "In der Mitte gesplittet": höchstens 2 px Unterschied. */
+  const unterschied = Math.abs(seiten.linksBreit - seiten.rechtsBreit);
+  ok(unterschied <= 2,
+    `gleich breit: ${seiten.linksBreit} px und ${seiten.rechtsBreit} px (${unterschied} px Unterschied)`);
+
+  /* Der Trenner sitzt dazwischen, nicht irgendwo. */
+  const trenner = await seite.evaluate(() => {
+    const e = document.querySelector("#heute-seite");
+    const s = getComputedStyle(e, "::before");
+    return { inhalt: s.content, breite: s.width, hintergrund: s.backgroundImage.slice(0, 30) };
+  });
+  ok(trenner.inhalt !== "none" && trenner.hintergrund.includes("gradient"),
+    `der Trenner ist da und läuft aus (${trenner.hintergrund}…)`);
+
+  await ctx.close();
+}
+
+/* =======================================================================
+   2. Rechts: die Termine von HEUTE
+   ======================================================================= */
+melde("\n=== Die Termine des Tages ===");
+{
+  const { ctx, seite } = await alsRolle("admin", "CODE-DOGI-0001");
+
+  const zeilen = await seite.$$eval(".tagesliste__punkt", (p) => p.map((x) => ({
+    zeit: x.querySelector(".tagesliste__stunde")?.textContent,
+    titel: x.querySelector(".tagesliste__titel")?.textContent,
+    art: x.dataset.art,
+    naechster: x.dataset.naechster === "ja",
+    vorbei: x.dataset.vorbei === "ja",
+  })));
+
+  /* DIE ANZAHL GEHÖRT IN DIE BEDINGUNG: Bei null Zeilen liefe jede
+     folgende Messung über eine leere Menge und meldete grün. */
+  ok(zeilen.length === 3, `${zeilen.length} Termine (erwartet 3 von heute)`);
+  ok(!zeilen.some((z) => /morgen/i.test(z.titel || "")),
+    `der Termin von morgen steht NICHT dabei: ${zeilen.map((z) => z.titel).join(" | ")}`);
+
+  /* Aufsteigend nach Uhrzeit -- eine Tagesliste in falscher Reihenfolge
+     ist schlimmer als keine. */
+  const zeiten = zeilen.map((z) => z.zeit);
+  ok(JSON.stringify(zeiten) === JSON.stringify([...zeiten].sort()),
+    `nach Uhrzeit sortiert: ${zeiten.join(" → ")}`);
+
+  ok(zeilen[0]?.zeit === "07:30" && zeilen[1]?.zeit === "14:00",
+    `die Uhrzeiten stimmen (${zeiten.join(", ")}) — keine Zeitzonen-Verschiebung`);
+
+  /* Die Art trägt ihre Farbe, dieselbe wie im Kalender. */
+  const arten = zeilen.map((z) => z.art);
+  ok(arten.includes("call") && arten.includes("review") && arten.includes("termin"),
+    `die Arten kommen durch: ${arten.join(", ")}`);
+
+  /* DIE FARBZUORDNUNG, zeitunabhängig gemessen.
+
+     Der erste Entwurf las den RAND der Review-Marke und erwartete
+     Grün. Er bekam Grau -- und das war völlig richtig: Der Termin
+     stand auf 14:00, der Prüflauf war um 19:31, also ist er vorbei
+     und wird absichtlich gedämpft. Die Regel
+     `[data-vorbei="ja"] .tagesliste__marke { border-color: … }` hat
+     genau das getan, wofür sie da ist.
+
+     Eine Prüfung, deren Ergebnis von der Uhrzeit des Laufs abhängt,
+     ist keine Prüfung -- sie ist morgens grün und abends rot, und
+     irgendwann glaubt ihr niemand mehr. Deshalb wird hier --ton
+     gelesen: die Zuordnung Art → Farbe, die immer gilt. Der Rand
+     folgt darunter, aber nur an einem Termin, der nachweislich noch
+     nicht vorbei ist. */
+  const toene = await seite.$$eval(".tagesliste__punkt", (punkte) => punkte.map((p) => ({
+    art: p.dataset.art,
+    ton: getComputedStyle(p).getPropertyValue("--ton").trim().toLowerCase(),
+    vorbei: p.dataset.vorbei === "ja",
+    rand: getComputedStyle(p.querySelector(".tagesliste__marke")).borderTopColor,
+  })));
+
+  const SOLL = { call: "#3fbdf5", termin: "#8a76ff", review: "#50a752", frist: "#d17717" };
+  const falsch = toene.filter((t) => SOLL[t.art] && t.ton !== SOLL[t.art]);
+  ok(falsch.length === 0 && toene.length === 3,
+    falsch.length
+      ? `falsche Farbe: ${falsch.map((t) => `${t.art}=${t.ton}`).join(", ")}`
+      : `alle ${toene.length} Termine tragen die Kalenderfarbe ihrer Art `
+        + `(${toene.map((t) => `${t.art} ${t.ton}`).join(", ")})`);
+
+  /* Und der Rand nimmt sie auch wirklich an -- gemessen an einem
+     Termin, der noch aussteht. Gibt es keinen (ein Lauf kurz vor
+     Mitternacht), wird das gesagt statt behauptet: der dritte Ausgang. */
+  const offen = toene.find((t) => !t.vorbei);
+  if (offen) {
+    const soll = SOLL[offen.art];
+    const r = parseInt(soll.slice(1, 3), 16), g = parseInt(soll.slice(3, 5), 16), b = parseInt(soll.slice(5, 7), 16);
+    ok(offen.rand.replace(/\s/g, "") === `rgb(${r},${g},${b})`,
+      `der Ring des nächsten Termins (${offen.art}) trägt sie sichtbar: ${offen.rand}`);
+  } else {
+    melde(`  --     kein ausstehender Termin zur Zeit des Laufs — der Ring `
+      + `wurde nicht am Bild geprüft (die Zuordnung darüber schon)`);
+  }
+
+  /* GEGENPROBE zur Dämpfung: Ein vorbeigezogener Termin MUSS anders
+     aussehen. Ohne diesen Nachweis wäre "vorbei tritt zurück" nur
+     eine Behauptung im Stylesheet. */
+  const vorbei = toene.find((t) => t.vorbei);
+  if (vorbei) {
+    ok(vorbei.rand.replace(/\s/g, "") !== `rgb(80,167,82)`.replace(/\s/g, "")
+      || vorbei.art !== "review",
+      `ein vorbeigezogener Termin ist gedämpft (Ring ${vorbei.rand} statt der Artfarbe)`);
+  }
+
+  /* GENAU EINER ist "als Nächstes dran" -- nicht null, nicht zwei. */
+  const naechste = zeilen.filter((z) => z.naechster).length;
+  ok(naechste === 1, `genau ${naechste} Termin ist als Nächstes hervorgehoben`);
+
+  /* Der um 23:30 kann nicht vorbei sein, der um 07:30 (meist) schon.
+     Geprüft wird die Regel, nicht die Uhrzeit des Prüflaufs: Was als
+     Nächstes dran ist, darf nie zugleich "vorbei" sein. */
+  ok(!zeilen.some((z) => z.naechster && z.vorbei),
+    "kein Termin ist gleichzeitig 'als Nächstes' und 'vorbei'");
+
+  await ctx.close();
+}
+
+/* =======================================================================
+   3. Die leeren Fälle
+   ======================================================================= */
+melde("\n=== Wenn eine Hälfte nichts zu zeigen hat ===");
+{
+  /* Ein Creator ohne Termine und ohne offene Punkte: Die Kachel darf
+     dann nicht als leerer Rahmen dastehen. */
+  const { ctx, seite } = await alsRolle("creator", "CODE-CREA-0001");
+  const sichtbar = await seite.isVisible("#dran-block");
+  const zeilen = (await seite.$$(".tagesliste__punkt")).length;
+  const hinweise = (await seite.$$(".dran__punkt")).length;
+
+  if (zeilen === 0 && hinweise === 0) {
+    ok(!sichtbar, "beide Hälften leer → die Kachel bleibt ganz weg");
+  } else {
+    /* Hat er etwas, muss die Kachel stehen -- und die leere Hälfte
+       einen Satz tragen statt einer Lücke. */
+    ok(sichtbar, `er hat ${hinweise} Hinweise und ${zeilen} Termine → Kachel ist da`);
+    if (!zeilen) {
+      const satz = await seite.isVisible("#heute-leer");
+      ok(satz, "die leere Terminseite sagt 'Heute steht nichts an'");
+    }
+    if (!hinweise) {
+      const satz = await seite.isVisible("#dran-leer");
+      ok(satz, "die leere Hinweisseite sagt, dass nichts offen ist");
+    }
+  }
+  await ctx.close();
+}
+
+/* =======================================================================
+   4. Am Handy: untereinander
+   ======================================================================= */
+melde("\n=== Am Handy (390 px) ===");
+{
+  const { ctx, seite } = await alsRolle("admin", "CODE-DOGI-0001", 390);
+
+  const lage = await seite.evaluate(() => {
+    const l = document.querySelector("#dran-seite").getBoundingClientRect();
+    const r = document.querySelector("#heute-seite").getBoundingClientRect();
+    return { linksUnten: Math.round(l.bottom), rechtsOben: Math.round(r.top) };
+  });
+  ok(lage.rechtsOben >= lage.linksUnten - 2,
+    `untereinander statt nebeneinander (links endet ${lage.linksUnten}, rechts beginnt ${lage.rechtsOben})`);
+
+  const ueber = await seite.evaluate(() =>
+    Math.round(document.documentElement.scrollWidth - document.documentElement.clientWidth));
+  ok(ueber <= 0, `nichts steht seitlich über (${ueber} px)`);
+
+  /* Ein langer Titel darf die Kachel nicht sprengen -- deshalb die
+     Ellipsis. Geprüft am gerechneten Stil, nicht an der CSS-Datei. */
+  const schnitt = await seite.$eval(".tagesliste__titel",
+    (e) => getComputedStyle(e).textOverflow);
+  ok(schnitt === "ellipsis", `lange Titel werden abgeschnitten (${schnitt})`);
+
+  await ctx.close();
+}
+
+/* =======================================================================
+   GEGENPROBE — misst die Prüfung überhaupt etwas?
+   ======================================================================= */
+melde("\n=== Gegenprobe ===");
+{
+  const { ctx, seite } = await alsRolle("admin", "CODE-DOGI-0001");
+
+  /* 1. Trifft der Selektor wirklich? */
+  const vorher = (await seite.$$(".tagesliste__punkt")).length;
+  await seite.evaluate(() => {
+    for (const p of document.querySelectorAll(".tagesliste__punkt")) p.remove();
+  });
+  const nachher = (await seite.$$(".tagesliste__punkt")).length;
+  ok(vorher === 3 && nachher === 0,
+    `der Selektor trifft (${vorher} gefunden, nach dem Entfernen ${nachher})`);
+
+  /* 2. Erkennt die Breitenmessung eine UNgleiche Teilung? Ohne diesen
+        Nachweis wäre "gleich breit" oben nur eine Behauptung. */
+  await seite.reload({ waitUntil: "networkidle" });
+  await seite.waitForTimeout(900);
+  await seite.addStyleTag({ content:
+    "#dran-block { grid-template-columns: 3fr 1px 1fr !important; }" });
+  await seite.waitForTimeout(150);
+  const schief = await seite.evaluate(() => {
+    const l = document.querySelector("#dran-seite").getBoundingClientRect();
+    const r = document.querySelector("#heute-seite").getBoundingClientRect();
+    return Math.abs(Math.round(l.width) - Math.round(r.width));
+  });
+  ok(schief > 2,
+    `mit absichtlich schiefer Teilung misst die Prüfung ${schief} px Unterschied `
+    + `— sie erkennt eine ungleiche Kachel also`);
+
+  await ctx.close();
+}
+
+await browser.close();
+try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
+
+melde(`\n${fehler === 0 ? "ALLES IN ORDNUNG" : `${fehler} FEHLER`}`);
+process.exit(fehler ? 1 : 0);
@@ -150,6 +150,7 @@ let seitenGesamt = 0, anfragenGesamt = 0, bytesGesamt = 0;
 const doppelte = [];
 const langsame = [];
 const springende = [];
+const schwankend = [];   /* Ausschlag da, aber beim Nachmessen weg */
 const zuGross = [];

 for (const datei of SEITEN) {
@@ -211,7 +212,53 @@ for (const datei of SEITEN) {
    }
  }
  if (dauer > GRENZE_MS) langsame.push(`${datei} ${dauer} ms`);
-  if (sprung > GRENZE_SPRUNG) springende.push(`${datei} ${sprung}`);
+
+  /* EIN AUSSCHLAG WIRD BESTAETIGT, BEVOR ER GEMELDET WIRD (05.09.2026).
+
+     Der Layout-Sprung ist ein SCHWANKENDER Messwert. Er haengt davon
+     ab, wie schnell der Server in dieser Sekunde antwortet: Kommen die
+     Daten, waehrend das Geruest noch aufgebaut wird, springt nichts --
+     kommen sie danach, springt die Liste auf ihre volle Hoehe.
+     Nachgemessen am 05.09.2026, dieselbe Seite, drei Laeufe
+     hintereinander: 0,478 / 0,262 / 0,262. Und bereich.html meldete
+     einmal 0,703 und beim naechsten Lauf 0,347.
+
+     Eine Pruefung, die zufaellig rot wird, ist genauso wertlos wie
+     eine, die nie anschlaegt -- man klickt sie weg, und mit ihr die
+     echte Warnung. (Dieselbe Lehre wie bei der Loeschwarnung, die
+     immer kam.)
+
+     Deshalb wird beim Ueberschreiten NOCH EINMAL gemessen und nur
+     gemeldet, wenn es sich wiederholt. Das kostet Zeit ausschliesslich
+     im Verdachtsfall. Ein ECHTER Layout-Sprung -- ein Bild ohne
+     Groessenangabe, eine Schrift, die nachlaedt -- kommt bei jedem
+     Lauf, der ueberlebt diese zweite Messung muehelos.
+
+     WICHTIG: Gemeldet wird der ZWEITE Wert, nicht der kleinere von
+     beiden. Sonst waere es keine Bestaetigung, sondern eine
+     Beschoenigung. */
+  if (sprung > GRENZE_SPRUNG) {
+    await seite.goto(BASIS + "/workspace/" + datei, { waitUntil: "networkidle" });
+    await seite.waitForTimeout(400);
+    const zweitens = await seite.evaluate(() => new Promise((fertig) => {
+      let summe = 0;
+      try {
+        const b = new PerformanceObserver((liste) => {
+          for (const e of liste.getEntries()) if (!e.hadRecentInput) summe += e.value;
+        });
+        b.observe({ type: "layout-shift", buffered: true });
+        setTimeout(() => { b.disconnect(); fertig(Math.round(summe * 1000) / 1000); }, 900);
+      } catch { fertig(0); }
+    }));
+    if (zweitens > GRENZE_SPRUNG) {
+      springende.push(`${datei} ${sprung} und erneut ${zweitens}`);
+    } else {
+      /* Nicht verschweigen: Der Ausschlag war da, er hat sich nur nicht
+         bestaetigt. Wer die Zahl haeufig sieht, weiss, dass die Seite
+         nahe an der Grenze liegt. */
+      schwankend.push(`${datei} ${sprung} → beim Nachmessen ${zweitens}`);
+    }
+  }
  if (anfragen > GRENZE_ANFRAGEN || bytes > GRENZE_BYTES) {
    zuGross.push(`${datei} ${anfragen} Anfragen / ${Math.round(bytes / 1024)} KB`);
  }
@@ -270,7 +317,15 @@ ok(langsame.length === 0,
  langsame.length ? `ueber ${GRENZE_MS} ms: ${langsame.join(", ")}` : `keine Seite braucht laenger als ${GRENZE_MS} ms`);
 ok(springende.length === 0,
  springende.length ? `Layout springt ueber ${GRENZE_SPRUNG}: ${springende.join(", ")}`
-    : `kein Layout-Sprung ueber der Grundlinie ${GRENZE_SPRUNG} (Ziel bleibt ${ZIEL_SPRUNG})`);
+    : `kein bestaetigter Layout-Sprung ueber der Grundlinie ${GRENZE_SPRUNG} (Ziel bleibt ${ZIEL_SPRUNG})`);
+
+/* Kein Fehler, aber es gehoert gesagt: Diese Seiten lagen einmal
+   darueber und beim zweiten Messen nicht mehr. Wer den Hinweis oft
+   sieht, weiss, dass die Grundlinie knapp geworden ist. */
+if (schwankend.length) {
+  console.log(`  hinw   ${schwankend.length} Ausschlag(e) haben sich beim Nachmessen `
+    + `NICHT bestaetigt: ${schwankend.join(" · ")}`);
+}

 /* Der ehrliche Zwischenstand, damit die Grundlinie nicht als "alles
   gut" missverstanden wird -- er zaehlt nicht als Fehler, steht aber