Aufgaben: die Bedienung, nicht die Kacheln

Filipe: "ich will dass du dass system jetzt wie die vier kategorien
bedient werden, perfektionnierst ... ich red von den aufgaben. das
system von den aufgaben, die bedienung ... die hauptkachel von der
kategorie nicht veraendern oder anfassen, die bleiben so."

Die vier Kacheln sind unberuehrt. Geaendert ist, was danach kommt.

--- 1. DAS VORLAGENBRETT WAR IM WEG ---

Gemessen am Handy: Der Vorlagenblock fuellte ANDERTHALB BILDSCHIRME,
bevor die erste eigene Aufgabe kam. Und mein eigener Ausbau von Profi
und Meister ein paar Stunden vorher hat ihn noch laenger gemacht --
aus 48 Vorlagen wurden 80.

Das ist die falsche Reihenfolge: Vorlagen holt man selten, das Brett
benutzt man jeden Tag. Der Block bleibt an seiner Stelle (dort gehoert
er hin, weil daraus Aufgaben auf das Brett darunter wandern), ist aber
zugeklappt. Zugeklappt steht dort, WIE VIEL darin liegt -- sonst sieht
er aus wie eine Ueberschrift ohne Inhalt und niemand macht ihn auf.

Wer ihn aufmacht, findet ihn beim naechsten Mal offen: Wer Vorlagen
holt, holt meistens mehrere. Und zugeklappt werden die achtzig Karten
GAR NICHT ERST GEBAUT, nicht nur versteckt.

--- 2. MAN SAH NICHT, WAS MAN SCHON GEHOLT HATTE ---

Dieselbe Vorlage liess sich zweimal uebernehmen, und die Aufgabe stand
dann zweimal auf dem Brett -- ohne jeden Hinweis. Bei achtzig Vorlagen
ueber vier Stufen weiss niemand auswendig, was er letzten Monat schon
geholt hat.

Die Kennung der Vorlage steht jetzt an der Aufgabe (neue Spalte
`vorlage`). Ueber den TITEL zu vergleichen waere die naheliegende
Abkuerzung gewesen -- und faellt in dem Moment um, in dem jemand den
Titel einer uebernommenen Aufgabe aendert.

Uebernommene Karten treten zurueck (nicht: verschwinden -- wer sie
ausblendet, nimmt die Moeglichkeit, sie bewusst noch einmal zu holen),
tragen "schon uebernommen" MIT ZUSTAND, und ihr Knopf heisst
"Nochmal". Darunter steht der Stand: "5 von 7 noch nicht uebernommen."
Es braucht dafuer keine zweite Abfrage -- die Aufgaben liegen ohnehin
im Browser.

--- 3. DRINGEND SCHLAEGT WICHTIG ---

Die Liste war nach PRIORITAET sortiert, dann nach Frist. Auf dem Brett
stand damit eine seit vier Tagen ueberfaellige Aufgabe mit Prioritaet
"niedrig" UNTER einer, die als "hoch" eingetragen ist und erst in
dreissig Tagen faellig wird. Wer die Spalte von oben liest, faengt
dann mit dem Falschen an.

Eine Prioritaet ist eine Einschaetzung von damals, eine
ueberschrittene Frist eine Tatsache von heute. Jetzt: erst was
faellig ist, dann nach Datum, und die Prioritaet entscheidet nur noch
bei gleichem Datum. Die Sortierung steht im SERVER -- Startseite und
Uebersicht lesen dieselbe Liste, und zwei Sortierungen fuer dieselbe
Frage laufen auseinander.

--- 4. "WICHTIG" STEHT JETZT DA ---

Die Prioritaet war ein 3 px breiter Rand links -- direkt neben der
farbigen Kante der Spalte und damit praktisch unsichtbar. Als Wort
steht sie dort, wo man sie liest. NUR bei "hoch" und nur solange
nicht erledigt: Eine Marke an jeder Karte waere keine Marke mehr.

--- Pruefung ---

pruef-aufgaben-vorlagen: zugeklappt als Vorgabe (gemessen wird, dass
die Karten gar nicht gebaut werden), Aufklappen, uebernommene Vorlage
markiert samt Zustand und "Nochmal"-Knopf, Stand darunter, Zustand
ueberlebt das Neuladen -- mit Gegenprobe, dass die uebrigen NICHT
markiert sind.

Dabei fiel eine eigene Nachlaessigkeit auf: Die Pruefung "die Karten
sind gestaltet" mass zu einem Zeitpunkt, an dem es zugeklappt gar
keine Karte gab -- getComputedStyle auf null liefert nichts, und der
Haken wurde rot, ohne dass etwas kaputt war. Sie misst jetzt nach dem
Aufklappen.

pruef-aufgabenbrett: die Sortierung an zwei absichtlich unguenstig
angelegten Aufgaben (ueberfaellig+niedrig gegen fern+hoch), plus die
Gegenprobe, dass bei GLEICHER Frist weiterhin die Prioritaet
entscheidet -- sonst waere die Prioritaet wirkungslos geworden, und
das waere die andere Uebertreibung.

Ausserdem gruen: pruef-css-klassen, pruef-start-ansicht, pruef-uebersicht.

Co-Authored-By: Claude Opus 5 <[email protected]>

server/pruef-aufgaben-vorlagen.mjs

@@ -295,10 +295,50 @@ console.log("\n=== Auf der Aufgabenseite");
         const st = getComputedStyle(k);
         return parseFloat(st.borderTopWidth) >= 1 && parseFloat(st.paddingLeft) >= 8;
       })(),
+      kopftext: document.querySelector("#vorlagenbrett .vorlagenbrett__unter")?.textContent,
       ueber: document.documentElement.scrollWidth - document.documentElement.clientWidth,
     };
   });
   ok(d.sichtbar, "der Block ist da");
+
+  /* ZUGEKLAPPT ALS VORGABE (09.09.2026).
+
+     Gemessen auf dem Handy: Der Block fuellte anderthalb Bildschirme,
+     BEVOR die erste eigene Aufgabe kam -- und nach dem Ausbau von Profi
+     und Meister am selben Tag noch mehr. Vorlagen holt man selten, das
+     Brett benutzt man taeglich.
+
+     Geprueft wird, dass die Karten GAR NICHT GEBAUT werden, nicht nur
+     dass sie versteckt sind: Achtzig Karten bei jedem Neuzeichnen
+     anzulegen, die niemand sieht, waere Arbeit fuer nichts. */
+  ok(d.karten === 0 && d.reihen === 0,
+     `zugeklappt steht nur die Zeile da (${d.karten} Karten, ${d.reihen} Reihen)`);
+  ok(/\d+ fertige Aufgaben/.test(d.kopftext || ""),
+     `und sagt, wie viel darin liegt ("${d.kopftext}")`);
+
+  /* Aufmachen, und alles ist da. */
+  await seite.click("#vorlagenbrett .vorlagenbrett__kopf");
+  await seite.waitForTimeout(600);
+  const d2 = await seite.evaluate(() => ({
+    reihen: document.querySelectorAll("#vorlagenbrett .stufenleiter").length,
+    karten: document.querySelectorAll("#vorlagenbrett .vorlagenbrett__karte").length,
+    knoepfe: document.querySelectorAll("#vorlagenbrett .vorlagenbrett__fuss .knopf").length,
+    auf: document.getElementById("vorlagenbrett").dataset.auf,
+    /* ERST JETZT MESSBAR. Zugeklappt gibt es keine Karte, und
+       getComputedStyle auf `null` liefert nichts -- die Messung von
+       vorhin war deshalb leer und der Haken darunter rot, ohne dass
+       etwas kaputt war. Eine Pruefung muss ihre Voraussetzung haben,
+       bevor sie misst. */
+    gestaltet: (() => {
+      const k = document.querySelector("#vorlagenbrett .vorlagenbrett__karte");
+      if (!k) return null;
+      const st = getComputedStyle(k);
+      return parseFloat(st.borderTopWidth) >= 1 && parseFloat(st.paddingLeft) >= 8;
+    })(),
+    ueber: document.documentElement.scrollWidth - document.documentElement.clientWidth,
+  }));
+  Object.assign(d, d2);
+  ok(d.auf === "ja", "ein Klick auf den Kopf macht ihn auf");
   ok(d.reihen === 2, `zwei Knopfreihen: Bereich und Stufe (${d.reihen})`);
   ok(d.karten === 3, `drei Aufgaben je Feld (${d.karten})`);
   ok(d.knoepfe === 3, `jede hat einen Übernehmen-Knopf (${d.knoepfe})`);
@@ -320,6 +360,42 @@ console.log("\n=== Auf der Aufgabenseite");
   const brettNachher = await zaehle();
   ok(brettNachher === brettVorher + 1,
      `Übernehmen legt eine Aufgabe auf dem Brett an (${brettVorher} → ${brettNachher})`);
+
+  /* ---- WAS SCHON GEHOLT WURDE, STEHT DA (09.09.2026) -----------------
+     Vorher konnte man dieselbe Vorlage zweimal uebernehmen und bekam
+     die Aufgabe zweimal auf das Brett -- ohne jeden Hinweis. Bei
+     achtzig Vorlagen weiss niemand auswendig, was er letzten Monat
+     schon geholt hat. */
+  {
+    const m = await seite.evaluate(() => {
+      const k = [...document.querySelectorAll("#vorlagenbrett .vorlagenbrett__karte")];
+      return { markiert: k.filter((x) => x.dataset.schon === "ja").length,
+               gesamt: k.length,
+               text: document.querySelector("#vorlagenbrett .vorlagenbrett__schon")?.textContent,
+               knopf: k.find((x) => x.dataset.schon === "ja")
+                 ?.querySelector(".knopf")?.textContent,
+               stand: document.querySelector("#vorlagenbrett .vorlagenbrett__stand")?.textContent };
+    });
+    ok(m.markiert === 1,
+       `genau die übernommene Vorlage ist markiert (${m.markiert} von ${m.gesamt})`);
+    ok(/schon übernommen/.test(m.text || ""), `mit Zustand dabei ("${m.text}")`);
+    ok(m.knopf === "Nochmal", `und der Knopf heißt anders ("${m.knopf}")`);
+    ok(/\d+ von \d+/.test(m.stand || ""), `darunter steht der Stand ("${m.stand}")`);
+
+    /* GEGENPROBE: Die übrigen sind NICHT markiert. Ohne sie hiesse
+       "eine ist markiert" auch dann ok, wenn alle es waeren. */
+    ok(m.gesamt - m.markiert >= 1,
+       `die übrigen ${m.gesamt - m.markiert} sind nicht markiert`);
+  }
+
+  /* Und der Zustand des Blocks überlebt ein Neuladen -- wer Vorlagen
+     holt, holt meistens mehrere. */
+  await seite.reload({ waitUntil: "domcontentloaded" });
+  await seite.waitForTimeout(2200);
+  const nochAuf = await seite.evaluate(() =>
+    document.getElementById("vorlagenbrett")?.dataset.auf);
+  ok(nochAuf === "ja", `nach dem Neuladen ist er noch offen (${nochAuf})`);
+
   ok(konsole.length === 0, `keine Fehler in der Konsole${konsole.length ? ": " + konsole[0] : ""}`);
   await browser.close();
 }

server/pruef-aufgabenbrett.mjs

@@ -377,6 +377,85 @@ ok(rH.ueber <= 0, `auf dem Handy steht nichts ueber (${rH.ueber}px)`);
 ok(rH.schnitte.length === 4, `die Ausschnitte sind auch dort da (${rH.schnitte.length})`);
 await bHandy.kontext.close();
 
+/* ---------------------------------------------------------------------
+   DRINGEND SCHLAEGT WICHTIG (09.09.2026)
+
+   Filipe: "das system von den aufgaben, die bedienung. wie gesagt
+   perfektionier das."
+
+   Beim Durchgehen der Bedienung gefunden: Die Liste war nach
+   PRIORITAET sortiert, dann nach Frist. Auf dem Brett stand damit eine
+   seit Tagen ueberfaellige Aufgabe mit Prioritaet "mittel" UNTER einer,
+   die als "hoch" eingetragen ist und erst in Wochen faellig wird. Wer
+   die Spalte von oben liest, faengt dann mit dem Falschen an.
+
+   Eine Prioritaet ist eine Einschaetzung von damals, eine
+   ueberschrittene Frist eine Tatsache von heute.
+   --------------------------------------------------------------------- */
+console.log("\n=== Die Reihenfolge auf dem Brett");
+{
+  const dd = new DatabaseSync(process.env.WORKSPACE_DB);
+  const tagT = (v) => { const x = new Date(Date.now() + v * 86400000);
+    return `${x.getFullYear()}-${String(x.getMonth() + 1).padStart(2, "0")}`
+      + `-${String(x.getDate()).padStart(2, "0")}`; };
+  /* Absichtlich in der ungünstigsten Reihenfolge angelegt: Die
+     ueberfaellige zuerst mit NIEDRIGER Prioritaet, die weit entfernte
+     mit HOHER. Nach der alten Sortierung stuende die weit entfernte
+     oben. */
+  dd.prepare(`INSERT INTO aufgaben (titel, beschreibung, status, prioritaet, frist,
+              creator_id, verantwortlich_id, erstellt, erstellt_von)
+              VALUES (?,?,'offen',?,?,?,?,?,?)`)
+    .run("SORT-ueberfaellig-niedrig", "", "niedrig", tagT(-4), idTili, idTili, jetzt, idDogi);
+  dd.prepare(`INSERT INTO aufgaben (titel, beschreibung, status, prioritaet, frist,
+              creator_id, verantwortlich_id, erstellt, erstellt_von)
+              VALUES (?,?,'offen',?,?,?,?,?,?)`)
+    .run("SORT-fern-hoch", "", "hoch", tagT(30), idTili, idTili, jetzt, idDogi);
+  dd.close();
+
+  const a = await fetch(BASIS + "/workspace/api/aufgaben", { headers: { cookie: kTili } });
+  const liste = (await a.json()).aufgaben.filter((x) => x.titel.startsWith("SORT-"));
+  ok(liste.length === 2, `beide Probeaufgaben da (${liste.length})`);
+  ok(liste[0]?.titel === "SORT-ueberfaellig-niedrig",
+     `die überfällige steht oben, obwohl sie "niedrig" ist `
+     + `(Reihenfolge: ${liste.map((x) => x.titel).join(" vor ")})`);
+
+  /* GEGENPROBE: Bei gleicher Lage entscheidet weiterhin die Prioritaet.
+     Ohne sie hiesse "Frist zuerst", dass die Prioritaet gar nichts mehr
+     tut -- und das waere die andere Uebertreibung. */
+  const dd2 = new DatabaseSync(process.env.WORKSPACE_DB);
+  for (const [t, pr] of [["SORTB-niedrig", "niedrig"], ["SORTB-hoch", "hoch"]]) {
+    dd2.prepare(`INSERT INTO aufgaben (titel, beschreibung, status, prioritaet, frist,
+                 creator_id, verantwortlich_id, erstellt, erstellt_von)
+                 VALUES (?,?,'offen',?,?,?,?,?,?)`)
+      .run(t, "", pr, tagT(10), idTili, idTili, jetzt, idDogi);
+  }
+  dd2.close();
+  const b = await fetch(BASIS + "/workspace/api/aufgaben", { headers: { cookie: kTili } });
+  const zwei = (await b.json()).aufgaben.filter((x) => x.titel.startsWith("SORTB-"));
+  ok(zwei[0]?.titel === "SORTB-hoch",
+     `bei gleicher Frist entscheidet weiter die Priorität `
+     + `(${zwei.map((x) => x.titel).join(" vor ")})`);
+
+  /* Und die Marke "wichtig" steht auf der Karte -- die Prioritaet war
+     vorher nur ein 3 px breiter Rand neben der farbigen Spaltenkante
+     und damit praktisch unsichtbar. */
+  const b2 = await seiteAls("creator", "CODE-ANNA-0001");
+  const marken = await b2.seite.evaluate(() => {
+    const k = [...document.querySelectorAll("#brett .karte")];
+    return { mitMarke: k.filter((x) => x.querySelector(".karte__wichtig")).length,
+             gesamt: k.length,
+             hochOhne: k.filter((x) => x.dataset.prio === "hoch"
+               && x.dataset.status !== "erledigt" && !x.querySelector(".karte__wichtig")).length,
+             niedrigMit: k.filter((x) => x.dataset.prio !== "hoch"
+               && x.querySelector(".karte__wichtig")).length };
+  });
+  ok(marken.mitMarke > 0 && marken.hochOhne === 0,
+     `jede wichtige Aufgabe traegt die Marke (${marken.mitMarke} von ${marken.gesamt})`);
+  ok(marken.niedrigMit === 0,
+     `und keine unwichtige traegt sie (${marken.niedrigMit})`);
+  await b2.kontext.close();
+}
+
 await browser.close();
 try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
 console.log(fehler ? `\n${fehler} Prüfung(en) fehlgeschlagen.` : "\nAlles in Ordnung.");

server/workspace-aufgaben.js

@@ -120,6 +120,9 @@ const SPALTEN = `
      das lesen -- ein Nachladen je Zeile wäre bei zwanzig abgebrochenen
      Aufgaben zwanzig Anfragen. */
   a.abbruch_grund, a.abgebrochen_am, a.status_vorher,
+  /* Die Vorlage, aus der sie entstanden ist (09.09.2026) -- damit das
+     Vorlagenbrett zeigen kann, was schon geholt wurde. */
+  a.vorlage,
   pa.name AS abbruch_von_name`;
 
 const VERBUND = `
@@ -138,10 +141,28 @@ aufgabenRouter.get("/workspace/api/aufgaben", (req, res) => {
              (SELECT COUNT(*) FROM aufgaben_notizen n WHERE n.aufgabe_id = a.id) AS notizen
       ${VERBUND}
       WHERE ${wo}
+      /* DRINGEND SCHLAEGT WICHTIG (09.09.2026).
+
+         Hier stand die Prioritaet an erster Stelle. Folge auf dem
+         Brett: Eine seit drei Tagen ueberfaellige Aufgabe mit
+         Prioritaet "mittel" stand UNTER einer, die als "hoch"
+         eingetragen ist und erst in drei Wochen faellig wird. Wer die
+         Spalte von oben liest, faengt dann mit dem Falschen an.
+
+         Eine Prioritaet ist eine Einschaetzung von damals, eine
+         ueberschrittene Frist ist eine Tatsache von heute. Deshalb:
+         erst was faellig ist, dann nach Datum, und die Prioritaet
+         entscheidet nur noch bei gleichem Datum.
+
+         Die Sortierung steht hier und nicht im Browser: Die Startseite
+         und die Uebersicht lesen dieselbe Liste, und zwei Sortierungen
+         fuer dieselbe Frage laufen auseinander. */
       ORDER BY
-        CASE a.prioritaet WHEN 'hoch' THEN 0 WHEN 'mittel' THEN 1 ELSE 2 END,
+        CASE WHEN a.status <> 'erledigt' AND a.frist IS NOT NULL AND a.frist < ?
+             THEN 0 ELSE 1 END,
         CASE WHEN a.frist IS NULL THEN 1 ELSE 0 END, a.frist,
-        a.id DESC`).all(...werte);
+        CASE a.prioritaet WHEN 'hoch' THEN 0 WHEN 'mittel' THEN 1 ELSE 2 END,
+        a.id DESC`).all(...werte, heuteLokal());
     res.json({ aufgaben: reihen });
   } catch (fehler) {
     console.error("[workspace] Aufgaben lesen:", fehler?.message);

server/workspace-vorlagen.js

@@ -1212,11 +1212,15 @@ vorlagenRouter.post("/workspace/api/vorlagen/uebernehmen", gleicheHerkunft,
           const d = new Date(Date.now() + (v.tage || 7) * 86400_000);
           const frist = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`
             + `-${String(d.getDate()).padStart(2, "0")}`;
+          /* Die Kennung der Vorlage wandert mit (09.09.2026). Nur so
+             kann das Brett spaeter zeigen, was schon uebernommen ist --
+             und der Titel taugt dafuer nicht: Er darf geaendert werden. */
           db().prepare(`INSERT INTO aufgaben
-              (titel, beschreibung, status, prioritaet, creator_id, frist, erstellt, erstellt_von)
-              VALUES (?,?,'offen',?,?,?,?,?)`)
+              (titel, beschreibung, status, prioritaet, creator_id, frist,
+               vorlage, erstellt, erstellt_von)
+              VALUES (?,?,'offen',?,?,?,?,?,?)`)
             .run(v.titel, v.text, stufe === "anfaenger" ? "hoch" : "mittel",
-                 creatorId, frist, jetzt(), req.person.id);
+                 creatorId, frist, v.schluessel, jetzt(), req.person.id);
           angelegt.push(v.titel);
         }
 

server/workspace.js

@@ -439,6 +439,25 @@ function umstellungen(d) {
     ["chat_nachrichten", "anhang_groesse", "INTEGER"],
     ["chat_nachrichten", "anhang_breite", "INTEGER"],
     ["chat_nachrichten", "anhang_hoehe", "INTEGER"],
+
+    /* WELCHE VORLAGE DAHINTERSTECKT (09.09.2026).
+
+       Filipe: "ich will nur dass du dich informierst und schaust was
+       man vielleicht noch besser machen koennte von der benutzung ...
+       ich red von den aufgaben."
+
+       Beim Durchgehen der Bedienung ist aufgefallen: Man konnte
+       dieselbe Vorlage zweimal uebernehmen und bekam die Aufgabe
+       zweimal auf das Brett -- ohne jeden Hinweis. Im Vorlagenbrett
+       sah man nicht, was man schon geholt hatte.
+
+       Die Kennung der Vorlage steht jetzt an der Aufgabe. Damit kann
+       das Brett zeigen, was bereits uebernommen ist, und es braucht
+       dafuer KEINE zweite Abfrage: Die Aufgabenliste hat der Browser
+       ohnehin schon. Ueber den TITEL zu vergleichen waere die
+       naheliegende Abkuerzung gewesen -- und faellt in dem Moment um,
+       in dem jemand den Titel einer uebernommenen Aufgabe aendert. */
+    ["aufgaben", "vorlage", "TEXT"],
   ]) {
     try {
       const vorhanden = d.prepare(`PRAGMA table_info(${tabelle})`).all().map((s) => s.name);