Aus dem Talent wird ein Mensch mit Aufgaben

Filipe: "wie talente bewertet werden, aufgaben bekommen, analysiert
werden von vanvan und mir, alles moegliche."

GEMESSEN VOR DEM BAU, und der Befund war groesser als erwartet: Der
letzte Schritt des Trichters legt einen Zugang an -- und die
Verknuepfung wurde NIRGENDS gespeichert. `zugangAnlegen()` gab die
Person zurueck, der Code wurde einmal gezeigt, und danach wusste die
Karte nicht mehr, wer aus ihr geworden ist.

Was dadurch nicht ging:
  - von der Karte zur Person springen
  - dem Neuen aus der Karte heraus seine ersten Aufgaben geben
  - in einem halben Jahr nachsehen, aus welchem Kandidaten eigentlich
    welches Teammitglied wurde

DREI SPALTEN WAEREN ZU VIEL GEWESEN, eine reicht: `talent_stufe.person_id`.
Kein Fremdschluessel auf `personen` -- wird ein Zugang geloescht, soll
die Karte stehen bleiben. Sie erzaehlt, wie jemand gekommen ist, und
das bleibt wahr, auch wenn er wieder geht. Ein CASCADE haette genau
diesen Verlauf mitgeloescht.

NUR SETZEN, NIE LOESCHEN (COALESCE): Sonst verloere die Karte ihren
Menschen, sobald jemand sie auf eine fruehere Stufe zuruecksetzt.

WOMIT ER ANFAENGT. Der Katalog mit 101 Aufgaben in 14 Bereichen gab es
laengst -- nur fuehrte der Weg dorthin ueber eine andere Seite, wo man
die Person heraussuchen und Bereich plus Stufe waehlen musste. Vier
Schritte, die niemand macht, waehrend er gerade jemanden aufnimmt;
dasselbe Muster hat heute schon zu einer Karte auf "Im Team" ohne
Menschen darin gefuehrt. Jetzt steht der Kasten an der Karte, ein Klick
legt einen Bereich an.

ES BLEIBT EIN ANGEBOT, KEINE AUTOMATIK -- Filipes Entscheidung bei der
Live-Checkliste gilt hier genauso: "was ungefragt Dinge anlegt, ist
schwer wieder loszuwerden". Und der Kasten ist ZU, wenn schon Aufgaben
da sind; offen wuerde er zum Nachlegen einladen, und das ist selten
gemeint. Daneben steht, wie viele schon offen sind -- ohne diese Zahl
legt man beim zweiten Hinsehen dasselbe noch einmal an.

pruef-nachwuchs 200 -> 236, davon 14 im Browser (Abschnitt 17 mit
eigenem Browser: der aus Abschnitt 15 lief, bevor es den Kandidaten
ueberhaupt gab -- ein Stand von zwei Abschnitten vorher ist keine
Messung, sondern eine Annahme).

VIER EIGENE FEHLER DABEI GEFUNDEN, drei davon durch die Gegenproben:

 1. `d.angelegt?.length` -- die Antwort ist eine ZAHL, kein Feld. Der
    Knopf haette "6 Aufgaben stehen bereit" gemeldet, auch wenn null
    entstanden sind.
 2. Der "Schritt zurueck" ging auf `probe` -- und der verlangt Buddy
    und Datum. Die Route antwortete 400, die Stufe blieb stehen, und
    die Zeile darunter bestaetigte, dass sich nichts geaendert hat:
    eine Pruefung, die immer gruen ist. Aufgefallen erst an der
    Gegenprobe (COALESCE ausgebaut -> blieb gruen). Eine Gegenprobe
    ist keine Kuer, sie prueft die Pruefung.
 3. Feldnamen `buddy`/`datum` statt `buddy_id`/`erste_schicht` --
    Fehler in der Pruefung, nicht im Code.
 4. Die Rollennamen-Zeile war ZU SCHARF und meldete prompt einen
    Treffer: "Die Modis, die mit ihm gearbeitet haben" aus dem
    Probeplan -- ein Satz, der ueber eine Schnittstelle kommt, die nur
    die Leitung erreicht, und genau dorthin gehoert. Geprueft wird
    jetzt, was hier neu ist; ueber die ausgelieferten DATEIEN wacht
    pruef-modi-wortleck (101 Dateien, mit eigener Gegenprobe).

Gegenproben, jede zielgenau:
  Nummer ungeprueft     -> "erfundene Zugangsnummer wird abgewiesen"
  COALESCE weg          -> "Schritt zurueck nimmt ihr den Menschen weg"
  Person nicht geliefert-> 4 rot

pruef-nachruesten fuehrt die neue Spalte mit -- jede neue Spalte gehoert
in diese Liste, sonst prueft die Datei den Weg von gestern.

Gruen: nachwuchs, nachruesten, modi-wortleck, namen, css-klassen,
struktur.

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

server/workspace-entwicklung.js

@@ -61,8 +61,12 @@
 import express from "express";
 import {
   db, sitzungLesen, protokolliere, echteIp, fuehrtTeamDogi, ROLLEN_NAME,
-  ROLLEN_SORTIERUNG,
+  ROLLEN_SORTIERUNG, MODI_KATEGORIEN, kategorienFuer,
 } from "./workspace.js";
+/* Die Aufgaben, die ein Neuer bekommen kann -- dieselbe Liste, aus der
+   auch die Aufgabenseite ihre Vorschlaege baut. Eine zweite waere die,
+   die beim naechsten Nachschaerfen auseinanderlaeuft. */
+import { MODI_AUFGABEN_FLACH } from "./workspace-vorlagen.js";
 import {
   ENTWICKLUNG_BLOECKE, ENTWICKLUNG_PUNKTE, ENTWICKLUNG_STUFEN,
   ENTWICKLUNG_ERWARTUNG, ENTWICKLUNG_FREMD, ENTWICKLUNG_SELBST,
@@ -262,6 +266,25 @@ export function tabellen() {
     ["beendet_am", "TEXT"],
     ["beendet_grund", "TEXT"],
     ["beendet_von", "INTEGER"],
+
+    /* WER AUS DEM TALENT GEWORDEN IST (17.09.2026).
+
+       Der letzte Schritt des Trichters legt einen Zugang an -- und bis
+       heute war das eine Einbahnstrasse: Die Person entstand, der Code
+       wurde einmal gezeigt, und die Karte wusste hinterher NICHT, wer
+       daraus geworden ist.
+
+       Was dadurch nicht ging:
+         - von der Karte zur Person springen
+         - dem Neuen seine ersten Aufgaben aus der Karte heraus geben
+         - in einem halben Jahr nachsehen, aus welchem Kandidaten
+           eigentlich welches Teammitglied wurde
+
+       KEIN FREMDSCHLUESSEL AUF personen. Wird ein Zugang geloescht,
+       soll die Karte stehen bleiben -- sie erzaehlt, wie jemand
+       gekommen ist, und das bleibt wahr, auch wenn er wieder geht. Ein
+       CASCADE haette genau diesen Verlauf mitgeloescht. */
+    ["person_id", "INTEGER"],
   ]) {
     try {
       const da = db().prepare("PRAGMA table_info(talent_stufe)").all().map((s) => s.name);
@@ -923,9 +946,11 @@ function uebergangVon(stand) {
 function talentKarte(e, merkmale) {
   const stand = db().prepare(
     `SELECT s.stufe, s.seit, s.notiz, s.buddy_id, s.erste_schicht,
-            s.beendet_am, s.beendet_grund, p.name AS beendet_von_name
+            s.beendet_am, s.beendet_grund, p.name AS beendet_von_name,
+            s.person_id, w.name AS person_name, w.aktiv AS person_aktiv
        FROM talent_stufe s
        LEFT JOIN personen p ON p.id = s.beendet_von
+       LEFT JOIN personen w ON w.id = s.person_id
       WHERE s.eintrag_id = ?`)
     .get(e.id);
   const stufe = talentStufe(stand?.stufe) || TALENT_STUFEN[0];
@@ -986,6 +1011,17 @@ function talentKarte(e, merkmale) {
        DER GRUND WIRD MITGELIEFERT, NICHT NUR DAS DATUM. Ein Ausgang
        ohne Satz waere dieselbe Sackgasse, gegen die der Satz beim
        Ablehnen einer Anfrage verlangt wird. */
+    /* WER DARAUS GEWORDEN IST (17.09.2026).
+
+       `aktiv` kommt mit: Ein Zugang, der abgeschaltet wurde, soll an
+       der Karte nicht aussehen wie einer, der laeuft. Die Karte bleibt
+       trotzdem stehen -- sie erzaehlt, wie jemand gekommen ist, und das
+       bleibt wahr, auch wenn er wieder geht. */
+    person: stand?.person_id && stand?.person_name ? {
+      id: stand.person_id,
+      name: stand.person_name,
+      aktiv: stand.person_aktiv === 1,
+    } : null,
     beendet: stand?.beendet_am ? {
       am: stand.beendet_am,
       grund: stand.beendet_grund || null,
@@ -1073,6 +1109,57 @@ entwicklungRouter.get("/workspace/api/talente/lage", (req, res) => {
          Wort. Beides kommt von hier, damit im Browser kein fester Text
          dazu steht; siehe ZUGANG_ROLLE oben. */
       zugang: { rolle: ZUGANG_ROLLE, name: ROLLEN_NAME[ZUGANG_ROLLE] ?? ZUGANG_ROLLE },
+      /* WOMIT EIN NEUER ANFAENGT (17.09.2026).
+
+         Filipe: „wie talente bewertet werden, aufgaben bekommen,
+         analysiert werden von vanvan und mir, alles moegliche."
+
+         Der Trichter endete bisher beim Zugang. Wer im Team ist, hat
+         einen Code -- und keine einzige Aufgabe. Um ihm welche zu
+         geben, musste man auf eine andere Seite, die Person dort
+         heraussuchen, Kategorie und Stufe waehlen und uebernehmen.
+         Vier Schritte, die niemand macht, waehrend er gerade jemanden
+         aufnimmt. Genau dieses Muster hat heute schon einmal zu einer
+         Karte auf „Im Team" ohne Menschen darin gefuehrt.
+
+         ES BLEIBT EIN ANGEBOT, KEINE AUTOMATIK. Filipes Entscheidung
+         bei der Live-Checkliste gilt hier genauso: „vierzehn Aufgaben,
+         die von selbst erscheinen, ueberrumpeln, und was ungefragt
+         Dinge anlegt, ist schwer wieder loszuwerden." Deshalb steht
+         hier nur, WAS es gaebe -- angelegt wird auf Klick, eine
+         Kategorie auf einmal.
+
+         KEIN ROLLENNAME, nirgends. Die Kategorien heissen „chat",
+         „team", „technik" -- aus keiner davon laesst sich schliessen,
+         fuer wen sie gedacht sind. Wer den Katalog nicht bekommen
+         darf, bekommt `null` und die Seite baut nichts; ein leeres
+         Feld sagt nichts, ein Feld mit sprechendem Namen saehe jeder
+         im Netzwerkprotokoll seines eigenen Browsers. */
+      start_kategorien: kategorienFuer(req.person).length
+        ? MODI_KATEGORIEN.map((k) => ({
+          wert: k.wert, name: k.name, text: k.text,
+          anzahl: MODI_AUFGABEN_FLACH
+            .filter((v) => v.kategorie === k.wert && v.stufe === "neu").length,
+        })).filter((k) => k.anzahl > 0)
+        : null,
+      /* WAS SIE SCHON HABEN -- je Person, in EINER Abfrage.
+
+         Ohne diese Angabe legt man beim zweiten Hinsehen dasselbe noch
+         einmal an; der Knopf sagt dann „6 Aufgaben" und meint die
+         siebte bis zwoelfte. Der Server verhindert Doppelte nicht --
+         er soll es auch nicht, denn dieselbe Aufgabe ein zweites Mal
+         kann gewollt sein. Sichtbar muss es trotzdem sein. */
+      schon_vergeben: (() => {
+        const ids = karten.map((k) => k.person?.id).filter(Boolean);
+        if (!ids.length) return {};
+        const platz = ids.map(() => "?").join(", ");
+        const zeilen = db().prepare(
+          `SELECT verantwortlich_id AS wer, COUNT(*) AS n
+             FROM aufgaben
+            WHERE verantwortlich_id IN (${platz}) AND status NOT IN ('erledigt','abgebrochen')
+            GROUP BY verantwortlich_id`).all(...ids);
+        return Object.fromEntries(zeilen.map((z) => [z.wer, z.n]));
+      })(),
       kandidaten: karten,
       /* Nach Ausgangsdatum, das juengste zuerst -- wer gerade abgesagt
          hat, ist der, an den man sich erinnert. */
@@ -1390,15 +1477,39 @@ entwicklungRouter.put("/workspace/api/talente/:id/stufe", gleicheHerkunft, (req,
        schickt Buddy und Datum nicht noch einmal mit -- und die beiden
        sollen bleiben, wo sie sind. Sie sind die Geschichte dieser
        Probe, nicht ein Formularfeld. */
+    /* WER AUS DEM TALENT GEWORDEN IST (17.09.2026).
+
+       Der letzte Schritt legt einen Zugang an. Bis heute war das eine
+       Einbahnstrasse: Die Person entstand, ihr Code wurde einmal
+       gezeigt -- und die Karte wusste danach nicht, wer daraus wurde.
+
+       GEPRUEFT WIRD, OB ES DIE PERSON GIBT, und nicht nur, ob eine
+       Zahl ankam. Eine erfundene Nummer wuerde die Karte sonst auf
+       jemanden zeigen lassen, den es nicht gibt -- und das faellt erst
+       auf, wenn jemand darauf klickt.
+
+       NUR SETZEN, NIE LOESCHEN: Kommt kein `person_id` mit (jeder
+       andere Stufenwechsel), bleibt die vorhandene stehen. Sonst
+       verloere die Karte ihre Person, sobald jemand sie auf eine
+       fruehere Stufe zuruecksetzt. */
+    let personId = null;
+    if (nummer(req.body?.person_id)) {
+      const wer = db().prepare("SELECT id FROM personen WHERE id = ? AND aktiv = 1")
+        .get(nummer(req.body.person_id));
+      if (!wer) return res.status(400).json({ fehler: "Diesen Zugang gibt es nicht." });
+      personId = wer.id;
+    }
+
     db().prepare(`INSERT INTO talent_stufe
-        (eintrag_id, stufe, seit, von_id, notiz, buddy_id, erste_schicht)
-        VALUES (?,?,?,?,?,?,?)
+        (eintrag_id, stufe, seit, von_id, notiz, buddy_id, erste_schicht, person_id)
+        VALUES (?,?,?,?,?,?,?,?)
       ON CONFLICT(eintrag_id) DO UPDATE SET
         stufe = excluded.stufe, seit = excluded.seit,
         von_id = excluded.von_id, notiz = excluded.notiz,
         buddy_id = COALESCE(excluded.buddy_id, talent_stufe.buddy_id),
-        erste_schicht = COALESCE(excluded.erste_schicht, talent_stufe.erste_schicht)`)
-      .run(id, stufe, jetzt(), req.person.id, notiz || null, p.buddyId, p.schicht);
+        erste_schicht = COALESCE(excluded.erste_schicht, talent_stufe.erste_schicht),
+        person_id = COALESCE(excluded.person_id, talent_stufe.person_id)`)
+      .run(id, stufe, jetzt(), req.person.id, notiz || null, p.buddyId, p.schicht, personId);
 
     protokolliere("talent_stufe", {
       personId: req.person.id, ip: echteIp(req),