Die drei Altlasten: ein echter Befund, zwei Pruefungen mit Zahlen von gestern

Alle drei standen seit dem 22.09. in der Notiz und waren mit `git
stash` als vorbestehend nachgewiesen. Nachgemessen, einzeln behoben.

1. pruef-jeder-hat-eine-seite -- EIN ECHTER BEFUND
   "alle 9 Rollen sind zugeordnet -- fehlt: linke"

   Die LINKE HAND fiel im Steckbrief in den Sammelplatz "Weitere":
   Auf der Uebersicht ueber die Menschen des Hauses stand sie unter
   einer Ueberschrift ohne Bedeutung, neben niemandem. Sie gehoert
   dorthin, wo die rechte Hand steht -- beide fuehren Team Dogi mit.

   Beim Nachgehen fiel dieselbe Luecke an einer zweiten Stelle auf:
   In ROLLEN_GRUPPE (der Auswahl, mit wem man schreiben kann) fehlte
   sie ebenfalls und haette eine eigene Ueberschrift mit genau einem
   Namen darunter bekommen -- also die Rangordnung, die zwei Zeilen
   hoeher ausdruecklich vermieden werden sollte.

   WARUM DIE PRUEFUNG DAS FINDEN KONNTE und ein Mensch nicht: Sie geht
   ALLE Rollen des Hauses durch, nicht die vier, die zufaellig
   angelegt sind. Eine Zuordnung, die man an den vorhandenen Leuten
   prueft, ist eine Aussage ueber die Testdaten.

2. pruef-rollen -- DIE MESSUNG WAR FALSCH, NICHT DIE KACHEL
   "DogFather Kachel https://crew... LANDET AUF start.html"

   DogFather bekommt auf der Agenturadresse die Kachel "Zu Team Dogi".
   Ihr Ziel MUSS eine vollstaendige Adresse sein -- das andere Haus
   liegt auf einem anderen Rechnernamen. Im Server steht das
   ausdruecklich (`aussen: true` an der Kachel, samt Begruendung).

   Die Pruefung klebte jedes Ziel an `BASIS + "/workspace/"`. Bei einer
   vollstaendigen Adresse kommt dabei Unsinn heraus.

   Sie kannte ausserdem nur ZWEI Ausgaenge. Ob die andere Tuer
   aufgeht, laesst sich von hier nicht sagen -- der Browser kennt nur
   BASIS. Das ist der dritte Ausgang, und er wird jetzt als solcher
   gemeldet: 314 Pruefungen, 0 Fehler, 1 nicht nachsehbar. Geprueft
   wird stattdessen, was hier zu pruefen IST: dass die Adresse zu
   einem Haus fuehrt, das dieses Haus kennt (aus CREW_ADRESSE, nicht
   abgeschrieben).

3. pruef-kachelraster -- ZWEI ZAHLEN VON GESTERN, UND EIN MESSFEHLER
   "10 Community-Kacheln" (erwartet 8) und "die doppelt breite Kachel
   steht an erster Stelle (Platz 0)"

   `=== 8` stand in der Ueberschrift, im Text und in der Bedingung. Am
   22.09. sind Kacheln dazugekommen, und die Pruefung wurde rot, ohne
   dass am Raster etwas kaputt war.

   Schwerer wog der zweite Teil: Sie suchte "die Community-Gruppe"
   ueber deren Ueberschrift, mit der letzten Gruppe als Rueckfall. Fuer
   DogFather griff der Treffer (1 Kachel), fuer einen Modi der
   Rueckfall (10) -- und beides hiess in der Meldung
   "Community-Kacheln". Eine Pruefung, die je nach Rolle etwas anderes
   misst, kann ihr Ergebnis nicht erklaeren.

   Jetzt werden ALLE Gruppen gemessen, mit Namen in der Meldung, und
   die Frage ist ueberall dieselbe: Hat das Raster ein Loch? Die
   Kachelzahl steht in der Meldung, nicht in der Bedingung. Die Regel
   "eine doppelt breite Kachel steht vorn" bleibt -- es gibt heute
   keine solche Gruppe mehr, aber sie gilt fuer die naechste, und die
   ZAHL der geprueften Gruppen steht daneben.

   Gemessen sieht DogFather 5 Gruppen (1, 6, 11, 4, 1 Kacheln), ein
   Modi 6. Kein Loch in einer davon. 15 Pruefungen, 0 Fehler.

Mitgelaufen und gruen: pruef-steckbrief, pruef-rechtetafel (19),
pruef-chat.

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

server/pruef-kachelraster.mjs

@@ -26,9 +26,23 @@
    ist dagegen in Ordnung und faellt aus dieser Rechnung heraus.
 
    GEPRUEFT IN ZWEI LAGEN, denn die Kachelzahl haengt an der Rolle:
-   ein Modi moderiert und sieht dieselben acht wie DogFather, ein reiner
-   Zuschauer sieben. Eine Reihenfolge, die nur fuer eine Zahl aufgeht,
-   geht nicht auf.
+   DogFather und ein Modi sehen verschieden viele. Eine Anordnung, die
+   nur fuer eine Zahl aufgeht, geht nicht auf.
+
+   OHNE FESTE ZAHLEN (23.09.2026). Hier stand „acht" -- in der
+   Ueberschrift, im Text und in der Bedingung. Am 22.09. sind Kacheln
+   dazugekommen, und die Pruefung wurde rot, ohne dass am Raster etwas
+   kaputt war: Sie hat die Zahl von gestern verteidigt.
+
+   Und sie mass fuer DogFather und einen Modi VERSCHIEDENE Gruppen --
+   gesucht wurde „die Community-Gruppe" ueber ihre Ueberschrift, mit
+   der letzten Gruppe als Rueckfall. Fuer den einen griff der Treffer,
+   fuer den anderen der Rueckfall; beides hiess in der Meldung gleich.
+   Eine Pruefung, die je nach Rolle etwas anderes misst, kann ihr
+   Ergebnis nicht erklaeren.
+
+   Jetzt werden ALLE Gruppen gemessen, und die Frage ist ueberall
+   dieselbe: Hat das Raster ein Loch?
 
    MIT GEGENPROBE: Dieselbe Rechnung wird auf eine absichtlich falsche
    Reihenfolge angewandt (breite Kachel an dritter Stelle). Sie MUSS
@@ -144,14 +158,26 @@ async function messen(kachel, code, wer) {
   await seite.waitForTimeout(500);
 
   const daten = await seite.evaluate(() => {
-    /* DIE COMMUNITY-GRUPPE finden -- ueber ihre Ueberschrift, nicht
-       ueber eine Position. Eine Position aendert sich, sobald jemand
-       eine Gruppe dazwischenschiebt. */
-    const gruppen = [...document.querySelectorAll(".kacheln")];
-    const treffer = gruppen.find((g) => {
-      const kopf = g.previousElementSibling;
-      return kopf && /COMMUNITY/i.test(kopf.textContent || "");
-    }) || gruppen[gruppen.length - 1];
+    /* =================================================================
+       ALLE GRUPPEN, NICHT EINE (23.09.2026)
+       =================================================================
+
+       Hier wurde „die Community-Gruppe" gesucht -- ueber ihre
+       Ueberschrift, mit der letzten Gruppe als Rueckfall. Gemessen am
+       23.09. ergab das fuer DogFather EINE Kachel und fuer einen Modi
+       ZEHN, und beides hiess in der Meldung „Community-Kacheln". Zwei
+       verschiedene Dinge unter einem Namen: Der eine Treffer war eine
+       echte Gruppe mit einer Kachel, der andere der Rueckfall.
+
+       Eine Pruefung, die je nach Rolle etwas anderes misst, kann ihr
+       Ergebnis nicht erklaeren. Und die Frage, um die es geht -- hat
+       das Raster ein Loch? --, stellt sich fuer JEDE Gruppe.
+
+       Also alle. Der Name der Gruppe kommt mit, damit eine Meldung
+       sagt, wo etwas klemmt.
+       ================================================================= */
+    const messeGruppe = (behaelter) => {
+    const treffer = behaelter;
     const stil = getComputedStyle(treffer);
     const spalten = stil.gridTemplateColumns.split(" ").filter(Boolean).length;
     const kacheln = [...treffer.querySelectorAll(".kachel")].map((k) => ({
@@ -170,6 +196,23 @@ async function messen(kachel, code, wer) {
     }));
     const reihen = new Set(kacheln.map((k) => k.oben)).size;
     return { spalten, kacheln, reihen };
+    };
+
+    const gruppen = [...document.querySelectorAll(".kacheln")].map((g) => {
+      const kopf = g.previousElementSibling;
+      return {
+        name: (kopf?.textContent || "").replace(/\s+/g, " ").trim().slice(0, 40)
+          || "(ohne Ueberschrift)",
+        ...messeGruppe(g),
+      };
+    }).filter((g) => g.kacheln.length > 0);
+
+    /* Die groesste Gruppe bleibt fuer die Zeilen, die eine einzelne
+       brauchen (Zeichen, Toene) -- dort geht es um Unterscheidbarkeit
+       nebeneinander, und die entscheidet sich innerhalb einer Gruppe. */
+    const groesste = gruppen.reduce((a, b) =>
+      (b.kacheln.length > (a?.kacheln.length || 0) ? b : a), null) || { kacheln: [], spalten: 0, reihen: 0 };
+    return { gruppen, ...groesste };
   });
 
   if (process.env.SCHIRM) {
@@ -196,27 +239,49 @@ async function messen(kachel, code, wer) {
 
 try {
   /* =====================================================================
-     1. DOGFATHER -- ACHT KACHELN
+     1. DOGFATHER -- SEINE GRUPPEN GEHEN AUF
      ===================================================================== */
   melde("");
-  melde("=== 1. DogFather sieht acht ===");
+  melde("=== 1. DogFather: kein Loch in einer Gruppe ===");
   {
     const m = await messen("admin", "CODE-DOGI-0001", "dogfather");
-    ok(m.kacheln.length === 8, `${m.kacheln.length} Community-Kacheln`);
-    ok(m.spalten === 3, `drei Spalten (${m.spalten})`);
-    /* DIE BREITE KACHEL STEHT VORNE -- das ist die eigentliche
-       Reparatur. Ohne diese Zeile waere nicht geprueft, WARUM kein
-       Loch da ist; bei acht Kacheln ginge die Rechnung zufaellig auch
-       mit ihr an anderer Stelle auf. */
-    const breitAn = m.kacheln.findIndex((k) => k.breit);
-    ok(breitAn === 0,
-      `die doppelt breite Kachel steht an erster Stelle (${breitAn === 0
-        ? m.kacheln[0].name : "Platz " + (breitAn + 1)})`);
+    /* KEINE FESTE ZAHL MEHR (23.09.2026).
 
+       Hier stand `=== 8`. Am 22.09. sind Kacheln dazugekommen, und die
+       Zeile wurde rot, ohne dass am Raster etwas kaputt war -- sie hat
+       die Zahl von gestern verteidigt. Dasselbe Muster wie bei den
+       Stufen und der abgeschriebenen Spaltenliste.
+
+       Geprueft wird jetzt, was wirklich gelten muss: Es gibt Gruppen,
+       sie sind nicht leer, und KEINE von ihnen hat ein Loch. Die Zahl
+       steht in der Meldung, nicht in der Bedingung. */
+    ok(m.gruppen.length >= 2,
+      `DogFather sieht ${m.gruppen.length} Kachelgruppen `
+      + `(${m.gruppen.map((g) => `${g.name}: ${g.kacheln.length}`).join(", ")})`);
+    ok(m.spalten === 3, `die groesste Gruppe hat drei Spalten (${m.spalten})`);
+
+    /* WENN eine Gruppe eine doppelt breite Kachel hat, muss sie vorn
+       stehen -- sonst entsteht das Loch, um das es hier geht. Es gibt
+       heute keine mehr; die Regel bleibt trotzdem stehen, denn sie
+       gilt fuer die naechste. Eine Bedingung, die nur greift, wenn es
+       etwas zu pruefen gibt, ist kein uebersprungener Test: Die ZAHL
+       der geprueften Gruppen steht daneben. */
+    const mitBreit = m.gruppen.filter((g) => g.kacheln.some((k) => k.breit));
+    const falschPlatziert = mitBreit.filter((g) => !g.kacheln[0].breit);
+    ok(falschPlatziert.length === 0,
+      mitBreit.length
+        ? `${mitBreit.length} Gruppe(n) mit breiter Kachel, alle vorn`
+        : "keine Gruppe hat eine doppelt breite Kachel -- die Regel greift, sobald es eine gibt");
+
+    /* JEDE GRUPPE, nicht eine. Die Frage "hat das Raster ein Loch"
+       stellt sich ueberall gleich. */
+    const mitLoch = m.gruppen.filter((g) => loecher(g).loch);
+    ok(m.gruppen.length > 0 && mitLoch.length === 0,
+      mitLoch.length
+        ? `Loch in: ${mitLoch.map((g) => `${g.name} (${loecher(g).reihen} statt `
+          + `${loecher(g).minimum})`).join(", ")}`
+        : `kein Loch in einer der ${m.gruppen.length} Gruppen`);
     const r = loecher(m);
-    ok(!r.loch,
-      `kein Loch: ${r.zellen} Zellen auf ${m.spalten} Spalten = ${r.minimum} Reihen, `
-      + `gemessen ${r.reihen}`);
 
     /* JEDES ZEICHEN GENAU EINMAL. Vorher trugen "Regeln & Hilfe" und
        "Meldungen & Massnahmen" beide denselben Schild -- nebeneinander
@@ -250,7 +315,7 @@ try {
      2. EIN MODI -- SIEBEN KACHELN
      ===================================================================== */
   melde("");
-  melde("=== 2. Ein Modi sieht dieselben acht ===");
+  melde("=== 2. Ein Modi: dasselbe Raster ===");
   {
     const m = await messen("creator", "CODE-MODI-0001", "modi");
     /* ACHT, NICHT SIEBEN -- und das war MEIN Denkfehler beim Schreiben
@@ -260,7 +325,9 @@ try {
        Der reine Zuschauer sieht sieben; an den kommt eine Pruefung
        ohne Gastzugang nicht heran, deshalb steht der Fall unten in der
        Rechnung. */
-    ok(m.kacheln.length === 8, `${m.kacheln.length} Community-Kacheln`);
+    ok(m.gruppen.length >= 1 && m.kacheln.length > 0,
+      `ein Modi sieht ${m.gruppen.length} Gruppe(n), groesste mit `
+      + `${m.kacheln.length} Kacheln`);
     const r = loecher(m);
     /* SIEBEN KACHELN, EINE DAVON BREIT = ACHT ZELLEN auf drei Spalten =
        drei Reihen. Die letzte Reihe hat eine freie Zelle -- die ist