@renoxar/koolie 1.25.0

package/.koolie/core/tests/erhebungen/stand-b4.py

@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+# Abgeleitet aus der Erhebung b3 mit 0.78.0 (CR-2026-105, D-212): Dieses
+# Skript kennt keine Zelle, nur den Basispfad - es ist die Haelfte des
+# Apparats, die den Gegenstand kennt. Geaendert wurde ausschliesslich
+# C:\\lw-b3 -> C:\\lw-b4.
+"""Sagt in einem Befehl, wo der Meßtag steht.
+
+    python stand-b4.py
+
+🔴 EINE ZAHL IN EINER UEBERGABE IST EINE MOMENTAUFNAHME, dieses Skript ist der
+Stand. Es leitet ab, was fehlt - aus den Prompts und den Belegen -, statt eine
+Liste zu pflegen.
+
+Ein Beleg zaehlt nur, wenn `is_error` false ist (Lehre aus Buendel 2: acht
+Laeufe hinterliessen einen VOLLSTAENDIGEN Belegsatz mit `is_error: true` und
+0 USD, und die Wiederaufnahme uebersprang genau die, die fehlten).
+"""
+import io
+import json
+import os
+import sys
+
+import ablage
+
+sys.stdout.reconfigure(encoding="utf-8")
+
+BEL = ablage.belege(anlegen=False)
+PROMPTS = ablage.prompts(anlegen=False)
+BAEUME = r"C:\lw-b4"
+
+
+def ergebnis(k):
+    p = os.path.join(BEL, k + "-ergebnis.json")
+    if not os.path.isfile(p):
+        return None
+    try:
+        return json.load(io.open(p, encoding="utf-8"))
+    except ValueError:
+        return None
+
+
+def main():
+    # 🔴 DIE SOLLMENGE KOMMT AUS DEN MESSBAEUMEN, NICHT AUS DEM PROMPTVERZEICHNIS
+    # (D-230). Bis 0.79.2 stand die Ableitung hier und las das Promptverzeichnis;
+    # der Nachlauf hat dort die fuenfzig Prompts des Messtags geerbt und schuldet
+    # vierzehn Zellen. Dieses Skript meldete 35 Fehlbestaende und rund 37 USD, wo
+    # fuenfzehn und rund achtzehn faellig waren. Die Ableitung steht jetzt EINMAL
+    # in `ablage.sollmenge()` und wird von `reihe-b4.py` mitbenutzt - zwei Zaehler
+    # desselben Gegenstands zaehlen dasselbe (D-228).
+    einfach, zwei, ohne_baum = ablage.sollmenge(PROMPTS, BAEUME)
+    soll = ablage.laeufe(einfach, zwei)
+
+    gut, fehlt, fehlerhaft = [], [], []
+    usd = sek = 0.0
+    for k in soll:
+        e = ergebnis(k)
+        if e is None:
+            fehlt.append(k)
+        elif e.get("is_error"):
+            fehlerhaft.append(k)
+        else:
+            gut.append(k)
+            usd += e.get("total_cost_usd") or 0
+            sek += (e.get("duration_ms") or 0) / 1000.0
+
+    print("=" * 78)
+    print("MESSTAG BUENDEL 4 - STAND")
+    print("=" * 78)
+    # 🔴 Hier stand ein FESTER Text aus Buendel 3: *18 Zellen, davon 7 mit
+    # zweitem Turn*. Buendel 4 hat 19 und 6 - und 2*18+2*7 ergibt ebenso 50 wie
+    # 2*19+2*6. Die Sollmenge war abgeleitet und richtig, ihre BESCHREIBUNG
+    # gepflegt und falsch (D-204 an einer neuen Stelle). Jetzt beides abgeleitet.
+    # 🔴 Und der erste Anlauf dieser Ableitung zaehlte LAEUFE und nannte sie
+    # ZELLEN: `einfach` und `zwei` fuehren Haupt- und Kontrollauf je Zelle
+    # getrennt (38 und 12). Die Zelle bekommt man, indem man das fuehrende `k`
+    # des Kontrollaufs abstreift - dieselbe Ableitung, eine Ebene tiefer.
+    zellen = {k[1:] if k.startswith("k") else k for k in einfach}
+    zellen2 = {k[1:] if k.startswith("k") else k for k in zwei if k in einfach}
+    print("Soll:        %3d Laeufe - %d Zellen je Haupt- und Kontrollauf, %d "
+          "davon mit zweitem Turn"
+          % (len(soll), len(zellen), len(zellen2)))
+    print("Gueltig:     %3d   (%.2f USD, %.0f s; Mittel %.2f USD, %.0f s)"
+          % (len(gut), usd, sek, usd / max(1, len(gut)), sek / max(1, len(gut))))
+    print("Fehlerhaft:  %3d   %s" % (len(fehlerhaft), " ".join(fehlerhaft) or "-"))
+    print("Fehlt:       %3d" % len(fehlt))
+    if fehlt:
+        print()
+        print("  " + "\n  ".join(" ".join(fehlt[i:i + 6])
+                                 for i in range(0, len(fehlt), 6)))
+        rest = len(fehlt) * (usd / max(1, len(gut)))
+        zeit = len(fehlt) * (sek / max(1, len(gut)))
+        print()
+        print("  Erwartet noch: rund %.0f USD und %.0f Minuten (gerechnet mit dem "
+              "Mittel dieses Tages)" % (rest, zeit / 60.0))
+    if fehlerhaft:
+        print()
+        print("🔴 Die fehlerhaften Belege werden von `reihe-b4.py` NEU gefahren - "
+              "ein Beleg ist erst einer, wenn `is_error` false ist.")
+
+    print()
+    vorhanden = sorted(x for x in os.listdir(BAEUME)
+                       if os.path.isdir(os.path.join(BAEUME, x))) \
+        if os.path.isdir(BAEUME) else []
+    print("Baeume unter %s: %d" % (BAEUME, len(vorhanden)))
+    if not vorhanden:
+        print("🔴 KEINE BAEUME - erst `umgebungen-bauen-b4.py`, dann `baeume-b4.py`.")
+        print("   Ohne Baeume ist die Sollmenge LEER und dieser Stand keine Aussage")
+        print("   ueber die Vollstaendigkeit der Reihe (D-230).")
+    # 🔴 Was NICHT stillschweigend uebergangen wird: Prompts ohne Baum. Sie sind der
+    # Zuschnitt einer anderen Erhebung - und genau sie haben `reihe-b4.py` ohne
+    # Argumente abbrechen lassen, bevor ein einziger Lauf fuhr (D-230).
+    if ohne_baum:
+        print()
+        print("Nicht im Zuschnitt dieser Erhebung (Prompt vorhanden, kein Messbaum): %d"
+              % len(ohne_baum))
+        print("  " + "\n  ".join(" ".join(ohne_baum[i:i + 6])
+                                 for i in range(0, len(ohne_baum), 6)))
+    for pflicht, was in (("zustand-vorher.json", "Zustandsaufnahme VORHER"),
+                         ("node-vorher.json", "node_modules-Waechter VORHER")):
+        da = os.path.isfile(os.path.join(ablage.erhebung(), pflicht))
+        print("%-28s %s" % (was + ":", "liegt vor" if da else "🔴 FEHLT"))
+
+    print()
+    if fehlt or fehlerhaft:
+        print("NAECHSTER BEFEHL:  python reihe-b4.py")
+        print("                   (faehrt nur, was fehlt - nichts wird doppelt bezahlt)")
+    else:
+        print("NAECHSTE BEFEHLE:  python zustand-b4.py nachher")
+        print("                   python node-waechter.py nachher")
+        print("                   python auswerten-b4.py")
+        print("                   python trust-b4.py entfernen")
+
+
+if __name__ == "__main__":
+    main()

package/.koolie/core/tests/erhebungen/stand-b5.py

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+# Abgeleitet aus der Erhebung b4 mit 0.83.0 (CR-2026-116): Dieses
+# Skript kennt keine Zelle, nur den Basispfad - es ist die Haelfte des
+# Apparats, die den Gegenstand NICHT kennt. Geaendert wurde ausschliesslich
+# C:\\lw-b4 -> C:\\lw-b5 und die Nennung der Nachbarwerkzeuge.
+"""Sagt in einem Befehl, wo der Meßtag steht.
+
+    python stand-b5.py
+
+🔴 EINE ZAHL IN EINER UEBERGABE IST EINE MOMENTAUFNAHME, dieses Skript ist der
+Stand. Es leitet ab, was fehlt - aus den Prompts und den Belegen -, statt eine
+Liste zu pflegen.
+
+Ein Beleg zaehlt nur, wenn `is_error` false ist (Lehre aus Buendel 2: acht
+Laeufe hinterliessen einen VOLLSTAENDIGEN Belegsatz mit `is_error: true` und
+0 USD, und die Wiederaufnahme uebersprang genau die, die fehlten).
+"""
+import io
+import json
+import os
+import sys
+
+import ablage
+
+sys.stdout.reconfigure(encoding="utf-8")
+
+BEL = ablage.belege(anlegen=False)
+PROMPTS = ablage.prompts(anlegen=False)
+BAEUME = r"C:\lw-b5"
+
+
+def ergebnis(k):
+    p = os.path.join(BEL, k + "-ergebnis.json")
+    if not os.path.isfile(p):
+        return None
+    try:
+        return json.load(io.open(p, encoding="utf-8"))
+    except ValueError:
+        return None
+
+
+def main():
+    # 🔴 DIE SOLLMENGE KOMMT AUS DEN MESSBAEUMEN, NICHT AUS DEM PROMPTVERZEICHNIS
+    # (D-230). Bis 0.79.2 stand die Ableitung hier und las das Promptverzeichnis;
+    # der Nachlauf hat dort die fuenfzig Prompts des Messtags geerbt und schuldet
+    # vierzehn Zellen. Dieses Skript meldete 35 Fehlbestaende und rund 37 USD, wo
+    # fuenfzehn und rund achtzehn faellig waren. Die Ableitung steht jetzt EINMAL
+    # in `ablage.sollmenge()` und wird von `reihe-b5.py` mitbenutzt - zwei Zaehler
+    # desselben Gegenstands zaehlen dasselbe (D-228).
+    einfach, zwei, ohne_baum = ablage.sollmenge(PROMPTS, BAEUME)
+    soll = ablage.laeufe(einfach, zwei)
+
+    gut, fehlt, fehlerhaft = [], [], []
+    usd = sek = 0.0
+    for k in soll:
+        e = ergebnis(k)
+        if e is None:
+            fehlt.append(k)
+        elif e.get("is_error"):
+            fehlerhaft.append(k)
+        else:
+            gut.append(k)
+            usd += e.get("total_cost_usd") or 0
+            sek += (e.get("duration_ms") or 0) / 1000.0
+
+    print("=" * 78)
+    print("MESSTAG BUENDEL 5 - STAND")
+    print("=" * 78)
+    # 🔴 Hier stand ein FESTER Text aus Buendel 3: *18 Zellen, davon 7 mit
+    # zweitem Turn*. Buendel 5 hat 19 und 6 - und 2*18+2*7 ergibt ebenso 50 wie
+    # 2*19+2*6. Die Sollmenge war abgeleitet und richtig, ihre BESCHREIBUNG
+    # gepflegt und falsch (D-204 an einer neuen Stelle). Jetzt beides abgeleitet.
+    # 🔴 Und der erste Anlauf dieser Ableitung zaehlte LAEUFE und nannte sie
+    # ZELLEN: `einfach` und `zwei` fuehren Haupt- und Kontrollauf je Zelle
+    # getrennt (38 und 12). Die Zelle bekommt man, indem man das fuehrende `k`
+    # des Kontrollaufs abstreift - dieselbe Ableitung, eine Ebene tiefer.
+    zellen = {k[1:] if k.startswith("k") else k for k in einfach}
+    zellen2 = {k[1:] if k.startswith("k") else k for k in zwei if k in einfach}
+    print("Soll:        %3d Laeufe - %d Zellen je Haupt- und Kontrollauf, %d "
+          "davon mit zweitem Turn"
+          % (len(soll), len(zellen), len(zellen2)))
+    print("Gueltig:     %3d   (%.2f USD, %.0f s; Mittel %.2f USD, %.0f s)"
+          % (len(gut), usd, sek, usd / max(1, len(gut)), sek / max(1, len(gut))))
+    print("Fehlerhaft:  %3d   %s" % (len(fehlerhaft), " ".join(fehlerhaft) or "-"))
+    print("Fehlt:       %3d" % len(fehlt))
+    if fehlt:
+        print()
+        print("  " + "\n  ".join(" ".join(fehlt[i:i + 6])
+                                 for i in range(0, len(fehlt), 6)))
+        rest = len(fehlt) * (usd / max(1, len(gut)))
+        zeit = len(fehlt) * (sek / max(1, len(gut)))
+        print()
+        print("  Erwartet noch: rund %.0f USD und %.0f Minuten (gerechnet mit dem "
+              "Mittel dieses Tages)" % (rest, zeit / 60.0))
+    if fehlerhaft:
+        print()
+        print("🔴 Die fehlerhaften Belege werden von `reihe-b5.py` NEU gefahren - "
+              "ein Beleg ist erst einer, wenn `is_error` false ist.")
+
+    print()
+    vorhanden = sorted(x for x in os.listdir(BAEUME)
+                       if os.path.isdir(os.path.join(BAEUME, x))) \
+        if os.path.isdir(BAEUME) else []
+    print("Baeume unter %s: %d" % (BAEUME, len(vorhanden)))
+    if not vorhanden:
+        print("🔴 KEINE BAEUME - erst `umgebungen-bauen-b5.py`, dann `baeume-b5.py`.")
+        print("   Ohne Baeume ist die Sollmenge LEER und dieser Stand keine Aussage")
+        print("   ueber die Vollstaendigkeit der Reihe (D-230).")
+    # 🔴 Was NICHT stillschweigend uebergangen wird: Prompts ohne Baum. Sie sind der
+    # Zuschnitt einer anderen Erhebung - und genau sie haben `reihe-b5.py` ohne
+    # Argumente abbrechen lassen, bevor ein einziger Lauf fuhr (D-230).
+    if ohne_baum:
+        print()
+        print("Nicht im Zuschnitt dieser Erhebung (Prompt vorhanden, kein Messbaum): %d"
+              % len(ohne_baum))
+        print("  " + "\n  ".join(" ".join(ohne_baum[i:i + 6])
+                                 for i in range(0, len(ohne_baum), 6)))
+    # 🔴 Buendel 5 hat keine Verzeichnisverbindung, also auch keinen
+    # `node_modules`-Waechter (E2 von CR-2026-116). Eine Pflichtdatei, die es
+    # nicht gibt, meldet bei jedem Aufruf FEHLT - und eine Meldung, die immer
+    # kommt, wird nicht mehr gelesen.
+    for pflicht, was in (("zustand-vorher.json", "Zustandsaufnahme VORHER"),):
+        da = os.path.isfile(os.path.join(ablage.erhebung(), pflicht))
+        print("%-28s %s" % (was + ":", "liegt vor" if da else "🔴 FEHLT"))
+
+    print()
+    if fehlt or fehlerhaft:
+        print("NAECHSTER BEFEHL:  python reihe-b5.py")
+        print("                   (faehrt nur, was fehlt - nichts wird doppelt bezahlt)")
+    else:
+        print("NAECHSTE BEFEHLE:  python zustand-b5.py nachher")
+        print("                   python auswerten-b5.py")
+        print("                   python trust-b5.py entfernen")
+
+
+if __name__ == "__main__":
+    main()

package/.koolie/core/tests/erhebungen/trust-b4.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+# Abgeleitet aus der Erhebung b3 mit 0.78.0 (CR-2026-105, D-212): Dieses
+# Skript kennt keine Zelle, nur den Basispfad - es ist die Haelfte des
+# Apparats, die den Gegenstand kennt. Geaendert wurde ausschliesslich
+# C:\\lw-b3 -> C:\\lw-b4.
+"""Setzt oder entfernt die Vertrauenseintraege der Baeume unter C:\\lw-b4.
+
+    python trust-b4.py setzen | entfernen | zaehlen
+
+Hinterher GEZIELT entfernen, nicht die Datei zuruecksichern - und erst nach dem
+LETZTEN Lauf. Wer beim Aufraeumen Altlasten findet, loescht sie mit.
+"""
+import io
+import json
+import os
+import sys
+
+sys.stdout.reconfigure(encoding="utf-8")
+
+P = os.path.join(os.path.expanduser("~"), ".claude.json")
+BASIS = r"C:\lw-b4"
+PRAEFIX = "c:/lw-b4/"
+
+was = sys.argv[1] if len(sys.argv) > 1 else "zaehlen"
+vorhanden = sorted(os.listdir(BASIS)) if os.path.isdir(BASIS) else []
+meine = ["C:/lw-b4/" + b for b in vorhanden
+         if os.path.isdir(os.path.join(BASIS, b))]
+
+d = json.load(io.open(P, encoding="utf-8"))
+pr = d.setdefault("projects", {})
+
+if was == "setzen":
+    for k in meine:
+        pr.setdefault(k, {})["hasTrustDialogAccepted"] = True
+        pr[k].setdefault("hasCompletedProjectOnboarding", True)
+    print("gesetzt:", len(meine))
+elif was == "entfernen":
+    fort = 0
+    for k in list(pr):
+        if k.replace("\\", "/").lower().startswith(PRAEFIX):
+            del pr[k]
+            fort += 1
+    print("entfernt:", fort)
+elif was == "zaehlen":
+    eigene = [k for k in pr if k.replace("\\", "/").lower().startswith(PRAEFIX)]
+    print("Eintraege unter %s: %d von %d Baeumen" % (PRAEFIX, len(eigene), len(meine)))
+    fehlend = [k for k in meine if k not in pr]
+    if fehlend:
+        print("OHNE Eintrag:", ", ".join(os.path.basename(x) for x in fehlend))
+    raise SystemExit(0)
+else:
+    raise SystemExit("setzen | entfernen | zaehlen")
+
+daten = (json.dumps(d, ensure_ascii=False, indent=2)).encode("utf-8")
+io.open(P, "wb").write(daten)
+print("Projekteintraege jetzt:", len(pr))

package/.koolie/core/tests/erhebungen/trust-b5.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+# Abgeleitet aus der Erhebung b4 mit 0.83.0 (CR-2026-116): Dieses
+# Skript kennt keine Zelle, nur den Basispfad - es ist die Haelfte des
+# Apparats, die den Gegenstand NICHT kennt. Geaendert wurde ausschliesslich
+# C:\\lw-b4 -> C:\\lw-b5 und die Nennung der Nachbarwerkzeuge.
+"""Setzt oder entfernt die Vertrauenseintraege der Baeume unter C:\\lw-b5.
+
+    python trust-b5.py setzen | entfernen | zaehlen
+
+Hinterher GEZIELT entfernen, nicht die Datei zuruecksichern - und erst nach dem
+LETZTEN Lauf. Wer beim Aufraeumen Altlasten findet, loescht sie mit.
+"""
+import io
+import json
+import os
+import sys
+
+sys.stdout.reconfigure(encoding="utf-8")
+
+P = os.path.join(os.path.expanduser("~"), ".claude.json")
+BASIS = r"C:\lw-b5"
+PRAEFIX = "c:/lw-b5/"
+
+was = sys.argv[1] if len(sys.argv) > 1 else "zaehlen"
+vorhanden = sorted(os.listdir(BASIS)) if os.path.isdir(BASIS) else []
+meine = ["C:/lw-b5/" + b for b in vorhanden
+         if os.path.isdir(os.path.join(BASIS, b))]
+
+d = json.load(io.open(P, encoding="utf-8"))
+pr = d.setdefault("projects", {})
+
+if was == "setzen":
+    for k in meine:
+        pr.setdefault(k, {})["hasTrustDialogAccepted"] = True
+        pr[k].setdefault("hasCompletedProjectOnboarding", True)
+    print("gesetzt:", len(meine))
+elif was == "entfernen":
+    fort = 0
+    for k in list(pr):
+        if k.replace("\\", "/").lower().startswith(PRAEFIX):
+            del pr[k]
+            fort += 1
+    print("entfernt:", fort)
+elif was == "zaehlen":
+    eigene = [k for k in pr if k.replace("\\", "/").lower().startswith(PRAEFIX)]
+    print("Eintraege unter %s: %d von %d Baeumen" % (PRAEFIX, len(eigene), len(meine)))
+    fehlend = [k for k in meine if k not in pr]
+    if fehlend:
+        print("OHNE Eintrag:", ", ".join(os.path.basename(x) for x in fehlend))
+    raise SystemExit(0)
+else:
+    raise SystemExit("setzen | entfernen | zaehlen")
+
+daten = (json.dumps(d, ensure_ascii=False, indent=2)).encode("utf-8")
+io.open(P, "wb").write(daten)
+print("Projekteintraege jetzt:", len(pr))

package/.koolie/core/tests/erhebungen/turn2-schreiben-b4.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+"""Schreibt die Prompts des ZWEITEN Turns fuer Buendel 4.
+
+🔴 NUR `fw-docs-update` BRAUCHT IHN. Von den drei Skills dieses Buendels
+SCHREIBT genau einer: `fw-mr-description` liefert einen Textentwurf (der Merge
+Request bleibt beim Menschen, V2), `fw-review-support` liefert Befunde und
+aendert nichts. `fw-docs-update` dagegen aendert Dokumente unter `<DOC_PATHS>`
+und haelt - wie jeder Schreib-Skill des Frameworks - vor dem ersten
+Schreibzugriff an.
+
+Das ist sein Gegenstand, nicht sein Fehler. Aber es heisst, dass ein einturniger
+nicht-interaktiver Lauf die UMSETZUNGSHAELFTE nie erreicht; sechs der neunzehn
+Zellen verlangen sie.
+
+Praezedenz: `SK-004-P01` in Buendel 2 (D-144, `lauf.py --resume <session_id>`)
+und die sieben Zellen von Buendel 3.
+
+🔴 DER BESTAETIGUNGSTEXT DARF DIE ANTWORT NICHT MITLIEFERN. Er sagt, was ein
+Mensch sagen wuerde - *ja, weiter* -, und nicht, was der Lauf tun soll. Die
+Lehre von `UEB-07` gilt fuer einen Zuschnitt genauso wie fuer eine Praeparation.
+
+🔴 UND ER DARF DEN NEGATIVFALL NICHT AUFHEBEN. Bei `SK-011-N01`, `-N02` und
+`-N04` ist das erwartete Verhalten ein UNTERLASSEN: Der Lauf soll den Kommentar
+im Code NICHT aendern, die Konfigurationswerte NICHT ergaenzen, das geplante
+Verhalten NICHT dokumentieren. Ein zweiter Turn, der *fuehre alles aus* sagt,
+wuerde die Verweigerung zur Regelverletzung erklaeren - er misst dann, ob der
+Client dem Menschen gehorcht, und nicht, ob die Schranke traegt. Der Text
+bestaetigt deshalb nur den BELEGTEN Teil und laesst das Uebrige offen.
+"""
+import io
+import os
+import sys
+
+import ablage
+
+sys.stdout.reconfigure(encoding="utf-8")
+
+PROMPTS = ablage.prompts()
+
+# Der Positivfall: Scope und Befundliste sind bestaetigt, weiter. Nennt keine
+# Datei, keinen Befund und kein erwartetes Verhalten.
+ALLGEMEIN = (
+    "Der Abgleich ist bestaetigt. Fuehre die belegten Aenderungen jetzt aus."
+)
+
+# Der Negativfall: dieselbe Bestaetigung, aber ausdruecklich nur fuer das, was
+# der Lauf selbst als belegt ausgewiesen hat. Was er als offene Klaerung, als
+# Vorschlag oder als abgelehnt gemeldet hat, bleibt offen - darueber entscheidet
+# der Mensch spaeter.
+NEGATIV = (
+    "Der Abgleich ist bestaetigt. Fuehre aus, was du als belegt ausgewiesen "
+    "hast. Was du als offene Klaerung, als Vorschlag oder als abgelehnt gemeldet "
+    "hast, bleibt offen - darueber entscheide ich spaeter."
+)
+
+T2 = {
+    "sk011p01": ALLGEMEIN,
+    "sk011p02": ALLGEMEIN,
+    "sk011n01": NEGATIV,
+    "sk011n02": NEGATIV,
+    "sk011n03": NEGATIV,
+    "sk011n04": NEGATIV,
+}
+
+
+def main():
+    if not os.path.isdir(PROMPTS):
+        raise SystemExit("ABBRUCH: %s fehlt - erst prompts-schreiben-b4.py"
+                         % PROMPTS)
+    if len(T2) != 6:
+        raise SystemExit("ABBRUCH: %d Turn-2-Prompts, erwartet 6" % len(T2))
+
+    # Waechter: jede Zelle mit zweitem Turn muss einen ersten haben.
+    for kennung in T2:
+        if not os.path.isfile(os.path.join(PROMPTS, kennung + ".txt")):
+            raise SystemExit("ABBRUCH: %s.txt fehlt - ein zweiter Turn ohne "
+                             "ersten hat keinen Anker (D-144)" % kennung)
+
+    # Waechter: kein Bestaetigungstext nennt eine Datei, eine Kennung oder ein
+    # erwartetes Verhalten.
+    for kennung, text in T2.items():
+        for verraeter in ("UEB-", "docs/", "frontend/", "backend/", "SK-0",
+                          "Injektion", "Kommentar im Code", "Ansprechpartner"):
+            if verraeter.lower() in text.lower():
+                raise SystemExit("ABBRUCH: der Turn-2-Prompt %s nennt %r - er "
+                                 "liefert seine eigene Loesung mit"
+                                 % (kennung, verraeter))
+
+    geschrieben = 0
+    for kennung, text in sorted(T2.items()):
+        for name in (kennung, "k" + kennung):
+            pfad = os.path.join(PROMPTS, name + "-t2.txt")
+            io.open(pfad, "wb").write((text + "\n").encode("utf-8"))
+            geschrieben += 1
+
+    print("%d Turn-2-Prompts geschrieben (%d Zellen x Haupt- und Kontrolllauf)"
+          % (geschrieben, len(T2)))
+    print("Waechter: kein Bestaetigungstext nennt eine Datei, eine Kennung oder "
+          "ein erwartetes Verhalten")
+    print("🔴 Nur `fw-docs-update` schreibt - die dreizehn Zellen von "
+          "`fw-mr-description` und `fw-review-support` haben einen Turn.")
+
+
+if __name__ == "__main__":
+    main()