Bauplan Etappen 4 und 6: Kachelplatz, Aufstiegskarte, und das Alte raeumt ab

Drei Dinge, die zusammengehoeren, weil sie alle denselben Satz aus
Kapitel 01 des Bauplans beantworten: Wer neu ist, soll nicht alles
gleich wichtig vorgesetzt bekommen.

1) DIE KACHEL STEHT BEIM TEAM OBEN (Kapitel 03)
Gemessen stand "Willkommen & Anleitung" bei einem Modi in der Gruppe
"Community" -- der FUENFTEN von sechs, hinter allen Brettern, die er
moderiert. Der Plan sagt dazu "zusaetzlich als erste Kachel in 'Fuer
dich', weil sie bei ihnen sonst weit unten steht".

Ich habe sie VERSCHOBEN statt verdoppelt, und das ist eine bewusste
Abweichung vom Wortlaut: Zwei Kacheln mit demselben Namen und
demselben Ziel hatte dieses Haus am 19.09. schon einmal (zweimal
"Chat"), und der Satz, der daraus wurde, steht seitdem im Quelltext --
"Zwei gleich benannte Wege zum selben Ort sind schlimmer als ein
fehlender". Das Ziel des Plans ist so erreicht, der Nebeneffekt bleibt
aus. Fuer die Community aendert sich nichts: Bei ihr ist "Community"
die erste Gruppe, dort steht sie schon vorne und breit.
Entschieden wird das an AUSSEN_ROLLEN, nicht an Rollennamen.

2) "NEU FUER DICH" BEIM AUFSTIEG (Kapitel 10, Etappe 6)
Erreicht ein Mitglied "Dabei" oder "Stamm", steht auf der Zentrale
einmal eine Karte mit dem, was jetzt geht, und einem Sprung auf die
passende Karte der Anleitung.

WAS JETZT GEHT, IST ABGELEITET -- aus TREFF_SCHREIBEN, derselben
Tafel, die es auch ENTSCHEIDET. Eine Liste im Code haette beim
naechsten neuen Brett entweder etwas versprochen, das die Person gar
nicht darf, oder verschwiegen, was sie duerfte.

Der Schluessel ist (Person, STUFE) und nicht (Person): Wer von Neu auf
Dabei steigt, bekommt die Karte, und Wochen spaeter beim Sprung auf
Stamm noch einmal, mit anderem Inhalt. Eine einzelne Spalte "schon
gesehen" haette den zweiten Aufstieg verschluckt -- und das waere
niemandem aufgefallen, es fehlt ja nur etwas.

Gemerkt wird beim ZEIGEN, nicht beim Wegklicken. Dieselbe Entscheidung
wie bei der Begruessung, aus demselben gemessenen Grund.

Dazu springt `anleitung.html?karte=<schluessel>` jetzt auf eine
bestimmte Karte. Erst beim Messen fiel auf, dass der Sprung ins Leere
ging, obwohl Karte und Abschnitt richtig waren: Unter den Karten
werden danach noch drei Abschnitte eingehaengt, und das sanfte
Scrollen zielte auf eine Hoehe, die sich dabei verschob. Der Sprung
steht jetzt ganz am Ende des Aufbaus.

3) DAS ABGELOESTE WILLKOMMEN IST WEG
willkommen.html ist seit heute frueh eine Weiterleitung. Der Unterbau
lief aber weiter: eine Schnittstelle, die jede Kachel einer Rolle
gleich ausfuehrlich erklaerte (genau das, was Kapitel 01 als Problem
beschreibt), dazu ein Skript und ein Stilblatt, die keine Seite mehr
lud. Entfernt: server/workspace-willkommen.js, assets/js/willkommen.js,
assets/css/willkommen.css und der Router in index.js.

Aufgefallen ist es, weil pruef-willkommen rot wurde und danach in ihre
Notbremse lief -- eine Pruefung, die eine zurueckgenommene Regel
verteidigt. Sie ist mitgegangen: Die inhaltlichen Fragen beantwortet
jetzt pruef-anleitung; hier bleibt die eine, die sonst niemand stellt
("verliert die alte Adresse jemanden?") plus der Nachweis, dass das
Alte wirklich fort ist. 15 Pruefungen statt der alten Fassung, und der
Rueckgang ist damit erklaert.

Nebenbefund: tools/kachel-regenbogen.mjs verwies auf pruef-willkommen
als Wache ueber den gerechneten CSS-Block. Die Datei hat ihn nie
angesehen -- die Wache ist pruef-kachelfarben. Zeiger berichtigt.

AUSSERDEM: .zeileneditor__weg war 34x34 und das einzige ungedeckte
Tippziel des Hauses (pruef-tippziele war deshalb rot). Er wirft eine
Zeile aus einem Eintrag. Auf Fingergeraeten jetzt 44x44, das Kreuz
mitgerechnet statt geraten. Der Knopf stammt aus einer anderen
Sitzung; ich habe ihn Filipe gemeldet und keine Antwort bekommen --
eine rote Pruefung, die liegen bleibt, wird nach dem zweiten Mal
weggeklickt, deshalb jetzt behoben statt weiter gemeldet.

GEPRUEFT
  pruef-anleitung     137 -> 166 (neu: Kachelplatz je Rolle mit
                      Gegenprobe aufs Agenturhaus, der ganze
                      Aufstiegsweg inkl. ZWEITEM Aufstieg, und die
                      Abnahme-Checkliste aus Kapitel 13 -- 14/29/29/34
                      Karten MIT ihrer Aufteilung 5/4/5, 7/7/15,
                      7/7/15, 8/7/19 und "Nicht deins")
  pruef-willkommen    neu gefasst, 15, gruen
  pruef-sackgassen    14, 145 Kacheln, 0 ins Leere
  pruef-start-ansicht gruen, keine Konsolenfehler
  pruef-rollen        454, gruen (das eine "nicht nachsehbar" ist das
                      Haus-Wechsel-Feld und war immer so)
  pruef-tippziele     13, jetzt 0 Fehlschlaege

Gegenproben gefahren: Umsortierung ausgebaut -> drei FEHL (und die
Meldung zeigte den alten Zustand, Gruppe 5 von 6). Datenbank vor der
Schemaaenderung gesichert (sicherungen/vor-aufstieg-20261006-172614.db,
integrity_check ok).

Im Browser nachgemessen (echte Anmeldung, 390 px, HTTPS-Vorbau):
Karte da, Satz richtig, drei Wege, 0 zu kleine Tippziele, Sprung
landet auf der richtigen Karte, Abschnitt aufgeklappt, im Bild -- und
beim zweiten Aufruf ist sie weg.

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

server/pruef-anleitung.mjs

@@ -969,6 +969,223 @@ melde("\n=== Rundgang: drei Schritte / fuenf Schritte ===");
     `kein Rollenname im Code von rundgang.js${gefunden.length ? " — " + gefunden.join(", ") : ""}`);
 }
 
+/* =====================================================================
+   WO DIE KACHEL STEHT (Bauplan Kapitel 03)
+   ---------------------------------------------------------------------
+   „Community: bleibt die erste, breite Kachel in der Gruppe
+   ‚Community'. Modi, Linke Hand, Rechte Hand: zusaetzlich als erste
+   Kachel in ‚Fuer dich', weil sie bei ihnen sonst weit unten steht."
+
+   Gebaut ist das als VERSCHIEBEN statt Verdoppeln (der Grund steht in
+   workspace.js an anleitungNachVorne) -- deshalb prueft die letzte
+   Zeile jeder Rolle auch, dass es GENAU EINE gibt. Zwei gleich
+   benannte Wege zum selben Ort waeren hier der wahrscheinlichste
+   Rueckfall.
+
+   Gemessen wird ueber /api/ich, also ueber genau das Feld, aus dem die
+   Startseite ihre Gruppen baut -- nicht ueber die Liste im Quelltext.
+   Und die Gruppennummer gehoert mit in die Bedingung: „steht in Fuer
+   dich" waere auch wahr, wenn „Fuer dich" eines Tages die letzte
+   Gruppe ist, und dann steht sie wieder weit unten. */
+melde("\n=== Die Kachel steht da, wo der Bauplan sie hinstellt ===");
+{
+  const ichFuer = async (rolle, host) => {
+    const r = await roh("/workspace/api/ich", host, null, kekse[rolle]);
+    try { return JSON.parse(r.text); } catch { return null; }
+  };
+  const lage = (liste) => {
+    const gruppen = [];
+    for (const k of liste) if (!gruppen.includes(k.gruppe)) gruppen.push(k.gruppe);
+    const treffer = liste.filter((k) => k.ziel === "anleitung.html");
+    const k = treffer[0] || null;
+    const inGruppe = k ? liste.filter((x) => x.gruppe === k.gruppe) : [];
+    return {
+      anzahl: treffer.length, gruppe: k?.gruppe || null, gross: !!k?.gross,
+      nummer: k ? gruppen.indexOf(k.gruppe) + 1 : 0, gruppen: gruppen.length,
+      erste: inGruppe[0]?.ziel === "anleitung.html",
+      vorCommunity: k ? gruppen.indexOf(k.gruppe) < gruppen.indexOf("Community") : false,
+    };
+  };
+
+  const jGast = await ichFuer("gast", CREW_HOST);
+  const g = Array.isArray(jGast?.bereiche) ? lage(jGast.bereiche) : null;
+  ok(g && g.anzahl === 1 && g.gruppe === "Community" && g.nummer === 1
+      && g.erste && g.gross,
+    `Community: erste und breite Kachel der ersten Gruppe `
+      + `(${g?.anzahl}x, ${g?.gruppe}, Gruppe ${g?.nummer}/${g?.gruppen}, `
+      + `erste ${g?.erste}, breit ${g?.gross})`);
+
+  for (const rolle of ["modi", "linke", "hand"]) {
+    const j = await ichFuer(rolle, CREW_HOST);
+    const l = Array.isArray(j?.bereiche) ? lage(j.bereiche) : null;
+    ok(l && l.anzahl === 1 && l.gruppe === "Für dich" && l.erste && l.vorCommunity,
+      `${rolle}: erste Kachel in „Für dich“, vor „Community“ `
+        + `(${l?.anzahl}x, ${l?.gruppe}, Gruppe ${l?.nummer}/${l?.gruppen}, `
+        + `erste ${l?.erste}, vor Community ${l?.vorCommunity})`);
+  }
+
+  /* DAS ANDERE HAUS BLEIBT UNBERUEHRT -- und das ist hier mehr als
+     eine Hoeflichkeit: Die Umsortierung sitzt in `bereicheFuer`, also
+     in der Funktion, die BEIDE Haeuser benutzen. Fuer die Agentur
+     muss sie `null` liefern ("der Browser hat die Liste"); gaebe sie
+     dort eine Liste zurueck, bekaeme die Agenturseite ihre Kacheln
+     ploetzlich vom Server, und niemand haette es bemerkt, weil
+     dieselben Kacheln herauskaemen. */
+  const jCre = await ichFuer("creator", null);
+  ok(jCre?.bereiche === null,
+    `die Agentur holt ihre Kacheln weiter aus dem Browser (bereiche ${
+      jCre?.bereiche === null ? "null" : typeof jCre?.bereiche})`);
+}
+
+/* =====================================================================
+   „NEU FUER DICH" BEIM AUFSTIEG (Bauplan Kapitel 10, Etappe 6)
+   ---------------------------------------------------------------------
+   „Erreicht ein Community-Mitglied die Stufe Dabei oder Stamm, zeige
+   auf der Startseite EINMAL die Karte ‚Neu fuer dich' mit Sprung zur
+   passenden Karte."
+
+   Die vier Zeilen in der Mitte sind der eigentliche Punkt: Der
+   Schluessel ist (Person, STUFE) und nicht (Person). Wer von Neu auf
+   Dabei steigt, bekommt die Karte, und Wochen spaeter beim Sprung auf
+   Stamm noch einmal -- mit anderem Inhalt. Eine einzelne Spalte „schon
+   gesehen" haette den zweiten Aufstieg verschluckt, und das waere
+   niemandem aufgefallen: Es fehlt ja nur etwas.
+
+   DIE STUFE WIRD NICHT GESETZT, SIE WIRD GERECHNET. Deshalb wird hier
+   der Beitrittstag verschoben und es werden echte Beitraege angelegt
+   -- genau die zwei Dinge, aus denen `stufeVon` sie ableitet. Ein
+   „UPDATE personen SET stufe = 'stamm'" gaebe es gar nicht, und ein
+   Test, der eine Spalte setzt, die es nicht gibt, waere gruen ohne
+   etwas zu beweisen (siehe die Hausregel vom 01.09.2026). */
+melde("\n=== „Neu für dich“ beim Aufstieg ===");
+{
+  const aufstieg = async (rolle, host = null) => {
+    const r = await roh("/workspace/api/anleitung/aufstieg", host, null, kekse[rolle]);
+    let j = null; try { j = JSON.parse(r.text); } catch { /* bleibt null */ }
+    return { code: r.code, j };
+  };
+  const merken = (rolle, host = null) => roh(
+    "/workspace/api/anleitung/aufstieg/gesehen", host, {}, kekse[rolle], "POST");
+  const ziele = (j) => (j?.kacheln || []).map((k) => k.ziel).join(", ");
+
+  const gastId = (() => {
+    const d = new DatabaseSync(process.env.WORKSPACE_DB);
+    const z = d.prepare("SELECT id FROM personen WHERE rolle = 'gast'").get();
+    d.close();
+    return z?.id || 0;
+  })();
+  braucht(!!gastId, "kein Mitglied in der Probe-Datenbank");
+
+  const beitritt = (tageHer) => {
+    const d = new DatabaseSync(process.env.WORKSPACE_DB);
+    d.prepare("UPDATE personen SET erstellt = ? WHERE id = ?")
+      .run(new Date(Date.now() - tageHer * 86400_000).toISOString(), gastId);
+    d.close();
+  };
+
+  /* ---- Stufe „Neu": nichts zu feiern ------------------------------- */
+  const aNeu = await aufstieg("gast", CREW_HOST);
+  ok(aNeu.code === 200 && aNeu.j?.zeigen === false,
+    `frisch dabei: keine Karte (HTTP ${aNeu.code}, zeigen ${aNeu.j?.zeigen})`);
+
+  /* ---- Stufe „Dabei" ------------------------------------------------ */
+  beitritt(10);
+  const aDabei = await aufstieg("gast", CREW_HOST);
+  ok(aDabei.j?.zeigen === true && aDabei.j?.stufe === "dabei",
+    `nach ${10} Tagen kommt sie (zeigen ${aDabei.j?.zeigen}, Stufe ${aDabei.j?.stufe})`);
+  /* ABGELEITET AUS TREFF_SCHREIBEN, nicht aufgeschrieben: „Dabei"
+     schaltet Rudel-Chat, Wunschliste und Mitmachen frei. Steht hier
+     eines Tages etwas anderes, hat jemand die Tafel geaendert -- und
+     genau dann soll diese Zeile anschlagen. */
+  const dabeiZiele = (aDabei.j?.kacheln || []).map((k) => k.ziel);
+  ok(dabeiZiele.length === 3
+      && dabeiZiele.includes("chat.html?raum=treff")
+      && dabeiZiele.includes("bereich.html?b=wunsch")
+      && dabeiZiele.includes("bereich.html?b=mitmachen"),
+    `…mit den drei frisch freigeschalteten Wegen (${ziele(aDabei.j)})`);
+
+  const m1 = await merken("gast", CREW_HOST);
+  const aWieder = await aufstieg("gast", CREW_HOST);
+  ok(m1.code === 200 && aWieder.j?.zeigen === false,
+    `gemerkt — sie kommt kein zweites Mal (HTTP ${m1.code}, zeigen ${aWieder.j?.zeigen})`);
+
+  /* ---- Stufe „Stamm": dieselbe Person, neue Karte -------------------- */
+  beitritt(40);
+  const aOhneBeitraege = await aufstieg("gast", CREW_HOST);
+  ok(aOhneBeitraege.j?.zeigen === false,
+    `40 Tage ohne eigene Beiträge bleiben „Dabei“ (zeigen ${aOhneBeitraege.j?.zeigen})`);
+
+  {
+    const d = new DatabaseSync(process.env.WORKSPACE_DB);
+    const satz = d.prepare(
+      `INSERT INTO eintraege (bereich, art, titel, datum, erstellt, erstellt_von)
+       VALUES ('highlight','clip',?,?,?,?)`);
+    const heute = new Date().toISOString();
+    for (let i = 1; i <= 3; i++) satz.run(`Probe ${i}`, heute.slice(0, 10), heute, gastId);
+    d.close();
+  }
+  const aStamm = await aufstieg("gast", CREW_HOST);
+  ok(aStamm.j?.zeigen === true && aStamm.j?.stufe === "stamm",
+    `der ZWEITE Aufstieg kommt eigenständig (zeigen ${aStamm.j?.zeigen}, `
+      + `Stufe ${aStamm.j?.stufe})`);
+  ok((aStamm.j?.kacheln || []).length === 1
+      && aStamm.j.kacheln[0].ziel === "bereich.html?b=highlight",
+    `…und zeigt auf die Highlights (${ziele(aStamm.j)})`);
+
+  /* ---- Gegenprobe: eine Teamrolle hat gar keine Mitglieder-Stufe ---- */
+  const aHand = await aufstieg("hand", CREW_HOST);
+  ok(aHand.code === 200 && aHand.j?.zeigen === false,
+    `eine Teamrolle bekommt nie eine (HTTP ${aHand.code}, zeigen ${aHand.j?.zeigen})`);
+}
+
+/* =====================================================================
+   DIE ABNAHME-CHECKLISTE DES BAUPLANS (Kapitel 13)
+   ---------------------------------------------------------------------
+   Woertlich:
+     Community:    14 Karten — 5 Muss,  4 Regelmaessig,  5 Bei Bedarf,
+                   „Nicht deins" mit 5 Punkten.
+     Modi:         29 Karten — 7 / 7 / 15, „Nicht deins" 5.
+     Linke Hand:   29 Karten — 7 / 7 / 15, „Nicht deins" 5.
+     Rechte Hand:  34 Karten — 8 / 7 / 19, „Nicht deins" 4.
+
+   DIE GESAMTZAHLEN STANDEN SCHON WEITER OBEN — die AUFTEILUNG nicht.
+   Das ist der Unterschied, auf den es ankommt: Verrutscht eine Kachel
+   von „Muss" nach „Bei Bedarf", bleibt die Summe gleich, und der
+   Fehler ist genau der, den die ganze Seite verhindern soll — jemand
+   bekommt beim ersten Anmelden das Falsche zuerst gezeigt.
+
+   GEMESSEN WIRD AN DER SCHNITTSTELLE, NICHT AN DER TEXTDATEI. Die
+   Einordnung ist seit Etappe 4 in der Pflege aenderbar; die
+   Erstbefuellung ist nur der Anfangszustand. Wer die Textdatei fragt,
+   fragt eine Quelle, die nach der ersten Aenderung nicht mehr gilt.
+
+   DIE STUFENSCHLUESSEL WERDEN NICHT ABGESCHRIEBEN, sondern aus
+   STUFEN_SCHLUESSEL genommen — kommt eine vierte Einordnung dazu,
+   faellt diese Pruefung auf, statt sie stillschweigend zu uebergehen. */
+melde("\n=== Die Abnahme-Checkliste (Bauplan Kapitel 13) ===");
+{
+  const { STUFEN_SCHLUESSEL } = await import("./anleitung-tabellen.js");
+  const SOLL = {
+    gast:  { karten: 14, auf: [5, 4, 5],  nicht: 5 },
+    modi:  { karten: 29, auf: [7, 7, 15], nicht: 5 },
+    linke: { karten: 29, auf: [7, 7, 15], nicht: 5 },
+    hand:  { karten: 34, auf: [8, 7, 19], nicht: 4 },
+  };
+  ok(STUFEN_SCHLUESSEL.length === 3,
+    `drei Einordnungen, wie der Bauplan sie kennt (${STUFEN_SCHLUESSEL.join(", ")})`);
+  for (const [rolle, soll] of Object.entries(SOLL)) {
+    const j = (await holen(rolle, CREW_HOST)).j;
+    const karten = j?.karten || [];
+    const auf = STUFEN_SCHLUESSEL.map((st) => karten.filter((k) => k.stufe === st).length);
+    ok(karten.length === soll.karten
+        && auf.every((n, i) => n === soll.auf[i])
+        && (j?.nicht || []).length === soll.nicht,
+      `${rolle}: ${soll.karten} Karten (${soll.auf.join("/")}) und `
+        + `${soll.nicht}x „Nicht deins“ — bekommen: ${karten.length} `
+        + `(${auf.join("/")}) und ${(j?.nicht || []).length}`);
+  }
+}
+
 /* ---------- Abschluss ------------------------------------------------ */
 try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
 console.log(`\n${fehler ? "FEHLER: " + fehler : "Alles in Ordnung"} — ${geprueft} Prüfungen`);