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]>

server/pruef-tempo-workspace.mjs

@@ -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