Die Probezeit hat einen Inhalt -- und man sieht, wer was gesehen hat

Filipe: "wie talente bewertet werden, aufgaben bekommen, analysiert
werden von vanvan und mir, alles moegliche, wie gesagt ich will hoch
profissionel arbeiten."

WAS GEMESSEN FEHLTE

  Die Stufe "Probe" hatte eine Frist von 30 Tagen, einen Buddy, ein
  Datum -- und einen Satz: "Nach 30 Tagen: uebernehmen oder sauber
  beenden." Worauf diese Entscheidung sich gruenden soll, stand
  nirgends. Eine Probezeit ohne Inhalt ist keine Probe, sondern eine
  Wartezeit; am dreissigsten Tag entscheidet dann das Bauchgefuehl
  dessen, der zuletzt etwas gesehen hat.

  Und: `von_id` stand seit dem Bau in talent_merkmal und wurde nie
  ausgeliefert. Man sah, DASS ein Merkmal gesetzt ist -- nicht, von
  wem. Bei zwei Leuten, die unabhaengig beobachten, ist genau das die
  Auskunft.

DER PROBEPLAN

  Zwoelf Schritte in drei Phasen: mitlaufen -> selbst machen -> allein.
  Die Reihenfolge ist der Punkt (Discord empfiehlt sie so, in der
  Ausbildung heisst sie "see one, do one"). Wer die mittlere Stufe
  ueberspringt, hat am Tag 30 zwei Sorten Kandidaten, die man nicht
  unterscheiden kann.

  JEDER SCHRITT HAT EINEN ZUSTAENDIGEN -- sechs das Talent, drei der
  Buddy, drei die Leitung. Ohne diese Angabe wandern in jeder Probezeit
  dieselben drei an niemanden: Der Buddy denkt, die Leitung macht es.

  KEINE PUNKTZAHL. Am Ende stehen drei Fragen, die ein Mensch
  beantwortet; die Haken sagen nur, ob er genug gesehen hat. Und
  "entscheidbar" haengt an DREI Schritten, nicht an einer Anzahl: Wer
  nie allein gearbeitet hat und wen das Team nie beurteilt hat, ueber
  den weiss man nichts, egal wie viele andere Haken stehen. Neun von
  zwoelf reichen nicht, drei genuegen -- wenn es die richtigen sind.

WAS DAS HINSEHEN GEFUNDEN HAT

  `.t-schritt` gibt es auf dieser Seite schon -- es ist die Zeile mit
  dem naechsten Schritt der Trichterstufe. Meine Regeln standen
  SPAETER in derselben Datei und haetten sie ueberschrieben. Gefunden
  hat das keine Ueberlegung, sondern das Nachzaehlen im Browser: 13
  Elemente mit `.t-schritt`, obwohl der Plan zwoelf hat.

ZWEI PRUEFUNGEN WAREN SCHON VORHER ROT (gemessen mit git stash)

  pruef-schritt (6 rot) und pruef-befinden (4 rot) -- seit den
  Erweiterungen von heute frueh: aus sechs Befinden-Fragen wurden
  zwoelf, aus vier Kategorien sechs, und die Personenkachel zaehlt seit
  heute in Kaesten statt in einem Satz. Die Zahlen standen als feste
  Werte in den Pruefdateien.

  Nicht die Zahlen angepasst, sondern ABGELEITET: aus
  ENTWICKLUNG_BLOECKE und ENTWICKLUNG_PUNKTE.befinden. Eine feste Zahl
  ist eine Rechnung von gestern; wer sie nachtraegt, traegt sie beim
  naechsten Mal wieder nach.

GEPRUEFT

  pruef-nachwuchs 123 -> 152. Vier Gegenproben, jede trifft ihr Ziel:
  Liste auch vor der Probe -> 1 rot, Abhaken ohne Stufenpruefung -> 7
  rot, "entscheidbar" nach Anzahl statt nach den drei -> 3 rot, Name
  nicht mitgeliefert -> 1 rot.

  Dazu gruen: schritt 65, befinden 75, entwicklung 43, uebergang,
  neue-seiten, rechtetafel, css-klassen, struktur, deutsche-texte,
  modi-wortleck.

server/pruef-nachwuchs.mjs

@@ -25,6 +25,7 @@ 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(4404, "pruef-nachwuchs");
 
@@ -719,6 +720,206 @@ melde("=== 12. Die Reihenfolge ===");
     `auch auf der Team-Adresse steht sie vorn (${crewNamen.join(", ")})`);
 }
 
+
+/* =======================================================================
+   13. DIE PROBEZEIT HAT EINEN INHALT (17.09.2026)
+
+   Filipe: „wie talente bewertet werden, aufgaben bekommen, analysiert
+   werden von vanvan und mir."
+
+   Gemessen war vorher: Die Stufe „Probe" hatte eine Frist von 30 Tagen
+   und sonst nichts. Worauf die Entscheidung am Tag 30 sich gruenden
+   soll, stand nirgends -- und dann entscheidet das Bauchgefuehl
+   dessen, der zuletzt etwas gesehen hat.
+   ======================================================================= */
+melde("");
+melde("=== 13. Die Probezeit ===");
+{
+  const probeplan = await import("./workspace-probeplan.js");
+
+  /* ---- Der Katalog selbst ---- */
+  ok(probeplan.PROBE_ALLE.length >= 10,
+    `der Plan hat ${probeplan.PROBE_ALLE.length} Schritte in ${probeplan.PROBE_PHASEN.length} Phasen`);
+  {
+    const s = probeplan.PROBE_ALLE.map((x) => x.schluessel);
+    ok(new Set(s).size === s.length, "die Schluessel sind eindeutig");
+  }
+  {
+    /* JEDER SCHRITT HAT EINEN ZUSTAENDIGEN. Ohne ihn wandern in jeder
+       Probezeit dieselben drei an niemanden. */
+    const ohne = probeplan.PROBE_ALLE.filter((x) => !probeplan.PROBE_WER[x.wer]);
+    ok(ohne.length === 0,
+      ohne.length ? `ohne Zustaendigen: ${ohne.map((x) => x.schluessel).join(", ")}`
+        : "jeder Schritt sagt, WER ihn tut");
+    const wer = new Set(probeplan.PROBE_ALLE.map((x) => x.wer));
+    ok(wer.size === 3,
+      `und es sind wirklich drei verschiedene (${[...wer].join(", ")}) -- `
+      + "eine Probe, die nur der Kandidat abarbeitet, prueft nichts");
+  }
+  {
+    /* JEDER SCHRITT SAGT, WOFUER ER DA IST. Ein Haken, dessen Zweck man
+       nicht kennt, wird gesetzt, weil er dasteht. */
+    const duenn = probeplan.PROBE_ALLE.filter((x) => (x.wofuer || "").length < 40);
+    ok(duenn.length === 0,
+      duenn.length ? `ohne Begruendung: ${duenn.map((x) => x.schluessel).join(", ")}`
+        : "und jeder sagt, welche Frage er beantwortet");
+  }
+
+  /* ---- Entscheidbar heisst NICHT „alles abgehakt" ---- */
+  {
+    const leer = probeplan.probeStand([]);
+    const voll = probeplan.probeStand(probeplan.PROBE_ALLE.map((x) => x.schluessel));
+    ok(leer.entscheidbar === false && leer.fehlt_noetig.length === 3,
+      `ohne einen Haken kann man nicht entscheiden (es fehlen ${leer.fehlt_noetig.length})`);
+    ok(voll.entscheidbar === true, "mit allen Haken schon");
+    /* DER FALL DAZWISCHEN, und der ist der eigentliche Punkt: Neun von
+       zwoelf Haken reichen NICHT, wenn die drei noetigen fehlen. Eine
+       Schwelle nach Anzahl waere Fleiss beim Abhaken, keine
+       Beurteilung. */
+    const ohneNoetige = probeplan.PROBE_ALLE
+      .map((x) => x.schluessel)
+      .filter((s) => !["pr-allein-schicht", "pr-team-gefragt", "pr-er-will-noch"].includes(s));
+    const fast = probeplan.probeStand(ohneNoetige);
+    ok(fast.getan === probeplan.PROBE_ALLE.length - 3 && fast.entscheidbar === false,
+      `${fast.getan} von ${fast.gesamt} Haken reichen nicht -- es kommt auf die drei an, `
+      + "nicht auf die Anzahl");
+    /* Und die Gegenprobe dazu: NUR die drei genuegen. */
+    const nurDrei = probeplan.probeStand(
+      ["pr-allein-schicht", "pr-team-gefragt", "pr-er-will-noch"]);
+    ok(nurDrei.entscheidbar === true,
+      `drei von ${nurDrei.gesamt} genuegen, wenn es die richtigen sind`);
+  }
+
+  /* ---- Am lebenden Kandidaten ----
+
+     EIN EIGENER, FRISCHER. Der aus den Abschnitten davor ist laengst
+     durch den ganzen Trichter gelaufen und steht auf "imteam" -- an ihm
+     waere "vor der Probe steht keine Liste" nicht falsch, sondern
+     unpruefbar. Beim ersten Anlauf war genau das der Grund fuer vier
+     rote Zeilen: meine Annahme, nicht der Code. */
+  const neuerTalent = await roh("/workspace/api/bereich/talente", HAUS, { cookie: kDogi },
+    { art: "ruhig", titel: "Jonas aus dem Chat", text: "Faellt seit kurzem auf." });
+  ok(neuerTalent.code === 201 || neuerTalent.code === 200,
+    `ein frischer Kandidat fuer diesen Abschnitt (${neuerTalent.code})`);
+  const lage = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }));
+  const kandidat = (lage.kandidaten || []).find((k) => k.titel === "Jonas aus dem Chat");
+  ok(!!kandidat, `er steht im Trichter (${kandidat?.stufe})`);
+
+  /* SOLANGE ER NICHT IN DER PROBE IST, gibt es keine Liste. Eine leere
+     Zwoelferliste an einem Beobachteten waere Laerm -- und Laerm liest
+     man auch dann weg, wenn er gilt. */
+  ok(!kandidat.probe,
+    `vor der Probe steht dort keine Liste (${kandidat.probe ? "doch eine" : "keine"})`);
+  {
+    const r = await roh(`/workspace/api/talente/${kandidat.id}/probe/pr-erste-schicht`,
+      HAUS, { cookie: kDogi }, {}, "PUT");
+    ok(r.code === 409,
+      `und abhaken geht nicht, solange die Probe nicht laeuft (${r.code})`);
+  }
+
+  /* ---- Jetzt in die Probe ---- */
+  /* Ortszeit, nicht UTC: Zwischen 00:00 und 02:00 waere „morgen“ aus
+     UTC gerechnet heute -- und der Server lehnt ein Datum in der
+     Vergangenheit ab. Die Pruefung waere nachts rot, ohne dass
+     irgendetwas kaputt ist. */
+  const morgen = tagLokal(1);
+  {
+    /* Ueber den vorhandenen Weg, nicht an ihm vorbei. */
+    let stufe = kandidat.stufe;
+    let schutz = 0;
+    while (stufe !== "probe" && schutz++ < 6) {
+      const naechste = tal.talentNaechste(stufe)?.schluessel;
+      if (!naechste) break;
+      const r = await roh(`/workspace/api/talente/${kandidat.id}/stufe`, HAUS,
+        { cookie: kDogi },
+        naechste === "probe"
+          ? { stufe: naechste, buddy_id: idModi, erste_schicht: morgen }
+          : { stufe: naechste },
+        "PUT");
+      if (r.code !== 200) break;
+      stufe = naechste;
+    }
+    ok(stufe === "probe", `der Kandidat steht jetzt in der Probe (${stufe})`);
+  }
+
+  {
+    const k = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }))
+      .kandidaten.find((x) => x.id === kandidat.id);
+    ok(!!k.probe, "jetzt steht die Liste an der Karte");
+    ok(k.probe.gesamt === probeplan.PROBE_ALLE.length && k.probe.getan === 0,
+      `${k.probe.getan} von ${k.probe.gesamt} -- und noch nichts abgehakt`);
+    ok(k.probe.entscheidbar === false,
+      "und noch nicht entscheidbar -- am Tag 1 waere alles andere gelogen");
+    const mitWer = k.probe.schritte.filter((s) => s.wer_name);
+    ok(mitWer.length === k.probe.gesamt,
+      `jeder Schritt bringt seinen Zustaendigen mit (${mitWer.length})`);
+  }
+
+  /* ---- Abhaken, und WER es war ---- */
+  {
+    const r = await roh(`/workspace/api/talente/${kandidat.id}/probe/pr-erste-schicht`,
+      HAUS, { cookie: kDogi }, {}, "PUT");
+    ok(r.code === 200 && json(r).fertig === true, `abhaken geht (${r.code})`);
+    const k = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }))
+      .kandidaten.find((x) => x.id === kandidat.id);
+    const s = k.probe.schritte.find((x) => x.schluessel === "pr-erste-schicht");
+    ok(s.fertig === true && s.von === "Filipe",
+      `und es steht dabei, wer es war (${s.von})`);
+    ok(k.probe.getan === 1, `der Stand zieht mit (${k.probe.getan} von ${k.probe.gesamt})`);
+  }
+  {
+    /* EIN KNOPF, ZWEI RICHTUNGEN -- wie bei den Merkmalen. */
+    const r = await roh(`/workspace/api/talente/${kandidat.id}/probe/pr-erste-schicht`,
+      HAUS, { cookie: kDogi }, {}, "PUT");
+    ok(r.code === 200 && json(r).fertig === false, "ein zweiter Klick nimmt zurueck");
+    const k = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }))
+      .kandidaten.find((x) => x.id === kandidat.id);
+    ok(k.probe.getan === 0, "und der Stand geht mit zurueck");
+  }
+  {
+    const r = await roh(`/workspace/api/talente/${kandidat.id}/probe/voellig-erfunden`,
+      HAUS, { cookie: kDogi }, {}, "PUT");
+    ok(r.code === 404, `ein erfundener Schritt wird abgewiesen (${r.code})`);
+  }
+
+  /* ---- Und die Frage, wegen der das alles da ist ---- */
+  {
+    for (const s of ["pr-allein-schicht", "pr-team-gefragt", "pr-er-will-noch"]) {
+      await roh(`/workspace/api/talente/${kandidat.id}/probe/${s}`, HAUS,
+        { cookie: kDogi }, {}, "PUT");
+    }
+    const k = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }))
+      .kandidaten.find((x) => x.id === kandidat.id);
+    ok(k.probe.entscheidbar === true,
+      `mit den drei noetigen Schritten ist es entscheidbar (${k.probe.getan} von ${k.probe.gesamt})`);
+    ok(Array.isArray(k.probe.fragen) && k.probe.fragen.length === 3,
+      `und drei Fragen stehen bereit (${k.probe.fragen?.length})`);
+  }
+
+  /* ---- Wer was gesehen hat ---- */
+  {
+    const m = tal.TALENT_MERKMALE[tal.TALENT_GRUPPEN[0].schluessel][0].schluessel;
+    await roh(`/workspace/api/talente/${kandidat.id}/merkmal/${m}`, HAUS,
+      { cookie: kDogi }, {}, "PUT");
+    const k = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }))
+      .kandidaten.find((x) => x.id === kandidat.id);
+    ok(k.gesehen_von?.[m] === "Filipe",
+      `an einem Merkmal steht, wer es gesehen hat (${k.gesehen_von?.[m]})`);
+    /* GEGENPROBE: Ein nicht gesetztes Merkmal hat auch keinen Namen --
+       sonst hiesse "steht dabei" nur, dass ueberall etwas steht. */
+    const ander = tal.TALENT_MERKMALE[tal.TALENT_GRUPPEN[0].schluessel][1]?.schluessel;
+    ok(!ander || !k.gesehen_von?.[ander],
+      "und an einem nicht gesetzten steht keiner");
+  }
+
+  /* ---- Die Community kommt an nichts davon heran ---- */
+  {
+    const r = await roh(`/workspace/api/talente/${kandidat.id}/probe/pr-erste-schicht`,
+      CREW, { cookie: kModi }, {}, "PUT");
+    ok(r.code === 404, `ein Modi kann nichts abhaken -- und erfaehrt nicht, dass es das gibt (${r.code})`);
+  }
+}
+
 /* ------------------------------------------------------------------- */
 melde("");
 melde(`${geprueft} Pruefungen, ${fehler} Fehler`);