Brett und Kalender kennen einander jetzt in beide Richtungen

Der Kalender zeigt seit heute, was auf den Brettern steht und einen Termin hat. Die Verbindung war aber EINSEITIG, und beide Halften fehlten: Beim SCHREIBEN konnte niemand wissen, dass ein Tag in der Zukunft den Zettel in den Kalender bringt. Das Feld heisst "Datum" und ist mit HEUTE vorbelegt -- die Funktion war vorhanden und unauffindbar. Eine Funktion, die niemand findet, ist keine. Beim LESEN sagte die Karte nichts. Am Fuss stand bloss ein Datum, und "24.09.2026" sieht aus wie "17.09.2026" -- obwohl das eine ein Termin ist und das andere der Tag, an dem jemand getippt hat. EINE REGEL, ZWEI VERWENDER -> server/workspace-termin-regel.js. Der Kalender fragt "welche gehoeren hinein?" (SQL, ganze Tabelle), die Brettkarte fragt "stehe ICH drin?" (JavaScript, je Zeile). Beide Fassungen stehen jetzt nebeneinander in EINER Datei, importfrei wie treff-tabellen.js. Das ist kein Vorsichtsprinzip, sondern Erfahrung: Zwei Fassungen derselben Regel sind im Haus dreimal auseinandergelaufen -- die abgeschriebene Spaltenliste (11.09., drei Spalten samt Inhalt weg), die zweite Artenliste neben ARTNAME (ein BigMatch liess sich anlegen und war unsichtbar) und `.teilen` heute frueh. server/pruef-terminregel.mjs, 35 Pruefungen. Der Kern ist Abschnitt 2: Er prueft die beiden Fassungen GEGENEINANDER, nicht jede fuer sich -- zwei Pruefungen, die je eine Seite bestaetigen, finden genau diesen Fehler nicht. Verglichen wird beides: WELCHE Zettel und WELCHER Tag. Neun Faelle, davon vier, die zu Recht wegbleiben. Vier Gegenproben, jede in ihre eigene Richtung: JS laesst mehr durch -> "die Karte behauptet einen Termin, den der Kalender nicht kennt" JS nennt anderen Tag -> "verschiedene Tage: Kalender 22., Karte 17." SQL laesst mehr durch-> "steht im Kalender, aber die Karte sagt nichts" Marke ausgebaut -> 0 statt 1 EIN ECHTER FEHLER DABEI BEHOBEN, und er war aelter als diese Arbeit: Das Formularraster gibt jedem Feld GENAU ZWEI Zeilen (Schild dehnbar, Eingabe fest 44 px) -- deshalb sitzen die Eingaben auf einer Linie. Ein Hinweisabsatz erzeugt eine dritte Zeile, und weil das Raster alle Felder auf gleiche Hoehe dehnt, rutscht ausgerechnet diese Eingabe nach oben. Gemessen: 328..372 gegen 351..395. 23 px -- genau das, was man als "verzogen" sieht. Mit `git stash` getrennt: aufgaben.html war dadurch SCHON VORHER rot (ein anderes Feld hat dort ebenfalls einen Hinweis), bereich.html hatte ich neu verursacht. Der Hinweis haengt jetzt absolut unter dem Feld -- beide sind gruen, und zwar an der Wurzel, nicht symptomatisch. `pointer-events: none`, sonst faengt der Satz Klicks ab, die dem Element darunter galten. Am Handy gemessen statt geschaetzt: 0 Ueberschneidungen mit anderen Feldern. Gegenprobe (row-gap auf 2 px): 1 Ueberschneidung. Und noch zwei eigene Pruefungsfehler behoben, beide von derselben Sorte: ein falscher Selektor samt `.catch(() => {})`, der den Fehlgriff lautlos verschluckte (danach war das Hinweisfeld leer und die Zeile darunter trotzdem gruen, weil "" nun einmal nicht "ja" ist) -- und die Marke wurde ueber `textContent` gezaehlt statt ueber ihre Sichtbarkeit. Aufgefallen ist das am Bildschirmfoto, auf dem ich sie fuer fehlend hielt; deshalb macht die Pruefung jetzt zusaetzlich einen AUSSCHNITT der Karte -- auf einem Vollbild von 2000 px ist eine Pille von 28 px nicht zu beurteilen. Gruen: terminregel, kalender, formulare, ueberlappung, countdown, namen, css-klassen, struktur. Co-Authored-By: Claude Opus 5 <[email protected]>
2026-09-17 23:53:05 +02:00
parent 528ee1ecc7
commit 5e628e0078
40 changed files with 1087 additions and 425 deletions
@@ -0,0 +1,355 @@
+/* =====================================================================
+   ZWEI WEGE, EINE ANTWORT (17.09.2026)
+
+   „Wann hat ein Zettel einen Termin?" wird an zwei Stellen gefragt:
+
+     Der KALENDER fragt „welche gehoeren hinein?" -- als SQL, ueber die
+     ganze Tabelle auf einmal.
+     Die BRETTKARTE fragt „stehe ICH drin?" -- als JavaScript, je Zeile.
+
+   Beide muessen dasselbe antworten. Tun sie es nicht, behauptet die
+   Karte „steht im Kalender" und der Kalender zeigt nichts -- oder
+   umgekehrt. Eine Anzeige, die etwas Falsches sagt, ist schlimmer als
+   gar keine: Man glaubt ihr ja.
+
+   Dass zwei Fassungen derselben Regel auseinanderlaufen, ist im Haus
+   keine Theorie. Es ist dreimal passiert:
+     11.09. eine abgeschriebene Spaltenliste warf drei Spalten samt
+            Inhalt weg -- ohne Fehlermeldung, bei gleicher Zeilenzahl
+     im Kalender eine zweite Artenliste neben ARTNAME -- ein BigMatch
+            liess sich anlegen und war danach unsichtbar
+     17.09. `.teilen` fuer zwei verschiedene Dinge
+
+   Deshalb stehen beide Fassungen in EINER Datei (workspace-termin-
+   regel.js), und deshalb prueft diese Datei sie GEGENEINANDER -- nicht
+   jede fuer sich. Zwei Pruefungen, die je eine Seite bestaetigen,
+   finden genau diesen Fehler nicht.
+
+   Aufrufen mit:  node server/pruef-terminregel.mjs
+   ===================================================================== */
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { request as httpAnfrage } from "node:http";
+import { portMussFreiSein } from "./helfer-port.mjs";
+import { tagLokal } from "./helfer-tag.mjs";
+
+const PORT = await portMussFreiSein(4192, "pruef-terminregel");
+const ordner = mkdtempSync(join(tmpdir(), "ws-terminregel-"));
+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(180_000, "pruef-terminregel");
+await new Promise((r) => setTimeout(r, 800));
+
+process.on("uncaughtException", (f) => { console.error("ABSTURZ:", f); process.exit(7); });
+
+let fehler = 0, geprueft = 0, offen = 0;
+const melde = (t) => console.log(t);
+const ok = (b, t) => { geprueft++; console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };
+const unklar = (t) => { offen++; console.log("  --   " + t); };
+
+const HEUTE = tagLokal(0);
+const MORGEN = tagLokal(1);
+const IN5 = tagLokal(5);
+const GESTERN = tagLokal(-1);
+
+const { DatabaseSync } = await import("node:sqlite");
+const { scryptSync, randomBytes } = await import("node:crypto");
+const regel = await import("./workspace-termin-regel.js");
+
+/* =======================================================================
+   DIE FAELLE
+
+   Jede Zeile beantwortet EINE Frage, und die Haelfte davon ist die
+   Frage, ob etwas ZU RECHT wegbleibt. Eine Pruefung nur mit Treffern
+   koennte auch dann gruen sein, wenn die Regel alles hereinlaesst.
+   ======================================================================= */
+const FAELLE = [
+  // [name,           bereich,   datum,   uhrzeit, geplant, ende,  status,      soll]
+  ["Zusage",          "wunsch",  HEUTE,   null,    IN5,     null,  "angenommen", true],
+  ["Zukunft",         "content", IN5,     null,    null,    null,  "offen",      true],
+  ["Mit Uhrzeit",     "live",    MORGEN,  "20:00", null,    null,  "offen",      true],
+  ["Zeitraum",        "agentur", MORGEN,  null,    null,    IN5,   "offen",      true],
+  ["Uhrzeit heute",   "live",    HEUTE,   "21:00", null,    null,  "offen",      true],
+  ["Nur heute",       "ideen",   HEUTE,   null,    null,    null,  "offen",      false],
+  ["Von gestern",     "ideen",   GESTERN, null,    null,    null,  "offen",      false],
+  ["Erledigt",        "content", IN5,     null,    null,    null,  "erledigt",   false],
+  ["Abgelehnt",       "wunsch",  HEUTE,   null,    IN5,     null,  "abgelehnt",  false],
+];
+
+{
+  const d = new DatabaseSync(process.env.WORKSPACE_DB);
+  const salt = randomBytes(16).toString("hex");
+  const hash = scryptSync("CODE-DOGI-0001", 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("Filipe", "admin", hash, salt, 32768, new Date().toISOString());
+  for (const [name, bereich, datum, uhrzeit, geplant, ende, status] of FAELLE) {
+    d.prepare(`INSERT INTO eintraege (bereich, art, titel, text, datum, uhrzeit, geplant,
+               event_ende, status, dringlichkeit, erstellt, erstellt_von)
+               VALUES (?,?,?,?,?,?,?,?,?,'mittel',?,1)`)
+      .run(bereich, "sonstiges", name, "Text", datum, uhrzeit, geplant, ende,
+        status, new Date().toISOString());
+  }
+  d.close();
+}
+
+function roh(pfad, kopf = {}) {
+  return new Promise((fertig, schief) => {
+    const a = httpAnfrage({
+      host: "127.0.0.1", port: PORT, path: pfad, method: "GET",
+      headers: { Host: "workspace.dogfather-universe.com", ...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);
+    a.end();
+  });
+}
+function post(pfad, koerper) {
+  return new Promise((fertig, schief) => {
+    const a = httpAnfrage({
+      host: "127.0.0.1", port: PORT, path: pfad, method: "POST",
+      headers: { Host: "workspace.dogfather-universe.com", "Content-Type": "application/json" },
+    }, (antwort) => {
+      let text = "";
+      antwort.on("data", (s) => { text += s; });
+      antwort.on("end", () => fertig({ code: antwort.statusCode, text, kopf: antwort.headers }));
+    });
+    a.on("error", schief);
+    a.write(JSON.stringify(koerper));
+    a.end();
+  });
+}
+const json = (a) => { try { return JSON.parse(a.text); } catch { return {}; } };
+
+const an = await post("/workspace/api/anmelden", { rolle: "admin", code: "CODE-DOGI-0001" });
+const keks = [].concat(an.kopf?.["set-cookie"] || []).map((c) => c.split(";")[0]).join("; ");
+
+/* =======================================================================
+   1. DIE JS-FASSUNG FUER SICH
+   ======================================================================= */
+melde("=== 1. terminVon() ===");
+for (const [name, , datum, uhrzeit, geplant, ende, status, soll] of FAELLE) {
+  const r = regel.terminVon({ datum, uhrzeit, geplant, event_ende: ende, status }, HEUTE);
+  ok(!!r === soll, `${name.padEnd(14)} -> ${r ? `${r.grund} am ${r.tag}` : "kein Termin"}`);
+}
+{
+  /* Die Rangfolge: Eine Zusage schlaegt alles andere. Wer „am 24."
+     sagt, meint den 24. -- auch wenn der Zettel am 3. entstand und
+     eine Uhrzeit traegt. */
+  const r = regel.terminVon(
+    { datum: HEUTE, uhrzeit: "20:00", geplant: IN5, event_ende: null, status: "offen" }, HEUTE);
+  ok(r?.grund === "zugesagt" && r?.tag === IN5,
+    `die Zusage schlaegt Uhrzeit und Erfassungstag (${r?.grund} am ${r?.tag})`);
+}
+
+/* =======================================================================
+   2. DER KALENDER (SQL) UND DIE KARTE (JS) SAGEN DASSELBE
+
+   Das ist der eigentliche Zweck dieser Datei.
+   ======================================================================= */
+melde("");
+melde("=== 2. Beide Wege, verglichen ===");
+
+const kal = json(await roh("/workspace/api/termine?tage=60", { cookie: keks }));
+const imKalender = new Set((kal.brettsachen || []).map((b) => b.titel));
+ok(imKalender.size > 0, `der Kalender liefert ${imKalender.size} Zettel`);
+
+const bereiche = [...new Set(FAELLE.map((f) => f[1]))];
+const mitMarke = new Set();
+const tagLaut = new Map();
+for (const b of bereiche) {
+  const r = json(await roh(`/workspace/api/bereich/${b}`, { cookie: keks }));
+  for (const e of r.eintraege || []) {
+    if (e.termin) { mitMarke.add(e.titel); tagLaut.set(e.titel, e.termin.tag); }
+  }
+}
+ok(mitMarke.size > 0, `die Bretter melden ${mitMarke.size} Zettel mit Termin`);
+
+{
+  const nurKalender = [...imKalender].filter((x) => !mitMarke.has(x));
+  const nurKarte = [...mitMarke].filter((x) => !imKalender.has(x));
+  ok(nurKalender.length === 0,
+    nurKalender.length ? `steht im Kalender, aber die Karte sagt nichts: ${nurKalender.join(", ")}`
+      : "kein Zettel steht im Kalender, ohne dass seine Karte es sagt");
+  ok(nurKarte.length === 0,
+    nurKarte.length ? `die Karte behauptet einen Termin, der Kalender zeigt ihn nicht: ${nurKarte.join(", ")}`
+      : "und keine Karte behauptet einen Termin, den der Kalender nicht kennt");
+}
+
+/* UND DER TAG MUSS AUCH DERSELBE SEIN. Beide Seiten einig darueber,
+   DASS etwas einen Termin hat, und uneinig ueber WANN -- das waere die
+   unauffaelligste Art, falsch zu liegen. */
+{
+  const uneinig = (kal.brettsachen || [])
+    .filter((b) => tagLaut.has(b.titel) && tagLaut.get(b.titel) !== b.wann)
+    .map((b) => `${b.titel}: Kalender ${b.wann}, Karte ${tagLaut.get(b.titel)}`);
+  ok(uneinig.length === 0,
+    uneinig.length ? `verschiedene Tage: ${uneinig.join(" | ")}`
+      : `beide nennen denselben Tag (${tagLaut.size} verglichen)`);
+}
+
+/* =======================================================================
+   3. UND GEGEN DIE ERWARTUNG, NICHT NUR GEGENEINANDER
+
+   Zwei Wege koennen sich einig sein und beide falsch liegen. Deshalb
+   zusaetzlich gegen die Fallliste oben.
+   ======================================================================= */
+melde("");
+melde("=== 3. Gegen die Erwartung ===");
+for (const [name, , , , , , , soll] of FAELLE) {
+  ok(imKalender.has(name) === soll,
+    soll ? `„${name}" steht im Kalender` : `„${name}" bleibt draussen`);
+}
+
+/* =======================================================================
+   4. IM BROWSER
+   ======================================================================= */
+melde("");
+melde("=== 4. Was man sieht ===");
+{
+  let chromium;
+  try {
+    ({ chromium } = await import(
+      "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs"));
+  } catch { chromium = null; }
+
+  if (!chromium) {
+    unklar("kein Playwright gefunden -- die Oberflaeche wurde nicht angesehen");
+  } else {
+    const browser = await chromium.launch();
+    try {
+      const sicht = await browser.newContext({ viewport: { width: 1280, height: 900 } });
+      await sicht.addCookies(keks.split("; ").map((c) => {
+        const [name, ...rest] = c.split("=");
+        return { name, value: rest.join("="), domain: "127.0.0.1", path: "/" };
+      }));
+      const seite = await sicht.newPage();
+      const konsole = [];
+      seite.on("console", (m) => { if (m.type() === "error") konsole.push(m.text()); });
+      await seite.goto(`http://127.0.0.1:${PORT}/workspace/bereich.html?b=content`,
+        { waitUntil: "domcontentloaded" });
+      await seite.waitForTimeout(1600);
+
+      /* SICHTBARKEIT, NICHT VORHANDENSEIN. `textContent` liefert auch,
+         was `display: none` ausblendet -- und am Bildschirmfoto fiel
+         auf, dass die Marke im Bild fehlte, obwohl die Zaehlung 1
+         ergab. Ohne `offsetHeight` waere das nie aufgefallen. */
+      const marken = await seite.evaluate(() =>
+        [...document.querySelectorAll(".im-kalender")].map((a) => ({
+          text: a.textContent.trim(), ziel: a.getAttribute("href"),
+          grund: a.dataset.grund,
+          sichtbar: a.offsetHeight > 0 && a.offsetWidth > 0,
+          wo: a.closest(".eintrag-karte")?.querySelector("h3, .eintrag-titel")?.textContent
+            || a.parentElement?.className || "?",
+        })));
+      ok(marken.length > 0, `auf dem Brett steht ${marken.length}x „im Kalender"`);
+      ok(marken.length > 0 && marken.every((m) => m.sichtbar),
+        `und man sieht sie auch (${marken.map((m) => `${m.wo}: ${m.sichtbar}`).join(", ")})`);
+      ok(marken.every((m) => m.ziel === "kalender.html"),
+        "und jede fuehrt in den Kalender");
+      /* GEGENPROBE: NICHT an jeder Karte. „Erledigt" und „von gestern"
+         liegen auf demselben Brett und duerfen die Marke nicht haben --
+         sonst hiesse „steht im Kalender" nur, dass ueberall etwas steht. */
+      const karten = await seite.locator(".eintrag-karte").count();
+      ok(karten > marken.length,
+        `aber nicht an allen (${marken.length} von ${karten} Karten)`);
+
+      /* ---- Der Hinweis unter dem Datumsfeld ---- */
+      const hinweis = async () => seite.evaluate(() => ({
+        text: document.getElementById("hinweis-datum")?.textContent?.trim() || "",
+        marke: document.getElementById("hinweis-datum")?.dataset.imkalender || "",
+      }));
+      /* Der Knopf heisst `neu-oeffnen`, nicht `neu-auf` -- beim ersten
+         Lauf stand hier der falsche Name samt `.catch(() => {})`, und
+         der Fehlgriff verschwand lautlos. Ein `.catch`, das einen
+         Selektorfehler schluckt, macht aus einer kaputten Pruefung eine
+         gruene: Danach stand im Hinweisfeld "" und die Zeile darunter
+         war trotzdem in Ordnung, weil "" nun einmal nicht "ja" ist. */
+      await seite.click("#neu-oeffnen");
+      await seite.waitForTimeout(500);
+      const h1 = await hinweis();
+      ok(h1.text.length > 5, `beim Oeffnen steht ein Satz da ("${h1.text}")`);
+      /* Die Anzahl gehoert in die BEDINGUNG: Ohne `h1.text` waere diese
+         Zeile auch bei leerem Feld gruen. */
+      ok(h1.text.length > 5 && h1.marke !== "ja",
+        "und er sagt NICHT, dass es im Kalender landet -- heute ist heute");
+
+      await seite.fill("#f-datum", IN5);
+      await seite.waitForTimeout(300);
+      const h2 = await hinweis();
+      ok(h2.text.length > 5 && h2.marke === "ja" && /Kalender/.test(h2.text),
+        `mit einem Tag in der Zukunft aendert er sich ("${h2.text}")`);
+
+      await seite.fill("#f-datum", HEUTE);
+      await seite.waitForTimeout(300);
+      const h3 = await hinweis();
+      ok(h3.text.length > 5 && h3.marke !== "ja",
+        `und zurueck auf heute wieder ("${h3.text}")`);
+
+      /* ---- UND AM HANDY (17.09.2026) ----------------------------------
+
+         Der Hinweis haengt seit heute AUSSERHALB des Feldes (absolut,
+         damit er die Eingaben nicht aus der Linie schiebt). Genau das
+         kann am schmalen Bildschirm das naechste Feld ueberdecken --
+         dort stehen die Felder untereinander, und dann liegt der
+         schwebende Satz auf dem, was folgt.
+
+         Gemessen wird die Ueberschneidung, nicht geschaetzt. */
+      await seite.setViewportSize({ width: 390, height: 844 });
+      await seite.waitForTimeout(500);
+      const eng = await seite.evaluate(() => {
+        const h = document.getElementById("hinweis-datum");
+        if (!h || h.offsetHeight === 0) return { da: false };
+        const a2 = h.getBoundingClientRect();
+        const treffer = [...document.querySelectorAll(".neu__raster > *")]
+          .filter((f) => !f.contains(h))
+          .map((f) => f.getBoundingClientRect())
+          .filter((b) => a2.left < b.right && b.left < a2.right
+            && a2.top < b.bottom && b.top < a2.bottom);
+        return { da: true, ueberdeckt: treffer.length, hoehe: Math.round(a2.height) };
+      });
+      ok(eng.da, "am Handy steht der Hinweis auch da");
+      ok(eng.da && eng.ueberdeckt === 0,
+        `und liegt auf keinem anderen Feld (${eng.ueberdeckt} Ueberschneidungen)`);
+      await seite.setViewportSize({ width: 1280, height: 900 });
+      await seite.waitForTimeout(400);
+
+      ok(konsole.length === 0,
+        konsole.length ? `Konsolenfehler: ${konsole[0]}` : "kein Konsolenfehler");
+
+      /* EIN AUSSCHNITT DER KARTE, nicht nur die ganze Seite. Auf einem
+         Vollbild von 2000 px Hoehe ist eine Pille von 28 px nicht zu
+         beurteilen -- ich habe sie beim ersten Hinsehen schlicht
+         uebersehen und fuer fehlend gehalten. Ein Bild, auf dem man
+         nichts erkennen kann, ist keine Kontrolle. */
+      const karteMitMarke = seite.locator(".eintrag-karte").filter(
+        { has: seite.locator(".im-kalender") }).first();
+      await karteMitMarke.screenshot({ path: "server/pruef-terminregel-marke.png" })
+        .catch(() => {});
+      await seite.screenshot({ path: "server/pruef-terminregel.png", fullPage: true });
+      melde("  --   Bildschirmfoto: server/pruef-terminregel.png");
+    } finally {
+      await browser.close();
+    }
+  }
+}
+
+/* ------------------------------------------------------------------- */
+melde("");
+melde(`${geprueft} Pruefungen, ${fehler} Fehler`
+  + (offen ? `, ${offen} nicht nachsehbar` : ""));
+melde(fehler ? "NICHT IN ORDNUNG" : "ALLES IN ORDNUNG");
+try { rmSync(ordner, { recursive: true, force: true }); } catch { /* Aufraeumrest */ }
+process.exit(fehler ? 1 : 0);
@@ -17,6 +17,13 @@
 import express from "express";
 import { TREFF_START } from "./workspace-treff-start.js";
 import { ARBEIT_START } from "./workspace-arbeit-start.js";
+/* Wann ein Zettel einen Termin hat -- DIESELBE Regel, aus der auch der
+   Kalender seine Auswahl baut. Sie steht in einer eigenen Datei, weil
+   sie jetzt zwei Verwender hat: Der Kalender fragt "welche gehoeren
+   hinein?", die Brettkarte fragt "stehe ICH drin?". Zwei Fassungen
+   derselben Regel laufen auseinander, und dann behauptet die Karte
+   etwas, das der Kalender nicht zeigt. */
+import { terminVon } from "./workspace-termin-regel.js";

 /* EIN KATALOG AUS ZWEI QUELLEN (17.09.2026)

@@ -40,6 +47,7 @@ import {
  externPruefen, externSql,
  ohneTeamDogi, ohneAgentur, siehtModis, fuehrtTeamDogi, MODI_BEREICHE_ERLAUBT, TEAM_DOGI_ROLLEN,
  TREFF_BRETTER, TREFF_ROLLEN, AUSSEN_ROLLEN,
+  heuteLokal,
 } from "./workspace.js";
 import { nachrichtSchicken } from "./workspace-chat.js";
 import {
@@ -1222,6 +1230,28 @@ bereicheRouter.get("/workspace/api/bereich/:bereich", (req, res) => {
      ORDER BY ${reihenfolge}`)
      .all(...(treffBrett ? [wer] : []), ...regel.werte, bereich);

+    /* STEHT DIESER ZETTEL IM KALENDER? (17.09.2026)
+
+       Der Kalender zeigt seit heute, was auf den Brettern steht und
+       einen Termin hat. Die Verbindung war aber EINSEITIG: Vom
+       Kalender kam man aufs Brett, vom Brett erfuhr man nichts. Am
+       Kartenfuss stand bloss ein Datum -- und "24.09.2026" sieht
+       genauso aus wie "17.09.2026", obwohl das eine ein Termin ist
+       und das andere der Tag, an dem jemand getippt hat.
+
+       DIE ANTWORT KOMMT VOM SERVER und wird nicht im Browser
+       nachgerechnet: Sonst gaebe es eine zweite Fassung der Regel, und
+       die Karte behauptete irgendwann etwas, das der Kalender nicht
+       zeigt. Eine Anzeige, die etwas Falsches sagt, ist schlimmer als
+       keine -- man glaubt ihr ja.
+
+       Kostet keine zusaetzliche Abfrage: Alle vier Felder stehen
+       ohnehin schon in SPALTEN. */
+    {
+      const heute = heuteLokal();
+      for (const e of eintraege) e.termin = terminVon(e, heute);
+    }
+
    /* DIE BILDER AN DEN BEITRAEGEN (17.09.2026) -- in EINER Abfrage
       fuer die ganze Liste. Vierzig Beitraege einzeln zu fragen waeren
       vierzig Anfragen, und die Seite ruckelte sichtbar beim Aufbau;
@@ -30,6 +30,14 @@ import {
   Aufgabenfristen: nicht durch ein Loch, sondern durch eine zweite
   Regel, die "istLeitung" fragte statt der richtigen. */
 import { sichtbarEintrag, BEREICHE } from "./workspace-bereiche.js";
+/* Die Regel, WANN ein Zettel einen Termin hat -- als eigenes Blatt.
+   Seit die Brettkarte dasselbe sagt ("steht im Kalender am 24."),
+   haette sie sonst eine zweite Fassung. Zwei Fassungen derselben Regel
+   laufen auseinander, und dann zeigt die Karte etwas anderes als der
+   Kalender. */
+import {
+  TERMIN_TAG_SQL, TERMIN_BEDINGUNG_SQL, TERMIN_GRUND_SQL, OHNE_ZUSTAENDE,
+} from "./workspace-termin-regel.js";

 export const kalenderRouter = express.Router();

@@ -448,31 +456,17 @@ kalenderRouter.get("/workspace/api/termine", (req, res) => {
      SELECT e.id, e.bereich, e.art, e.titel, e.text, e.status,
             e.dringlichkeit, e.datum, e.uhrzeit, e.geplant, e.event_ende,
             pe.name AS von_name,
-             /* WELCHER TAG ZAEHLT -- abgeleitet, nicht im Browser
-                nachgerechnet. Eine Zusage schlaegt das Erfassungsdatum:
-                Wer sagt "am 24.", meint den 24., auch wenn der Zettel
-                am 3. entstanden ist. */
-             COALESCE(e.geplant, e.datum) AS wann,
-             CASE
-               WHEN e.geplant IS NOT NULL THEN 'zugesagt'
-               WHEN e.event_ende IS NOT NULL THEN 'zeitraum'
-               WHEN e.uhrzeit IS NOT NULL THEN 'uhrzeit'
-               ELSE 'termin'
-             END AS grund
+             ${TERMIN_TAG_SQL} AS wann,
+             ${TERMIN_GRUND_SQL} AS grund
        FROM eintraege e
        LEFT JOIN personen pe ON pe.id = e.erstellt_von
       WHERE ${eintragRegel.wo}
-         AND e.status NOT IN ('erledigt', 'abgelehnt')
-         AND (
-           e.geplant IS NOT NULL
-           OR e.event_ende IS NOT NULL
-           OR e.uhrzeit IS NOT NULL
-           OR e.datum > ?
-         )
-         AND COALESCE(e.geplant, e.datum) >= ?
-         AND COALESCE(e.geplant, e.datum) <= ?
+         AND e.status NOT IN (${OHNE_ZUSTAENDE.map(() => "?").join(", ")})
+         AND ${TERMIN_BEDINGUNG_SQL}
+         AND ${TERMIN_TAG_SQL} >= ?
+         AND ${TERMIN_TAG_SQL} <= ?
       ORDER BY wann, e.uhrzeit, e.id`)
-      .all(...eintragRegel.werte, heuteLokal(), von, bis) : [];
+      .all(...eintragRegel.werte, ...OHNE_ZUSTAENDE, heuteLokal(), von, bis) : [];

    /* DER NAME DES BRETTS KOMMT MIT -- und zwar aus dem Katalog, nicht
       als abgeschriebene Liste im Browser. Ein Brett, das morgen
@@ -0,0 +1,109 @@
+/* =====================================================================
+   WANN EIN ZETTEL EINEN TERMIN HAT (17.09.2026)
+
+   EINE Regel, zwei Verwender -- und deshalb eine eigene Datei.
+
+   Seit heute zeigt der Kalender, was auf den Brettern steht und einen
+   Termin hat. Die Bedingung dafuer stand als SQL mitten in
+   workspace-kalender.js. Sobald die Brettkarte dasselbe sagen soll
+   ("steht im Kalender am 24."), braeuchte sie eine zweite Fassung --
+   und zwei Fassungen derselben Regel laufen auseinander. Nicht sofort,
+   sondern beim naechsten Nachschaerfen, und dann zeigt die Karte etwas
+   anderes als der Kalender. Das ist schlimmer als beides wegzulassen:
+   Man glaubt der Anzeige ja.
+
+   Dieselbe Krankheit gab es im Haus schon zweimal -- die abgeschriebene
+   Spaltenliste (11.09., drei Spalten samt Inhalt verloren) und die
+   zweite Artenliste neben ARTNAME (im Kalender, ein BigMatch liess
+   sich anlegen und war danach unsichtbar).
+
+   DIE DATEI IMPORTIERT NICHTS. Muster wie treff-tabellen.js und
+   workspace-bewerbung-rollen.js: Ein Blatt ohne eigene Importe kann von
+   ueberall gelesen werden, ohne einen Ring zu bauen -- und ein Ring
+   aeussert sich in JavaScript nicht als Fehler, sondern als
+   `undefined` an einer Stelle, an der niemand damit rechnet.
+
+   -------------------------------------------------------------------
+   WARUM GENAU DIESE VIER FAELLE
+
+   `eintraege.datum` ist ein PFLICHTFELD und faellt auf HEUTE zurueck,
+   wenn niemand eins waehlt. Alle Eintraege in den Kalender zu nehmen
+   hiesse also: jeder je getippte Zettel steht an dem Tag, an dem ihn
+   jemand getippt hat. Nach einem Monat waere der Kalender ein
+   Protokoll und kein Plan -- und einer, in dem alles steht, sagt
+   nichts mehr.
+
+     geplant       Eine Zusage: "Wird gemacht -- am 24.09." Das ist ein
+                   Termin, den jemand jemandem gegeben hat.
+     event_ende    Ein Zeitraum. Wer ein Ende eintraegt, meint eine
+                   Veranstaltung, keine Notiz.
+     uhrzeit       Wer eine Uhrzeit tippt, meint einen Zeitpunkt.
+                   Niemand traegt aus Versehen 20:00 ein.
+     datum > heute Der Rueckfall ist IMMER heute oder frueher. Ein Datum
+                   in der Zukunft kann nur Absicht sein.
+
+   Der letzte Fall ist der wichtigste und der unauffaelligste: Er
+   braucht kein neues Feld und keine Umgewoehnung.
+   ===================================================================== */
+
+/** Der massgebliche Tag eines Eintrags -- als SQL-Ausdruck.
+ *
+ *  Eine Zusage schlaegt das Erfassungsdatum: Wer "am 24." sagt, meint
+ *  den 24., auch wenn der Zettel am 3. entstanden ist. */
+export const TERMIN_TAG_SQL = "COALESCE(e.geplant, e.datum)";
+
+/** Die Bedingung als SQL. Erwartet GENAU EINEN Platzhalter: den
+ *  heutigen Tag in Ortszeit (`heuteLokal()`).
+ *
+ *  UTC waere hier falsch: Zwischen Mitternacht und zwei Uhr morgens
+ *  liefert es in Deutschland den Vortag, und ein Zettel von heute
+ *  staende dann ploetzlich im Kalender. */
+export const TERMIN_BEDINGUNG_SQL = `(
+  e.geplant IS NOT NULL
+  OR e.event_ende IS NOT NULL
+  OR e.uhrzeit IS NOT NULL
+  OR e.datum > ?
+)`;
+
+/** Warum er drinsteht -- als SQL-Ausdruck. Die Reihenfolge ist die
+ *  Rangfolge: Eine Zusage ist mehr als ein Zeitraum, ein Zeitraum mehr
+ *  als eine Uhrzeit. */
+export const TERMIN_GRUND_SQL = `CASE
+  WHEN e.geplant IS NOT NULL THEN 'zugesagt'
+  WHEN e.event_ende IS NOT NULL THEN 'zeitraum'
+  WHEN e.uhrzeit IS NOT NULL THEN 'uhrzeit'
+  ELSE 'termin'
+END`;
+
+/** Welche Zustaende NICHT in den Kalender gehoeren.
+ *
+ *  Ein Kalender zeigt, was ansteht. Was gemacht oder abgelehnt ist,
+ *  gehoert auf sein Brett -- nicht in die Planung der naechsten Woche. */
+export const OHNE_ZUSTAENDE = ["erledigt", "abgelehnt"];
+
+/** Dieselbe Frage in JavaScript -- fuer einen einzelnen Eintrag.
+ *
+ *  Sie wird beim Ausliefern der Brettkarten gebraucht: Dort steht seit
+ *  heute "im Kalender am 24.", und diese Auskunft MUSS dieselbe sein
+ *  wie die des Kalenders. Beide Fassungen stehen deshalb in dieser
+ *  Datei nebeneinander, damit eine Aenderung an der einen die andere
+ *  ins Auge springen laesst -- und pruef-terminregel.mjs weist nach,
+ *  dass sie fuer dieselben Zeilen dasselbe sagen.
+ *
+ *  @param e      Zeile aus `eintraege` (mit geplant, event_ende, uhrzeit,
+ *                datum, status)
+ *  @param heute  Heutiger Tag in Ortszeit, "JJJJ-MM-TT"
+ *  @returns {null|{tag, grund}} */
+export function terminVon(e, heute) {
+  if (!e) return null;
+  if (OHNE_ZUSTAENDE.includes(e.status)) return null;
+
+  const grund = e.geplant ? "zugesagt"
+    : e.event_ende ? "zeitraum"
+      : e.uhrzeit ? "uhrzeit"
+        : (e.datum && heute && e.datum > heute) ? "termin"
+          : null;
+  if (!grund) return null;
+
+  return { tag: e.geplant || e.datum, grund };
+}